From 660be42c4415236a606410938c29930bb70def68 Mon Sep 17 00:00:00 2001 From: Dick Ameln Date: Mon, 2 Sep 2024 13:07:23 +0200 Subject: [PATCH 01/45] Dataclasses and post-processing refactor (#2098) * use dataclass for model in- and outputs * split dataclass in image and video * use dataclass in torch inferencer * use dataclass in openvino inferencer * add post_processor class * remove default metrics from CLI * export post processing * add post processor to patchcore * use named tuple for inference outputs * validate and format inputs of PredictBatch * update torch inference * remove base inferencer inheritance * update openvino inference * fix visualization * PredictBatch -> Batch * post processor as callback * use callback methods to apply post processing * temporary fix for visualization * add DatasetItem class * fix pred_score shape and add __len__ * make batch iterable * add in place replace method * use dataset items in inference * dataset_items -> items * use namedtuple as torch model outputs * formatting * split dataclasses into input/output and image/video * merge input and output classes * use init_subclass for attribute checking * add descriptor class for validation * improve error handling * DataClassDescriptor -> FieldDescriptor * add is_optional method * add input validation for torch image and batch * use image and video dataclasses in library * add more validation * add validation * make postprocessor configurable from engine * fix post processing logic * fix data tests * remove detection task type * fix more tests * use separate normalization stats for image and pixel preds * add sensitivity parameters to one class pp * fix utils tests * fix utils tests * remove metric serialization test * remove normalization and thresholding args * set default post processor in base model * remove manual threshold test * fix remaining unit tests * add post_processor to CLI args * remove old post processing callbacks * remove comment * remove references to old normalization and thresholding callbacks * remove reshape in openvino inferencer * export lightning model directly * make collate accessible from dataset * fix tools integration tests * add update method to dataclasses * allow missing pred_score or anomaly_map in post processor * fix exportable centercrop conversion * fix model tests * test all models * fix efficient_ad * post processor as model arg * disable rkde tests * fix winclip export * add copyright notice * add validation for numpy anomaly map * fix getting started notebook * remove hardcoded path * update dataset notebooks * update model notebooks * fix logging notebooks * fix model notebook --- .../001_getting_started.ipynb | 354 +++-- notebooks/100_datamodules/101_btech.ipynb | 364 +---- notebooks/100_datamodules/102_mvtec.ipynb | 330 +--- notebooks/100_datamodules/103_folder.ipynb | 512 +----- notebooks/100_datamodules/104_tiling.ipynb | 87 +- notebooks/200_models/201_fastflow.ipynb | 330 +--- .../600_loggers/601_mlflow_logging.ipynb | 1401 +---------------- src/anomalib/__init__.py | 1 - src/anomalib/callbacks/metrics.py | 21 +- .../callbacks/normalization/__init__.py | 12 - src/anomalib/callbacks/normalization/base.py | 29 - .../normalization/min_max_normalization.py | 131 -- src/anomalib/callbacks/normalization/utils.py | 78 - src/anomalib/callbacks/post_processor.py | 124 -- src/anomalib/callbacks/thresholding.py | 201 --- src/anomalib/cli/cli.py | 11 +- src/anomalib/data/base/datamodule.py | 32 +- src/anomalib/data/base/dataset.py | 37 +- src/anomalib/data/base/depth.py | 27 +- src/anomalib/data/base/video.py | 63 +- src/anomalib/data/predict.py | 17 +- src/anomalib/data/utils/video.py | 19 +- src/anomalib/dataclasses/__init__.py | 38 + src/anomalib/dataclasses/generic.py | 313 ++++ src/anomalib/dataclasses/numpy.py | 170 ++ src/anomalib/dataclasses/torch.py | 486 ++++++ src/anomalib/deploy/export.py | 59 - .../deploy/inferencers/openvino_inferencer.py | 195 +-- .../deploy/inferencers/torch_inferencer.py | 197 +-- src/anomalib/deploy/utils.py | 44 + src/anomalib/engine/engine.py | 100 +- src/anomalib/metrics/f1_max.py | 2 +- .../models/components/base/anomaly_module.py | 102 +- .../models/components/base/export_mixin.py | 39 +- .../models/image/cfa/lightning_model.py | 15 +- src/anomalib/models/image/cfa/torch_model.py | 22 +- .../models/image/cflow/lightning_model.py | 15 +- .../models/image/cflow/torch_model.py | 5 +- .../models/image/csflow/lightning_model.py | 17 +- .../models/image/csflow/torch_model.py | 15 +- .../models/image/dfkde/lightning_model.py | 15 +- .../models/image/dfkde/torch_model.py | 6 +- .../models/image/dfm/lightning_model.py | 19 +- src/anomalib/models/image/dfm/torch_model.py | 5 +- .../models/image/draem/lightning_model.py | 16 +- .../models/image/draem/torch_model.py | 6 +- .../models/image/dsr/lightning_model.py | 20 +- src/anomalib/models/image/dsr/torch_model.py | 44 +- .../image/efficient_ad/lightning_model.py | 26 +- .../models/image/efficient_ad/torch_model.py | 90 +- .../models/image/fastflow/lightning_model.py | 12 +- .../models/image/fastflow/torch_model.py | 14 +- .../models/image/fre/lightning_model.py | 15 +- src/anomalib/models/image/fre/torch_model.py | 5 +- .../models/image/ganomaly/lightning_model.py | 31 +- .../models/image/ganomaly/torch_model.py | 6 +- .../models/image/padim/lightning_model.py | 16 +- .../models/image/padim/torch_model.py | 18 +- .../models/image/patchcore/lightning_model.py | 24 +- .../models/image/patchcore/torch_model.py | 34 +- .../reverse_distillation/lightning_model.py | 16 +- .../image/reverse_distillation/torch_model.py | 12 +- .../models/image/stfpm/lightning_model.py | 15 +- .../models/image/stfpm/torch_model.py | 23 +- .../models/image/uflow/lightning_model.py | 13 +- .../models/image/uflow/torch_model.py | 6 +- .../models/image/winclip/lightning_model.py | 18 +- .../models/image/winclip/torch_model.py | 5 +- .../models/video/ai_vad/lightning_model.py | 33 +- .../models/video/ai_vad/torch_model.py | 17 +- src/anomalib/post_processing/__init__.py | 9 + src/anomalib/post_processing/base.py | 22 + src/anomalib/post_processing/one_class.py | 196 +++ src/anomalib/utils/post_processing.py | 2 + src/anomalib/utils/visualization/image.py | 170 +- tests/integration/model/test_models.py | 12 +- .../tools/test_gradio_entrypoint.py | 17 +- .../tools/test_openvino_entrypoint.py | 2 - .../tools/test_torch_entrypoint.py | 2 - .../test_metrics_configuration_callback.py | 74 +- tests/unit/data/base/depth.py | 30 +- tests/unit/data/base/image.py | 8 +- tests/unit/data/base/video.py | 38 +- tests/unit/data/conftest.py | 2 +- tests/unit/data/test_inference.py | 13 +- tests/unit/deploy/test_inferencer.py | 3 - tests/unit/engine/test_engine.py | 13 - tests/unit/engine/test_setup_transform.py | 14 + tests/unit/metrics/test_adaptive_threshold.py | 34 - .../dummy_lightning_model.py | 36 +- .../visualizer_callback/test_visualizer.py | 2 +- tests/unit/utils/test_visualizer.py | 5 +- tools/inference/gradio_inference.py | 14 +- tools/inference/lightning_inference.py | 2 +- tools/inference/openvino_inference.py | 10 +- tools/inference/torch_inference.py | 8 +- 96 files changed, 2457 insertions(+), 4876 deletions(-) delete mode 100644 src/anomalib/callbacks/normalization/__init__.py delete mode 100644 src/anomalib/callbacks/normalization/base.py delete mode 100644 src/anomalib/callbacks/normalization/min_max_normalization.py delete mode 100644 src/anomalib/callbacks/normalization/utils.py delete mode 100644 src/anomalib/callbacks/post_processor.py delete mode 100644 src/anomalib/callbacks/thresholding.py create mode 100644 src/anomalib/dataclasses/__init__.py create mode 100644 src/anomalib/dataclasses/generic.py create mode 100644 src/anomalib/dataclasses/numpy.py create mode 100644 src/anomalib/dataclasses/torch.py create mode 100644 src/anomalib/deploy/utils.py create mode 100644 src/anomalib/post_processing/__init__.py create mode 100644 src/anomalib/post_processing/base.py create mode 100644 src/anomalib/post_processing/one_class.py diff --git a/notebooks/000_getting_started/001_getting_started.ipynb b/notebooks/000_getting_started/001_getting_started.ipynb index cfc4620eb8..a13261e2ff 100644 --- a/notebooks/000_getting_started/001_getting_started.ipynb +++ b/notebooks/000_getting_started/001_getting_started.ipynb @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2024-01-26T12:18:56.096138098Z", @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2024-01-26T12:18:56.101357180Z", @@ -106,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2024-01-26T12:18:56.112607883Z", @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2024-01-26T12:18:56.112848196Z", @@ -170,7 +170,8 @@ "from anomalib.data.utils import read_image\n", "from anomalib.deploy import ExportType, OpenVINOInferencer\n", "from anomalib.engine import Engine\n", - "from anomalib.models import Padim" + "from anomalib.models import Padim\n", + "from anomalib.utils.visualization import ImageResult" ] }, { @@ -213,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2024-01-26T12:18:57.203133970Z", @@ -225,7 +226,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "dict_keys(['image_path', 'label', 'image', 'mask'])\n" + "\n" ] } ], @@ -235,7 +236,7 @@ "datamodule.setup() # Create train/val/test/prediction sets.\n", "\n", "i, data = next(enumerate(datamodule.val_dataloader()))\n", - "print(data.keys())" + "print(type(data))" ] }, { @@ -248,7 +249,7 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2024-01-26T12:18:57.203997320Z", @@ -265,7 +266,7 @@ } ], "source": [ - "print(data[\"image\"].shape, data[\"mask\"].shape)" + "print(data.image.shape, data.gt_mask.shape)" ] }, { @@ -278,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2024-01-26T12:18:57.312944404Z", @@ -294,7 +295,7 @@ "" ] }, - "execution_count": 79, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -311,10 +312,10 @@ " Image: Output image with a mask.\n", " \"\"\"\n", " # Load the image from the path\n", - " image = Image.open(sample[\"image_path\"][index])\n", + " image = Image.open(sample.image_path[index])\n", "\n", " # Load the mask and convert it to RGB\n", - " mask = ToPILImage()(sample[\"mask\"][index]).convert(\"RGB\")\n", + " mask = ToPILImage()(sample.gt_mask[index].int()).convert(\"RGB\")\n", "\n", " # Resize mask to match image size, if they differ\n", " if image.size != mask.size:\n", @@ -339,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2024-01-26T12:18:57.633634551Z", @@ -355,7 +356,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2024-01-26T12:19:03.278278808Z", @@ -367,39 +368,59 @@ "name": "stderr", "output_type": "stream", "text": [ - "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n", + "Trainer already configured with model summary callbacks: []. Skipping setting a default `ModelSummary` callback.\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "`Trainer(val_check_interval=1.0)` was configured so validation will run at the end of the training epoch..\n", + "You are using a CUDA device ('NVIDIA GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "\n", - " | Name | Type | Params\n", - "-------------------------------------------------------------------\n", - "0 | model | PadimModel | 2.8 M \n", - "1 | _transform | Compose | 0 \n", - "2 | normalization_metrics | MinMax | 0 \n", - "3 | image_threshold | F1AdaptiveThreshold | 0 \n", - "4 | pixel_threshold | F1AdaptiveThreshold | 0 \n", - "5 | image_metrics | AnomalibMetricCollection | 0 \n", - "6 | pixel_metrics | AnomalibMetricCollection | 0 \n", - "-------------------------------------------------------------------\n", - "2.8 M Trainable params\n", - "0 Non-trainable params\n", - "2.8 M Total params\n", - "11.131 Total estimated model params size (MB)\n" + "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/lightning/pytorch/core/optimizer.py:182: `LightningModule.configure_optimizers` returned `None`, this fit will run with no optimizer\n" ] }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a9db1de73dc6413e844d3d3bd5d2d2c1", - "version_major": 2, - "version_minor": 0 - }, + "text/html": [ + "
┏━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┓\n",
+       "┃   ┃ Name           ┃ Type                     ┃ Params ┃ Mode  ┃\n",
+       "┡━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━┩\n",
+       "│ 0 │ post_processor │ OneClassPostProcessor    │      0 │ train │\n",
+       "│ 1 │ model          │ PadimModel               │  2.8 M │ train │\n",
+       "│ 2 │ _transform     │ Compose                  │      0 │ train │\n",
+       "│ 3 │ image_metrics  │ AnomalibMetricCollection │      0 │ train │\n",
+       "│ 4 │ pixel_metrics  │ AnomalibMetricCollection │      0 │ train │\n",
+       "└───┴────────────────┴──────────────────────────┴────────┴───────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┓\n", + "┃\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mName \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mType \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mMode \u001b[0m\u001b[1;35m \u001b[0m┃\n", + "┡━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━┩\n", + "│\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m│ post_processor │ OneClassPostProcessor │ 0 │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m1\u001b[0m\u001b[2m \u001b[0m│ model │ PadimModel │ 2.8 M │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m2\u001b[0m\u001b[2m \u001b[0m│ _transform │ Compose │ 0 │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m3\u001b[0m\u001b[2m \u001b[0m│ image_metrics │ AnomalibMetricCollection │ 0 │ train │\n", + "│\u001b[2m \u001b[0m\u001b[2m4\u001b[0m\u001b[2m \u001b[0m│ pixel_metrics │ AnomalibMetricCollection │ 0 │ train │\n", + "└───┴────────────────┴──────────────────────────┴────────┴───────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
Trainable params: 2.8 M                                                                                            \n",
+       "Non-trainable params: 0                                                                                            \n",
+       "Total params: 2.8 M                                                                                                \n",
+       "Total estimated model params size (MB): 11                                                                         \n",
+       "
\n" + ], "text/plain": [ - "Training: | | 0/? [00:00/home/djameln/anomalib/.venv/lib/python3.10/site-packages/lightning/pytorch/loops/optimization/automatic.py:132: \n", + "`training_step` returned `None`. If this was on purpose, ignore this warning...\n", + "\n" + ], + "text/plain": [ + "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/lightning/pytorch/loops/optimization/automatic.py:132: \n", + "`training_step` returned `None`. If this was on purpose, ignore this warning...\n" ] }, "metadata": {}, @@ -425,6 +469,29 @@ "text": [ "`Trainer.fit` stopped: `max_epochs=1` reached.\n" ] + }, + { + "data": { + "text/html": [ + "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -443,7 +510,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 76,
+   "execution_count": 10,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:05.567521337Z",
@@ -455,35 +522,42 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Restoring states from the checkpoint path at /home/djameln/anomalib/lightning_logs/version_144/checkpoints/epoch=0-step=7.ckpt\n",
+      "Restoring states from the checkpoint path at /home/djameln/anomalib/results/Padim/MVTec/bottle/v5/weights/lightning/model.ckpt\n",
       "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n",
-      "Loaded model weights from the checkpoint at /home/djameln/anomalib/lightning_logs/version_144/checkpoints/epoch=0-step=7.ckpt\n"
+      "Loaded model weights from the checkpoint at /home/djameln/anomalib/results/Padim/MVTec/bottle/v5/weights/lightning/model.ckpt\n"
      ]
     },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c88160bbf6344547803bd1ca8aa4035a",
+       "model_id": "29cc1011024b4ee39e6ffb0339ec307c",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "Testing: |          | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
        "┃        Test metric        ┃       DataLoader 0        ┃\n",
        "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│        image_AUROC        │    0.9992063641548157     │\n",
-       "│       image_F1Score       │    0.9921259880065918     │\n",
-       "│        pixel_AUROC        │    0.9842503070831299     │\n",
-       "│       pixel_F1Score       │    0.7291697859764099     │\n",
+       "│        image_AUROC        │     0.997619092464447     │\n",
+       "│        image_F1Max        │         0.984375          │\n",
+       "│        pixel_AUROC        │    0.9841534495353699     │\n",
+       "│        pixel_F1Max        │    0.7346382737159729     │\n",
        "└───────────────────────────┴───────────────────────────┘\n",
        "\n"
       ],
@@ -491,15 +565,38 @@
        "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
        "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
        "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       image_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9992063641548157    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m      image_F1Score      \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9921259880065918    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       pixel_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9842503070831299    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m      pixel_F1Score      \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.7291697859764099    \u001b[0m\u001b[35m \u001b[0m│\n",
+       "│\u001b[36m \u001b[0m\u001b[36m       image_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m    0.997619092464447    \u001b[0m\u001b[35m \u001b[0m│\n",
+       "│\u001b[36m \u001b[0m\u001b[36m       image_F1Max       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m        0.984375         \u001b[0m\u001b[35m \u001b[0m│\n",
+       "│\u001b[36m \u001b[0m\u001b[36m       pixel_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9841534495353699    \u001b[0m\u001b[35m \u001b[0m│\n",
+       "│\u001b[36m \u001b[0m\u001b[36m       pixel_F1Max       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.7346382737159729    \u001b[0m\u001b[35m \u001b[0m│\n",
        "└───────────────────────────┴───────────────────────────┘\n"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n"
+      ],
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "
\n"
+      ],
+      "text/plain": [
+       "\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -513,14 +610,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[{'pixel_AUROC': 0.9842503070831299, 'pixel_F1Score': 0.7291697859764099, 'image_AUROC': 0.9992063641548157, 'image_F1Score': 0.9921259880065918}]\n"
+      "[{'pixel_AUROC': 0.9841534495353699, 'pixel_F1Max': 0.7346382737159729, 'image_AUROC': 0.997619092464447, 'image_F1Max': 0.984375}]\n"
      ]
     }
    ],
@@ -547,7 +644,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 74,
+   "execution_count": 12,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:06.645604243Z",
@@ -555,13 +652,31 @@
     }
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/torch/onnx/utils.py:2078: UserWarning: Provided key output for dynamic axes is not a valid input/output name\n",
+      "  warnings.warn(\n",
+      "/home/djameln/anomalib/src/anomalib/post_processing/one_class.py:151: TracerWarning: torch.tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n",
+      "  preds = torch.minimum(preds, torch.tensor(1))\n",
+      "/home/djameln/anomalib/src/anomalib/post_processing/one_class.py:152: TracerWarning: torch.tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n",
+      "  return torch.maximum(preds, torch.tensor(0))\n",
+      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/torch/onnx/_internal/jit_utils.py:307: UserWarning: Constant folding - Only steps=1 can be constant folded for opset >= 10 onnx::Slice op. Constant folding not applied. (Triggered internally at ../torch/csrc/jit/passes/onnx/constant_fold.cpp:179.)\n",
+      "  _C._jit_pass_onnx_node_shape_type_inference(node, params_dict, opset_version)\n",
+      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/torch/onnx/utils.py:702: UserWarning: Constant folding - Only steps=1 can be constant folded for opset >= 10 onnx::Slice op. Constant folding not applied. (Triggered internally at ../torch/csrc/jit/passes/onnx/constant_fold.cpp:179.)\n",
+      "  _C._jit_pass_onnx_graph_shape_type_inference(\n",
+      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/torch/onnx/utils.py:1209: UserWarning: Constant folding - Only steps=1 can be constant folded for opset >= 10 onnx::Slice op. Constant folding not applied. (Triggered internally at ../torch/csrc/jit/passes/onnx/constant_fold.cpp:179.)\n",
+      "  _C._jit_pass_onnx_graph_shape_type_inference(\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
-       "PosixPath('/home/djameln/anomalib/weights/openvino/model.xml')"
+       "PosixPath('/home/djameln/anomalib/results/Padim/MVTec/bottle/latest/weights/openvino/model.xml')"
       ]
      },
-     "execution_count": 74,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -585,7 +700,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
+   "execution_count": 13,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:06.867644218Z",
@@ -596,22 +711,12 @@
     {
      "data": {
       "text/plain": [
-       ""
+       ""
       ]
      },
-     "execution_count": 73,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -632,7 +737,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": 14,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:06.869599561Z",
@@ -644,7 +749,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "/home/djameln/anomalib\n"
+      "/home/djameln/anomalib/results/Padim/MVTec/bottle/latest\n"
      ]
     }
    ],
@@ -655,7 +760,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 15,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:06.880794392Z",
@@ -667,19 +772,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "True True\n"
+      "True\n"
      ]
     }
    ],
    "source": [
     "openvino_model_path = output_path / \"weights\" / \"openvino\" / \"model.bin\"\n",
-    "metadata = output_path / \"weights\" / \"openvino\" / \"metadata.json\"\n",
-    "print(openvino_model_path.exists(), metadata.exists())"
+    "print(openvino_model_path.exists())"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 16,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.127278601Z",
@@ -690,7 +794,6 @@
    "source": [
     "inferencer = OpenVINOInferencer(\n",
     "    path=openvino_model_path,  # Path to the OpenVINO IR model.\n",
-    "    metadata=metadata,  # Path to the metadata file.\n",
     "    device=\"CPU\",  # We would like to run it on an Intel CPU.\n",
     ")"
    ]
@@ -707,7 +810,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 69,
+   "execution_count": 17,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.221219176Z",
@@ -716,7 +819,8 @@
    },
    "outputs": [],
    "source": [
-    "predictions = inferencer.predict(image=image_path)"
+    "predictions = inferencer.predict(image=image_path)\n",
+    "predictions = ImageResult.from_dataset_item(predictions.items[0])  # convert to imageresult for visualization"
    ]
   },
   {
@@ -737,7 +841,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 18,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.222396309Z",
@@ -749,7 +853,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.8962510235051898 True\n"
+      "0.7244761 [ True]\n"
      ]
     }
    ],
@@ -759,7 +863,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 19,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.347717385Z",
@@ -770,22 +874,12 @@
     {
      "data": {
       "text/plain": [
-       ""
+       ""
       ]
      },
-     "execution_count": 67,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAAGiCAYAAABd6zmYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9XYxt23bfhf5a672PMWdVrY+99/mOj7ERuVfAvYpFPqxIvCAsBYGQAnnAUh6igIiECBIyH8IPBEVCssQTikDiMTyAxBM8WkLmgRcrgFGkq0vIdRInPrbP3muvqprfc4zRe2/tPrRR69gkIbF9cs4+58z/0VlrV61ZVWPOqupttNb+H+Luzg033HDDDTd8AaHf7wu44YYbbrjhhr8fbkXqhhtuuOGGLyxuReqGG2644YYvLG5F6oYbbrjhhi8sbkXqhhtuuOGGLyxuReqGG2644YYvLG5F6oYbbrjhhi8sbkXqhhtuuOGGLyxuReqGG2644YYvLG5F6oYbbrjhhi8svm9F6r/8L/9LfuInfoLNZsNP//RP87/8L//L9+tSbrjhhhtu+ILi+1Kk/rv/7r/j537u5/hP/pP/hP/9f//f+UN/6A/xJ/7En+Ddu3ffj8u54YYbbrjhCwr5fhjM/vRP/zR/9I/+Uf6L/+K/AMDM+OY3v8m/8+/8O/xH/9F/9L2+nBtuuOGGG76gyN/rL7gsC7/yK7/Cz//8z394n6ryMz/zM/zyL//y3/Nj5nlmnucPb5sZT09PfPLJJ4jIP/JrvuGGG2644bsLd+d4PPKNb3wD1b//UO97XqTev39P752vfvWrv+P9X/3qV/k//8//8+/5Mb/wC7/AX/yLf/F7cXk33HDDDTd8D/Gtb32LH/uxH/v7/vv3vEj9XvDzP//z/NzP/dyHt/f7PT/+4z/Ot771LV6/fv19vLIbbrjhhht+LzgcDnzzm9/k1atX/7eP+54XqS996UuklPjss89+x/s/++wzvva1r/09P2YcR8Zx/Lve//r161uRuuGGG274AcY/aGXzPWf3DcPAH/7Df5hf+qVf+vA+M+OXfumX+ON//I9/ry/nhhtuuOGGLzC+L+O+n/u5n+PP/Jk/wx/5I3+EP/bH/hj/+X/+n3M+n/mzf/bPfj8u54Ybbrjhhi8ovi9F6l/71/41Pv/8c/7CX/gLfPrpp/zUT/0Uv/iLv/h3kSluuOGGG2740cb3RSf1+8XhcODNmzfs9/vbTuqGG2644QcQ/7Dn+M2774Ybbrjhhi8sbkXqhhtuuOGGLyxuReqGG2644YYvLG5F6oYbbrjhhi8sbkXqhhtuuOGGLyxuReqGG2644YYvLG5F6oYbbrjhhi8sbkXqhhtuuOGGLyx+IFzQb7jhBgD/bX+/mHLe8tRu+OHGrUjdcMP3DIa7AIIAjgEGpPVvWx/3MuBwcF9rkrN+EEhfH/PyjrS+bXwoZKLIh/e9PPaGG37wcCtSN9zwXYFHefjwhwAd9wbuOAo0cMMtIQL0RsfxmqlMNG2oOWKKuNIAxSjuNDGyCq0lEKFop7rhaqhsUTJSOk5jkITkDF4Q6UCOoiVpvda1CEr8cStfN3yRcStSN9zwD4T/fd6suBesV1wW3DreE9BYxMjVmZeJZmA9gYHLgrlhtSO9UU3patQqiDW6QKKxmKBaSFRwo7mTW8JSxXMioaCK4mBHVBXLmcTMRhKaCqKJnDuCokVR3ZKToqJIciSB6IjiCBlPipC/U7Tkwx833PB9w61I3XDD3xPf2f+493VM14GO94y1DnahVmWaznSM1itenW6NhtG9Qe0sHaw5tRqGY22htY5LB88YDWvgbpiDq2PeQaKwZV9wdO3GjKaNxEgWB9+QBMgJVBDrFHGQRB4TORnFN6go5C0pd1SNcdiwyY6VgUEHtAiMmYENRQ1PBdEBEfl7FK1b4brhe4dbkbrhBpzvZAEYeAcHs0btE71WrDfaArMtSGv0yWht4dI7rTlmE7UV3GaWvmBduFojNcNtwVvn0gXzTm8TZonmgrhj3UhtoQm4F5ouiIJ6B1M6imKAkNyoksiW0QyqHUFwKaiDCqSccIUxZTQZnpVBFGWDpIEhN3JRNroFTZSxQMrk0dmkO7ajYoNQ2DLmhKbEMHZUC+h9FE8A5B+YqnrDDb9f3IrUDT+yiMLUwRruDWtKa2daOzPN4F2Z5gnrncUnpivM7UyqzjJ1JptpvWO9Y+ZMU6ULNKv0qVHdcYu/rS80A21KtwtmmW4gZpg55muR6pnsE10EdwV1DAHLJJxMw8hQhEZnIFPcqWokUZRMyoKSQCGnjGVhUEFyYZMymgcKipYDQ3ZyGUgpMxYh5S25FEpRSsoMWbnLA7oVtuM9kq+kMjJKRocMqqCF7xSsW9G64buLW5G64Ycc/nf95TTcGm6VuS30qTFPCyzGqV6YlopVY7bOMs1My0RvxlKdpV6QDkutLHWhOdTaSLVzqTNNDGud1o2GY7NhPtFbx3rCxTHrYE510A7dDKNiFuQL10bqA+YNNMNoMCkkZ+iOiOCidANLBZWGiCMpsVUQTfSekCyUMiDipORQMtucUBkoVmBwcnFECsM4cpdGNJ0RzQwboZSRkp1N2aJb5b7MbJKwHQs+ZMowsC2ZXO4YckLLAKmgApD+L/XqVrxu+L3hVqRu+CHFd6qS47iB28JcLyzzTG0LfYZTPVOXhXnp2NS41ol5mahLZ14WWq1MU2PuC71Ct0rrC60uLLPRzajdwTrz3Oi10qXSTbHW6N3ovdNxxBPdOmKdtr6vNUdRYuRYaQ7qCuaYSJDLk9Kt46KoGWiQG1yA5BQDF0VEyQWSFAwnqyBJEEmUrIgKOSVUM2VQRJWtKqRELhuGNJJLYshGSjCMAyUXxjIiaWS82zFoZlMKebPhbrOliLC5GxmHTCl3pPs7tlnRHEQNVSeeBTcixg2/J9yK1A0/RIg+CXeMTvWGNKVNF67XK0ufuF4mrrVTl4lp6tR5ZqkT09JYpoVza8yz4fXMXCu1VvrcmFtnXsDsQu3AYvQ+U/tC70JvUK3RmkEP4oR1w3una8Mz9EkRM3CnNSP+p6S1gzLvsXlSxfv6r+JgCSSjdMSD3u4KIoqKI5bw3BCBpIIwRNFCSVlJCpKU7KBFkZRICiVlkii5RMeV0oCWQs5Q8kApypAK45DQXBjKhmEobO5GUhbu88g43JM3iTwod2XLsBnZDgObEcZyT94MjKWQiiKagQE+7LFuBeuGfzBuReqGHwIY7mAY9CM2w7UvXKZOnw5Ml4nT1ViWK+06cW4LS61czg2zxmW6Mk0zrTvXpVKXidorc620qdJ6i73UBM0nerdg53WnWaeb01ujt4Vmjluw7DCnSxQvSYI3Qbvg1mhIaJhivoe5wTrCSxqFDBHUPcS7Di6Z5EIXI/HSmOT4LwHxCkmBCuKhnZINKV/XHZXhWtCkJHE0BfliSEO8T4U0pChceWAclHEopCSUPFJypowPjIMyFBiGkbuSSOOWYRjZbgpDHtmMI8Ow4dV4ZNhsGDcb8j1stFC2byilgCiQELkJjW/4v8etSN3wA4qVGg7RdSyV83KmTifqJBznPdO1cZ1OTJMzTVcu14mlzkzzQmuVeZ65nhtzuzIvlXk25tawxbC2UNtEXRqLdcw6tgjVYrRXrdF6w3ujm0LvYIa54HTEoWO4ETsoT6hKkAe9gTguCfGOCXR31AVxoYqTgCaOOOANwUEHmuhqIpHj89AwF5Iq5gsiCdEYJSoF8WldDzmuQmIBdVSUlAquRl4LVxbFE5SsJM2kkslZGYZEziNZlTIe2Qw5HlNGhqEwbEc2ZeAhFfJmZBwL201mn+8Yhns228zwkLjLAw93E3nccDcmyjAiZRNUd9Jv67BuuOE7uBWpG34A8B0xrbvhq3PDPFeWOUZ183Tlsj9yXWbqtXG6XjgvE5dlYpqu9HlmmiqXuTLNM0tt1OlKm4WpX6lLY1oqrceeyOtMry3etni/rUVJDLoo7gZWcU90q6iDKZjFFsbNMDfcYwzpyYLa7hYdkDeEKGyC0tfHSXbEBW1hk2SawHp8Pe8ITqPH6FCgi2Mtuil3QdWjUGrHLEFruICQMBIpOSbg7pgaVRuiioohonhODKpoEpJmSslIvpBzJiVlLIVNKaRxDEZgKWyKchwywzAybAbGsTDme+7LPcPdhnJQXg+Z5+09ZUi82o7cjQ9sHgbuxowOA5reIPpi88Rth3UDcCtSN3yh8UJ+8BC8mtD7hfky0duJ3WHiukzU88JxnrhcKsvlwnVeuEwT87Uy1YnzdaJeZ6w3LnVhvl65NqMvlbZ0ltppbWHuC94da7YWpU43A3PcHHqlSUe6roe+gDVMWuh8U6LbgntirTeYg7rj0jF3nAzJgIYaiCku4bknL3ZFljCr69uOu2AeHdTLjqo7SJDTcVHcE0kWDKe5RsGEVUOlGPahqLmFLLhjiAki4e/XZJ3CLZmujiZFNaEiaHJS3pIELqmQByPnkZJTECxKIafMMBY2Y2HcbCnDwnY4MJwym7LluB0odzObTeI0DoybI3eHO+7vtmyGkbu7iWG7IQ8FSRl8WMeBcCtWP7q4Fakbvpjw6AbwhrfG9bow1ZlpnjkfT0zTwuFyYr6emC7G8Xphul5o15lD7VyuR+yycO7GfJ2oy0LtC/PSWGaj1oXWGtYatcXocLEaXUcTXDpi0NyQnnAxzFoUDs90CbuiODpjrCfqmCXEwMRjxGaCqaNrx4TX9SOIjoy+Pl3D8Sg6Pfz+gvrguBoitnrN6rqfcswAGlBwqdgH38AwpW1dEGJUaELYIXkUYE0eRcA7iuGpIpIwi46qtRqWS0lxjT2VSEVRZO2oUp6RVNgkJY2ZrEFLL2OijFs2RdluCts8shlGzqNShh3D/YbN5p7NJvMw3DHeZR7uCtvxNcN2y6tXhe24ZdjckfK4iof1txWsG36UcCtSN3yBsI7F3MEbvU7sL516vXCeLpxPV+bridO5cr4Yx/mJ+XJkvhrny5VpOTFPjWleuE4TdblwXQxbjLku1FqptdE6eGv0Ftok60Zbux4xx7yFe4M7JmFVJPj6t+FcUdewMBLi4Cb2TeJRUAxijKfRIZkrpo2E0Du4vowMozCJJFQ6phodlsTXe/k/8VkQ6ag4UVoElYyK4AhuFjT19Vp7d4qGV19Q2vvaKjmtJ5CGOKS1YxV3RDrNHCXRMLSDWqdJFD5VQ3qnJ4EZJCWaAlMmZWVIGS2Zki4MbxLby8BQlFwe2JZCGWa2pwt32zPbu4Fj2bIZMuP2jvu7K9v7Lfv9hlevCq/v3jBs7pH7kfsyAsNNMPwjiFuRuuH7jJVS7Q4Y1iu9zUzXE/M883ScuJzPnM4npmvlepzZzwvn64HpcuFyrVznietl5lqv9GkOAe5cqXVhXipeQ8tUrePdguzg4D26HbO2lkdFekMsSpFLXF0mDF5fIPJCkABRwbuthSLMXE0lkjV0Zd2Z4dpJuu6MPriPG5IUPJHpuGYMRzQ6qI6TiKLjaBD+NK4ziaMK+OrZ1xVPwerDwXNC1dYxY17Hg+uA0NcuLzl06JLwbogLSHRxqGEiuBAdm4T17MsY0tbO0XvGRfDZ8KRMaWFMA9dcKbNyzQNlGMnDQk4bNmNhOxa228xmHBiHB8ZtYjMeuH/9wN3hFdvhzHS643zXGbcn7l8/YHcjd9stmrZoTojk31arbkXrhxm3InXD9xFrXhKG+ZV5mrlcJqbrwvF04XC8slzOHK7P7M4T02ViOS8cLzOn85nrEm4Q88WY5yutXlgWY14qtVesVlo1rK2eeVS0Cb7mOqkILg6sncbKiXNlPZlBDbpYdEwWDDyTcCAnBYmCJKsBbBSXLEFUs5R4qXRZfP16IDkhPdh9L1FRSXTtgjrCKuj1EO1mlTUBxCF11FOMQgWchJuT1eme10JjmComRESHJZJH+6YfxoSsV5w+RFZFfya4C25hcLsOIOlu667NUNWguEdrSaXFc1/Hoj0ZWTNtEpY0o3omjxktI2NJDGVksy2MY2bIVx7GQrlPbA4HHu7eUraF/eWB7d2JV3cbtpdnXt09MG5e8erugbsHGIYHUi5rsfqOl+ANP3y4Fakbvg/4zliv9Uabz8zzhePhyPl84nhxdocjp/OZ+XhlN+04nxv1OnE8n7nMM9NlZq5nrteFugRbz2qjN2HpjV59tRrKeAdsXl3vglGQJNPFokKguHVUotcwQrPkHt2U6rrPIZh0+kInJ61EtIyYI5pijyOGrAVLcUwSKcXoD7MgRqSGuK5FEpBMwj64M7wEFspKcUAGcEPX3ZIL0e1ZOJY7HfV1b+OdvI4D18Fj6K009FZdhrUUgmbH7cW+VuPao8KCG2YSHaF33IxO7M9i6JbAoiK7t3htRBAWamuoZHoyRGCpmZwXWs5MaeFydXIZGfOFyzZTriNlHNleLrzZ3jGNFzZ3mev9J2yPmefNzOv7icv9lXLc8Pbhyt3dHcPmjpzHML+9dVY/lLgVqRu+t3CPTsaOXOeF0+nK5XThetpxPHeOlzPn05nd+cLldOJ0mTifLlzPV6a5Ml9OnOvCfK0sLzumpdJ7g250q/SudHPUDZeGWELESCy4KyKZ7vaBsi2+khM8mGzicWhrElwzGVvp2hmlklLojEQKTkb7gq+HsUhkMuGCi62ZTrFjEy3YvSMzSEvR1SAhDxIPJp5DIjo8YXU1F6V5j9gMF0yEnBRv0a15Bu8SHZaMwBmV9NvCFgVc6R4JwOKQ6euyKzrH6Ko8TG9xSPahRCqEWa567K3co1NcPQfdo8DiRhdBJWG9kgWwcMew3mmzo3lB05W0FDTP5Lxlvjppe8cwnLkbNyzbxjBOPNwXTqfKq03Q2qdXG86XB4Zx4Pp65OHugbcPn7AdE+PmDt0MIOW3hTvCrWD94ONWpG74nsG9432hzQu7847pcuV4ntgfDuxOB077mcv5wvl65TRduZwPnM8Tl/PEeanMl4V5uoZvXqv4AtU75h1fWnQ+K8lBLA5mxxBZgkjgKQqACu4W8X4aFO5EBoe0jgJlHb8NHsWnA0WV7JmmxOhOO0JaGXhKJlwbOoCvOUzraCz1QhchL0aXhCYhe3QmaCI7NPoqyo2RG9JRlfi4HnuylIRCimtM61xRnJrDhcJ9QaXEa0GJ3RMxtisErV7UcBPInW4JQ8mAiVIsOlzzVaPlUapybO9AY7xoPUgYbtGhdU/I2oHihqM0KtYd94KL0FnQ5qSm9AYI5FKZNTHMjaFkrsOV0zix2W6ZTkLaXrnf3nG/2XB3veNhO7G9H7icB17dnzk9LNxvX/P2obJ9KIzbLSlvV39DvdWoHwLcitQN/4gRh57bTJsrl/Oe/enI6Xrl+Fx5Pj1xuF65nE+cdkcOp7Awms6PHKeJ5dqY54XrfKXNjVpnWjPcGtLXmAugWyNZ8Oy6BAU8mcSZ6aEVSgpFozCorBHuIoh4EBBSDysiC8KC+GrmKg500LpucTJJgm1nYpGQqxH5nghmHkKMoKI/wlPsiLQLWaDjIawNtdJKluisXPaobXEVQQtPnaSCi4AnkkQHZurBBkRQBXNFVspFdDyOuFFd1g7thdgOloTk8Xa3eB1EwKRjvrqsY2A9Xisf40ZDHFPHRHFZRcbkGGMqYQtFCIhdFfEeZA1zSBKsSO+IBB1etEBr1LQhFWceZqbrhes4sl0q03XmNI5s5pn7sXB/GmMk+DBzvS6cNieu1wfeXO8Y7+7Z3l+5G+9J4wPwYmRxq1Y/qPhdCw/+5//5f+Zf/pf/Zb7xjW8gIvwP/8P/8Dv+3d35C3/hL/D1r3+d7XbLz/zMz/Crv/qrv+MxT09P/Ok//ad5/fo1b9++5d/4N/4NTqfT7+uJ3PBFw2r0asZ1njjuTrx7/8Rnnz7ym5/t+dZvfc5vfvaOTz975t23H/ns2zt+690z7z7/nMd37/j8/YHnpyO75yP7w5Hr8cp8PlGnGVugLca8GK05vTu0RDdhWT38HKdJMNkSGmO3EpHsRZyyxqcn4qBWdZIkhBzuCypoSqSkaMoMWihayCmRk5Ik3MazJHIeyCmTsyApipPmYOBlbNU7KQNCygOeEpISmgFNIEFnV0rokTQKRn5xOU+GJkW0oCmHEWx2UoKMxL8NYeBaRMnrHk000aWACrkkclFKFlJJpJwZZPXjS8JQhCFlSlF0UPKQGAel5EQuAyVv1s+RSSWRh00IeUtkTuWkSA63C8kEKUQ0xn0WXViXuKlwcXqv9O5UU5obS51ZrucoSKeF4+nM8XDm8WnP49MTu8cnHj9/x7v3T3z7/SPfenzmNz5/x7fePfFb7x759rtP+TuffcZvvH/k3fs9u6cnptMTvV6CBPKirv7w/xt+UPC77qTO5zN/6A/9If71f/1f51/9V//Vv+vf/7P/7D/jL/2lv8R//V//1/zkT/4k//F//B/zJ/7En+D/+D/+DzabDQB/+k//ab797W/zP/6P/yO1Vv7sn/2z/Lk/9+f4b//b//b3/4xu+D5j1TnRsHbhfF143l247E8cTjuO5yO784XT4cTxOHE+XjidTxyvZ07nmev1zDw1rtMcpq11obWF3lfT1d4RW+JLiWAEgy66odD5IIXkQLKIwRCCRuDxMegLky5IAiIvY7tEcsM1k8QRD5qzi0VEu4RHnxJGrVFDGi5BkGia1j2SoS7RXaHBLPTo0sxfxoEWnRiKWMdSXJ+4rvspMDrrM4ini0f3QWcM/jnaNLqTVcDrQoiwPJNVgtW30hxEQpwbj8580Ma6fth3uQtl1V2ZNjakCHX0+BxdnE1LXLrTPANB3GgGyTpmRl+vv5vRhehoPSJJuva1s/b1ecV/O2vKcA0vRm9CzZU8j7TcmIbOcJ0Zhom7zcBle+H8KvP6vHDd3jNdt7y6a9TrlWXzmvPDPW8nZ7M98/p+YLjbovk1YDdT2x8wiLv/nm8rRIT//r//7/mTf/JPAtFFfeMb3+Df+/f+Pf79f//fB2C/3/PVr36Vv/yX/zI/+7M/y1/7a3+Nf+qf+qf4X//X/5U/8kf+CAC/+Iu/yL/4L/6L/MZv/Abf+MY3/oFf93A48ObNG/b7Pa9fv/69Xv4N31W8MPY6Vq9cLlfOl5nn44HT7sz+cOR43DFNJ573M7vjhevxxO564nqZuFxnputEnc7Ms1H7glULAoIb1fr6dTr0GKEh0CXo2oqt7DkBzSsbrweBQFahaoqPe5EXJQcjrSGCQlo9H3SNxYhitCq5PMdIzetKy44OCGmrpir+W3pBJNwiHAnncY9uwrDYzXgc5kqPr+859jkuQI+ojpeCS5i9Spa1yDq+CnhVDLGy7r7qKu6N52oIKcVVeIuSp0lJaWUt9kLSF32YIZJXxdqyhi9+55qsx3WbBcFkMJgsBTXfnPj064iwB5HCesXc6S9djINQMOnBNHRFkq3PNQgaScBTuEsoQHJUo5sdipKGDWNO5GFgHEe2r+55ux0YtxvGu1e8uRu5vy/c373hzast21cPvLq/49Wr17zaZh7uv8ywNdDfLgy+4fuFf9hz/Lu6k/q1X/s1Pv30U37mZ37mw/vevHnDT//0T/PLv/zL/OzP/iy//Mu/zNu3bz8UKICf+ZmfQVX5K3/lr/Cv/Cv/yt/1eed5Zp7nD28fDofv5mXf8PvGGpVhE226sj8cOZwPnI8nHncLp+OJ/fOOw/HK+XLgdJnZnY5M05njHLqodu3M80xbGt4qzRzrrAw9C+2POdmCmC1I9BmyUqQlRnCSYsSY1UlrRyAEuw/pQCfpEHuh1X9PXEhSQsCKk+PYxtcDNK+E7i6hixKcLiuJWz5YQgRRww2TKFrmFloiD00UHkawruHV5xYyXfcehrLSwxXC+irh1YjYcKM3DQ/AFAzCJoZ4J6/BiNajGAd9Pgp77N4IakdyWsisyC6IB4FDtIMpIkFvd08ITk7hJmguZM2YK6lUXARtibS+372SVib/YkoWAes0EQzFO8GkdKW7RYe77qTMiH0VgBa6OVARMqYCrcdConeW3mGp1DQwjJU6V6a5sdwNbDYXNved6ZzZnra8flW5ToWH0xvqmwf6dWa6v+NyMe4f7tneG5uNgWy4dVRffHxXi9Snn34KwFe/+tXf8f6vfvWrH/7t008/5Stf+crvvIic+fjjjz885v+KX/iFX+Av/sW/+N281Bt+34iDOfpwY14m9scD83niebfncH7itDux2505nC48H/ZczlcOp4XpcuZ4OTDNjXmZaMtCXTqtOr23WLz3jrgFM20dS2XPUQDoOJmskEWCGi1CJuE0Bg0GH6vuKUuKBT4RiSHyQruWdawWxQ139GWuEFO3eFsiFwpRasiQEAmNUve0jhqjOOAe0SEJ6IrTMClBn+jhAEEP0oR60CdYgwxrZ9VaBdNOpK8ZWeseB8AtQgujPaRpp1uJw14F6SHmRcKNXbxTVT+wHlU6C07SDN2iFK7+gnhGVdEc1HTRRvLYLak3lBRGtzle6+yKi1D6S3EnCq8FBX1xcBX6+ppaj+9dM8FaC+q/GO4ayckQBd9nxAuyFuImEq4dyVbt1sQyV0qdqMsdeZN5uFSud4Xt9p5lmjldC6/uG8d65TDNvDpfeftw5jS/4e30wNvXhXHzETJs1puNmy/gFxU/EOy+n//5n+fnfu7nPrx9OBz45je/+X28ohsg7oZrr9TpxP6w43k/czoceX5+5nA5c3w6sz+fOZx3HI8z02nmcDlymWaWaWGeF6zOtNYiLLB3TBO67pzs5U8Hk7D5EYXimeKKq4Qr+Mq2M5HfYUKaWZldyRnsxSg1fdAEueiq5dW12HqM93w9pF1xqzSp4b7gI+ILIFjERyHiYbEkIFTwAoS7EKu10osxrXlHTVd6esfXLiJ8LjLmwdRjjdpwi8Fi4zsFswuIt3U8F3ZS4j32WKa4zPj6b6k3TAR6uJyjle+4otfQdPUUVPcelO1kFkWfyLJSLAq4Cm4a48QUYYwhXM5r8UhrsnC4vUsPs/feo83qJlgLyrukCkGIp8n6/TXDOvF9XOnuamBiuCpVZHWjv4YOSiJCZa7GOI9QGss8UKeZNlW208B86VyulXqeON0/ME2veJgr/TIxtde82TbuXj2EP6CONxbgFxTf1SL1ta99DYDPPvuMr3/96x/e/9lnn/FTP/VTHx7z7t273/FxrTWenp4+fPz/FeM4Mo7jd/NSb/g94sWex71xXQ6cjleen04cL3uOuzO7/TsOh5n9/sDxeGQ/Nc7HE8fTheW6sCydy/VMrQvURlvj190cEyH1iI/wOCHXjCanSBxgqhqqHnESgsjq7LBSwj0JysrqS0N44HkUHwEG8fCaM0fMMIk7fCNcHNRXbZCDacRXuAtJHOu67rfWG/4Pe6TQC5lr+CgBeIu9C0YnuglNQZWHRMiQfKV2O8aCa1of6+tz0NXdISEJXFoQLboyaY3dV8uI1AhclHCwSBIkjY6E/RJ99a9wugvJY0yKxhgwqdA9us4uPeyfVhp9VyGZoJqjQ1upHC4DQwLzhjNEyOM65sMF0cSAY7XhqvTe8VLozdBVGtAsuuVusU8UUbDQpbH6BXYPar61iCmJEW1CpKEKrV/x2rGemdrMVEemubFdBs7zzN0yUS8D4+vKssxc5i3X7YmHeWZ6eM2bPvOmLJTX9+RxG+zOW7H6QuG7WqR+8id/kq997Wv80i/90oeidDgc+Ct/5a/wb/1b/xYAf/yP/3F2ux2/8iu/wh/+w38YgP/pf/qfMDN++qd/+rt5OTd8lxEFqtFa43rZcTw+sT9e+fz5wuHwzH7/zG4fLuWnQ1CIj+cL18uJy3Vhniu2LLTaqL3FHXNPkcmkvvrVaSzP1WKZnkLvU8ixSKeTkpAGsCqrxZGACqOE811Ml5SSAOLQDWJD6Ijcg1Vn3tdxn2DruCn+HmKHZdEVvPjfdb8AintdCRux+3GJjshEkf6dF6u/MArXkV43wpz2JVzQJLofXiI/OkJeCSGO0OmmqDSkOiQwCycHW/dKRl07RFlDE2MH5CJkccQjaN6FGKvREE+YBLuwW2icIiTREBUSKbo5CaYilqhWSRAUc43PVz2F0S2OJUieYx+FBLsRxcKLAtV1J6eQrIAJ2Tqtd6pZ2Dup0Gy9zr4aOglgkWC8SKd4+CY6nWVxJAtuC9DJvVHNI015aWynYPv1+y2bqdKnO+brlunuIeQL08zUtly3ldf9zP3r12yGT9YW/GUYfMP3G7/rInU6nfgbf+NvfHj7137t1/irf/Wv8vHHH/PjP/7j/Lv/7r/Lf/qf/qf8wT/4Bz9Q0L/xjW98YAD+k//kP8m/8C/8C/yb/+a/yX/1X/1X1Fr583/+z/OzP/uz/1DMvhu+H1h3LnSu85X9Yc9xd+X5+cDusGd3PLPbP3M67Tker+z2Jw6nM9PlwnSdma4h5K3d6K2u+RPhFgdx166eQ4ib4hAvmkLvE41KPIb1DYTUhSQx/kMTKgm3l24qCAnBUouDxlxIplRpIdJdnRasNyDGUapB1zZjZaG99B8xknNpYBpjyVyi6Livuiwh+xKjq1UsGzsVBVG6hyNGliB5YBYiWOnhuq4RmWEWJIpgFTrJYwMn7kiXGBdqUPxdogBIr/SU151OfJ/cYFGJrgpZu1Nb9UoxO4ybAsG0x3Wu49Rmgqfg95E09l4udBVKykCny0K2HOSQQVFzRBVJyhgzU5AX0oXE81Kn96Cq45VmiVQTWSpimd6N2WLc2lKHrqQuOEsozSxTvZF9wjV0aHTBJK22WDEi9aarn+PIvCTmeWHcLExL5dU0Mz1Eptg0nbnM95zvG5f6wEdz5/4V3D9sKGkMPZskbl3V9xe/6yL1v/1v/xv/3D/3z314+2VX9Gf+zJ/hL//lv8x/+B/+h5zPZ/7cn/tz7HY7/tl/9p/lF3/xFz9opAD+m//mv+HP//k/zz//z//zqCp/6k/9Kf7SX/pL34Wnc8N3He44ldYW6vnM+/2O98cDp+c973cnjrsTj7szh9OO6/GJ02nmcFq4TqcgRkyVNl/xFoUAOr3bGvWw+rNKFCEXIyUYPHZNaS1ULkIKR571D0geh6LpOoLDVoqz8XIPb15BhnA3N6dJAxO6rbRwgjEY5cBpLWZ57g2zimt48JmtGicMXT+2txmIzklkpZbjqxdgA9WIx+jhSGFmSIoxIxKjwiSr36ysVkQdIkDxO3fxvnZUgkCToH0TWiPVlSJuGixIXgq/xL6rhcuFrP7uJkIYZDTchSoWxAjzuBnwhFsjDGkTTRzDqZbBFC2+7tXCUqqqUzVsjpIGmUL4jgbNxVbLJyOJYmI0dcSicKkLZKO74N1ZrKB2pTYDg5wca07rmfSirZLVMqqv40o3XCpiZR3jLpB1fVyMaJfZGOdGq5V52jDPNWJfppHTpfLwenUyuZy4TgutDrzafsJwX5D0aq1Rt0L1/cLvSyf1/cJNJ/W9wCoO9cp8PrE7H9nvJ573B54OO4679zzvzuwuZ/bHE6f3O67XM9fzhdOlUueFZY3M6N3p3RALLUxbBabqjqijKYXLA0pSXbsmSCphBbQO8LKOq7jJg2KnGTQFC9B7jInEwAtmPQ5zVaT1VarTcRtw73Ra0OZlVXj12Pd8oJNbxjQID2KGr7us2Mf1CEBUiVHUyqaLyJHYyWTVCA0kgXm4pnsUwyB39HUU6EF990j0dbG1V9Rg3K2WR+YvbMUoTqEtCoq9anjlRUBiX/ViOYgWSBAZJB6T1iRgIUV6sIQPIWvHEFPR+MyIrfZLGh1FCuahSrhduCg5QdIRTSvT0g3NkFJGPcWuKUOyhLrQFKQr3eoLnQ8XjRuXBotXeluNgg16C8ZnswWzFN8e73jXNfY+RMopybotkxBeJ4GUyLlQsjAMI7kMbO8G7u62PNzfc7/Z8vAwcv/wmrevH3h4/cD967d8+aM7Prm/59XrNwyvHkh5XPegt0L13cT3RSd1ww8LPO5QbeFy2rPfn3g87Hh+3nF4PvK4O3M8HdnvdjxfJk7HI6f9wjKduFyuTM2w5RoHT1+FrG4knC4KEp50CUGTkxTSGnOhKoiPqNRwbEhBO8/u4Uougqihnlcdz0oPd8F9PeyoiPbollpdD+8obv4ykvMe2iUi4r07QaTQNdAPQ7rTNV4PMYISvoYMYglZF/4vg8hg48mHG+/kqyHrquHydfwoEp2KrSM9fCBJx8TRrEHNNgthsFq8XtaxFEQI8TBxNWEVw/KBdh5C4nXcKY5gqOiqLeuRGOXBEHQ04u4lSBkisSPr9NVhI8aJpj12Uev1WwrNk2NgQtOF1OL5QFD7u1mMY31A1tGfS4iGNSvZ4rUPwspqmluM0hs1KbUPdIsdVjMn9Q29B/GkWZjZ2trFdjese+irJIXLxSonaKb0pvQ+k9qCtYGlNZY6M21eU/tENaP1ialNtH6l+5dYLp15XnhVlc3dwri9R1O5JQN/H3ArUjf8XXCcuR457q8cng/sjs887554PpzY7U487k7s9wdOpyPn85XLaeZ0OtGWmbkutLYWub6OsFa6sq8ZTSkpw3qH/uI/J6JIhrIu2EOgm8gShrEqsSRPLayQRBvNOt35UGDc0zpyM+i2FgWle3Qi3nvEstsag2SxnMfWDgcNAbEA0uJzrZ2MrIcpq64oiB1rl7c6kZtr6Jc0feiczKJTEWlB4/ZgJBoahq4axdDW+Hi1dcy3jjFDryW4rgGJkmMn5bHHE/V1PEjs2kiIF1LqNGsRprjuyTpBMhGMZtGVyTrSw1vQwyU6qJVgjpqTU0SF4HEtag1ZdWZLFzQnPK2x80nQGbI6lh3RHCJhsSCyiGHaGbKs7Mew7NVBYzyrm2AG9pAl1NTILlgzlm70ntC2RPFaqfJ9jQ8OAoquXbO/kBEp2ql0mme8VXrv2NKxWag2cF061/kVl6osi3NelPnuylTv+Lgt3N2/5qO3jfuHOzy9RIHcdlXfK9yK1A0rfNWrXLguzvPukf3nM7vzM7vdM7vDE7unK8/7HU+7E6frlcvxzPly4npttOlCr5XeOmZrUZDgW4SFj6IpggGzQlrHS4MqJQmqEs7lEhEU4kPsrHw9gJPG2FCicFRXWgfoYFC7Y9KQ3kNIuzo1NDPEIyvqRW9k6/N9IT285DjFzklWZpujiTBH9ZfHrwlLKqtsOA7tGILF6DJo8+uAUgtRJlt0K+qrviitzDnHLeEphSXTmoOk6x4OWM9BXZ/Dmknlcfg76+fUFxPXdSJlgpOiOyPFTktij+SuILIGLDpIjC5VIy1Y6XSJbs5cMYLNyUsBlGFlLfoH8XBnpq3hh9ohk7EUxTzliZRT3EzIyFg7mmFBSKKklEn2cuEDafX2600YeqJZYukZS0aqnSaGqrG4o7XTOiRbcEnr92eNFIlvKEnmKGK9oNao2eiu9B7Sg2YLy9yo80JbGm2aWOaGvx6o7RWtzrxaKq13aI3h1UgZHhDSrUZ9j3ArUj/yWHdPGK1dOJ8WnnY73h8+5/j+zH635/PjgcNhz3534Lg/cjxeOF0uXK8L1/MFb0br4UfnvWKSYaUhu8ZSXjVTSlC+M4kkhuYcoz5hdQ1n9dWL2HS8I9JRL3G3L0bvjtuaHWWrg8S6IHfCocGqgzUaEROhEmanYe0a5A1bbSzUFbeVlRERvuv7g6zRIRge3iFF7lT3GkxCXaMwVuJEspcuz0gfaIlOYgCJziv2URrpuilErDkFDR5fx57+kt0U2icwtBsumXBMF9xe9k8aol0rdNqaGBz0dO9DjOcQrK9UegeQD4LdoHdbdGy68vAljHKzx8gQj32XrKw+9YRZuCB26UjzdZcVx0ldxbuokaxRrESMSFdMhdwVyZ2cc8gPBHJJqNyRfKave0rrldyV4spcBU0Lah2WkeRKZUFTw3qhdaOvXoHa1+Wn9NCcdV39FeMaXlKPIdzYhxqhmUtvXOo9S51pyx3n2WjLwlydumTaInyyNO5fZ/I2ntNNU/WPHrci9SONF8dyY54Xzocdu/2Z90/PfL4/cnzesds983TYsT9cOBwvXE9HTqcr18uFZTZa65gtEYfQC5F1BF0suqUUkRZJEkUGXI1EXyMvgmCQNJHUY5QlYJrjul5EvRbEi+7hjt09xl3NWId0jmsPI9QuawcgiFZccuxY9OUuO/PBNZbYW4muxAAUssV4SR33RM5KTpneJsxCnJtE8RTuC05kP7koKXdUV2uhFA7r0UGWtYOLAqYCWV987sL+KK3aI1k7MethT6TidEuoGWhHNZ5bq0EEeaF3Gzlcx9F1d9RxoHXBfEJMsZdi7uvzBhSn+lokk65u5WFylF72XO5BWBBBu0bttVCkxR4qWJO+2iS5NrIlksXXm1uj5BJ7wuT05CTX1aEiyDAjQkqX2MlpIblhkvAcHZEmY6mFZAODJFp3qji1Q2sZ1Ur3tI6aWzxHA5F4NtgqWfCON2jFEOs0j26sudKqYUuD1llq521dwD5iMmWZwOsV6lsuS+X1xzMPd/eQtrdC9Y8YtyL1Iwx3cLtyvp7Y7S9c9zs+3Z14fD5wfHri6XnP8/7E8XDmcDxyPJ+YLlcu14W2LPROdDW2Uq9XmjMoWUGTonRyjoM9uQV7L2VUMkUFTTFqMmK89kJHj24hxnVmsHTo1NWqCJrzISdocYEexq62CnXdw1EiC8EGo6yU7ciRUtNYZrHeWWvYA7lKWPokRTO83m75KBW+fRJqrfGaJV/3TOGEnhKknBhTCmdyCqrKkMKpPCPgie5GU0FtIKUQHisLbRXmjsmZPZ570ob0jK10hzDwLSv1PqPaUcnhVS6hOTJbHTnWkMYksWNbPMf+zoRmCj5TXakGtE7qwb5zWlAZLK/7wx46MxGyCpZWtuEagugSJI7wGiwgGaWCG73PQMJ1DI/C3pEsoY3qKSjrpnQqOTuzCSlVFjJjlpftEiopujBxkirVwXti6U5etpSqNF1FvL1TCePc2tddpQtOR62uXWkIxb0bKguyKF2jm/a60HuhArV1rF9pJvTaSA8Xut2z1MrG75hlxltjvINxvLsR//4R4lakfkTh3mm1cjpOHA5PvH8883w8sH868n7/zPF5z/P+yPPhsJIjLlwuF+brTGsL3toaQbEy5zQW86qQFLImcoI1VJ1Ro/PQJNEhaAQQysrEkhTu2xAHWYwPhbYKRmOHAIiy9IqY0cRJFoauAnST2E0Ety1YcKy5UEpEXKghlqMgJcUkOpYyJLZlCymFLip1tnnkTgrHZcGzktIY2q0i5BR2RVkTZS3KhUxzYw46IVM1VBrWBZhp6929+bTm8WYGaYzqWDY+TsJ1SlQzyHGQ1hZRIqPDxVYNWF5fOwtXi0jGlbVgSrzuIhTJdILEMSYlm5AzJO6YXajiLM1YWsW6sZhhrb/ogVe69+pzaBb7QekhA3gZKRK6L7F4ru6rWkuVKob2GunFKGoRLrkkiYTk3kLsa4LkSjahmDAXQ1Xi5ob43kHEjEiLbi0lp6mxDJDqiLcZbR3XSmrgTUk9LLF6tzUqpaMq9B5Ei+5KppIUFg82YXOjd6HXSqsDvWXq0rgud3zSHZrwyjvSBFmU+9b46FUnb+6D/HPrqL7ruBWpHymEBsi9Y0tjf3zi+XHPbvfI+8OJw+OJp/2Ox8MT+92Zw+7C8bxjmiYurTJPC7026A1zC+dqD887cUjJKJLJScmakQyZzpA0upeUKaq4egg/U4qd0Oos0b2yeI+7/3WxbW7hD9czHbC2YFaJuWAwu8J0Ne76ffV1i/DClaDgCVUPXZV0hNjBKIVN2fDR28J9eWA2kCQ85MSwVaZmPO1PtCS8utswpAwyIOaUSOej9XAVX5rjfaHjtN7wDtXa6jeX8FoxcXqPgxKL42xR56JwX4R3fWSrxifbxEMS3l2Eukm8KcpgcGrGqEJKjUZlf+2clyhOpsGCy+a8LpltTpz6lann6DJwtBGpvMlQzWRVxqFAKUCEGFZfEDeuy0KribkL5j26UW+YpXBzdw125gdXegeLaHl1p3l0LSEg7iQlHEBedokS3aqoMWZQL/SuWFLUGikXrDs5G54jNbgj68+UQHPSUMlWqLqgaUNNCykpCwmk0oQYk36wwXK6G12UhIVziKxWUl3oBi4D1iekV7w7bkdarbQ+0fvC3BpTNVq11TOwkqqy/cTZlILq9rd1VbeC9d3ArUj9qMEnluXC6Wnm27tHnp6eOT6eeHd8z2l35PC84/G453A8cT5OXM4T89zDd69PuKWVjhy2OqpBOtCUKNpjvySQEwwiuISYUlIsw4c1rVZXa55OjGQaMaoxnGY9dkvW6HRac6qvO5DumMdoSgladnaPjsF7uD3ISvOWD4mFcZh+GF+Fdml7N/KNTz7m4WHL0/nMdK547zQZeNs3bEvhbrNBL0ahIV6p7ci1d47B2qC31YNQQJpR18yJcIpwso6oOqbO3PtK9ujgwpDg7Sbzdhz4yr3xk68K/883mbdZ6NX5jQnutgMfp5G5TnxWG18eEx+lzOfXhb/6dGEx5Q++KlyTsJud35gq//R94f/9JvOrs/Gt2pmrMs/OpXZKch4Go9KZXTjRODfnWoVBnVcpsfGRfRmpzZkFaJWlXpm60C1jfQ5mZRgCBiOeyPVSsxdSOUZbnfvCfPaFTIMvpOR0Xwk2JuQuWA6NmnommeIaHVB4RgXRQjTFbjB1RHR1jS9kdSYVMh3xcKhoc3TdsMVsotsqUm79Q8dtawik9h55YbNgBUQSi3n4TC5O9xiXVivUptRuTH2hNsNq456J1/evuHslqA6/w43/ht8fbkXqRwTujnnlMl3Y7w48P+55f9jz+P7E8+6J3fOO/fHA9XnP/nDmeL5ynS9Ml4llAawBsX9SSyEeLREYWFLseZIkhhRaJ02xS8gpkxIUkViIrzsrU/vANKtEmkTvYfHTLOItKo51obUWjgsWQzLMEUp46a0jwvzypyhdg7RQZI0wVMXJmHo4Loigmzs+fniFZuWaOmW74a5WvCvajOlcSaMzChzbnutKd8Z6jILEUYsA+M2mMIgzdUgY25x5XZykncXhrgyghf3ligDbQSgIrwbjD9zd8U+8Eb48Ol8ZCl96NQDO+7nzx15nPhqc2RceF/iqj2wH5epGScJPjSMbhT94N5Jz4m9fZ54W+Mlx4Eujs9tHbtXbNxkxZbJGU2dMwrXBoUEZ4OTKXY0bj29X51unypey8jhDIbEZB6onzIzanEstXJYG5itxJhZAvgqHgxq/5nUJOIUkDVtfL9Yx8UsKcWvhvZfX5N/kHbGZXjZ4rXRXNk1WqnyjpEgmzgieoktu6mxVaFJRzSFREKM0mJOxtBKElNbRtFLU6UH4MCD3YP9R8UWpHiNIVs9Fsy1WO70tWJuwumDV6a3jtTIb0IJBuLl/TUm36I/vFm5F6kcA7obZlet1x/75xOfvjzzuHnl+3vP4+DmP+2mll185Xs5czicul4k2VWprcXdrhrkifbXVSYKkSLhN4qQUB3VWJZdMWQ+PlAQkh+Yp64eDwlaXhtahWcPFqd3pLd7ua3jg0hveV+3MSh9XFE8t7IPsxUI2QVJsje6gFzwJIn1N01jtejSTNJPHYI5lFj6pmZw3fDpUTpc93WLn5MvE9bywXCe6NazJ6pjRg5VYIhlxMyTepk4fhPuc+dJ9YTuGI3hvzkcl2H/1zZZPijKo8LQk3uTG65RwU/6/u4nPhsY3PfGV7HzrWvl07jwU+GfeKHdauE9CKc6hOTUr92XLu3nm3Wx8VISv3BV+4k4ZGHg8Tfz/DpX7nOg+MpM51hoGu6Js1cliZMm8UaXT2Gjix+/hGxtI5vy1U+fXjxNDGbgbRuY50XDejoXZYDbluixc60Rvjdqg94aZhduGr7lPCvLC+nxJsFxHg+IlXK6k4U2o2qIL0s7UjTEN5JboSRmtk9KAZdiURE85fvYQsiZsVGZNlGwsJtQUeyXpji4Rbd9cyCLxc2UWo0xJIVQmHEncUowKPVzoJ1tlYi5Yn0Nf1RrGxMIn0GCiIr3BAv2jypvXH0EZvsMaveH3jFuR+qFG7AC6Xzmc9+ze73neP/P5+yO73Z7984H3+zP75xP7/Z7DaeJ6uTJNJ9rc41DuCaOuaRORcJvUSbmQUsz2Swq9SEkp9k+jkiWHz5sapExZ3VQrkRTbPQLxWpd19t9p7jRffdqaYn3dJ/TIlFILASji9MhRD50QtgYPyuoWkYPu/KLP0sKQB3RQxhGKFsacKGK0qfLr14qyQwSmDq9KhqnxW3VmuXbUjdwdl87dkHgYC3eDk1LmLmUeRmXuzijKQ3L+8XvhrJlTTdCNN0nZqHMnyuDOb1XnsVckKYel8zg1dnPj3Si8mxvbDt9eZp6q8MkWxl7YqnG/GfjKAoMn7rpwdOdvn2A/T/yB64YfG5Qjxtln/tah8TYpP7YdcTqPbSUFKDQyo1RKGli68So75y4819gdzRXK4PzTH2f+H29hVuXjkvj8tPDXz85PbjIHzTxfhOuiNCtcauOyOHOdqTWIGNSwf4LI8zKzEDpLC4GtEw670oPIYgXvNX4WNJGtQXJaygwlHMlVGnkJU2AMhpRizJhSdH3ZqCnYimNWaipodZIYS1OQSq1OEaeuI2VHwBriimj8XPnSSVmZXdYx8gRmLH1ktjOLr275LUPtVG/QFVsac/8IgFev7kjDA0JZG6pbV/V7wa1I/dDCY1HczxyOew77Zz5/v2e3f+Lx6cDz+z2f7/Ycjyf2pyPHw4XreWaer9RlXt2nw2ImQunCcy6tHdKQjCElPGWyCEMmNEWSKFoQhUyBHFobEw0KdK+r5FZpvdGrY2Z0MXqzeF/vYau0HmKCI2vgYFCRib2WOSmtYuHV4aKvgtmUNYpmKWzGwpAzSTLJKzk1knemyTkvE1N1hMpmHLjbPuC9MfU9dyKkIiTvjBvnbhReD8p9TgyjkLKG9U6HuzXTKiVnvxgiV1pXpG94rDPJjbcu7KrzVJVjr0wX5bMJnnuntc7r0vk0L6hDtc7JYD85x2Pn6s5DSbwdE0MSmjlvx0ySDX/zNPNr+xPVjGNt4JmU4f/1euC1Nj53490ifH0UJBVkELY581AyZpXalffVuHTnTjPdFmo1VIw3JfFaOtVmvrw1fvJO+WSbOIvxq8fO33w2Wip8JPf4DIe+4TRHLMb1OlNrQxqr80aY/uKJogI0lBjvYiEoN7GIJKHRejiU9PQSUtmgGTmNGJCTheO5DuRs5BTf99g7ZaqAj51NamGCuwrHk3Z6E7R3phaJ0HgDhP6hq0qIOdZjxyU4uFGACcXliPUaj/GF7m21tF9oWZDUwRoPb0byEOPpwK1Q/W5xK1I/rPAeDhK7K/vdjsfnHZ89nnh+vvL504Hj44nn44HT6cLxdOJymqjXytRqBAO+OI0Tya26im4lKaPCUCIrKK0jtBK+sbGHWJ2nw5+o0rqvGqYeTtYreaD1HrTf5pgFY7Bb7KFk9ZYLFlkYiSaV1SYvURQ8WeiyJIxoAUZRUh4Ztpm7QXg1ZgYdaL1i7cB5MS50XmnmQZ3Zexx8g/CwUb561zjPja+WkaHAaXaWxRmSMGwgawhE1Q1pznXpnJZwncgSu5LfbIb0Rqdw7VcajT4HKWPpibMFI7G70LoFg7ErV4XHHBY/hczcG4bzN5nBFKOTJEWRFShj5tXQucyNa13FzNZxaWgu7KaZb50azWHfE7s7YdgKVQdeD8Ino7HBuUsLrQpbFVwq3ZxpVgaBJSnnHESB3jsH6zziqEZh/sdfN1Iy8Ma83XBl4Ft75VS23A2NaZqZW+PaJuoM9PSSZIiQo5GSILvEQNfAotMOp48Xf76ON0dKJ2fopgzJ6S2h2XDPmCWGYmRNSE6UnnHtIDVE1RqdIrKs9koxiutUmiveWyxHfXX2IMS/qEaKcBeMZXWWT7B0evdIl1463TqzQ/WG9Ssub3ET7l/fU7b3qGz+fr+tN/zf4FakftjgkTc0LQun446nxwOPT4+8ezzw/vmZ58cnng9nLoc9p92Ow1KZTgvLVLGlIrZSuSOIKBhqCYoksipSYNDCpnSSOJI13CM0RnGSo6Cxug80d7qFu0D1SrXgYFSvtN5i8f7ilu6KeMPESKQ4oxDU1/2T5JUVmEJUKxHtEYVSyHnDMAivhpGPi6Jj5j47l9Y4Xxe0VcwaCIwCHxfhLieOgzGUzKuHxMMmdkY0J3swFHUQmgmX2ShrBMciRjNnWuD9XGPRzgxduPRKreAE4cNJQb0mbHvMB0wSya/UcHsCb0zixAIn9iEhQo4oC6EiSHjWpXDIlfnKPnW6ARYuhEnCUsqb8+1qPF6DYp2ysBsGvmn3/Oq7Z8asfPnhHl0WsldebTI/8fHA1wbnHcJuhvs0sEnKvRrnAk+WqWb0CpuVel6SMmp8rzdp5t6VwxAi6buNch1Hsm251A2768Q0d5a20CO2itCxvcgYonOX1cDK1tys1B0zgZRJQOsNa4mWhZw7A0skiFnwCl0LOUFOPUxwUapmNAkpGyndMy9LCI610BWkaUiZm2M01C1CLYkbrwionLA60GnQB0DopwtiITnoOL0rqb8Jh3yJnyOTxv2Q2KRC+B/euqnfDW5F6ocMRqNPB56frzw+P/P+cOD56cTu+Zn3nz+x3z+zP5x5Oh6Zj1cu80yfe8S6W/tAjxYvkc+jMUJRhJKVoRQ0RXEoKa/kiIwmxaVHNpQFtXz2jrew7Wmra8Rijd4JJ4kWOhPrjnuOOHQxlIIkW+MxcsRRAGFbFE4TIpkhKylnxjGzHTLbYeTN6GxEGayT/Uwx5zQ3tDY0Vb5WwgkiZ+ftRvi4JH5rAlR5k4Mw0My5NOfUEm2pNAuBanc4mXPpjhpc+sK8KLO1eO3d8RaHFZKiMwRU1jv0NYjP/YJKXsdb4SMXx9bqmq5KsxpvuwBrICSKeqeKkFktjnqnrf4MIkSxtAoqdFdmc9SNwZUv95HHa2J/6RTtXLrRp0rzhbtkTBW+vdXIfTKjAtMsvBkTX38lfOX1wPsrXLQwu9OXCrVheUYYgUg3/uZD4w/0ON5/Y8mcWqf0kc04sizGYb4yzwvXZaFXwzsrgaEhksKPkY5awjA6HdFEtZluBdKMmzJ4DoPebtiglBTOEVag28hSnI06qs5omZYinVnHjmqhz4qzUEk4E1BoUpHVF7F7ITt4b7gKFjYnGKHlc9IqFDaaG4uF80V3Z+lb3BO1xc8EmsmvIA/3uJSb6Pd3gVuR+qHA6mBO57JMHJ4vPL/f8+55z/v9pzy9P7J72vP8vGN/vLDbHzhfLtRrZa4LVmPW31e3AAU0L2QpaCpscxjClpK4ywnJUaBK0tUQtiAptg6R+Npp1mk1tCXdoLVK7R4jvt6oK1mimwcV3fuH8L240dQIzBNFyIi0sDKSjKRGHjLjUHjYDLzZbHk7OA85luLvL2fcG/cZPrLERwNsVUll4KOceRBnJhwnXo/CuTuXnrlY3OWfp8axNnqLmPH94jQJa6K2caaL0pvQm+HqK5s5ymjEXgjtRTTcFVs7P4EIYRQLWrOk1btHMCCp8urVHQ+vXnPaHzgdryQx2sqW7i87ub4OxtZvlgrfcXOnxmvn0apYUzQpden8zffP4aDeKk2F6/wY9lHuLNr5/ywzOQsihW3pPJTGJmc+2hg/Lhu+8ZEwaGXozlULO98y6JF9jVHdQ1ZGKTSW1YEDfmLTMG/sW+c3JeOW+Vp+oG2d52niPFVqnVmWirVldWkPrdRLQrBrj0RgBG8z3hMtKd58ZWxGzEcrSrPG4JWkRu4D4cmr5JwoHdogqIVpRpWENydJI8lABmaPz0GNWBcsEpnF4nuazEhLopfMMi8xIrRw0+9NYmrQO+r3JE3UNdNrlkLrwscfKXkQIN86qn9I3IrUDwWcTudyPbI/PPL+/YHnx2d2uyOPTzseH0/sdjsOxxPH/YnpdKJOkZzrZtDCCw9hZc9J5DytbL1hUIoIpSRyUiQliiqpFERz/JJKpMvWVmkt4b5QW6N3obaY19faWWyhmSM9It093FnxtI74Pni2Oa5C9k63StIBGYWSE8Ow4dW28NHdwMNQeCNXtslQnbi0+Lzb7LzKiS9v4OuvN1xb4wIUcV6LgQy8W5znCocqzMvEZM61G7uTc1wqswmtwdINM8NI9KsEDd9WRqFFp2MfDHHDtFU8Co8QOyeBNdMqos1RcKuIrQUqqIh8/PaBL79+w29eO2cumNn6LQ6LJ38xZpVgW6rbSjIJEsHdwz3WO9errVyAjuRMsso8v+iTBDSsqtqaw5TUWZYWVH1pQTxRJ8nMWBLTsOHSMqmfuFSn4Jx0G9qrWinZuSYhuTNZ6Lju88JWlZyEj0tFabxPwmWJOPovly2vtxsus7I7K9OSo2vpYYCbCL898zDYbd4/pBrXnmhSSVaRPNAEhm70pLhtyXnGUwdXJEcYYlajyEjvDS8NSRUpJbrQFMXQu4ZrurewiXILPZxEjFcEYjrqjZYjvqTP0KVBjxuuJB6RKjxSvTN358uWkXRlpLN5M7PZvAW/sf7+YXArUj/giF1H5zo9c3p+5OnxyPunPU9P7/l8d+T56cjT8zPH/ZHTYeJyOXK9zrSlxjI64mHDZJWIIk9ZKJoYUmZTElIKg0LKmSEnWFl8rHezXSLwrjYBq2EA2ztLdcwqS/PI6vEYpXWPwyyC6YKYgefVUbzDegCLx4EuhSiWm8LDNvHR9oE3Y+b10Ch65I5wRc8Kd9vIq3olThqUL22Ub9wr3QufXRdqB5XC1DupGe+v8HyF49V5nsPy5ri02L2YrtZPa7djtnpiWBxYskZ9ILhVPpABPPRc7lHYNhLpwtVf7rrXUCsXGqvruYJZ59e//chvfXZgWaZVcBoHoeZwUVg8YufdenRx6EouSWyHxD/z499gf5n4//7GO2qrQT5ovjZ6HnfvHjGOc6+x81pdORzFm1HUaZZZiII71c5f+809v5Z3jBId06BgaQbNfHnMjHmkd/jsOlGtM6TEZ97YIHxphNcPIw/ZeVWcebNw7onj5DxlZdAH7jdvOE0ndtcLTI3WLIx0+1rota5uFeAu4DOu0Ej4MoUnYkqYdtyujGWDZMdEyb6mGSeh5Og4c054F8SdPHamtJBly9I60zJT88Bgne4TjY71HMygdQQr1kiSw2LJFsxyjKddEMk4e9yWcKlvjpqH+bBnPpGGeGbcbBE2txr1D8CtSP0Aw9fD6jqdODzNvH+e+PzpxNPTjndPJ/a7HfvDkcPhyPl04ny5slwrdQktyos9DDRQDYFq9tj1pETJhc2QES2UlMnFUdGgMUdNw1MLI9im9N5pPWbw16XTutFaozs0b7GzcUg0hEySHlRfidFesPTCkUAs9k1lVMas3I2ZT+63fLQN26CiF4yFryRh8sSolS/fDQiNT4ryNEVA3jZlPpsq1yUKw1SNd7XzPMHhuvCuwnV2LkvlVJW6OE1e4j4IE1UPA9U1ypA1AyIID+GvsBb5lQsQDqsRhiiOpcY3x4HfXIzavpNfJUT0RkS1h7vF0oIIkUUYktJQGpDLQC4ZXSZ8CTKLCWgWtsPI18rAt6eFv/XuHd4LSZWWyodOqxuICmXdi23VmVxhTSK+S9FVTZ6iK/QaxVac1pTn/RVJRiLGa5s1UuNuaFwGg2MQaXISPr7PoCPvjyc+r43nKfN1W/hkFLYbuMvCXYFXWXhd4TnPXNrAfXrg7bhlt8zsLwvLdab5jJmjXlgt2D8QeszDhULcsXYFtswtxOvVOqMVBhlomui+MPqASKdIaOVMheDwXSEN4YaihoiStbF0p8kmOjsaLw4VkbK8FssW0wBzpUqj2xxOhnIfMgvOkdmVI94luZC6kn1EUmEY6uqXchP8/v1wK1I/0DCu1zPP+z3vn5/5/P0j798/8/nuHYfnE4fDgefDleP+zPV6YZprpOfWOLgEjVHUGoNQkpByYijKmAolJ1IqlKyUrGuiLjS1cAlwaOYs1ai90xrUZtTu1NrpNgfpwIIcwRqv7hK7rCSKaVQ7EUWx8GJLmVIKZVTutoWPNlvebIWPBxhSI1lloIeRrCZeAynB66IUyRRpFIG5O3/jOHO8dgaEbs7fOhvPk9GWxrw4zy2cLsxrdE4udAwsCijIyjYEtdj9uEMNK1vcKyrhIWirqapKuHjHYRpvf+qKSYnMKQ+Gl1piLIlP7u94bAtjhtnBrj1GXIOQtwnvcJ8y3/jGV3l/Mfaffboy3Tp/8Mc+xvLIb70/Qp3ZXWeszpTk+CB4W1mTySibRNbM5Vq59vDvaETM+rmH32FKSklByuht7RvNUDJCpnljzM65ErlNesexd1pd2GjnbkykrHxUTmSfeCvhZP/tvfFYjNfbxJfvNzxsnFE6223j9QCfVmM/FQYtfClvuCtb9uXCZVKmZaEtPbrWNYIlfoZebg4EvGF9wcSRlmJ8akanMSo4OSLmJYGWyMzScBiUMjD2Fl2m9tWhPyOzgffIzFKhLWvApiXUOj31eAVTCT/JWVFfYpfl4F1xawzuSBKKwZMZshrpvtXOx/dvSNsR0e2HG50bfiduReoHErEDWa5Hds/v2O13fP604/3Tjs+fnnnaXdg9n9gdT5wPRy6nK3WemWsPQeRLKqnLB+uikpUhKWPK5KyUPDBmoWShlEzOmYJG7Lcri3eWHrY/fRGW1Vw1hMDB4Ku9rQ7aOfQubqhq0ISTgepKLRcy4aotxSml8HC35c0m86W7wuvSuUsLZehocx5KvAZbEd6O8XGXmkID1Rrn2njsSlqEb5/CCWHpjbk1fusC82LMLQI9ag/z09gaCWoeBqlSMMIFI2j9KYxpbQHCs9DVuduOlDJwvc50i/yjlCK6/mUflSS8C3XISFK0gawmpHmE+1dbSt/wtRGeSTwfo7gXTdxnOHdHVKjXytgaH9+NDJrxBHee2Gyc4+vGkB/Q7uz2R5orG7cgwkimZ3j98R3/xNu3/NW/8452XWje2YpyVxKokorQJPNQEofTzNEn6EGlzmNmUwauS+XH3t7x6dzw60Sy0HrNrSMaX++tDbhXDnMiGZRk1Gg6mGtlWRJffz2ieaGIsc2Fbw7Gl8rE+2nmMGc6A196yNTNW57mM6fLRJvBesV1XneCqzegO2IZ0yCTuFeyJFrNDG6QZyozvd+Hrmkw+hCHX9LYx0HIGzai68+pIQwkqWiHWSJ/rBP+jqGh8u9EpXgFM3JNVBHUY+qgVHYWP6O5eWjZcqLvHddGInFXnG1JIOP6+32b//123IrUDxzCX2xazhz3O94/PbN73vP4+Mi7x3AxP+52nA4nzocT02Wizgu9LagRoXfETiKrkLKQByhZ2aTMMAykHLqolAtlWPVPuqb4irF0o1Zfc4g6dfXYa1VpvVJ7wy3yoDAhaUdE8CRrNEcw+YLN53HXmp1SMsMm8fr+gU+GgU8G4yE3is7cmeHN2A7CPzYIh/ZCWQ+/tl1r/J1Lp7bGJkzi2FXYTc7TZeFaO1N1zg1qN1oLp3I+jPAEX93YxWX1CSTuuP0l9j2hKVhZIo5k+PpX3zKMH/Gt3/wN+hLhjuP9iHtB+xUTp0hGs+CrQ7x0R0pogVzg8Vpx4NgctRoMx2SYC0sKM19bOvvDniSCaA6iixvf2p9gn+lEd4Aob958QqMi1YN9ljLuRhnuoTzwpY9mpu3MNM2QEz/29g2f3I8ca+dpOvOl+3vGzZnjt2fEUzh91MgPC413500a2PuFz69HXvwk3GFy+PWnHfOY2V1j3DuWzqusbMZMyco0GX+7Try9E4Zc6Nl5NXbuRuXH7gvXYnz7OnOuMJRMHt7yUCZO04XTZPRW6M1iFGsxTsUL4itTlOjuVVtkbvVG9nVs5x3RzKQLQw/R81AUUaVo5KGJbqHNqIXFki2KLw0dOrVlKr6SVYKAQreIv/ExOtMKVRyfT7hvwwIqdbo3ZgErwb7Upphv+Nid8nZDHuzmnv73wK1I/QAhfv+c6Vp5PlzZPT7y+Hjk8/2Rx92Jw/Mzh92e592B0/nM5bpQpx7ZN239hbZEkg45kwSGnMgpMwyFnAqlOHd5iI5nyJRU4gDXKEatN6YFanVaW+i90xejrbEF3QyzUOQrhidABvCI5xDJUbRWtpqpknNmuM+82mz4+K7wpc09D+nCVhYGNbYJ1JwiiXt1SMpWlN1FeX+deJyF3o3RhGTOVY1zGrh0eHe58Hydw2Our8GIQQYP+ruEe3d3R6ysr7OzUhpCJKoxiMlq0U1hSIIhDfSpstiRTSr4NrrDIYVjguSR4v5hUeUWdkaigjZjEUddYldHwtVQS8T9+cog7EajQzVIUSzFl3ByJ8ZIiK8ehiFqfniTuc4xjktpXMXPEVy4e96zJUglD+UjdBzZ3kVsyOFa6alQXr3m3jfcbS60+Rrmse4stWIOf/tgbOXKxTxeH7FwM+8d6Z2Dw/nagxDiiUWU7sKhzWxS581YGLxwmEfE73h33vGVDXzyeuRhA9tsfPNeOLXO52enqvFqzNyXtzxsL+zPFy7zgk1GT4b6WrSbBR3fEi4VN6d6QnG8Znq/0twxGyj9Di9G9oS7xvRADNVC0Y6wpW+EuqqOk1yYdUA8OqgYYwPd6GRUOtgMlPCVVKOyegP6jKhG+KYkSnIyBbU9KomMsPUD9x9nUslrobp1Uy+4FakfGMTY6bycOTw+8fh05PHpuI753rN7PvF82HM4HjldrlwuV5ap0mpk/4jHYVLSqt4XQjsyDAw5M6aRYciMg0XUxhDdVBFYXKiWac2CVr606JyaYM2ovbFUiRwob7iVyG96OUh5WdorSQTXASM8+MqYudve8fbthq+NidcJtrLnLk+kDmrCKMRYUmAgcV0S+9b5tb3xG+fOoMIbcZrDc4d3U+eqI+Lw2clYFlmdHiI9WKStOyH/sEsS9w9s4CSCszpZEGw4J1JtkcSw2kMNKixVSTZTilJtTRZufe3SNDzd4uXGWgiD3RSxiS7x6og33IO4oCKIx64oAbPKh+9XXF4UVVRXJllBxEAyCWMshfHjgVoVr85kHZWOJigoJ5ycHUh0caRNnI+VU0qMmnkoSplPvN0mvvzjX+U6TZw+faS2BDaFeLV3Lr3TRdAEbsZGhMmDHXpfCpNn6jyFQ4gbU1W6KydxLh0+GY2hz9zfbVjmkV87XXg3N772Rvn665GchVeyMNxVvtaNz6pxqImHPHJfMs9TZ5/P1LnSbUa6oikBkUWWyGs8Tbj2d6t4DqLKgtKZwRKlpzW4UyMTU2GwQkqdKiPeYXQHH3FvSG+ILrCkcJjw2Ozh0U2aJ8wbtERxC5d/gfninGA1RQb3IEukpAyl8zwoMiQe3tyDbm8aqt+GW5H6wuMlTbfS+szj4xOH3SPvd098/rTn8emZ5+cDu6cTh8OR/eHAcllY5hY08x6WLjEdckjCMLwYsColwzAI4+CU4gwpknVJipFZRJh7x1pnqZWpGXO3YKHVhrUeDhLeY8QnQtZ1pS2N5IpLIiUJR2wNUkFKwrApvL3f8OWHgU82hSJnPqKSpDF0X8XCfbW7Car1t5eJ53nkUiu7y0L2jlfhsXX21dgvcFiEqZ/A+qrVisA9h/W1EHRlahmCSgrquyoYqHh4D66ECNVEloSXRkkDaoJKdF/VCeEncXet3lbapbJYvCYhso2QRDcwVgeN1JFViyNrwjAeqbnu0IBZHe3xcyApI7IFv8ZC342UwtNOpXH/5Xuu+4Vv/c3PuR8zf+AbD/zGpxemq+NEYS5FKWkkSUdLo6dEzYnchdQqy6JcrmF39KXNPXUDyx/4GsfqHJ4+Bw9a4TQdGCwIAovD0gzzcB95df8KZjjXhd6NuTniKeLoMcxiFziq86XBuB8ygw88XiqnXnkQxTU6jmEIV/IvTUa3hXNNaNrwlYcHNkPh6bBnmlaPyPV1F11vxIiCH2SXhrrQSfQuFDrYGHIJlHt35q7YAKDxMyqJ7AnZNJCCpRBL2TIgwFyNbhUziUDNNcYldaVbheToYCzVcK0fEqxlTTJu+BojI7iOWMpYMl69chJ3hKr9VqxuReoHAO5G7RcOz0eOj3se9wfePx55fnzmcffM7vnMbnfkdI6Qwvm6sNRwd7Y1J0fU4pckEdTXnBhLZhyEYZPZ5IExCTklPAXdN7mzWBSoVpd1xDfTWwtj1NpYKrj3GG91yDpACuq2okgSVEGJ3YakjI4j93eFL98V3o4jXxqubKgUmylrnpDkKASDRxDeucU+6bg4F7vQq9Ir7OaRU7tyXozjYjRb6dY9uhhzImPKne4NiXoVGi+NVCtRYSyFJImlN5L02IXogKpTU2QQuQ1Aj2BGd8zCly1yowzzBWOIggT0Tvy3h64q8pNCei2i4RPnhMURIQyWVWArBkgirUa7aBBPkCUseVYDYOsdzwlxeHjdOZ0q0+SkV8Kvf+vAdZ5ojQ+eha2/ZdGK2YxK+CPmobDJymYsuI7IWtyvs6Elhp5fG5XXX/4qlU6bLxxP90HRtk5ZOhniWrpzXRopZR62heO1Y31ZDWR1LdcCBrM7p+nMdI3bhqxG6vArn5/YiPDR2Pl4W7i7SzyUYKAu3XieJw6z85AT248+4nCdeD7NTMuF3hvSYjwNTl0dLEQqZkqpsT8VBmRQMCFbZuqVoYSHIKOQHAohyl0sMYwVVePqBXFlodFIFO9IN8yG6LR8CaZfSsGWr2Hwq6pUr5xtQrWBOlkSu6yktOp61Ul1QfvMw+sZSW/XPKofbdyK1Bcc7k7tV/ZPe95/fuTx+Mzj42Ed753ZH2aOhwOny5nzZaLNoU/qhNEsaFCIBYqsgYRlYBgKm6JsypahrDP5XBBdx3G+UHuj9yBKzNVZ+kyrldYi0t1biygPfwlCVEQ7Ql4Lk8dPmAjaQUthvEvcbwe+/mbLVzaJezpbn9hiuMZOSzWskfZLp/SCJDguC5cltDsbTzwvxrcvzm6eOC3BmuoGTsW94F6DlSeK9OhKkmWyOl2DhYcaCUPV2aaMpISWvEZKgGuio3hbqDTEhG6C2QToqv0CehAKolNoH1hfOcw0VjPcQiJEu3hkXWUcS4J6xiXhEgSTbHygsCOKECJQPAIoJcuaCpyQFDvG7s5v/eoZQhLN81N0Hi8jL/cInGztQjdjGAvWYZ4rOjWuYmzHDZIuQasZlEETuQ+oQG0SbvdlYLvdsrl/xSZnjIHffP+ODJRp4ng+sJtm8iB8fXvHpV2Z64KqowlgIA0pNERuXAXma0dp3KfEm80d2a5cFuPvTJ3PLsY/pq/5A3eJ+9LZDomUDOln3s+K6paPt1tyVnaTcz1nFqvR8fWwsjLamjUW0onkmboALDGW9fA2j58bJdHoKaMZsigbEYoqiwj4AmRMGnfSmRmQpbF4jwGtrx1lh54qbmPYIk0LfSvY0pHzhpkJ54irULSRU6fYgHiil4SUzMN9/P7yIz76uxWpLyiCJGH0PrM/XNkdTjw9P/H5457dbsfTfs/7pyeOhz3H84npNNGmC3UJ9wdxw2wlK+RCSkZJG8aslJwZirIdBoaxsFEhjwWVAmI0FpzQPtXqTEsNS6Na432t09YOCos77UQQAiCHMH8Vu/oqZMx3mYfthrd3W75yl3gzdN7IzNYnBunfofOmCMers/PuajyoodaZm7HMwmVxPp8r76aZ52sPN2yN/YB7Q5tgElHonYRbLLqLGLJ2Ty/jyCSJUkronCTGkrrSJsw71laWIp3ea8RB+Oo64QovxdkFITQ44doe+5EU7ROSGuQQLXvzdY8EEXUf+UqQSNJQJ9S1kkI0iq9jyAxeULVw4zBfP0ZwCirhXi8rOzFuTNK6G1tdM0zpvvrjLcEoxIymAEIeG9NFaNXRqkw6k1hQzQyvYDRlqRXRxDYLMjplLPz4lz/i9WbL5/sTf+czw035iTvl88WotWHiDCivUmJarbZOy4Q0YZo8DGZJPC+dakfuM2wSVNZdZi/8+rkzqvHlu4GPBmN8UIZs7K4XjnOi5A1fv3/Doyyc9BrMRQ83eSchYuu4T+JnQju2OJZeiDOJHgo5TJyxGNWUXgo5dcSEJAObAnhDuGOWKSQU3lDJVPvOzrHhaFfcZ2iK6ohfZ8gFN8Ek9nOIxo1hGlB5ggy9QJKC6sTdVgFdd1Q/msXqVqS+qHDHeuV4OvL4vOfx/TPvd088Pu94fNqxe9pz3h/ZH05czjHiqz1yd8Q7brLe2TlFhJwGhqIMJbMdNuSibIZM1kQaiHFMUszW7KA6Mc/OVCfm2qiLMddgCvY1QgKUpJ2GRKGSDBKHdfziOSUX8rDh4T7zpfstX9lmXqWJB53YmDFKJN5V4mtHnIXi3bgXGLxznZzPL/Bbl8Zh7pyXxtycamEJ5dax9pI7BN0aeb37FPUQDqtgqmgqFIecPESdqrFDEKOKoeYRgd5bLMF7o69047Sy7sIOKZzOhYgmUTqoB2HEgiY+qKxO8iM6ltAr1RrLfA15rJFxidfSvSC+Ut9VoSjeYzQmKSx+hAaWVjG2k+h0K6xlmujPwhWiWzA6hbTGT6xL/TiW48jTILd0h0sLn0XrDb9GThgygSYahcWBtFBUaGXg3BJDnShpRLtRsvHjn3xMHUaG7T32W7+JaoRPdodzD+Nh7+F8rqwau9pBglK+m+CS4L4oDzmReufTy4HT3NmkhPTKm02miPC1u8RDNn7zMPOux03Yxw8jd5vM+5NwOU5oC/LNi+NJRMjYKgg2qsfOtjEEicbmmAzYGOJrmZGcKQhSwn1/JAg1IsYswpaEJEerQKtR7Gw1xyW+h2YW+ikiO0umiEG8ypmBgSKX+Boe/ujqHjExnxib7T0/ykf174qU/wu/8Av80T/6R3n16hVf+cpX+JN/8k/y1//6X/8dj5mmiX/73/63+eSTT3h4eOBP/ak/xWefffY7HvPrv/7r/Ev/0r/E3d0dX/nKV/gP/oP/gNba7//Z/LDAHaeynM8cnw7sH594/7jn/X7P8bjjuDtwOB05XK5M14V6nel9jtl/j8U07gxqDEnRHA4O41AYtiNlo9xthyggJaODUkpQlsNzr3KdGnVZmGplmi+0OtFbp1vEZIsLSUIoOihBcsisYl0hS2IcBu63A5+8Gvixhzf82L3ycTnyUbrwis4YVmxMJLolCv0DPfxsnW7KczX+1m7ibx4a7y6V3XXhskBtYKb0HjoY83BUN6txd6tB1sgK2+3IePeGbSncFyUNgpSypgU3GjU6paVxnRvT0uiV0Bi5kmVD8hwMsJWOLikEzkNJlKGQxoG74Z5xc884jmw2im42lE0hDYW03tXnURnGxDgoeVByUVJJDNnY5MQwxE1Dzn11Eg/KPQpZnSyKZCclJQ2KlEweEowjebgjlYEhj5QsjEXZDsKYC1m3lDQw5oE8DORhJJVCHjK5lHDsvtjqIhG7MZHO3XZDLnfM14WpwlQXjteZw/HEYXfiuDtzPB153p85X65oSXxtk/hIOw+bzNtXG968+ZjNdsSppFZjZ2SRotwaqCUEpYnSzZkX4XTtvJ8qx4uxnBbG3qh14dOz8a2js18cUefhDn7sFfz/2fuXWNvaLD0LfMb4vm/Oufbe55z/Fn9cMpzplEwJbIPKhZAcQoVoILuRSEhOuhgkWlakJWwJIRAdkDCIDi1jeoiOO24gJBs3kCWMcLqEikKlwpTB2CYjIyP+6zln73WZc36XMaox5j7hrAJRmRmZigj+2Yr4zzprr7XPWnN8Y4z3fd5vLp1kK7WuvMjK73v5gvdf3JGmGXKJ8bMEPDf4khZj2iGB7motphBtZxs7W68R09I6zaARfMQlTeQyMc2JpRROeWae4gBYchA9NEVkydGDM9zBonC1XmNk3hrr1lj3nfPtyvn8yOP5xuP5kaenAEE/Pp65PV3o+xadMP+Ar+//QNdvqTz/9b/+1/nud7/LP/FP/BP03vk3/o1/gz/2x/4Y/8P/8D9wf38PwJ/5M3+Gv/JX/gp/6S/9JV69esWv/Mqv8Cf+xJ/gb/yNvwHAGINf+qVf4hvf+Aa/+qu/yg9/+EP+5J/8k5RS+HN/7s/9+N/hT9vlsRC/rWfePL7li/MTb89veHN+y5u3F7748hY3iKfrIZSo+BEKF34bwT2TxSElNAllzsxTZpoyy5xZSmYqQTlP2UGczY0+jK11Wm203VlrYzej9szoLVR25seORGOno0omYaK4OCWFQCJNE/NJeO/ujg/vC1+fBnfpyuKVYiEiGBjrKLzed14l5yaOOnR3rtX55DL44jZ4c+usLrQWv6JBwxBsErRajNA8RlqaFNEQBBRRUGfJkLOwSYIDvWQeHhazFnlElo9coIEKDDtyrMRIuZNTRGUIEyXUBOgRwpjVcaZQCQKkgOSaQnQ2kT8khMlYRDAPRmGnIwh1OGJr0M0HIPVgGDouGbOBqAStgyNQT6JLDNrCYKSCquMyh9dGWniohjOl50Hm/K5r4fCMdXNyHqgJRZ3WU9A4bLDXFqnKBj42ROP3MKShXamto3vhVBolJ8Zm9HVHinJKidOLe8hKbZkvXnf2vbMPYgTtjvVQvVmPnWVOORiCw0ktAkiqNe5y4uH+xLc/+JAv1xvfe7qx7s7794VcEt9KwqvU+fvnypsVTvme+/uXiF+47DtblSMuJUbgcbOP53c5crq6417IDHZrGHByCcRSXkgiJJHIrZIZI/aBojcGQYswl8gUc6Wbk0bHxegS2WtuQh8eRmv2aBu5BeBXNSC0ORP0emUqgap6kYyU7w/I7f+xLvEo0b+t6/PPP+fjjz/mr//1v84/9U/9Uzw+PvK1r32Nv/gX/yL//D//zwPwt//23+Yf+Uf+Ef7m3/yb/NE/+kf5q3/1r/LP/rP/LD/4wQ/4+te/DsB/9B/9R/xr/9q/xueff840Tf+7P/fp6YlXr17x+PjIy5cvf7sv/yfuejbrjj38T5988YZPPv+U1198yevXT3z+xZe8eXvm9dsL62XlcjvT97jJRvhaYxCig6IWJ+WsTMs9d3PiVBL300yZUmCO5gWREbHmXdlrZd82bnWwV4/TZNsZHXowaY69k5I1RokpyZFnVIKmUIIicPfyxKt55qNZeK8IL3TljkZWi32MG70Ln+8dXHiZhL0PuiduzfnBZefXz4On3WgjdkB2wIv6QZ8YMsjjUMaJkjQKgBxop7lkssM+Ij7BJCTmw5xm8fsyC2NxSJY7lo78KmIf8hxZoiJ0D+SRIqGSRECMJBmXAQlsxE5N3I5/0RKwVguChLrEeC+FHHkcj61u+AimnzNwb0d0iUYel3YKCdEQhRiRWAwaez/f3zERg0EXLMSU4v8LE65HtIqASotxlHvIRMwRU159+EBfG5f1epiznyX1oEUZzeluZA4FIhoKQZkoJXF6uMN7YyrCNE2UaWFOoZY7tx0T503tTEz45cKtdxKDmw0+urvnRc78xrWx7ldUlCkvZOmkPPjwNPN/+vg9rv3K55edOSkfnmbeu4P3phnxxvcvje/flKeayVpYcuCMX1+f2NeNUYM6YYeCcjxzFlWBEp+dBEtO5GnhlBPLPJFKYZoyp5xRyeB2kFa22JfWnbE1rubs20brnda2iEtBYveUUhweVUlamOb4GdM8czqdjq7zBe99+JL333/Fx6/e5+sffcB7X3ufjz54yYuHV5Dvf2b2U///3sd/R4POx8dHAD744AMA/tv/9r+ltcY/88/8M+8e8w//w/8wP//zP/+uSP3Nv/k3+Uf/0X/0XYEC+ON//I/zp/7Un+Jv/a2/xR/5I3/k/+fn7PvOvu+/6c39TF4+aL3y5fnKZ1++5rPPvuTx6YnHN1dev44xwOXpwu12Zt9vcQq1oECIHV8E5YhzV6ZZYrxTMneauJsK05SCxadzeI8M9g6tdmrrR1RBpXdn9EarNSTdPkBymHM1yAdZ4pSvOCmDZqXMMy/u7vjo4Y6PJudOrtzZzuJQkkdyhBl1DG7deJBCLkYd8NkurHvj88349DbY9kEbgAlDLLhnEkmoI+z+DE0kzWQikypLjM+y5vCfdAcPGfB43tVZYxgMSSQIY6z40YFOpCwH8TuRcjoK4CFJPoQh5lGMVIVhjYFTRiCDbHCQLABvUQwPMG14vhzxwhDHvCNA0fCtRbcq+DSRPDH6oKrxMGUUYfgIosEhmqg947oHnFTDmGwHfy52hn4cRHawnSUl7FAjeg7RC5pxzYgZ9bIf+VcZLZVsEWkxDo+T6KCMEGuIhILUXGg26OL4VrFWuW4wTcb9ZPQlbvJ3aWEqma+/r+y28QkTPEkIfJKyjk7dG621I5PL6W3H1WiW+GLsrOMtrxYju9NIPO4pIK4Pg/tF+OaDkmTwvdG4tA3yPS+XB5byPp+lR9brju87TeWIiQzxi5sgMpARxvWg3+/IiDFltoDObmJMuZHIkRRABnEyxm0o0+hIOYjtvrBLZwynuCOW6BjJo5Meu6DsNIluKuUY7XpJZBFmJnIWRopEakN59aJAmn8WatT/39dvu0iZGf/Kv/Kv8E/+k/8kf/gP/2EAPvnkE6Zp4r333vtNj/3617/OJ5988u4x/2CBev7z5z/7X7v+3X/33+Xf+rf+rd/uS/0puIIF1m3jfA5RxNs3bzg/PvH05ok3j088Xi68OZ+5nM+0241e+ztfyrCBHv+U+ZDLTrkwZ2We0zsl31ImtDglK0kD0Nkr9BYZOrd9o+1G2yPhto0RSa4eOKB8LHYjqiIMjiISyjWFZZp478XCh/eFj7JFgWKniOGSQYThlVaNWxfmrGgSaitcdufTS+Oza+XcjNoOufeIeI+uHcOR7rhEkB5EV1bmoJ/jjkkw+IbZ4Sey6E49Mq6iv4luJUgSEbAomtCkUfCSHLgfJ+eMWXi9XByx8Cl1yZhF1Hj4Ywa7cSjsAoukMtDnEEkyTmd4ZQwNE/IAkaBum8GWoSRwMWwIkqJr8RbR7qIaP1OFVAojCbkYJ1fWbkQQfSCdkjiaEjJl8ERncBLYLf79oht1lESmoRJjwHUE9UILZMugFmnCFr9LSVOIY8yOYsjBPXSsV7ZLxTUoHaN3rO7UfSZPQp/vmaVRLgUT4X7KjFMo495/75usdeeHn/4gILLEZ9QJz9UAbrUFZX/PfHTKaM7cfI9QTel8ZJm7Iry/FJTG57vjtnLtQtE7vv7wHp/JhQ3B6g0gxuTwrlsc2jCPbLSEsvnANYzH6x7UDHdlyX4YvGOEm8jIgNKNqyuWComId+k+YpxJBXEGCp5pEOkfdcPJ3G5CFkiaSJJQfUvKMKWZU8lMozDLHcuLHBON/4OM/n7bReq73/0u//1//9/zX//X//WP8/X8r17/+r/+r/Nn/+yffff/n56e+H2/7/f9rv/c36vL3Rm+8XS98Pox6OWPjxvnxzNvH9/y5vHG09OF9Xql1Y1ejdE98DtqpAl8xI01J6EcVIlSTiw5wvCWOQy8XjKSR3QjQ9h7Y+2VdTNqg9o6u3XG0a3EaCsfCbFxs34uSk5kUGnJLEvi5Wnm47sTH5bBPVfuZKc4CDnEve5cmnGt8DJHBzZ65/VN+V/OnU8ujWsjojOOAsRhhpU+ggxFdD0qTpKJpBEyp8iBYRLCcBtG5t48TKyeI2IhhVmYFMv00zzHPs04yBOgSXE9vhweN32zQR0etHZNtHrBXRko6pBCgodo7DfKUaD6YWFtvQeaySIB97xXDCdroHNwJ097QH+nwpIKNjyW8Q7b6MGNIxh527pRe8SdXDLQY4+jh2lWfTDdn7ifGjmHfP3cGkP2UJEthTk5bs6wFrilBOIVHYUhQk6QdMGSHf/+CRuFbg3zMLI++/DGsGOXB4wYAXcHoSBpsK4hFDhtM3fLibwUUiq8OsF79zPT3cTnbytZJ5pKcCYP1FDvEnnvEnvXrTlfJlgYqBoPCc6bstrgownemwsv5okXZbAP4deuG49bo0x3fPTijrdJuDw6seQc6DBMjBjNDrLHCLh5C2tBV5AZ84ZpjGDFE72EFy6VELGoJ8jQpUOFfWoR3+LEYcNbHGLMQQdmEXXj3ZEEdR9s0oAN0RD9SE7kJKQpVG6nScmTkU/3vIsp+Rm/fltF6ld+5Vf4y3/5L/Nf/Vf/Fd/+9rff/fdvfOMb1Fp5+/btb+qmPv30U77xjW+8e8x/89/8N7/p+Z7Vf8+P+f++5nlmnuf/1T/76b4ODwuD9bZxeXPl7dsnXr/9nNdvv+DLp7e8fTzz9nzhcr6xXht1D/HJGBEmqC1c8qJOSaApUfLENCWWIwIgz5ERJFOJFFwTbq1R28pWO7faqG1QW2XvnV4tpLjmiJxQHE0WBG7JQNyEYl+jnE4L77+85+OT8EGqLLpx1ztzOtRNQ+l23ME6LDFopFX4/m78nWvni7eNdpDJXdJx4wsPTT9k9REQ6IgYaU4kotDZcIbGfsgc+rDjbhlEBz9Askdqe8BYcw7Wm6Z3AgjPiopGou5o2LAodrRQTUo8lsOHpdlJrTFGxUSZNVGG8bbu2LDjppXAehihqx1jxYgHCS+XHCgmqM3ZqJQBoxw7rLFjoqF+dZjmiAjpzeht0NwxN5ZTxg7FXFboYox1Z9RBThlodANNQldnST3wQRzAXXe0+xF98byvajQbUAzJc9DwZYORcVLI5MUZe0XIeE7o6PiIz7RjNNuxm4NNdO00c7a+M+8T8zIzT4mnXUi3J0yEl6/u4Xqj1cZdUqYpUySxto1LhdGDZtJs8JEUvqyDkpy7ksgk3vRGyUHgL8m5n51fQPn7vfF2O7NMC19bCpO95M3tiW0X8EYiDOwWehKcyOtKQ2g1lIFiFWGBeQCVLCUOhpJjP5mdAszZEWtgQjel2MCkYSMqtx4RLjqc4aGK7VtHqKzu0cGXRkqO6kxKOX7XQFoUn5T3Jg18mTzfwn92i9VvqUi5O3/6T/9p/tP/9D/lv/wv/0t+8Rd/8Tf9+T/+j//jlFL4a3/tr/HLv/zLAPyP/+P/yPe+9z2+853vAPCd73yHf+ff+Xf47LPP+PjjjwH4L/6L/4KXL1/yB//gH/xxvKefqsu9U7czb5+uPD6eeXrzhjdfPvHm6cLT2yuPjxdulzP1ttL2Sq87fURsAtajzGmoolIS8jxRpsycC8sSANk5R8quq4EVdjdqD9/Tundq7exV2FrEvOODZOk4p4X6rHhBtDDEQjUnimbl/n7h/Yd7vnGCV2XlZCuLD5JAtRRZSGQsx+uN0Y2zDuXXnnb+/mPny92xkUJGPg7fk6WQhUukB6sm8KBZLEWQOYch1YWE0PEoKP0oLK4Hiiei6nNJoELSgqSCpug6JHl0Tx7v1EaljxZMQg8lo5Goa0dlkJfwscgY0eHJ0VlZx+pKKxnLoYYkW/is2gALyoShEf1+wARGj+gIU0GfT/DbRl090EkeRSbNoT6sWw2v7wEqHR3Mnds6mOcYUXlKWOtY3/Gc2KXhUsEhO+SiCDNbC5k5WvCDaK4pOCVpa1SrILAsiuT1kFhr1N1jXCpGkDrEOOQUuEQ+l1ijjh5dmHc0JVQ7l6uypc58WynzxHR3F6GSdfDqfuIP/Nwr/qe3N141WN5/xWeff0ZrmRd5IS3G+dbZW+dL31jNaeqMZHyowiTCJcAPtNrJkni5ON82xc6Vx33Qx0tenGa8PPDmcqNeFLOBS0FCx/MukdktvmsVw/NzOvAELswiJAKdlXMCHUgWFiZEjeHGdGDJxgiTtHlkrcmRUaam9G5obsgOyQ3bHbnG4NZTBF+pZrRcKUvkiUyeefFhDgGO/I6kBT/x12/p3X33u9/lL/7Fv8h/9p/9Z7x48eLdDunVq1ecTidevXrFv/wv/8v82T/7Z/nggw94+fIlf/pP/2m+853v8Ef/6B8F4I/9sT/GH/yDf5B/4V/4F/j3//1/n08++YR/89/8N/nud7/7M9ot/W9f7tBs583lLa8vb3jz9JovXp/54s0lojjOF54OHl8ohcLHNAaHoygF7ysFjTrPiVNW5nlingqlJDTNlDlOXU1C2VZbpbXKug32tkVk+mHg9dFD5qwjAvz8EOtqInm471VhKjOn+8wHDwvfWISXunJKK/kAomaBpz543YCk/MLDC8R2tstGbfDDa+PvPPWIhzDBfaZTEev0Qexeju6pEOMQlUQ6SORUwT2hRVirYM0BYQxiDwS4SIgoyKQcWB9FkJJxPcTc4gxp1O4wgllnXmIkM3YqFktzN7RMNOkxeVKl7521N7Q4Q4zeHGkVsUEqCRsp6B+j0lHa0OhUhkXxtTCajtHjRq9RZAZgvYeAQY1mxqgNT4IxIv/IAU8YDevQiYJ5mhOj7ax7J5nRe8jh9UhcBqhDaVujnJT92qnbik7KpAvvvchoSdgEuidgo9lEYWJ0xaVHV60TJsp0ekHrG1JDQPEclZGAZolslaimIfYYk2N7o3rHLFE7bM2ZF2WZF2pvvP2y8D4neHD+z9/6Nv/vsfH/enOh18rd9JK7+8R1Hbzew5AsEiq7bcu8d1JeEFlptw5f4PAA94vyC7Lw92+VSz1T+8wH80ySzGtutPVKrYqnZ0N2+A27xOeIYWE7GI7UMCI3TUxAyyHzL0nJaabpBkzYnBBprBgqE+sIqr1gMcU+DMGg2HBMjNoaWWBHSbqjeqMQ34F5OvyIsrDIE2VKzK9eHuisn93R32+pSP2Fv/AXAPin/+l/+jf99//4P/6P+Zf+pX8JgP/gP/gPUFV++Zd/mX3f+eN//I/zH/6H/+G7x6aU+Mt/+S/zp/7Un+I73/kO9/f3/Iv/4r/Iv/1v/9u/s3fyU3bFQrVzPq+cz4PLlxfevrnw+PjE5emR89MTT9eVdd1Za6PvHuMwSyAdNzk6gYh5P5VMKoVScshmp4lpmlhKJkuKbJvW2M3Zd+dWnb12tr0zmtNGO06TPaTLcsA2U4x1JBfcWsSL58JyN/O1FxPfXBL3+cKdVYr1kPB6pnZhJQyqM0brN+jCD1fjN86D37gMLrdx7B2cNm4BrbXo2JOCplDtpZwoU4rdDQNkoDh1JHq4eQ9+XhjCRWOxXKaEZkV9IueEphivaha69RCHGHDgj4Yb3nfcK70ftHRRunY0BU7KCG9SF+jZ8WYHt09ozWL5vkdxUQ3CgoiHJ2tIAEMlHmejM5CD/2eHcANsRHSEEF2ScMBsLfw93fQI2Tv2dK6kFDvG67aHR8o9CB5KdHwt1HfMKeJVboPbCqCoG9MUO7Cn287dXXAYPQlmE7OW2JuUzpQjIHBrB8vdV9SNIRqsQnVkZMRjRDZ0xkbsBTHDrkA+xrlH8nHZPagMQ+hTpufOCWUenf/pzQ85uTPlib1XTBp/4P2X/P3XhcfLCt4DHwZc94GhVBl88PACTZVrHeRt8LVZ+PhBeDUVPl2dz6qzjc6LaaG8yHyuA2hhDLcRI2GXyKlCcCv4Ds3HEfUSGWAqYIdvDjIJmHRCc8ZljxE0E/hOT8GCbN3BKofH94jQiTG1ieCjo7XTV2Fn5VYS0yy8fQy1qUwxAkx54dVUuL8rCFN4Gn4GC9Vvedz3v3cty8Kf//N/nj//5//8/+ZjfuEXfoH//D//z38rP/pn7nI3tnbl9vbG5Yu3vH288MXThbfnRy7Xjcv5wu165XbbqHWP0MLRDjFDo5CPDupwuqfElBOn/Ox+N6YkcWNOMIazN2dtla03trpS90qvlWbgdUcdTOND7prihqoRd5DbjkyFMifuTjNfe5j49gIv5ImZGrEGJhScaso6jEWMaY7iuF4bv3GGX39qfLkb++bhf0IZNmJHMwYQajdNhayZIkophToscpcQzMOA2toGXSM5Vz1GXRIEhanEiFA0xn4iKajoY0OaUPvALQCxvQ/GfmQlTZmSnJE8iOkjohikBBswp8QYg/W2U/c9jNQ3eZdb1FqktOak7CMwRh55ESEiyNHdWRuopkM92RnjwOfEUiiwUwIxo0toMrQZ5kq3FpHp5TD2mh6G7hFF4oghgVAtpgOvZN3ZescPXBISScEmsF13NFe6JdSN5eF03O46vQef0Icx5pC+a5row7lcr0cWV+zaSDNJIxZFteCtH3J4w/UInfRB8uPxQgRwFme9rfQ99m96t6Atcf78RrXYSxdJMJwfPK2ggyQ9MrgIkcw2QEbBq/CwVeY88G58foMkxlSUu5Pw+4tzvw2+f4V17Mxl4eMXL/mCG9u2M5q+EwoJA5dD9u+O9YxKwxNMoyJb7ARldNQXNEtAf9NC8YHF4habYLhg2wY6GDkFsb8LOcXoz03w0UgHImx9JkykIPUnPfyNScJEngucEpMo0+kl8jOKTvrZfFc/0VfEsPd+ZX3zhi/Ob3lzfs3j+ZHzmwuPj0GTuF3P1HUPqXnniJ14hp+WY6mamdXISchzZp4nykmYppkpF3KZ0AR9NEbLtD1QR31v7M1oHeowhh0KOSWkrx4zcxGPG5JrjMfmifuHOz6+y3z9ZDzIRvbwHGU3clb24Vytk46TNTaotfC/PG38vbNx2YytepykLYHt72IvlAg3VA0qRpru8VZpveFk3BPDDezoUA4BgqtEsrAqqhMpT+SUIAWzcPRG643RVobXGJNZKAt7q1goCpiWRNdMvd2oo6IkTnOEQWpOgLKvnetl47bFWE+SHoXC8OPmjKVD6h5F8Jl0kNTRJIcJNiZIwwQ8kDvqR76QPwtqAu9UVGP3hCEpuhIhClzUMsdHdKRYkCjCP6rRZYyB+IxkgT4YPSOHqTqpBxGhN2pLJAa9TOzrTpknzJztukMJ5SNbw00psjMlJ80FTzlEKT4YzVBtnOaMe0bShKrgfceAdPhQg2J3BGSqkeaXjPWR4Z127XhvjOme+UFJDi9PC8tD5tZ3ZO3cekWOkEIoiGfcG8Ma2yZ8zzrvLYmXSVhQzt04bXBPoqTE/aT8HMLralxHZ54WvvaQ+DJnbusVqmG9IQz0iF9RPHLdemJsGc8VnQSXRJGMdD9yqAaanOJLJAQDk8Uhx3yCVtk9CB+WohD56KAZ6WEw7g6oRxbV2pByDSN5noM/KYm384nTXeGWE2maSOnZ6PuzdX1VpH6PL3fH7Mr5/MTbtzfevr3w9vKax7dXLpcL5/PK9emR67qy7Z3W60HjDpq0knAPgGjKMM2ZZSF8FCWky0sulOkURGUz+lB6d/bR2apR15XeB20PqTkevL2Y7ydUFKWiGjdJnZRUJl7enfj6/cLPzZWJlTS2SPGVQZLENoR1GN0TcwZMOW/G/3I2fu3cecLpjQM/c4wXLWgSzgAVSipMZSbxgNdbjKoAvDFs0KwjnjgQCBQI/qBmUtZjOS/kScg5se47db9hrdLdAjTbO/tumDRUEqf7gmsQ07fLzl4jMmPKCRz2vaMj1FnrdWXsPQLtDsq6EydizPBkh0JQjvRci5ohR2dzUMnNOMQKEb2eJ7AhtOrhO1IleQcD645awE1NIjJePCT9khVrEggkVzQbSSMoMCDFzmigueMjnFQlx05ORdGcolDKQEd4ep7OKyKVaaqIRvHza6gNpymT1LkO4yYJuVVSmpgm5fSBIiNjzVi3HaeTc6OkGZkyoztkDk/RCDyVjvgsPj7G+FPDKH1bK70ap76zLBPLcmKi0eeZbSjWVhTl/VPh5Tzx2a0xaqMOIYkypZmXp5lWN+49gK1nS5xXmBjcZ+Fhdl7MTkf4ZBduaWKajE+kc/WGmJPd4xB1jKVH0JSQfQcPOfokQnZAAja8pBLeN7WACGfntAgw4RZiCdcbnkBbKDL1yArjCGUUbUh39ha7sHozViZyfkNWYy6Z6emRp0kouTCXzOlFxuX0Mzfw+6pI/Z5ejtE4X2+8eXPmy7dveHz9BV++WfnyzZm3j2eu5zO3daWund4bPnqM+lxAg3RdSol9TU4HqqVQpiW4fLPHTTspakatRt13rn2wbY29buy9Y73TRyOshcGRE1FUxuFPygdiaCYV4/4+87W7hW8ucOcrhR11OyLdlSaF3aEnUE8MF85b439+2/jB1bnsElHaYzC84yOykVxCZTdLGHvz6S6iJto5btDHGbaHXSo2QhLjwDDeJuasIDESy2KMlGltMLbB3ldsBLm8qNBHxLsX7TRRplTIGt6qtQ56h5Qz05wOxl+nDehV6Nst9mUpkedC30MxZ8eNzHGyGVoECyg6ke7bggGocqjcJlJJIAM3xVFsxGEhF6WPjppjOEnDrO0e5mWaw/AjnylMtO4hJVc4fF2OpMLo4SNSmclqoXZUOQjkgIWa02zE7/UgxguxJ9laRSz2XZqF5HpAfC3CLEfs44bGXrOfC9NSEPUj9bjjPTxvIfPPgR8Sx8iAo+6hxByRgByifKFZYlil26D1A4i1zAiN2Z05Tcg0YM7sHntLzSemFF6nPoxPrw16Z58KXy+JBeXSG3sdXFPna3cTL2blPhlC5bUOznrim/eZT/3K1RWvhzgDItjTQHSgHDs06SjK6opnRzih0mKKyYHO0gTJYsTnsX/rY8a8UpNBTxgD9ZCmR/yKMUaHBk3aYZs4ozcj60KZb8zTzJRPTNMjywSyLCzTdLSXPzul6qsi9Xt2Rbs/6o3r05m3lyvnp0fenGPEd76euVyuPK1XrutG6xEL7mbxofOOWPglVIWcPZR8WQPmOkUke84zWQsqRuuDtcNWK1ttrLWy1529d0YPH4u6hxpOD2gpxiyOacEUSjZengpfOxW+VRozNwob2WNOPgRWH+yykyQxdUAzb3vnB+vgh1fnujk2IpOpWQts0Ih0WiUMwzkX5pyDqTcakAIbZEFHMJMDv+QxSiyZUnKw6IiQQNdEt07fb0e3ZpCMJEZ+HrtZ3FQig+mQmidl3zvX68ZQmOcYk5kHtXo0Z2vh/4lY+eM1ehQZCCPr81gvMqSOhUuPyHjNFgq+rKSSGVsP1qEK5NgppemIK7HYzUmOwmH9+TbZES0B0ZUWnh73I2MqJOmJjBr06rGPPPZaBoFsEj8YjIVuHTGnq6DmgFKSMdxRI0a8ehiIu1PSIGVl7E4WRybInkMsgtNNyNWgDGwUzCp3eUJSYVtvASPOGfSOLLE/w4OnaBo39GQaxHCiAG5uDF8Z6owOZcksS+YlM7tX3BLX0bibE9988R4v7u7Z+87f+uSHPJ0r4sa1GbeeuCyVJQk7yuzC2+ZoHjQcl877KnjOsNzxoYDZ4GYL2gPTZBIcQzuEGmlEFxYs38peTqgWpEVMzankAzqcUIxSFhZZyUOOoJSMS0eIpOsIONTDQ9cxibRjOmgTthuoTExsXKcLT1MnqzIXZSqJnGem9xNa7n+mEn2/KlK/V5eDjcrleuXLpwtvH9/y+nbm6fbE9Xzm+nTmer2xXyt9N0Y9osHdYjeBh8/nSNCdS2aaM3k6cTffMyfIszLngh8BbGsTalvZO2y7Udtg64dvRzyApSlwPSIZ9UxyjbVGFpZSuL+b+ODhgY/vlft05q4N8AlSFJmbHbbNLrxME10Hn6+d37h0Prsatx55U8Ogj3RgihouQjlQSl2hpFDqqRlDwolfux8dRHiZsgpSZkqeo4O6XxiakRZRJbF3qrjBc5icDGVYjd1RD9RSxATD2KH1nbY7t9rZ20FeqPkwAQt+qLB8pIPTF/w8sR5BiUqYZUcIAyAhGbJp7M9ynJynwDcwo7z3wR1fft7YbGCaWJb38H6BETs2Qd8R7GM91dEcY0IZIarQPKF9RHdk7fAsHTuODCrOMs20YchoICnyxswOmkJI3JMRhSK4R9Sh70asipLV4/PQA96b8hThmgOSJfJk2HB6EwY7TDk0bmNnNONcN3Kr5DIx8Oju5ArThJTpMLcOREL8EEgpx0XiBu09dqeXK1vaudsX2qLMupByoWQQv8NG4zeuN16ZkYCH0x0+O28eL4zmPHmhy8rX0syrOR9iiIF34fOauBfhxQQfcoNs3Lrx3mmmN+N2IJ/Un9eFdrAFU4wrR6QnUwfoDqJ4n0kYUwKVIJlnDqrFnJjGjpcjW8xLeATdSMT3auCHPcFDJSlGU2ffdp70hhQlFUX1wrxkpvtMme6ZphsvXi4R7/Iz0k19VaR+jy5nsG07b57OnJ8eeXp74elx4/J45Xy+cV03ttslqOMj0nXDMEOcmjVGGjnDXUlhgpxmTtMpWHxFmXLGNRRPvQ/2ARuVve3U3tj7hh07D+BgDfjRjYRiS1zwHBEcy5L58MUD37pX3k83Tj6YUkSx96E0hL3DnEM9d+vGbR382lPlNy6dbYcxjG6DfRiMHt3NYURNCVLKmCRa77HTkR+ZetU99lUpTKYpTUylkFIo+MQVGVFcRq9YD4BsLhkXp7dB3zoUJZswxgiJbz9+P2uNTkiM3iveR3hivAUhwwZZJNSGAmhhWAUGbpEbVLK/k4EPB5P+Li6+DwsigMTvOJlw/2riF/8vf4T8f/9/8umXb6l7p12foquw8Dv58fOEQjtCF2kJTRlhBEyjN9Rik2hGdH4SUR5Z4rMSTLo4UbuPKKoW6kP1KFauHL/nQ3DhwZuTw8PTByGycGeMRH97wQVSCqKDuFCbMjxSaamDaXnBNCdSmRjD2FpjlsG8TJjHyLPu4SxOouHxQ2lD6L2Gl00DiRR+ogYjEqJH3VlvmTnD8qKw3E/cW6HPxpu98cPXX3Ja7vn5b32db9zd86t/5++R9p3sO0/V+ELDh/RRdopO1Da41sHQwb0qmoz3FV4DWQofTgpDuXnI5oP5qLhGfAmW8LbRfSZJZ6hT/YSKsduAIpQc2dXlGPtZNqYpRQSKF8YRSOkt1KvxPQBDSGZ4F5qDZGPbHdXCmm+sRbiWzJtppixXpnJhOU0sc6ac3o/Dzs+AkOKrIvW7fDmAD0Z74nJ+zeXtE0+PjzydL5y/vHE+77y5rFzPlVpDcWbDwLbjxiGIB8g1pcKU40M/l8QpO9McY6+5RNBgH4b16Jr6Xtn2yr7v1Nqx6sco6QgaT4E9zSKYJmDHZSIl5bSceP9u4Zv3Ex/olZe2IQK7xzL3Oow5TzwUAOHWB69vg08une9fBmuXUNWNoC7QW/iBNKSzeZrQIex2cPnEGCKI+5Eme4ybpJCTMk3hB7MUEtz5vcTt7ca2V1qvyIhE3cPWEpDQWkkjzJg9heTZtp3aKt2gN0M0BQHCokjHkqWDSXhhJJGKUHLsucyMECcb5lN0MVEq4jX3Q2qcBmMYIhvpQI1O88x0d+Ly/U/Jr0DflAgZzIeashgFpTdQ11CWSQ/yhMZ2znP8jgLxFEnM7qAkBON0mhA/+Ic2SFoYzRlWj/TiMPSGKjExrAV38Bki67F/KinGVMMjRyzlOHCMQ6KnrvShjBZKy5DSK9UdWkW8oHkc/MPEvg6yd3TOsacbjrUbzYR5ypQyo5rIehfJwN6IMWVEz3hsuOgeJPlhV2Sfud1lTsVZ0sx7RfnCVtZ15dMv33BPjPfO4yiyTdiK8zo7d5J5aIM3Zlhyqiivm/C1SVHpfFzgew2GKktSBonNRwCOCXZSx1B21OOgULvBDhOVzqClBe2JHHPRAC2r4xlGCUr+8ImFkOU3j5Fm99jLyYiDRSdYf7VmnJ01C2WD6y3Fni6/5WGGN3rH3d09y6nyoDfKfM/zcfSn+fqqSP1uX24M23hzvfHZ45kv3648Pu28fTrz5nLl6Xxm267stdLXzhgh6baobkcSrLzzR8wl9hpTgjIlphzRHK4pkk4tUDtrbVz3Rt8rtXX6XhnWsHATxWkY4gaIvItDZ1JOp8wHL+/4hYfEB3KhjI2wyTqfnnfeNuXVHcwp4tN7Ez6/rPy9p8F5N24tKArWxxGWJ7hwwFmj68vPxWFE52BICCoszKXoFIKKOZE1vDcaTkkMePzyxr6vMa/HEDq1dzTNkbbbIyKhi0CtTKcwlV7XTmst0mfJZCJaHonupQ3BRkKygR3x8AiaEtmU2nbc41ZvBmMkRDs6JSYSfa8xonVnmhKqS0B/l4n7+4W6w/d+7VNqvTF6P3A6gbYRNVqDlCMqA4V7TWQP7FMH8mEgHg0sO946HDdyNEd3lEBaGJ4dR1IYTynOfFLWp0E6dk7ugh1WAz98xvkQOIxhB80g9o9+4I3EgpAw5DAk+3Fg14QNo/cVt4G2gNLiQjlNYTQ+aO1735mXRM4LrbcYPaZCTjOqituMH5R5MyVy4B01wz3Th7OuG2OAvTBevDqRsvDq4Z7qg9fnR86XCzZG+MpGp5swDeHl/QMPy8zT+gZ14eX9HXO+5832xGlvvJoz75fOVhrfl9gfTVlxFqo3rDdMjPSO+uGR2ojQRFi1MYmRtoxOiSSVohpYMlEymbn0sFSMgSTo+SDJ6JHsSSg7XWL83sfAU42OWiurbuia0KeJS1JezxMyP7G8zUw5dmEPUyFLgZ9yGsVXRep39Qpl021dubzZeXxceft05u3jhdv5yro+sq8rfW20urN7ZYxAsDiZQ/IEKmhJlClk5vM8My0zeZ5JJaTXSNAT9hbeinUf1Laz7419H0fkxUQSQzTQQXr4ZFRCdCBJOS0TH71Y+MX7mQ/yDcZGESeNwePufFqFVyXxflYWyVSrfLYbv37tvL7FHsnGYNh23BxyCAqkIInAE+H0bQvBRjoKVPdj9yaYzpQMU1nIpZDlEBe44a1yHR3b94PPZ1g1Ujbykni2GSUPUUcfRsmhxLted2oNQ6yaRdaShmRbk0TerzlTWeK164hiJBbFx0IBmZ5x32PDNHFfSrw+y+hJ6J6DJp4yd3cTd1OijUGrjvUO1pmXhYeHE5oG12ukKw8IwYUFsaKUiayQJbHbswAjw2mAAWrU7rRusNdAZUmQ0cscPDoEvJQQfA0BN3KyY+ymqCtBjRckKzlNpKy4V0wsuHAO41lhKiXGmR16DitEcaebxY3aJTp2qSGjL0FlH7f12IMOprkgI7FdO/dLxe+m6GwtghuTnN7lcYXa1BlayFhI8M3o3djHwGyLz4wnHh5OvHeXySJ8QeVp30MhRwnDMPEefnBeObeYWDwk5/0xcK8olc3gzo15Fl4N5W0ZrDUEC+LKKPGtVnvel3Yg4wZGZxjUDsygo0JPuNxwzSzlRNFCKw11YfYImO90klVyyTR3nE6yI/OLgzpiA6rCnBj7YEsNWRtJV3KBp2liXm68XTKnHN6+0/2JNKUgkPwUX18Vqd/Vy2ntyvW8cXl6y/b4yPX6xOVy5XLZwhN1WdlvK73GOMbNQzUW1k2SO0mFpINJc/ghppkpT0wpU1IOgVR3ulW2VrnunbXu1L2z7YPRYqYfn1WJm45rmCpFSBhKJpXMB/czv3B/x6t8pYwbTaAAO8LrAQ/LzKuiTElZW+MHl8ZvXIzPz4Pag7k3xqFI80wpdqCcgudnGiMidQ8Qqg9sSIyZvARIc0qUrOSUkOyHSdbY207fWoy9pGMu7OsO3ZjuNKTdAuKZlhXdGyoZ641andYG3gN+GpahiJ03d1RCjZamCTGDZiFckCBu9DFCnecZZdBFoTdSyrz4xkfUy6DWLfxGPmBoFGXVEKXkiTkLaVo43c3cPXzE7fZInhOXv/sle7sxZUMVTApojnj1YazeEc2xShwdpJFKDtWYOIWO6UQbYey2A6mUVRldsGEkvWOUgbVKKRM2DJGEZKWOiihMJSN0ZFowS3gbDG+RIWaHX0oOibqHEECy4mMcRB4LYomFMRkMqwNLwnNHJcXJQ4IOnxO7DaY2KEVwEnXbUTplymEz8IynIy6lp8OLJiFiOAI/L7dLjDd7h1cvKElYyoJOMFFoLczKj+uNvYKsG63uJBdkTvzwaeOu7Czleb9qMDLGIKuzJGP3RCkwo+ATo8XuzjxuoXYoZXtXsEpjQeeBSAUyyTNJOvruc624O8UmTknwPOO2RsDhMMzDPA4jOlU08Fvd6ClBH+z7HrvaK4FAmx6Z7pRXp8zT48J0V/jglZHSy5/q3dRXRep37QoJ9K2uPF5Wnq4r51vncl05rzeeLleutxv7Vmmtx4nPNZayIU+jJCdlDXn2NLOUiWnK5Am0CHkqYebsMSrbq1Gbsdcgm9fa6aNH3HfyA5uiR9DecUpOHnP3Sfng5R0//+qe93Mj2cbwzizgOdEk8XIxTilm7DY6n10af/ep82aLjB+zCBtsfRw5StERqiYmjdfIaLFjSIXuQRIHJyVFJVOmEykXcooOx9Xp3ai2x8hSgnSNhHouicMchUA67GOgaUZsgjKQrVEBs84YJUIB1clJ3u0LgxtVSRrMPO8xQvMxQlpOiE3EnZycpAX60fkgXF+/hZTRGZLMobrqAupIuqO6IdZoQxmSuRPoNri9PsdIq+4RvJiiUx7o0XEqtEZtQp6UXkcYP2WiV8gyUM3YciKbkg/SequDsXWYCxB7qbQok2TEMi1iiRltYDE3xIn9n1ORZrgbIhPCFtJ1FBEJ7I/l6PaQEPaYImIB98UpJVJsW99DGWiAhOwdi+NXkhnJxnQET1qPLlIlRme9GzkPNM8YmTQc0Q5qDC8UjlDMNhhAbY3bbQVvvHr1imV5ydzglIUnX1lrZdGZUTqTKLMIt9G5rqEifHmX+Nqc6UXpIzBKyZzJRwRoeqeUwskVwdmZ6K0iRORKlshz6x5ZW30Y2kK1KCRUBzrCrK4eoFiR+ASZw+wJ9wnzCRuJ6v1QXDqJsKL0pDCERCf14Gz2aqzXiVuuPE1n7h4Tj9P75PnCcpl4mO9Y7kPe/tNapr4qUr8rl+MeJ531sXK+nlnXJ86XC0+PV/brmW2/0vaNXnsYVT3UPBzBdkUjbLDkwnKQJKYps0wTeS7MU5zs3CMWfe+NvTp1C2J2bU4bsZ9KHkIJxA7sUPhucqQPwZS5f1j4uVd3fHMWqDviRhdh9oNIgLDkGBH2Vvns1vmfnzqv9xjnuIQyaYyBWY9RIrFcm7IG0NX7Qc/Oh0H1MKGKMmmhzIFz0hRmUbcQXrQ6aD0SX4vEKdrQiJ9I0/ElFrrFsn3bBvSdWqH2Rj/GUH6gnkQUkdjdKB74IIuiZXU9fqcdlUT3TiawSCLHrtATU0nIHIbi6WEJkYI4EfIXUeRtAPsaRfe0RJdsnacvdiRfwQXVidNLkD1QQN2cboMuKbq80aMJ6ZlaA0wrEko+S+FnUpNDkKIHvaIwTmFKHtcwcI9thN1O0lGEI75kpIW5RNHyIXgK6kXqGaeCCpYUtQhvTKKkJUWYpPuRIByKtBCbxP5xWChUVRMpC9aM5J0xT/H32pXt1tAUUTIjObLulDnjOQdiqYcoo5QFVyXLhIoxZ9h3Z3RDJcWBwSpbdQYD90fuXzn388LreuPWdlJythoRKVUG7bB2DHOsQvXGovCiJ1ZxRu5cRuftgP04kEzqzDkOXRyGW2kNO77vRsLlkPmPThNhIgzrTSE3YdedU4rdYfFQtloZiE8MhOF7pAV7QJ+HR4QKPpHN4/ml02sIZHKudLlx2QrlppyvM6e7t8zL4OE+c14WmCaWcn90Uz99peqrIvW7cTnYMK6Xt3z5eOH8+JrXb554c37N+XrmfNnYrjt1b7Q+aMMPHl2c3oYIU8pohnlSyuxMs5KnRCkTcylMeUZlijC9Hsy01ip739jaRt87rduzjZNYrstBQHg2pSe0JO5Pd3zr1QPfOiVyfwvWcI/UUUmJx+H04SwJvHW+vBl/723n83UgkngvZT5xAd8wH7g4WTh8XYU6GtaCoK46MSw4hOogSZjKibkEqbxkYuxjRu8bo1r4p8Rjf/L8RXMFS8fJHJTOcGe0cezldkbteJiXMAbiEn/dI96klMxo/ZBgDqzpgZEaB9RaY/dikCWKwDxNcSbVRNaQYN9PGdf0bnxKT7QOBY2dgA98VPpW6T0oDMMcxaNTG4NhnWHP7L3w1khJ1H1HiH0ZKWEeOV8x8gySAxZBiGgw9EhBgc8ZUsks9wuijrgxLRM5z2w3WK9X0rPwJoWvTNMdZTZqDRCv9U6XBAy8d9ycjOM5I73Rk8TO1EtQFSw+I+52HAwk9qwitDHo+x6BkpZwa0xD2EdnUsGnhFnIWTzQHxGx3hpJFXQCjvRkFTLxvjV77PxGdBaQ6XJhvIBluuMug04KTxt63ajuuAe+6TkMsnfn8yuk3Hl/ySyWuQ2h7w0fQkmVKp3kd6gqU56wIewuMCpu+RmJgiKBMRtKFWAoPow0BmqOjBBiJIn4mKk6TMZig54h98ySQrk5vAEHdf3o4mwkBoOkzrqF91DzxnVOnM8Xlrs35Gni7n7jNK0sp41cThR+Og2+XxWpH/MVuMjOvj/x9ukt5/MTj49Xvni6cH6sbJcr13Xlsnb2bcRC2oK0jRmmFoo+FWbNIX8uC8t84m6OyIIkEVlu3hjV2Rqs+85aV7a6U/dBPTxJMWqJOXuWoGazCDoiCn46zXzw4sTvOyUmf4vYhqpilihC7LUG3KVM7c7TTfm1x8onF6O5YKNxpaOjg3dcjCwaOwV3WqtgjqaEpHIQJwwY5FTQrMwHD07ycbrtUGuN0EPX8N6WiAqJBTUgIXIw348bk9PqwKzSRwpihzkldZzCGCFA0ClHPgKRbiuA+KD3TkfD+0JCJCjylMIyzZSHGe97qN7M8H3QKZQxoCjeB11zLNS3ld42rAtb62EmtqAJmCnmNyA6EzziSY65Is2F7ImhTs5yRJfYcfAZCHaoMo/PmrZ3Xil3I6UOPfZoLkpVwDLTksl3CW3w8OKeb/zct/ny13+DN+cLboM8PWC9Yq2SknB3V+hWGHVj1EiY7WJxuMBi/GQDTXEy18NnF1LqWPyHE8+OcWkYj2U39nYQOVxYbZCngzuy2ZGhFG9w8oHqTLdGG8JQYykzo8abD8JSZHllhSGRJ7bXFfGG0eHhJfe5MFvnvY9e0L7xMS9N+J8++5zHpwtejeGCUrjUwaePxmaFr93HvrKr0n3HHcoQTDpaSnRDUwRiugt+HC7Ssbuz4ag59djVCZWqnZROTAmGREAiNt6JT7wkxpiQ3lBzmk80D9GTBS6FTtD2uw/UCtqdKp1cV9ar8lgm8rKSy5mHJ+WUZqZTocwP5Ckd7Mifrm7qqyL1477cMVu5bpWn68bT9ZHrZeVy3bltFy63ldu10vdgpg07pKbmyEEtSJpISUmqTJpZ5kSZjJJPcQLLKWIP2mDzSmuDrQ62GpHiZoYPQ01BMiox3oGBSMErkIVpnvno7o7ff79wkvVHZkIaJKWT+KSHA2f0zCfXne9dO5/feJdp5BYz/b1H6F6csiFPKYqwDYokRCeGK+6BJZLkaCksy31EjhwRId0q+74FtumgWrg4aBhjRSENYzdjbSEOGZuheTC6M4ZFzMI4knc1g8VuL5o7o/vAGiEWmVMs3BW8R47VfFfImljuF3Iu3L1Y8F25rs7YBymFKlFKjuLFwnZ9TdveMlqFHsUvy4xZw2SAN8SEAQewlCiWYrgXvBuqQVvoOigGzYTugpgy6CGlsUQTjZ3iCAPu4PBZYcgI/l4WZaQoFo6TtoY12NjpTyvr4xt6zZR5olcjUclZ2Ladugvz/YkshswLZQolW7eJ1uJ9lN5wLbFXGVGKzCKtNx2dl3jsstTDq4ZE52kWOx/0AMx6IbtQSuw0t3VjWmYawuQ76YhnrzZgXJnyHZOmeE4Dp4TE3ioSzTVbq/SLoWOQ7l/i+R6a8/t/3/vI7Ynb9y6MfT9iRmJMDcqldsZlI3vmg/vM3Ty41sIicWDaZKBDmSZh0gLaEZ3Ya4N2+Nk8ImjMw6DeupOzYbXQgaY7yQvojEpBcseTMUsJMosN2khMqrgWmjni4/gOyxGbEoXLphppyo0IMt03breNbb1yXWe2F2f2/US7XZhLQqT8Xt8Rf8fXV0Xqx3jFIt64XRpv3m6cb7eIdbheuF2uXC4r69oYdcVHo48aSH4PhtpQyKkwqzLl8Agtc2FOMzkV0rSQ5siVsd7ZmtGr0feN1jq9Nmqrh3ruR6SAOJnmWG5L7KGSnnh1d+LbL+74KHXULiD9IFxMoPDrq7EafJiFH1x2vndufL51rDk2xTK3tUHrDdyCiafClAr7bSB9J6siOcyKAK5OVpjSPdNpJknsMVSNZo1t3em9IykKrdWdcioRBugD643LZuy3na1WWm2IJGYVNGcGQZMQgl7R+yHMKJkiEsGG7kEKKMFhc81AZ9LBcrdwuiukPJM10SVR60AP+bXOwRD0BLVVttuG9C8O1Z0jljEJ+nztG8OcIX5wA2N3hOhBRvdDHqxYjpysxDOI1hmtH/4jQz32Qcg4zMQe3D8h9kX6ozBFF6G6RyEWwW2wSvx91UrtjetqJEkEiEfD0nC6QyiUJZ4/pRxoKK3IyEwH1FiHs3eFW7jnRgIbCfP9gNU+E9ZzcAXHMaUd4MUPsIUcBQ3AWLfKsEJZCt2F7E6rDVoizR0nkVN4txobMi2Ih48tE9T6Lhp7vxHjtt0rsgpw4b1knNIHfP6DC1W2iCuxUErOKlSPseXAWffG05L4xjd+jp9PmfZrv45chTe7sTVDiiCayJooaWIucuR8DXLvEUGChQiHCLzs3RAXsm7c6oKmSH8uqR//OxiQKXl0i2WjWgIvqO/YEMxjlCkuWLKQ53tYS9oQ2Cq57FyXG+fbxP3lxNvTYLpvnE4rp/sTMpWfsj7qqyL147089iiXbeV6uXB9uvF4PnO5XVnXldv1yrqt1N6p1g6sih9kZSFRwheTlWmeKMtMKiXk5mVmSXKMmyLWulosj3tv9DZowxij0T1UZ9mjQwld37MXKp7/4UXi4xcv+foMyAXpRlZheMIcPlmheuaDItQ6+Ow2ONdY/BsKzej7oPc99itJyGoUXejVcKuklLASN8FnhHTSzHLs1nRK6IgusvXGZcRiWzUC9jCJvB6PgLg8nNvZWFvHe5zazdJBCpdQxJWZtK8YckSAhAACD/Opj4ihz1mC9rALWgydE0Vn7l+8eHei781Jc2WZ78NbVY1eQyPQthvmW0izLUjkzVIk8B7/zfyghWugivSgmYdIS8lBaItuRNJBQnc0KxZohcMrE6NBc43nETn2GUdouIwDo2MHVS5u5pln2bjQ3ICwd/UmDIcisdfISbCts+0rg/AVaZpIp0KaMloKIpkkRu3QxZnniSmXw8zrrDTohWqx+0r56F61YASRwpKg3g/0lKMuuBg+BElKbYTaUBNqTl7CHDGbwDOIOIVyjtuNNM3knOO1JcNbir1QFmwUfDTW0fFbZGqZF0Ya7GPl1d3EbRi3Otg94k8i+ysxiE7oD3z4MR8/FNbXr/nk1sL/tw+ahErPCItDUaEWY3QP+X9Lsf+EI+IDWg+s8dYGi1ZamigM+gyaBkkHKRVmi056ztMxaRF2j4BOPSYRDodRW/AGXQeqFaRw3XbmS2VdNh7vN+brjbvzE7dpYn1x4iEnRBd+mkZ+XxWpH9vl4JXH9cbrpyden9/y+nLhcr7y+nLl/LRyuzW2vdGqMVoQvt3tOUQ1UnBTyI9VEzkVljSTZ5jnGMK7C+0wcNZ9Za2DW9tpzRitHTEMQeVWwqSqh3xCyKjAMi18dH/HN+8h+4U0dgqJ7E6l88UG55F4f1akO1/cGj9cK7VFURCL+Ig+9uOekMiSKaRAE9l+GHCjg7IeOUqahGmZSHnGteDD2aXiY9DqFYhTXt1DfJGSht9GQayzN2eMRhaDKTGaU44REyb01n7UeRx7Hn2O1baQngvGIFHpsd+bE3kqTFNhWWbm5RQstmaUl5n5/iV+u7G+eWQ931A6779/z+vN4lAgilcLtZg5IkGTzwdYFIlCiekhyVfycEjOdQSf0Y5NpiMh1W5RUIzYJaod7AgZ9AOxBBboJD1Mrx6qupIMPXY0WVLQCggGnEioIOuBMapE4VybkrOxiKDqpGSIVVoVqi5MizAtMzbfoyij7jQgL6FAzR2m2XFGNJQkNClzKbh6GJGHMeUQRqgqnpXeahweTEhE4GVrYTZfrVF6sCrTaTli2hvJEqJCk4K0xsDIeTpiUSJo0xw8ZfCgXjQ8yBS8oafGqxcPvHgQijh+dvZacevMZWaZ77jebjxeB3/tb/1d5uLY+Ro7Lhsxjq1GkxsyK0nvKEk4+YTnRmuOyTHqlAM8G+JJqiW0Gi039npD5cQiQpqXUIQmMBNSyWQ31DLTUVzdQrkozxYVi0KPKjY69RkA3HbWeuN8zcznmds8cbuDp9OJ+7ePLEUpy/xTFY74VZH6sVxH2m5b2Z7OXC9PXG9XbrcntuuN27myrTv7VsPXYXGyC9inHx4VIalTMkf8+cI0Ra7RXEp4hpLgFvLove9szVj3xj6MrdegRluMLWKxHlJZ0XTsY4RpVt578YJffP+OB1lJ7UJBkWysLnyxDt72xMsMicFn18Gvr4Ot5vDLHCf72sPQqRKYm5IEG5XRenRCJRJLfXRUlZyCzzbljGjIxw3o2x4mW0lBw3bDJeKx9UiWxRujC9fLzrZWciHgpCrUoeQcqCRRj9FSmoPSjh8+rES3jI0WN+8SkvO5JMrpIeC8RSEt9HaD7szvvY+OM+ff+IJ2PcfNYRiI8XTZD9ipo3P4dLIkcgno1DFsBIzeQ2ZvLrhnAlAKtKC9x+FGUY3HcwgUAvB6nOzFAhWFHP4kD1AucZ+KnxC7pzoUcwuWn8R+KokduVIZTc6siQSYG/shyOhdOXvsZabszClugMVW+lVot4rOlbQsyDyjtVEvFfMS/Mg5HxL/iBqxZ2GFCwVFU4yz0CNR2DvDC0IlueIDeo7PDhKPE5RMpVVIqaCWGakewZghTug1hBklL2h2siXa6CHPnjM6Obe10V3Z9g156xTNvHr4mFf5QtErnz2dqdser3n06KT64Ae/8UPulsLX5xPXHiPc4cf4zjI+hFMyshamnGPIZ8HOFLGjcMZY00ejW2JLQM2YtIiq0Yykcey3MilnzFfMB3kUshnFE2YTeH3XbZscBz85yBcmjFIZLVH3xr41btfG7bTzeOnc3V05v1i4awt5uUeY+Wnppr4qUj+Oy8Ft57ZfuO4bt9uF/enKft5Z1419vVL3K72vNBvHqe7YU3D4djSR1chTZipKmZypZEqZKEnIkqkO3XuQsZvR605vnb4bVhvejxsdYQqOl/bsD4owvruHO775auJlquR6ITuItggpbJmLJV5p5iTwem382mXQuvMiwZMNGNB7x6wG+kcLcyr0MbDe0RKChOaCWURE5CSUPJGmGQ56BBKoot4cALURJkrNlCVuoM+JtgPnVnfWveF0Ws/ETvqQbdcRIoaSGd6RHpieLBy/hwhnDCxTpix3zLMw5RmnIGmQpsycosvatp3+xef07YKNTqQHFTpKMyXvlSyC54QOY8ohD+5mNBsHBDVYbT4ONZUH2y18YcR4z4+9AnFYCe2Ixv4rAE+HkCWKEiKYQDqMmTHShEP7znMde860GtbD9CzCGEd2l4dpNpfg9c2qnDSguPVg8tVutBH7r0mFORGRGLXidGzN6LKQ5hlqY7tFBL0WZXkoJC/suzFGpEpDJmWLUWj3kKSjIHuQ/jVAv+LjEPpEACai5PcK9Sb0upKmID2UUz8mBhmRMDlDJecJEyVJePtcjrTpHAraYcp6a5w5kyUjL19yOsHdHgXPhnDb9uPWLdCNfe08UdnbcciwQVNjNsEqdHWSR/c6SWJMiWYZagiEAj8FpIR7mLFbj71jP7BWKe3UpJQ0oynER8WcOx14mo7AxAgJ7UYEaJJ+k9JVe2dcCm0ZTFtlm1bWdWG7TZyvMy9uC+t6z3brnJadUsqxD/3JL1RfFakfw+XAuneeLp3L+cb5Unm83rg83bhcVy7rjX2LEZK1gfdnD0l8RJQIqCt5YkqFKRWWtLAcAYaiBVIs260NWq3c9sHWd/Y+qK2FgfAASYbKNGGpkyViNKapMN2d+ObDK75+OpH7Z6h18BgJmSutg+qMzpm27XzvafDltR8w1RAdDDdGr/G904mHuxP7gH7dSUkwVYyEjRg/ZC2UaQ4+nvq70NDbtjP2G6p6jEZCjGApbtbZBTWhN6OLs1+38J5YjL3QiJ03YsyWTWkNRgAAEIMuSlEHKUxFkGlhWRLzNEfMPAJFWDSxvHfHeq30txs6NtJyR93AyAw9Rf6VRBfk4wi9E6P2jpnQ3d4VjPh9Ojri0yES4YXYYarWWPA/F6VnUbAfkm2O+JCI/HCQRDr8ZxC7tejYYhxqEsicI5k+ujiJAtdc0MMf5uI0F8SMVuNzkqSTNFJxF42T+UaoCnFhG1DHIDXnbjLmlhjWqXuDrKS7iXku7Hujro3UMstyYl4cS8dBZDucXWOE5JroKMUSXoLbqAzcUoy/R8XISILba8XEaD0xyUCtU3c7zLROyiWk9i34eymXGBMn6LuyW4BrlaBauBvXdSW9FXIqvHi45wMzlhIxGL1X1r7jo9HMacP5wirZIxVbJDBFncFymJY3hUUC9gwZSwtralirDA+IsR9KzuGN3gp7Gsio5Kb0LLQ20DTQ1MgMSi54ceaxMkZCR0ZyGPNHjcOoHBErbjniXDC8N1rK6N7ZbxuXZabc7Vyujafzjfv7lYf7B0qJrvmn4fqqSP2OL2d45dYq13MNqsTtzPly4XLdeFo3tlqpY9C7470dM2WLUZTEKGTOiTxNzDkf0Njg8k1FIIfPZ4zKqFA3p9VObYNWg5o+NJE8uqikIUlWT2FmVYcp88HDPd94eGDhjLQViPyi0eFcnc+b8vEUhPK/d2t8fm1UCy8KQ3BvjB7x8jkpDyehD6eua8iVcw6ahMfwKWmM+FLO0TGmYJLVsdPaesjO/SCgC1kDZipHvPz5Orhte3QndT+W0UKaQDyx1+hOwBi9Yf0YgR0oGnDIIVSY7ucAfBaBpNH1ne64e3GirZ2nH55ptyuFynRXKKdEtQ+o1xXckbGz9Q7eoDo3jgW+GSoxzjuY34eYwY7srLhBO0Gh0OedQkhBo7cSPTre+G+m9ly1CNF6Ov48RoMRgBk3LD9+novHTevYb9nRSaOH8TeUFYcAI8ohJJoPuglinUaIMuYs3KuyjZDKV6CZ8bhBVmNOypxGyJ6fKiMvTC8myrSwXxvr+UrOQpoSOSXSLOw1DlGq4x01XSWhCXzE4QMNwQ8W8S7N/YitiM8kBs0chjN2oUwg3igpM6zgtR1ilbs46GRIPQI3PWWS9wjTHHC57bi8wRPMpxOLJ967M7a28v03Rmt7GIjd6f1ISuYgivug2Ijk4yE4nZ4nihZKSswp0xORkeYO0o9dkkOP2BjtTkvOLo2UlaRGaTtNYrRfssEUo+NmhcXCfnAViQ/ZqLjIOxm+pUgCaENh9NhN7YW3+8y8Xtm2K9fbzPWycrtvLJOQ5t+D2+OP4fqqSP0OrtgJDGqvrOuF637jvF5YnzZul8b1dqXeVmxr9FYx74zjBIg7Kik4cirklN/FQC/TiXlScgqe2hiDzZ0+NvYWJ73aR0Sfj4i7SDZIMoJhR8RXy7E8T5PwsMx8/e6O99OKtLcoguSEpsSn58Zl77w3ZRY3fvBm5ftvKq0O9JCuNx94T4gFXienRJVEbytJBqolvjRuYIMpzUiJ51eN9+pq1HWl1YbmjBzcPjGliODiRxw6rFvjcl3pI3Z4bmE+5hmGK4OeHR2BeeoWeUZJBJNCLopLZp4SL95fmE4T1oSUOlkT86sX5JI5f/GI+CDv1ziJ393x0dfew+7uWM+fU/tKq502Gn14RKGYH+ZNfzdaUznGcxaeoQQxX3z3Ho+RHODeOaoHLvn5kxSF48jUipRaO0QRx7iP2NcoA7PY7YWd9ODfKfjRXSnjkNc7WI6hjvhhBtZjlxV7O0ExBk4iDeNqmTUJpzS4S0oOQxN1ON06qwvrgCU7cwK1FW4NUubuVOiWGXVj2yqaj4DOxVFdsJ7prQf41wet6tE5hjo0qdMtMboxzIlMrZja1t0PKodjfcUtke+XYyrRkeTYyIhVyhSElZEFHRmzDrmQTOg2WPca/0r6mg8/+pD5bqGb8OJh5lt64vtffIb0DgzMlcAS9yN/DDrOCcLSMKDTcFJwKielDqHnRCTOh3hpSHQvMuLRqtCAmpUpFVqGeSgpJZIOvHSyFeYsVOtgEbq5u1JNEVfwhokelAtDe9DnTYXaNtq6sG0r1/XMui9c9o3rduW+Tpym934qRn5fFanf4eXeWbdbRMCfH3k6X7ldN277jbX2GPPVSm8SGTw2wuQnx2I7R05STsKUlKlMTGWKtN38o7m6d+ibUVtnH8ZeG3sl0mS9x8dME5lIsg3PTIIszHcLH72841v3MPVHfNRgsIlhumBeOZXMy+y8ud34tdeRCzVI4MHYe5FhxbAWabqlLOzbig4HTaAxr3c3VCdSSRErkSV8SD4YW6P3HUkSYFgB6cYQj4Krkds09k5dO6PGGFADLRAR3Hl+J4OfpkSrccrNOT7KwzuKscwLpyWTTyfe+/oL9ltnWGe5O6HpHjs/8vZ8pa0b91+74+73/wHEhNPLmenxU37973yPN09ntupYN8YRpeHih+dLjvFPmFMVRaTi8qOd0vNuw+V5DyfHxjB2ODIEkUPSH9uFGNm5o6JhvD78VI6/o5EjIVgxDk6eBy1fCePz8y2VQ1km4ogf0Nzn4kgcyA1Clx9tW4g53LHRuXqIaTKDpQhLEYZPrC0KyNmMqspd6UwK0gd1bchpJr+c0V2pa2W/VKYlM2WwkskZBg5NUOtY9li2SEHkAKoeYiQfHjlj4zlywjGfEHN238k1UeaE7Y1eIqa9i6FDoygxAvl0HKBcM6qd0Qatr9xuSv7yife/lrhfjv2lb3ztxT29N7683RjVg1aifnirwv7hOEk67lN8PrSBNLJEWkFnsNvhJbMf7SYPCiJ9DKo6uSl73tFxh6Yo7BOKykJOSpqvzEPwVMiphSdrHJ2Zh93DXXBRhgrWB01Ba8G2jX2duV0Hl+vOi9uN2/pIaxMzE8kfftJr1FdF6nd0udNr53bZuZxX3p7PRwzHlfNtZdu2SMg1joylwxPlcXrWsE6ScgSV5ayktETAYVFyiSJRx6A22JuxVWPsO63v9BZpt0qARSExxI+dVCZpPMf93cy3HmYyN2gb7pmuEvihtkYn54Vrdf7upfLl1uhdjih0hRFz93HkP6Ui7PsFzBiSUXLEnstRTEpCy0Q6oi7SAcD1NshzwlpgdUSJEZMTTDrNYI19b1z3SnMLeKobOoVS0azF2CgXrAWWR3QJb0zv6JhZpsTpxQseZkWmE2yVeSno6Z7ad24//JS6XWOMlxPr1ajb9ylufP5rndvTjb019tHZh8TolMPzoo56ei4p0SFhGB0zPXBERL4JhnR93m4fOyDHJEetET82UuOd0MXk2C0ecnYXxyRu2yqESvBZfGFGcg2z8OELCz9YAudHAgyRdx1WGEwPkocD5PiZxz5NsBi9JRhoGKjNqT7ISSkJXsyJZsbWhTacx+FM3TllY0pOv+602kinmdPLB+p5w3ol5QUHcplQs1ByqtJbi5j6pLRWjxyso8gfishh40D6gHsjpRk3Y7sRU4ST0lfDSgRQ7iP2SDrNJDsAyFpiEmAJS4kxGm2vPLlRspE+eImWxJaEDz54n2+lyv/t+51LbfG51hGd+lCGxO+9EKixOEDEz0CFKQs7yhg5aPNH2u4BoEdHKB+HQ9VKyqHCVZ0oCiOFgT0nJZeZqUB7Zv/ZSs4zrVeG5dg5ekwiuoGq0UdBurHvO9tWua2N9Wnl+mLlui9s6878AFr8R0KRn9DrqyL1274cvLHeVrbzldtl5XzeqeeV6/XCvl6o20arg9r6Ea9NjK0AO27okhIlz5QkpDxRih8FKsZ2OHjvcZpvLSCyu9F2ww4QrJKPRbkfOyghEVEed6eFb98/8F4WvN5o7gQTNLYdm2eUTm2Vv/NY+fzc2XtnMAUctA98DHaJ3ckyKc3iRqYSpze3yD1y0QgpnFKMcIhMo906tdb4wmlC9Hkl16NAiUa3ZI39VjlfKnfziVvfaHtwDSd1cs4Bpz1u/n7QGxiDrJllLhQyp5cnUkn4AnMu5GXC8+D2ySPr4yOjbjQNJJBosAEv1yu17oxh7PWIZX/2rx0CrXfWEj18SQ6ueuyDnm/00QWlEYNJs1BxyCFQiYne0QmJR2HTZ4VfGHHDMncIazx2gUkSKuHLEqJ7koM+gdm7bk3g3esOqEN4xhzi58mxD5WjYB17Lo6QQRMhFB8RJ6/Y8XzGPozehaqDU068mhO1K3UYYxjn7swZ7iaY3KjnTp9n5tMSJJBb3KzRDJNQstOrBI7KxvFeQ5SSNcgqeMG9vtvX4WC1YykxpYK5sraVTCGpxmflUHS2MfDm5FSYcqLjkWA9nOJOI+C2NjqPVyHNEy9fvOJFOdGS832DMhfeyzPX8xPmE1kiKBQLhuNc5AAEg4wJkYZJoKHuc8bLYLUENuI96LPGMw5c3Qo6nDycZE6v0HNg0XJysk4UA0oNdekQPIU3qkv0xshgaIrvn8XBqY+O1syWOrpWTtuVy555ua48Xu64vrxwv12Y8hKRPT/B10/2q/sJvtyh9sp5vfJ4eeR8fWS7PXLdVi5r43bbaFtQmVvroQiLKdExJvDDsOvk1MnLHWlJaMkkhUTsPHYfrKOz751bDcp56z3GIBZUYzskzelg50kyIBAz77068c2HwswT0CFJ0MKPZNGUOo3M9y4XPrt0th3sGN2ZhcxbksaNVxRFoVaK6EGTe8a/WAT8acZ9Pjocp7fO6JHVhAh1r3hvIZpIkbvURhhtt/PG+Wkli/KH/q9/mO//P77PD3791+magrIwZWyLRFXzQUZQWUhpMM9KWSbyNCECrTe03eGT0q4r1y+f2LcnuiW0zJQUTOjee9gEtsY2QsH17JXEA7fjP/L38y5bSgTDwGscPgjptx7KvvGuskWhUfFjP6THOO+5OMTQzQ9irFgwCqNoHCpQMn48px6vL/7+j4rSs13bJaTcMRoL8YgfEvd4cfIjG4Dbu/FkdFrPz+FHcZ0ZXnGB5COMvC4MU0aF1J374pzmKFStOmsb7CY8zEZWx1Zja53ycMf8cKLXFnT+rVMWInG6pRBJtI4NIcvzIDI+QzY8QhJH7CYdZ73u1NqQvJFcEUkgyrJAInh6gw69Hf/mGdXYIYnHmDlLoeqGD7isG/4mSCgPp4VimW2s3GlmFuEqSh+B9BKP3VwfCtNBZPcQtsSBDTQpk3RmzVgZ7H5YNI7u1jxQT25Gb42alZIyXTN9DMpkiCrFhTHBsJlCZZ4ywzM6niXugYAcw46Uaw+siIRqsjfHamW7rex3J9ZLpb6/87h1Xm6N0zKgpH/gBPaTd31VpH5bV0hAb+vG9Xrh6bJxW1eut53burHVYOmN2rDeYjnthkk41lVBNJE0kXViyhMlJSadWVK0+xbHZcYIFl3zGqq4PjAbdA9eXhGQd84ZQuqliZKEl3eZX3y18H7qeBskF942WAckEU7ZoGWeLo0vLp2tQZNxyOKhjwDOvvrwfe7YeXxs1NpJKpEZpT8SgSQt5Bxst3yE15kZte/hFaHhFqblTmJoongUOVplN+OyrrTeMO/8vV/927RhyJxIPQpD3S0UdT4Qi9GXpE55sXD/UhFPeHfWfVDuQrSxPV4Y25V93xHPyFLIKpg57XbjXCujGfVAFsVex44RjoayESLAkGN054ZrjNzc0hGjEJXKVYjx3UGGUIuohkOHF8/2I/VewhiuUXRE3u2nxKPIuIwoYMeIT+LpQqDyLnrhCG4UOUCkEeOBT8QwuDGkID5QGQfpPfOuEDyP1iQOEjZCvCHSn5dkx+EjdnByYKhsDJ4c5uzMWZkXqG2wjcHTBncZ5uSksdOfGjbfUe4fkNzZLkbfHcnOdJfxaygI9ch5wokgUIlimj0CKweDhB7fJZAenUxygaky2sJ0/xDA2AGdFEIUa6RSUJN3xw0xSJKx3hHv1HXjzZePlI8L6T6+nzvGm73SuiPmVFdMIk6nH1EkkoRJ4vX6AYk288AcTRFnI62wa4+icrwGOfZu3ZypG7WB5kEeldQTqoWSnGwzc+qIF3wiYl1Gog8YGsIjIUDE/rxpdMFtx4fTdqXVwVY7131jve1sl5Xby40XrZLKT7bM76si9du43KH1ylora72xrWdutxvX2+Byq9St0rdj4Uuo3brFl09MDwKAkielzMpUOEy7mZIdyVMo6szYG7SaaLvT9x7mXVMMOThuQTonOVkUGIgmlruJb76a+NYi5HGl2c6tdtaqNAqNjQJ8ue788BI3djFHJTMcfDTGqCRNjOuZsRQaIZd1T3QEHxri6JQoJQdVQsIHlDRk0K4RmOcSUefR9E0kIhm49Qvn20atldbkUCYmHq+P0RVlOSI5BO/1nUkzESPC033hw4/eQ9Pg9jZiHj78xh3eEu3ySL9tQUafMpMWtMR+cF9vrGtjfw4HBgJhFFJn0XD0Y/os0CPaYDtEL0Hdfs63EhVcAn/knsK067GHEg2Fl5hHtPwR2RE+qYMgcYgw/JDZv/usxV8O87cctHh/fuyB3TkoF8/2XxUFT8EE9HiupAfdxKNgKgaqx04tDl1OwGGju3PswPCEK6iHrF/CZ6UeHdpwYe2DNpRTEu4WYWrCtcLWoRksCabs9P1CHYPp4cRySmyXG2aQTwv5lMg06hbjt9GfzcmBC/KjiAeMOHN/d2KrKyk5PhJ9ODSo3rnTj5Hth6xbJU+BeapdSSosKXG3ZC634BwmhJHCqjHMWPeVp6eNVAq5nHj1fiKfG3X7DKvj6Erj/bcx0YdSGJgIWRyzQjUhaUMIHqSXRF0MrSe8VvR5LDsbYoaY0scgWcX6oNY7ZlU8xUg9yyCXE8LGKJ2tZ0rOLEWoZuwcB0t3oGKaUbfj37bRR2Fvg22L/dTl3Fhf7qzrlb1XCkYsCH4yr6+K1G/5ii/n3ne2y5nLdeeybjHm287cbittr7Ra2XqPG6RzeFgU07jZ5DSHpyLngKKmMFNOxF7AcPYRar7aG1sbQYBu/cCuxA3NVJBkPN96UGUuMx88PPCLL+6Z/Ab9yhjwZnd+4xam0FfZ2Xfj1y/GF7fBOsLrM7xiPTKODn0Ye4dxuZFcME24h1+mDwXpTKqHifJYwouw1YqJhRTciZO3jWOHZZgGTPbxemNd4wSKFlIJKoSbBUbK7Hi8xZdbQnK+zJmHlw+897WXpKw8PXXKNPPymy+wJ9jra2y7gQlWZnIu4I32aKzbhbV3erhl4wZ4LL5FGh53RTioh4Ii5HfopWdChMnxeZAUKrKjC3LTKHCHUs6fvVLuIOlHJl2iI3I0CuRzC4Ec2Yf+biEurpE+rHoIOfzd6/aj/4p/tEMYgRwdrB2jwTi9c9yQjHp0RbyTozvxvqN5inEzMngWyOu7lxfdprgiAsMmhhrnbqzuPBTh1ZI5d7BhrEPYzblfBOsb+9NOvrtjfvWC7bZjXcjJgQmdhV6ddRho8ABlODZajDVdSTpx/80X+A8EZETg4fH2fd95+8XfpWiKP9sGuswgx+hLJoYtaE7MNuhkRPwYmwU78HJ7i6bGB++9z8fLxOsdHsuJfVSSRoHqrdG9h49QIklb9Rj3AlrB5qCaTyrsJZENvOmB3VNk7wfCTBjm7K2CTFFUp51iE4VQyCKQSCyj0EqnV6enDUsFVad7qE9VHBmDIYVmkJqBNra6se8T+3qlryfqNtPHzl5XTuMFOf/kBiL+lizHf+Ev/AX+sX/sH+Ply5e8fPmS73znO/zVv/pX3/35tm1897vf5cMPP+Th4YFf/uVf5tNPP/1Nz/G9732PX/qlX+Lu7o6PP/6Yf/Vf/Vfpvf943s3vweXAGDv79cL1dn434rueN9otFv1tNbwb6R3vSw4PS8hrU05oFkqCrM4siaI5xBIloxD0hGr03tl7pbdKPYqeEMqgpOFil3e7C0gFlrvMt95/xfszR1Kv0fbKJ9vgs63z9tYZu/DlzflyTaw9dg1+nPG6GcMHCOQsYdS1IFBbc9wjI0eloRow0dDRB6NPXBith0/HwtcziZI8k12wXml1Y71dqbfw6qScSU54RKaJpBNoweyQfvdO7w4DppR48cHEh998SUnGdttYBty/mhhvdm5ffEq73OiS8TlEFKk1LteNy+3MtVqoyfyZ0BEYKSEx/BidHLfm5yyrYKXZuyJjElRugUM04ZShgJKSIykGbSbHV0yOkMNjmPosvHi2P+khPY+fPXAJTqI9752O53juYsztKIDRxckhR4+JZDq0EY7KCPyhP+sRFTkIE4crNDiJUt69uhjvPUOK5SjSoUKUg6yhHju551WX0IOGMITL7lyG894kPCzRxbVhPG2BApuAsW1I7zy8vIt95HWnrxs5CS5TvCYiU80lAg9DfGR0u/L2e59j3gNFdXgFrXf2btQamWG1DfowWt2DF2id1kPEk8SxPKG5oKnECDuFFaKuLb7PdfD+Rx9wev+Bj+4nchkkFUqK3yFAHU4zC5+UQMnOjIF0hg/EIhJl0cysGXKOfyeJ/ScWEnJpFQ66f2s39rayt04dYBKg3ZyUlJUpJ6aiZFVKSpGZJoZ6bImHhHnbh9E7jG7YVlm3lb139r6y1sr17Nz2DWz9B8YJP3nXb6mT+va3v82/9+/9e/xD/9A/hLvzn/wn/wn/3D/3z/Hf/Xf/HX/oD/0h/syf+TP8lb/yV/hLf+kv8erVK37lV36FP/En/gR/42/8DQDGGPzSL/0S3/jGN/jVX/1VfvjDH/In/+SfpJTCn/tzf+535Q3+eK/Yv+xt5XG9sq4b63rhcutc1866Vra9sved6jvjgP4bHq24KJIVTZkiiZJjUZuLkieQMnCd6GbUXtlaZ68be93pzWgdOIgFeuB+RITkcVJHIE8Trx4WfvFBkHYmj04bcO3Omz2K28ti7Ko0C0L1OG56jmIDzGJFL3kiTwUbxmme2GrkG41RUddYGGdBc0E0PCPdobbOSALewDPjOcFV4kRctxrdWe/UPgLLY06aM+kEUqELuPcI0SVO+0mFu49e8bWvPTCVApLZrrcYz00z9fGGbzdGH7S8ILnEHmW7cb5duPQAvh6LoXjSgyxP8oMHF+O0eMhx83+W9nmc6kw1MD4+wHOc+EViUW+Ka8Il8sHkoJO7W0SGxNIwiNbEiZpDliHOO3Co+NHKPvuuPKQR7rGjkmNXxDEmREM9KsTI1vJATRlSDmirHwqzQ2YOQBAwQiF/jNOeqfzPknWN16cWXZa++7mHgfQwH/d3xSq65t7CW/ZigrtJkQa1GRczfEqRTnu7YtZZHh5whf1pw/fnvVfCyChH6q7Hd0eOnd8Qp4+G2BGk6HYc4BKbbLjOZBdqrxgFSfAwaUTZkMmSSUc0TcjuM0ljBLgPw2vn/uHEz/38N7nKWz754aeM/w97fxdz25bVdaO/1nofY87nedbH/qiqvSmgChResSIExZOwz9UJ8lIxxBu58IIgF95IKkYlMYaEGIUYDBcSTdAYQ9RECYkXXmhMBEkkOQGUg4dz6oUjyfH1PYVQuza1914fz5xzjNF7b+1ctDbm2qXga0FB1cUeZIVdaz0fc445Z++9/T+BmZw+VVJYNBhSGFboKkxKcKNmjDbY5jOzHamlUg/OZDWUo73jXvKVjyZos4G0QZlu2LaQ9G9lQevMKBOU6NaaTJk3YZs1psHqrM0i9d/BRsVLw0qlO5QenW+tGdu2sazOtoSheV1DMVy/hGOSPq9N6k/9qT/1Of/7b/7Nv8nf//t/n5//+Z/nK77iK/ixH/sxfvzHf5xv+ZZvAeAf/aN/xB/+w3+Yn//5n+ebv/mb+cmf/El+5Vd+hX/7b/8tr732Gt/4jd/ID/7gD/JX/+pf5a//9b/OPM9fuGf2e3SZN5ZlYzlvXE6d03njfD6HFP1yYawrvTfMjGE91FpmyFCYNBt3J2opzFPhMAvTPHOcAy6TXdLd4kPYLYr+urXwYfigBIUQtR5lJ8oLUxVujge++qU7bsrKusb3u0x8tg22odxVuCuV0zb49OpsI0hlI9IRfDTwmKBuDgeGweF4S7eVbh6qPxdKmVEVRGoonsKaQ9u2UGNJmGxtiyQCxKNi/RLNu617lBs61/sxVcVWj3xAC0HDvoB7cUopPDweeHD7kGfPztj2HIpznI7058/wywZ0fDpSS8F757Kc2M6NdaRiLfkcCAJbbAMUN73CcxDqSktBRIhAiEmKUM9dkyIktBGmlhtSqvRGxOeA4Gr5c8N0Lfv0u8v/Em6T/F4Q1Cuem9+eLh7cl+VmJVTdyff0Z+1ZbpK0vITPLCKaApZ0CPVfiZ9hSCZ/CNGjGxvz1fxqe6szqXLcvVfBl8UWVwL6u27t8dWbw5PVuJlmHhwLW2vc98F5MXw2jlWxJdIXbh9G2+66DLZ2Rr2iFdRjCpNEIWqtjBHPw3uICMxDvl8lEAsbg7Zc0MMukumMrugcbdPDN3QotZLtzRErVCx8e5hxqPD6V36IepipU2eaCjNz1LazHwiEbqns0xmVTnNDtAd3Zo6Z0MRQLRx8olenb40hAY1f+UBXxGpMVn2hb0eWeYN24FA7UmpESMkBrVBqZzZoHUptzCOr5t1wbUSiSRw+u4VXsfdG2y5sfeO8dZbtwlijBPPo/iUr8Psdb51jDH7iJ36C0+nEG2+8wS/+4i/SWuNbv/Vbr1/zdV/3dXzkIx/h537u5wD4uZ/7Ob7+67+e11577fo1H//4x3n27Bm//Mu//Nv+rnVdefbs2ef8+WJc7kYbK+ty5vnpnmfLcy6ne9bLiVO7cOmDrY8gfbtGtUUqeSIVx6haKLWEaOJYmeqBuU6IRBPssM5mg82U1jV8E10ZvUcRHE5hjmBWceKcESP/PE988OENX3FTGduayc5KU3iyVbrF4rta4501wlEZneE1iOMxrqfqUiKT7jhH+sU2wudhVoka94KUSB6XNDD2vscadWQYZSsR0SIV94Z7nPjWZqw9qgo+9GUPkOK0Hqc6c6CEAq0Wwj9FJHJMx4pO8Pxyj20bZZ6p5Zb1/kxfLvQCdngQ8uO2cX//jPv7hVPbIpU9i+jCUC1ppp3St0QIDTSWQxPHUr2YMw8SAv/wlWQ6cHzddFXjKVBzcjYpyScUnCPGlAKInXdUhs8MKZiGyET2aUQjCkly8fDc9EWU62/auSOPiZ1ccCEyDff8QnfBvRBgX0RnYXEokeTSIl5pn5IIgVjGJ4lIbMoqL5Is6Olp2kUfEUNk4gwVnEMWDzrn1nm+NuokPJzD73XfhXOTENqcFy7vPEenwnyzJ2L02KTmQq3hr9Ma74Xdl2feIsh4OEXhcPc4cvy60ZpFf9sWHNdmgzPhLbTRGWPBvFNKPL9aU4ad9Rcf+LIP8uE/+FV060zWuTlMzDU+y1HC7BHP5BP0go/G5kbzF1OmaPjRzDvDwjJxqIXjoVBKhP5KxmmZhDy+W2OMxrBAUUZzlu40G4jDJIVjnTgcD+ikTEWY6oROERsWB6A5I8bi823u2CiM3lj6iCzRFtFqY3TGYpkWs0MMX1rX571JffKTn+TBgwccDgf+/J//8/yLf/Ev+NjHPsabb77JPM+89NJLn/P1r732Gm+++SYAb7755udsUPu/7//2210/9EM/xOPHj69/vvIrv/Lzfdi/6ysoA2dpG6fLYLlsXM4rp6Vx3ha2c6O3NaCCvkV1hQV5iwVEU0QpJXiXQ5kjmn+eY9OSoL+7K71vrFtn2SJtuq2dbiGmMJMoVdtPcxaVBfM88eDhga9++ZZb7fRtgTborfGpdy48WS5MxZhn4dlwnudkNTxGoEgY71ezZT3chGrvrnBeLtgWGXqIoZmOMZVIy5AS8uHVNkyi5wkBq4PD8cB8qGEMlhG8Wo8ixD46p+eGaIghhkMfGz6gFAlviyT2Xg/cPrhjKke0Hbi9u6O44M+eI9uZUQpWb3Gc83ri/uk995eNrW+hVvSBZ2ndECKKSVPNlydOQXBLv1DgnhgQS3HMdMOMZv26KYRgYrzwKl03rlTkOTmpxEQS9RoCXgJ603gt43QeviXbB6qQP+BEQrxUcHsxge3+LHOCUzDDzMBiE3XfQ2cDdCbN0+QcJ56QFZ4wcr3OTKFii+QHtzQl+86XebxPPOA115ii3EpweznmCBsQKr1Lc54uMak9PFSKRP7f08UCDl831nefUUrl4aNHzNOR6kqdDxxv75juDkxzjUOfOH1EZJJJz7COwXZ5zuhZtZHm+WErbXTaOhhbT+h1pndnXaPoXQqIFNSFKsrjh7d89A9+Odo2Tk8X1IybmyNIoep7Dgd5j5o7KwF5+ogJdBaYVZmSa6Q3lOC0itb9BBavEY4Mi+Zmi0T01jbG2mn9wtKcZRuBZDghvEI4pNWkasSMKWHyxnso+2zgw/FujHamWWNdOq21+HPZOC8p8OorezTXl9r1eW9Sf+gP/SF+6Zd+iX//7/893/M938N3f/d38yu/8iu/F4/ten3f930fT58+vf75tV/7td/T3/dbXj4YfqGdF55dTlzOS4gmzheWc2ddNsa64X2heUuoJKYvk0iBkBKp0LfFKFU56MxNEaYp2kYR6M1Zu7O1ho2FlgVo+wKLBIwTSjFP7sMotfCBh7e8/qBiLMgYrMN5dxPeXgpi8KGbmUlvePcCp61HrYU5zdbofvJYRG4nodqRu9sD26WxLluKWwyqMxUok6QjXpkeP2DYlFyWwCGk41jn7vGBSaPkcbR4Hm7xwfFBJJl7TbgvqJG+xQm5d6FMEw8e3fLSw0fcPnwpg10taryf3TOWc1RyzDeoG5fzme3+nssaJPkgNgm3EADEUBRQDDZAgmfTDI2VrOMY6WkqwRgE5Jewm+aMskcZRS7eLnrQBHBGTEFXAQMpRMicPod9kVOXUE5mEWZwX/W6EIpKpkbEIcH3zUmAa+VHmD81pydJCMzS1BsnbE9Femy9CLgqxRNyEieSvrNSJJ55pCRk75XwIk5JpCaK2eOgIyll9ugP3p+05XjYDN7dIhPylZvCTYXFnFOL97H0xvb0GbUqD186criZwvJgYWcYVjKF34P7IaK0RCo2oPfG8A4aLdCRMVlAozrmdNoAQw9OqXFwactK1IfEZ/LVx4/5mq/9GK+9fMu2nhmjsYni5UA9VupcmeawWZhLHO5EGAjDathDRlg0poRgxaLfbHNHHaZSOdQDVZPX40Uk1si+udZ7pP93h25065C9zDdVmGblOBUO05G5zhyniVILkwZ0PHa/GR4MpBljCGOMsHtk6HVrWxjZe2PnOL/Urs9bgj7PM1/zNV8DwDd90zfxC7/wC/ydv/N3+DN/5s+wbRtPnjz5nGnqM5/5DK+//joAr7/+Ov/hP/yHz/l5u/pv/5rf6jocDhwOX3zDWRsbl22hX1a2daOfNrbzQlu2MDH2UMYJwU8oQYZWifbYqQqlCrVOHA8RC1OlMmlUMfTRaBYKHx9rJEE3aBYVEU4J979MJEOBiDBV4ZXbma965Y4bWWmXhiG00Xj3opgINxM8qspbp4UlW3XNAyLQFuKJKZsBp/nA3TGqxJe1xaSxTzSlInWi6BSROXSWZ89Q6xzmCTVjkoLozFIG7/7mib7E85Iq3Lz0Etv2LqOvFB8cbhTxGbMVcLyFCk4lRA3zsXC4veUw31FaYPMyhHF5Au0CtVLKAzBjPT3jtF5oLWAXlTCsBk8UqgdJojy2IQ1z9d4W6JKj6TWciD3lPMJ4Pficq/yciDW66vwysYJIYw+l3b5RkZxNC2WgxiIJEas0Qj2OEhNlaB2SzDaJCWX0kMeHpDBeP3H2lO2d3wjUKg4VseRUnBobbcYiqZCiB8F3o3IQW6g5XTp7VJN4RZhCcZjZkHEXs7xLQ4oRz7Flml18BkJKn5uiV9yE58vgOMFchCFKN+d+c+4Ogo6Ny5OnHF56wHR7ZGyN4SPSQSymOLdKlR7h6QGmsyfMkzJ6H1Bugv9l3Ri9sfbOs6edxy8dmI8z67aBb4wuzPMtD28n/sAf/DAvf7AgCPfLhbWNtIFsPDwKpwFtnim90UdUz3g+BjOhi7AJVM8WggLbiMPIsIm5HjjqwBh0rVgV5FqsKahbZmZWvHvYWYpS5zsuRZBJKHKg1MFUnSJGrRJiCp24yEA1vFcukpmBhc2hth59dm3QWufUFs7LhXW9MPoDdg/gl9r1u5ZzmEWI4Td90zcxTRM//dM/ff23X/3VX+VTn/oUb7zxBgBvvPEGn/zkJ3nrrbeuX/NTP/VTPHr0iI997GO/24fye3g5HeN0biz3F8b5wvly4dn6lPNyYds2GCtmaxQaDssYmx6+B42oo0mVuVbmOjFpDXVcqQyBTTtbj2iYS28RM9O26KCySDAQAnvfM/8guqjm45FXHz/k9VvBthOt32PDWDs8aYPLNnhYCr113rqE5ypOw53mDUiy+/r4Cjd3N5xOpHm4h/+iTGido1bkQUWqsLWNy2XF1KgiHG9v+fCHX2W+mykUrG+srTNWo5077fQ8YCLN9HPpWJo4L6dGbx2pE5RbNIUgooPR14SoBv3+HXy9p08C84xYZ332Dqd1YdkGrceiHskR5OYDu0/IMIaWlHinv0w0kyN2H4tl/FD4XwZEJI94PO6UhpciqKQR1lM0kadnT3I9YqPYgbvgh1xCBeZZraIRaYS2UBoSfjORMAZbbkziEspKIqA1CK54bvvvgYLJISKSrlnn0QKcygn20KSoIyoBI1tMTSOr26OkI71iEtAhV6tCws1S2KvqIeKJhpTg8TQg1F3ev6smB86pdy69c3tw5hLryGkJ2T2jszx5BmOgpeSj70gRapnjfrkw3dxSa0FrQeaQ4tc0/4o4tnaW+zO9d9qIzX/ZjPtn79DWy76lM2zDxfjghx/y+td+LXN9yDIcX7eIarKF9XLOxuCZVx+8zIObQ6r8BkJFfQ6OcRBT04A24uerK5PP4V+yFYWAyg+ajS2WKs+IxHILle1qg41IXO+20QZ0cwobhxLpLuV4CIVwOVAKTHVCNCiBkdykm4EFPNps0LaVdXS2IZFGsV7o65aHpi+96/OapL7v+76PP/kn/yQf+chHeP78OT/+4z/Ov/t3/45/82/+DY8fP+bP/bk/x/d+7/fyyiuv8OjRI/7CX/gLvPHGG3zzN38zAN/2bd/Gxz72Mb7ru76LH/7hH+bNN9/k+7//+/nEJz7xJTEp/baXQx8r5+We50vn/rxyvlxo28AWoV2M3gzvFa6JdiE8QCMItejEVJS5CNMEdTb0UJBJ4o1J1CN0G5FO3kdE9aTiKlKhI9am5GIrJeCwm9uZDz++4WDOZY0U7DE23jkbbRs8LBOzKL++wPNNk3cK0x9mMDpajpR5YtLCzYM7LlvntJ5SYBAfTpWsfROivA2l9RFpC+aR69Y2Ts/PMIRalLHEh2BpicenxHrHv9dnhsqGVI2GdY3qcEluq7tFfE2Nhls7nyh9sEml1hvMncvzJ5y3haWFFDiGmPCK2OQhgUopuOzSaROQ8Pao7PFHuWGZACEU2KUTewpDGKZjE0rDFC6ek8muHAxYsexfQiygscBHDmFQQ+HRkkyEFxHE5zTJXnV08XvFQ7CSHId45B0GyRJfGfxGTWVITI/BaRWEkcKRZKh8j0LKVIyUpauHJ4mhuICKhQR+TzfJ/D9NsUZsYYT0Xgynvgim9fewHNfIpj31orAMg+7czeEdWpvxfIVHN1DMOD95xu3LL3G4qfQ1Rk0DpGok4JtRDwccY2wWtgfCqsDWaL1BjwireYoAWlVlWxr3ZeXm7jafd6SkH27uYH3GupwwU+ZZYUyMTaNmxiO7b56M481D6rnT+xZRU1qyNVooFm+hTaGYU0pweGIB26IH5mLcFGHUgo05m38HsOE+Mzw64oY3us/0bszzyug1BDkoVZTj1LFRaP3ANMVm7D1CbtVeAH5SBnhjjB6+rnXDF2PrF9b+KFCgPpg1R3q+dKR+n9cm9dZbb/Fn/+yf5dOf/jSPHz/mG77hG/g3/+bf8L/+r/8rAD/yIz+CqvId3/EdrOvKxz/+cf7e3/t71+8vpfCv/tW/4nu+53t44403uLu747u/+7v5gR/4gS/ss/qCX44vG/0SPNST5cJ5u3BeOst2Yh0rvQ2sRfipY1k/EX6aqoVaKlpLRPLPBdUjRafI+RIYTdia0TawdYu20hHJD5ZIjuZmJhKJx1HjJHzwwZHXb5RLu2dpC6UJ96vy2TVKFg8VLsN5+zwinDZP/W5CHyGUePzKAx4+vKWfF6Y68fzJM7wPNg9oSlUoc1aCiDBGZ+tLwGVDspZDuSzGtj1HMZrDqTdOy8poPQQiBMzkicbbaJhWSh9p3ARrG/PtgcPdHbVEMeQkFbt/jvYzJhWtR155PHOh8O7b73DaojMp7bR0lCIgY99YEnJLuGqH5TTT40N9XvYbnQv87v/ZwdVQWKkXBhqbQfJQMaFYBgulHB1JmXHcm13q/eJPFOkFjBi/c6+IJ+FGS79UcWFc/y2FD1JBQMcOG6YpOENY7TpZSUw7RI8VFhtqTJmxAZuEYMQiViO2Hvc0NxObnEhkJjJCcOAxYe4wkefXhfVL2Y8EAdFxzQiUrCZxF5YOmHE7Rer6OuC0OLczSG8sz55z88pjpqkwtkHX2ARW0/QWlfiskLcUx4ZEXckY6d2KPqk6R31N82iTnub091WlujA9vOH+/jnaQ1yzLgY+WJeVdVtxVw7HCBHSBw84nM/YyRgaGYyO0L2FgIEpJ9WR8Cd0jUgls5WihVkLU7H8+xCeCB5Ig8HokskSGzZrrC860QSKh69rymDauRKwoERIAKZXgdUutRmjYB3W1mhbp29nlu2Wy7pyaSutX5jmGfkS80t9XpvUj/3Yj/0P//14PPKjP/qj/OiP/uhv+zUf/ehH+df/+l9/Pr/2i3w5bltgw4txuTxnWVYu55X1dOKyhjdqjOCfoqnTiYlKEQ9Vn9ZCmSZKnUPdp4VJp1hM+krfIrm7dWPtg210+mhg0Vi6pxTEthdEu2jh9njgqx494JaNp+cTZTitO++sg2fNOVbl+TC2bmyZHq4WwmPzWBikGtNo9NW5u71h3TbO60bvRpkEYaJIoYoiJXiQbQzYOjoJRR29ESwa6endGd1YLifOz55hrUc8kQsbHfWQzB/vCtrg+WVLcj6q3qepcqhTPEcr1DIh6z3Kia4F5gM2jGf3J7j5UHigcjOJxDnDmXAbyVfo9bXMSNzYsNxI80l2CebmtHuEPKY+t0ho8Iwu6lN2PvX3RBBJqrRMrgKFgOAkjNzXltzcEPdHkt6qvfJeXKJDSzNHj5hKLNMoYgPJiW1XCeb2wAilnOfUvedmxK/JnHQnJ7n4ownxhHw870noc9jTooLTS+UeWz6O4NzUeQ8f5Kn8i2Uu7rPjbIQNNqTuZExUTGSwjkg3uZlilujDOa3GzeGA9gv9rNTbh5SDIsugHEH0SB+dtm2MscVnrSo+iFgvzwVaC0U8D2SOe8cdmjhtNGgTBzcmnSit4GNjlULxEKx0US6Xhb4FH3ZjlVInXi7K4aUbfr13JoS5FM4jLBQNqCM2p2iIjkOejh1hiUNsLTBroZUSRn0soebOMMXoqLVIM98qrQiiG6JHjoeBjEO8VuocaqeVylYb21CKtFD1SUE0xCeOMXpHVqFt0aqwbMHX+fqM3h+8SEH5Errez+77P7scRt84rReeLQvbeWNZGtsSRX5bM9pwrLerFwhy0SwOUpBSKGXjoAcmUbRMUBQp4bsZ1mi+Yi3K3dpY6SPSFmSvKVfFpxrJBV6gwlQLrzx4wAcfTGz9Xcw6pSp9NZ5tg6koj6pwasbzS8jRY1Eb4KGyQ4JL8jG4mzq13PD28/vIzMOYtIQnSqLjxlVwLSFa0OjNEQTbiH4odcxWzucT50vUriMBeVax+BkWSQ19GdFN5YaYU1WYDweOh2Oo7lwpZYJlw9YVLzXCd01Y7i/c9xXzM73lhCH72AlSI2rLI/YhyHevVxHFzqHs1pDr32vCbLJzR6mIsz19IRZUTSl7QHiVZK0CABNLqDAflsa4fFVkkikWnpNSFinugGMYoz2mnAB7M7EkxQfIPsQF4Z5a9JhdPH9OPlbVa5TSkJIbJxTPTElKPo+MSCLmuxhLIqBWRRI93A9emd4OaR6O83rxFwG5IbbfYU3NVIi0C+9ZhLrL2Z2lF3wI8xzf04dz2gbHqdCfLOgq3L70kPmo6PERY/xm2Ba60EwZ5mgP4YtcvWCG2KDMBZMBPYQjcfiaYQzKdEDa4MHdA7wZF3GW05m2rNw9vGG6uWE5LxEVNgbrXHlUJx4o2O0jbm4atnb2TCrV4PFMVjYitSOmuVAQ2p7r6BFFVYoxTdF0TA/WskgJuwfgY9BtYu1O7YJW6EPYhjLVQfHBXAY+OTJXtM/MzfESlSH7ochMoK/QS0jRe3DVbdvolzPL6Ybz5cLN7cKs0+/RYvo7u97fpP4HV6xfxroNnq8L96cLz1tMT9vlOX27MFoY78zaNdFYsBBlWWGe4tRZmVEhsrdKqP3Ue5g5u0OLXqU9scF7KrzUUJ2gZoaax/FVqzDdHPjISw84iHK5rEw2aFpZrLOYcDtVjuK80wdLtzC0EnyLm6N0XCqHLFycp8ppObFuG6XWEDV4Cj6Owd1YCd5nZC+ReIoNxp647fRtsK2OSg/yvRYGI+VrE9BQgdFB0zgsRGHizcMHHA+V3jemqVJsYOszbBhMdxR3zpd71r5yuhgjvThCcALiqW6j4WROmu/y8z2JIXkjOsjAvebiFiq94ZE+rexChzitVrJePdt2I3cvF3OJ5T2KIJMz2je4ndMJpA1PQrsAoxDZa27YDHJJkEz8+h4MA7HkLuRIz/emCyI73xbJkDsfZ2ZpVTCEelUFilrCgfGYIs1CEoK71vHl9JWvr40cRiU2a4nNaR+5RCJeSWWXvcO+wQW/poj0hAujTdjzuO6ukaBCZ6Ui5tzVwoXKZrB1mNSwy4mtzjx4dKSfPxt+Np2ZjxOt3SMjprI24v2oGjCp5sP0MSItYkpYtTujO7UMyvGGRx+8jRT052fOlwtrE07dmJ88ZV23OEg2uGRtDMfK2iY+8OjIbz65gG24hsl6EqVwQKyxdUemnCNVqZll6V4o0jnUStcDwzodZQxPBWrI1sUMHY02Cm0otStjuoDdocURFWY90svgUI1WC31ySg9usecrql4jecKCRxtbo61x6H56Me4247xsPB4rU71DvoRUfu9vUv8nV7POqW2slzUiW07Octk4941Lqn9G75jXIKQl3hTiYVAtKtyUylwmpjJRpxAUFI1U7ebBPfW+smX/Uh+N0RuxqsSyVjyKBUYFcKbpwO3NzOsPBOvPYDjNA8L4zcXpffDKUVmac25O84DC3MOtLxivHiee0tHDkTof2Kzw5Fmj9Q2TkM4XOYQ6UTT4FYfNzlCDG4AWsTNmFI3Nb20rhtE3xXpDqzJpzbV6INMRsw2tjm9OcUWnwvFQuTlW8MI030RX0PqMyY0+H3GE+/NT2rpFSGwSEZqBmrsaDpL4j1EBXHbHDyNFVLneIr7r1+JnhRg7PU8OaNSR6Is1OTLcxK9ChOCCkmeRPWooZpr4/wGpeYJgIXjw9FxF7xY4MgIalj2njxBtKGBSkBFwHw6UEYtdPu7dA7Ybd101ocP0hmGh8+t5nzx0jlVD4RgbVsDUEaKbysH8OTtCgM6ZK+ixsRFijXi8I29uhNfuqJG+Z7OOgIUdUk1FIB4tUa5sm1Fm51hhbE5LpWwthe30jGUWpEy4bLgXJlVuDpEwMgzwKTZSt+T/s1Id8NGi3n2K5I1l3ZjKxKtf8Yh6qNw/XzjfN9oWFo6FlYt11m0LnssG1jesr7x0eJnT+RkvPXxIG8bpLOhYcIOxew4cqg/aIOBEKl4i81FsQ+uBYx6exjTTR8N75BC6aPCAvtF7wdXwadAno7dBKxulhKpPDyvKxFw7dYLSIg3GR49pEkBH+LAcemtc2oW77ch53TivC6d147KstLVxPCwId1/IZfR3dX1pMWRfapc7ozUu68K5O+u4sPbGul5YFmgL9BbyWbOVni58twjZdC24VrSEVLxOwqQ1HOdSQCvSN6xtbNYDYzfLD2bIdiVVZiAUiTp2qlLmmY+8dMMsTrucCYe/0jbn3S05i+G8vTr3XZInCzWWAsOcJ71TNJIvjrdHTsvKed0wRjTxlilqrDUlx6K01rN3ipAbj0is0Owp8r5gq2FdWFsUHY5htD6SNCY+PMPBehgMXZjKxHx7QDDqHNXh2k54W2nTkV6V0+VEX1futxEblIcQYLiT6ulUlCnDYkNQK8kBhUDlmil+XSAjSkiI9Oi4YqOJSaITYt5dhh6bRJcUPshA8jGEhLenQMNiOkIYugfW7oq9QvGQwF/5MXNkC39R16hsj8eV0UTBXkbUjYyI5Enj754psadqXDcUAqqDlLsTSk2nMpJH64SJd5+QJL01mdkTdyLhWHI7j8SOXfJuMMbVC8YOZRLbokuITEw0ecB8jSw5Nt+34TgamBUuDZah2ZcWr4V1Z/TB5dk9UhW8Yt0odXA83jIfbyhTZT4IkhuBRRJfTKMWr4UPz8cXz7nMBz70wZfRDm2Nz2KYaDf6tkUsWXPcOt02+rLy7mnFZfD40FmK8qHHD8N4XKaQ9Ftyym2w9TDRrpmULhYqv56b1w73TqWgUimyc6vxefEusG30sZepNjbz+Phkr5VKcMaiJaXpUyT/F0eKIbQXaSNWGOb0bWPJVJtlPTNOF/ry/Fqdcn0RvwSu9zep/8HlDNa2sqwLy7LQl8ZlOdPXC2NdWLtFFUd2MYkPdMTihEwcNOL1RSNpolaJoMjQuDEy5btlYvJoQWKOkYuUBcRWdKLqAS2VIhPHeuDRcebLHz6gSkSmrC0Wi7cvsSHclsrTDvcbWG+gLbw1FlL3YQ4Yx+PE8VBRmbm/X/EWUJTOUzxOVYZGrpk5Wb0R0lotnnLxqAxQL1wuxjYa67Yilll4Y5/eYrElq7RtOGUyDrcHXvrgSxxuH7CdnVKUmwPcMBgapXS2rviysHYNqNEjwUOyqDCW03ichTDfCoZLT0ViLNJlP0jsIj6J3UBd0eThdj9SAHPxM6NKYx+nssBSBPMSEK/stlLBqKHsVEfUro/ONRO+CVNwwROaFFRqToKR+6dO3DsRKAW52WemfSONQ0ycuD2bFiQOP7khxFSTm6iGETcS7yPotkoGw7rmjph5gzl5BREVZnAr+3y5p2cEJIqnjViyFysnUfafqf36vovJamBqIP3FvdT4tIl7lmUK24jX5lDjYZhIyLLVaPdnDsdKnQvT4ZbjTeXu7oZadhjW0epUmdBsrR4Jaw4XrEMfUOfKh19/yN2DA1sbKcAIkcoYHWsGPczE3UOxObqzXE5sY+Hh3S2rzNzd3vLw9pa7m5kyVUapRNbhBMxXgQjuuBnNg3vuvcU0azCLUCdBpxGlqB7FnjFLO32ADWdskdxiPYKYDaeIMMlMLTOzFg61hECrClU1oF4sPVyEErkP+jpYTme25cL9srJcVrb1OWO9XKf/L4Xrfbjvt70c98ayXVgXx86N5X7QTp1lbbS+YL1nllp4HCxP9ObOVAZSlKlWprkyzxUtB6rGm6dkaeBwo9lG807rgzEUGwK7XFmjwRZCFCApO33l7sDdPLEtzwISUri0wjtLYyKc65tF3fYgPEzuMHwwLII1H9w8YKJwOB44X860dSHOy7F4acl8sbnjk2DnlnEwAxsVtTjVi090Ot7DPPnsYuAdN49mXSK7cEQxVEhzvVDEuHs08+DllzhOB+5PK9NBKevK3c3MMlXEJqwbt2PBDze8uzwPVWJm0xX2Aj5JebVd5xWRaFw1JzinHZJD0ocUuQn7mVFFo01YRgTbuiB7QLDnEpztxy4eij6Lye0aX4SiSiQReEA2L7Rv8TPJPD2kxM+XhMo8N1pSEdgTrcSRNfcMQpwRqFlsZrt6LIxOQdIHHzeSpIfI1Nur6PMLLSKD9veuXJt+a9y/yF26cmye6tJrNJPvEnMFN0Ts6kWLEc/y3mje53h+imV4bgko0DMbcX8ymZm4mnOswoTTMyGlrY1te4q4occDbTlR6k2o5Y43zLrBuad03uLwxIRf9rE18vJw4+HNgQ9+6DXKNHP7wPBl5XK2TA53zAvFN/roYeRGI/x5bTy9X3n5K17jA+PMXXU2P6AOqnC+9DSI9cilHAPX/ZUs0YyQ7wq3gFxVB1WdJhPD94LHOIy5RaD3aiA2mLoz2oKPW3QORaVOg8kKfZoRW5m36FJuMgcOYBH/5dYZVmjN2dYeaRqXwbpcOC9Hnl06D5YT9eYWLXG8+mJf729Sv83lRE1B31aW5cK2brTtRF8b2+Zsm+C2hVs9oYOQeZYkirmaV0vxrIwfoeZRp0skTazeaa2G63ts2BgURiyWZcdNOr0GfFMK6DzxgcdHjrKyrBeqD7oJz1rngnJXDWuwbUZrLU6RFmcyG7FYlzpT1JkPB6Zp4p13nkbjb8J6YgI1Tmmlx6Y5ekwlEZLaGNsWdfci+DCWLSS20K8LQpyO43Qb+X8Ok0Re3FSYDgcmFy7PTpFo4c727ClvPxPGzQcwLizn57TWubfOyHK2MOj7dcOxDDYVCiYBHnmGjEIsPCrxsAI9jVNtBKiGNE4Jbsm9JGez5/HxQlwAydEoRUbwT7LL2vc2XAfpCbjldGO52Uj8DCNz9iSJLhKuNFD1UL7ZnsXX8eEUIVLl9wQSj4nGkrscsscjaW6/JZSUuXHuCRiaocKBo4wUVyRXdX2cgtACpiPhZyE3LAGBcpXUO6aWp+8pwcf4FAW81zFxVIJ3wvfMipG/MwoOPT93O8DjOOtQJg0YtWvBijG3wnJeKH1Q54kijeWy0FM+b0WwdQTb5SD08GJHRhMqURz4odc/wEsPbwPK7Q/ZxnMGK6N3xuiI9VAFDsuA3YEptDY4ne451Nf50OOJz55WXrk5cjRl8RHRWSNeI3en6Jb8ElSPWXt48H7ineEHqlcmbTR1NvVoqs73niFRUz8a3oRehTZu6CM4pipQNQz7vXRu6symDtWQscX7Jife4Z1hNTIJ+8q2dZbLymXpLBfjfB6cFuOub6hG4wFf5I3qfbjvt7scLt3Y1sGyNO63E9t6ZmvniPnpLZPOA8pyP4DOkAubakV1YqqFAwdqVW6nmamE690NRm8hXzfPrqY4UY8kK4SQPWuB4pHS7CK8fHPkww/vsL5k91LACc+acSPGrcJFnJMZ2xCwOM93rxE4ehDqPLHe3DAfDmwLtGUJuFICbpuKUopcXfqMqI6oRZhqxRWcwqDQWqcvC1uS7lUqqhpV8JNAnRCLacMtmollqkyTInOh9YBi5kmQ9Yxb56KKjYXtcmKMxtubcdlGLqYpQGD/GMfEEvXyYZqNKJ/YH5CsV5cSfCCScFSq+FJbEDxU1NS7pIlWw8yMBLRCLvSSzbzhOcpFdp8m3PP5xmnZ9kVf4vtk534IwYdadCUhA5U9gkgSftuLCktMQRaHoJKc1bjei726heRxYsJHdrGCgNTkEi1HtNiGHagIU6aL5LAXE5JkN6/GFJmzVEBfFgkQlpDpdQLz+LNPnqIlo5wC3tvl+ZIQcsC09cq7ifbr5u05VdUSIgTf9iYug+JMs7BuC/fPT4yeKRRWqDqhLmw2aB7vG83E8GlSHj1+yAe+4sMwF7blnqdv/R/cn+4ZqYpkGNvWWTNCzLMJWYbiPd6LT5tRbu94soJvndu7mZvjgbkSJvSi1BLTKu95z7oErDnJSvGGeJiRqyiqhQiaMjJcCiO8f1sftDFYR3i+bKz0Hq3QrkKdjcNEwH7TxFTD17gb8GOXCnO1DWesjbZeuB8rp3XhdGm0y0JfL8GFfQlMUfD+JvU/uIx+2dguRrucaGvjvA2WfqFtC71FWnEkiQtOQ6xRMYpmcKvEIl8nQUvUoWs5sKJgSt+M0Rq9N7zF6c2Gsae8mQUcNFI0ZaVQ58KrD+649cG2RamhinPfjfvVmURoo/B8gaXti4CiSc6bgt5OTAiTVaDy9MmzwOQR0FgEQ94acmJTp4eFGCOc7EVjUum9sa4rp9ZppxZKKq3oFB+1ohL5QCV4H4CtG14EnSvt3sN8ON8gl8HUGl1mit7Qz43eFtY2GGnYjXP2LjXPdA8seBU3xLdYsj3hlJ0kzw+p0ePriESGkdOQJ+d09fYQJ92xS7Cx9AsFZ/SiGTe+z5Pkio0yuRbfxSpTZu+Be2H2qIRAYsKM6TSKFwWyYDGgFk3eCilBluOh0pORP7Pk0jcyoDY8MZbQYogbNJWMufl4wSWEBCUPQw2jEV3SQezks8v0eElIEwP3Gt+346RuWTzoOP06SQWsRsjx8RQzhNU6ChhjY96X4SEj1ZEjq2MMZNCHYhZG70J43lofWWXhbMsWdRxbD4HSPDEfI1uSfA7xLpCYxMrEV37Fl/H4dmZdNi7PjTYKYyijdWzpWPYw7WKmMZxUzuBj47R27LxQJSa9p+cLsytlmvEqbDLoQtTeY3Sb6F7YUrk58pDjFhCcMihusVHVeB8OByzeb8UMG5GS3kdjG5Hy30eKzGXCtSBlRkthnuMwWaRSqqPqjJHoQTf6CCXwtq5cLhuXbeV0uXA537OcV+6X5/jYMz6/uNf7m9RvecWHa2yNbVtY28q2rGx9o20dHwvWF/oIJdXwHvyACCqFIkLVicOsITcvylx3+E+pTGwZ7tp6JBL3AT5KdlApWizTDjJKJXAL7o5HPvzoGBDEtnBbQp32dts4j46iXFhpHjAfSXKbF8yMMpybtSLTLQ9uKq13zn2LOB9RapnQKkSnu0AJRVkXiQ99idI3c0FKBGH2ZvTVsC3US6rOXAs61ag56s4YEZcjUuJrAB2FWqK4TXCOstBUYD4SXTgXNhO2Ri6AAfUNSC6l7OqHjJdSTAUpFm24+R0iAQGGcTQW+IDGIsVDbMREVCPVWnbJuhBya4tciQBqIptxn58gJPTimlNV2WfpSBlg54B26E/ZJP1WuUmZ95yWcsrLDVA9on9Qw0vCVxqqvGB+9hgdcGomREQ/V0nhQxFQ4iATnFzAkUKh6M6TTQlNZRCs5rQVZNl1Zg0T1gjPkxLSf4GAF0tCo/EYY8cMWHGIYBo8lHoae/EUhuTrmPNcQK0TJAAY1o7BZsmJeW7mw+lbp51XpqkyHY/Rhu2R1CEq1GkOyEp3XnHgQ3j84JYPfdnLjE05PV9p24azAoNhRMealOzHCqgsDOnhoeveWZYT4/4JxSuv3R45941lOXOnhRod8jCU0aOzrVtlDKGbIjoxUeMIIvEOKThTqdQyU2vBSoT2SrFrFUuoIgc6GmNEZ13zweYVz8ltrsJhUqaqHKYIi1aL+xp8Zbz5fBhts0SFBm1pbG3lvq2cL2cu9wtrX/N1+eLuVO9vUv/dFR6LNqJmeRkrS1tY1s6yrqyjsW4Bz5EdREH2xoJmUkJyLo7IRJkVrxOiR1ynpNFD2eYjTjfdYPNoDy0pKxUxVDuqA9GC60Br5cFN5YMHxduZPXpp48B5FI4SMTdrk+ikck/YZuDSCGn5RD0IxxnmWViWe7YRJH6RimqhekFtikWpRDFesRLy3TaC7MYjgX2aqFMNtVDfGB69VBWhvhcx0IBuVIyic27owuEmIFHOF6w3epkodaKtjVfnGXzQcspR8+tCiNfM1Iu3cJS8yXUaQgqqCTGZoqZMXrgFIt17R2B2WbZmmC6YKkE7T9HRpCkkIVSCphLTiNWE5WRHD3OCPoTgJNVZL6KZPHKENDbMeOQpLNARfJVyhR+5pl6U2FBFkkTO/+0tYE6JSTnuaUU8JlcStgsFIaAloUsgO7Cc2JCKhBkXCVlGQHYeYoaUoydblVNSRj7tS+zuU/MXPFDE/HhyfaGyC1l7vDE0f8d+p8IBsDOBoUpzjxsS04ijapSSSesOfduCX6VQkbBM1EQEpnptdnaLKpHDVPng669zONzSxhoqRVV6EVw9RRONNiygVtOQjXtClyKYDdrW+czFeGdrlMMjTr3y5LRyKHB7uEH1wLBG7yH1buMSnBmhAi4adpKbotwUiQ7EUpmLMGuhpCTdXZMGADHDh9L8QGvR2m19A7uAp5rxwUw9FKYyU2tlqlGtE4N7cITha2w4oQTe1ksENK+NtjbWttK3C9uyEGWdX9zr/U3qt7yMtS2c1zNtM8baWbdGa522QfeQnpNFhIbnGzxgF4gSQlXBmSgioQwuUU09RkSzxLhudAZuK9h2PQlqdvhkGTkiEc3/oQd3zJPSxsLYOm1rbJeFbTOmAqsJ76zC1iaKZVzLsIQNlGkSXG+4OUz0BqfTBekr8zwyhy9VaiX6lrR71nRE6vqVbzCCE2vO2iutBUc3mqM1q9ALgYf3WNSkEMVsVZlQ6t1MKcdoJW33nLcBemA9L7itvLlcWJaeQseINDIPOEm8R8miZSaejlBSheIhiGdLAcV1BnL6dWOzgHRI75REm2ms4cYulR8Jz2hOZleBgYe83bEMkY0KjyEDfAlxgFh6bwPqUiHeCwmguYN5chWSGxh+hdHKe/4b35V6YX0VskzTYxP09Gtl9GzAbKpX+HKIJ6+iwf/ItKtPoMieB8uesRibVzJ+PhDG9UAW4cQJuSJXr5h5bN6aqR+Wm9CLNt/4HsiDTmCPV5ELFgpDiCLPuN8NGeEtYgTsqx7RVEIstuvlGXrIA0WZqSKRfN8HuyUxKuIPvP76l/EVH32FCtyUiVdujggDxsbw8ACKVZApiy2n2HQtxBOetcneO2/fXzifnlC1o1p4d1lQGg+PlfloNDHWHqrdboOWcvYQTMCBwQOBWwnD8+SNgzrHEtwvNZWfGu9FMPro9H7B+sq2dtatMkYJoYaAjzzM1ODeSgWtHSm5QRGHVXcihq1vrOtguzS285n784Vn541n9wvWTpgvv7dL7f/E9f4m9Vtd3tjGxroN7teNZWtYvzA2aFvHWuLTO4Ftgg2h53FaVNCqzAI34kFgShg+3FuUmbXM1hqGt5Ceu9crGa/sC1CEyZYqHB7MfOXDI74tWFuAgBqfLE4fStGZZ0NZ+wDfArYgprx9M52rcKwwTwcul421d2DgI7i0UQSrBZOK+2BtnZ5FhFJio3HxMJq0xv3lxOndJxSp1BoThBRBp4J1wVrHVZimmUlmDjczh7sHzIcwIKoN6nKi4/g0M8zZLmeWrfPkvOEWsJZ7+rcyOyIWpJqG2yCGXTKVOxUTe0ZerL3xby2UD0h2OhVeTDSp+GVXOMZ/v4iSCiuSXaXaRTxO7DkZBLee7wFSwu1ROBhZgKkkTG4JBEkVoFvwh5oS+d0/pNdpRYJr8oFeI2siAqjv46rHRgAx1cfpf097j8nH0uNlsmfuKTpKKiMJaJFUcGaOIbuCkFCriXg+n+SvUrHnWLz+lDwgxPs+tvwoggwkIcQuOVTSfTC8Rt2Fh5/r2iopYDlRDZRmzrAUs2gkqfdlMCloLbTnZ6QeoPfwIVnEEc218FVf8yqvf+RVtCp9a1wujfsWtgW2QTGQkvBqwqzmjWi/Do9ZcFIVNmV5tsJpQb0zl8JpHWxWeHy45eHhllkK1j3g7pbcJNmvq0ILQJMixsEh8v3iNa8aBmgXic+ABHjtFpBlFvbSbdCt06xFAPWI7L8yRW9d0YLKjHMIGwjx89IHjqdvalkH58Xol05fzyx25rRt9LEmt/rFu97fpH6Lq5lhW0GsMfrKxQb3m7G0jd42bHQYGqo8B3Sk2ioWR9ESUvFakBpE5lQDAhxe2Ww3DHp0u+SC7x6qJhHDNIJDCwJqqBqv3E7c3hbO28o2WvAeduD5UKYCL82Cesi/Y0gXSMmDOdHDo5U6BUx1Pi05pQQ8cqglEprVKYUomdOGliCObXjCM/upvsAwyo3TbYBF5JP7wLfYYFw1wnC1c7wpPHh8w2Gq6PHIrJXJjUnST1MOFL9QqnBZnd4kGKCMY9oX1t0zZhZcoJnhVgMmJcQNJcUUsYwOxI2SJP3OI4pkk25goqiH0tI9TKGhhFM0ayjKFa7yCNnNJBDBUjEXLifNosH9sYYnSzP9IVIqrt1MsrueUpyw82qZGu5SMjO3JA4YPh+TIyIB4wT3BbhGt5fGBrdPg+U9snGVuA8xT+4bdCPkNZLKwYjzMilh3HUNBaJ0akKHmko0iKBYSODSOsieARiX7hC25wHDC1FrMnCpydVavq9eTLKe452keGTXuzULM7j2sH0Mc3pbiDOScfuKcnx4BBdsOFUKrzx6wOsf+nJ8EZbzyvPzxoJxOp+59ISUBeZJubmtaAn+Eh2RiOGVCSjF8/kNWjvz7jo4mXA4TmzeuJXBzVw4zgWdoxvN9wNV0YDeaoWi9FTgLua4RP6jiTDXwjRFBUdEk2VSC2Fcd9/yPewMG6y95+HBYoPSyiQTU/HssCP8Yqr50YnD0hiRs2nbxtgG21hZ2sb5srCdFi5Lo106kTX5xduo3t+kPueKBWsMZ71snJZBWwe2DMZqjG3DutHHYBULSMlbJlJbJB1JtLWWhOe0CjVmgUgy945bB1sZY8UsiPihu5ZrfyiZlweoFg7Tka+4u+HYF2y9pwxnQljMWKRzMznNnPsWkF9zUkk1IlfPjZs5ZKmHY2HZVtYW6RbihXl6xOOvepW5HmKBF6A4UipFp4C3RigRbVgIF6qynFbWc2dYT1WgUuqEayYoUFBz1u5IKUxaqKrMU6G4cNBIARjTMWpORDje3OyOJCCEH6HO8xd8SPK5cb+ST9k5uDRVD9p1GgohAhSfUuggya8k3xK4StLEgyFhHpVcPDX5Fc+Vt+Rmt088QkBKDpiS4oF9wY0r9A6aR1jPU3PAfDu8ZpJEuY/4XbqrGHP+SBJddMMlNpciJG8TZL8yoxLTUdk3deEafusZrJvSO1wqKlFiGc2/NTftfKhZD8LuNRMPjZ6kLN736SiEG8G3xQYm4iFlr0IXEpINZDPaekNdaRLTqrgS2bCpCERiekmIE8C8xmvl8dp3M9bzyljDG/b8rQt6nLl5dBu82hi8/tWvMD14wKQdW0P8cayKtaiVURFKOTLND/nqDz3k9vaGUiKxQryDtGuqhqRir7WNp5eGr53b+QbzEmuEL4CFwXpSylQDdisF0YC4VRU0uqnaCL6N5BXdZ4rNXHvjUpRyjeQaHnU4vuJjxUeYnQcVLYLWmVILpRyYp6gGqsWvdoxoQDDcNsw8rDDbPX3pbEvnvnVOA5YuLOuGje2LKp14f5P6by5jsJoxmrGuG21buKxLEJ/Jddhw6D1O6NITqgmSvtbYVEpRdPI4/JaREBDha3JjjM46Omvf6LbhYwdCkkgv4NqhRspEPU588DjhPbJNBKVU5+lwbDN8wFtL57RFp1WyCpkPF/Bj1YmpzBSdWS5bdO5opWjBxsbzXz8jUtEyMVzoLQy827qCtRSpBRTV1o3TkxO9r4g5U52YDhED5S1SuGuJJHS39NvUwvD4sBSdsHFhWd7h+eiownZZac8W3nrr3ZjapCe0lZ4mghsI82i0FouEFygSG3IjQFNtSQBXnudxl0w3cFRqLkD+YvOD8PCIpNgksvSgvzjdjx40HzWARyd4OnY+K8FD3zeV+fpvYxcwCLDDcWE4e89jNTRrGoIo0s/xcoX4QKGPELJAvsZxryWYt1Q1TvjVgyQh7LDshTJlL9PYN2uRgcuI5ywh/w5VXIhS3CPB5MqqmcViJ7vuMl7nYzvZBQABAABJREFU4ZHQIdYQCwEF5ojF4mgpNfeEs+Jw1vOeh4gnFIcBMWYdABEQFBzkSPFh3M6ZMYzRLqCwXS7IqDy4fZnD7RFEUJuQ+zNVQ3E6Heb0HjXG1lGpTIfCzd2Rcpj5X155hdce3DLXAzARUVeRLWiZvtHdGdvCWC68NFemeuDN88rSGphy0MpUZ2o1CoVJa1bfKIMpxDfs56+eG8eg6KAWYZYSCE3cQYb0YFZtMPoSZt5G8sFR9yMCc5FoW5gOHA5KqaEwjqlMQTqDTPf3WM+sDS6XxmVbwvO4bCz3Z85LJG58MbXo729S/93VKe2Ebe9gLSTiDAvzbut0s4SSgpg3CxiqyB76ItEZJVApFI0/riUK2Qb00aOA0BTf07rNsiwuOQgTxLJqYhJevZs5FOWyLkG+1sLmB+5HSbMkvHsJvlhM8o8mjt4QEQ5lMB2U5vFmFI+NBK0IxmYhBIioo+hz0howwRixmMdKXLG1sa4NKUFY4yO5BQ8ifnhy10H+1uqUqaByiODabrxcja0LTEfWzRnrhWeXjc1ycrj6fGwPZaAIkcsXBAoiL1LQY1rY+5dyQpIQVZhI/iE4D21Q0ljqkUEIQrFQoVWiC6h4eI5Cqh32gRK/GqSw6w2AmF4A8ZqbIDm1EJus7Kbe6Oe6lkLtMvqciEQKroJIo3hjnwIhQ2A9onBE9s0tw1pDjhHPx9Lz5BlGm4uMExBS2Nf8hVk7oVJ2SHLnqIQ4LCjBA7ILPSJoVsQpnhMhUeZXGKDGKKlWRFKeFpC4E20BmvmFu6AjEkKSK9N+NdFmyAiSn6nJS3SQ5aLruqESm3XBmVTZ1jPWztzdzbz06HH6uKKdFy2wLKzLxkajW0fqxAdeumOahHdOK7+5Xli1wOwBj2ZYcFS6xHPFjO184u37E6s4d3d3PNtGZEuWgM9vp5TpqOOlo9WRQ0EOhV5eqDwjvGPLQ1jAitPsARMSk2XJA5GbwqgwlHUYa2+MHhUoJsqkheM0R2NvCdhQFFxCzBU85w4hDoYEChNV8gtt62yXhX4+BRWxhTz/i3W9H4v03162sbUzz0cLubl11mZsW2PtK62vYeJlYrihmb/nEhl7qkItzqTh9J60MhVBtdA9FIBjKMHXDsyCyER23002wCqUKRbPWiY+dHeLVmG9xClossq5h1/jgSijQ9tigjHPCgUnlH0U6nQAmTkeZpZlY2sbNizftB4V5jTEK4jSonERRo9CQw14h81AGz42tAre03yKYYtF4Gw9RhJQQoNlgqqFWRzxFptcW7n0xpAJGUI/n2ljBF8nnnL+WAx2hVvAYU6Ku3DVXMiy5C6l8Z5cjL5Hq4dFmoRrTD9RpxFTismIv5NQke0TT+Y4BA+wn3aTb8JjKg41Ws90hozl9JjC4vSZOXdc2ZXcAGLDGvvfJ+cS3FIn4mjqFX40Xjwf2aeQ9/QySU7McZ/y94mFhF32pINyNdZaSsq7C8LI919JDiso/Jq82g5D7+4wB/b8vr2eJDikHnBYPrfd/zQwSvr/4pskH3tKzxMGdXLzjf/Jrr0e++uwT16BQdKGMGm+91B8dPoG5eYW2kabjxzLxAe+6lUelcLz50+5fXiDMrEB47LgS/TBzbfwx/8v/wunz77L//a/v421ih8XFjrL5RKZ0SJEHFXyja6czp3ffHZmmmZeqsKlD+YhkTQzF1ornNYSAbVD4TjxoEyICmuPw2Ah1pG1D5pGL9WkE5MKqh2vCs2CA5Ys2HQwzwbicYAObQwOo4Lm7FfD9zgVoYpQyqC39N7loWGMgfRG21bGONLWTmudbd1Y+5ltXVm2xpyxWF+M6/1J6r2XxyK/9UprE9twfEkZaTPGBlihdSFrLxmeJ3s03lR1itNpqWiteUKf0Rqhk70rwwbeYVhUzu+ktaZUWtKEKUNQE27mmce3M2WLmvfJYmF5toZqbSrCOcNkjVCBRRgm4GESnOuETzcgyuXcY4orCjV8XVJCBWQlIIg6CeJbcGJVEJ0SMoqT7UZhDOJDppaJ5MTi0dcgZC2CWkspHI63MN2hPkMb1Hbi+bqBKOt6AVui1mAHn2QA5Zru7RgRWqu5gO8LngJT8C8qOTwlv8EudBC0GFrC8Fow1KfgtNxz8ckAWtkJf0seiuRVMtsiuZ5IKrcX0xAxTYoEf+W7QC0X+ZKbWEm5+j6Z7dzLflqHEGVoCiY8py+oOWGkUdhLJtCnb4kwkxcRPJWk+HttxBHsivbcGMO7JZLiFqmxeBGLHwy66LWh2bJFF2JaJUUYMcnmUUByIdeA6nzPOPQS3yueMvWIscIzVkxI0j+mwPDypPEsf6antcCMzG8M4UCXjMIKwoXW44CjMnGoUOYjr37wdT7w1X+UWWfW1Xj27MyzpyvnYWwEV3o5Gf/b/37Pu+MDnNYL6MbX3sKHbkqqEMPfhDasxAHKDJa+cV47l/OJmxLdxu+eIjXdiXimKhNuU6glFQ4iHAVmnRhWuHTn7IPuQjMBi6ijyY1aBC0FPTiiHWWNw5DD6APvG8OMpXfaEMauxJRKrY7UQp1mahEqFdHIAXQKNkL4NSw8jH1ttN5Zm3NpK5dNOK9nLtuGWUz0X4zr/U3qPZczGB22sbJtje28cV4utHWhN8c8Cv5ERh7yCnvyM+ov4BqdUUq+KQyfHBsaycpGZJ4Ni+SGnjXubldJrruHelAqTBOPDgcOMjH681DT1cJWK+sIv8mpGc2VJoJJwEtxpt8CjtEAhOa5hihka8GruVxPhVVq1i+ErBctiB4QLYygMcIvI/GzusVjRyuern6pSvMtTmHLxujBGRUt4RsrhlWBtkZW4TQFHr5cWIO2yAWPdOKnRixxp3FNS0jpc4bmyp72vQNvGpBll326yIXcek5jQgSrOvtXjMy2S0dpbHQe34sYOlJ6rYOhChYbFqTiMLkUHXn/PPIbRSdUPavaU4aeij/TjDwi6j1C8Ler/UZ6it4TwSQZyUQPfMh3l1dMhd3kugF5KiEloUahpQAh4EiY4nEy0hTc804J7tPVD/fexHMs/w6P9PZRg0/bv2+/F7v7lJGcahqZ84uVHt+TJuEiKUDxhEZzbjOxoLkIOHzPHIxg4Hh52kjkIbBEhsdiK1J4eHPLKx96xE1fuB3/BZuF9X6hX54zSYtesx4qwq/+io/w+qPOf/ov/4mnJ6c+/gCfftr49GfvcZfwRUrYQeKIFPfIutO3laeXlbMXcOc3z/fBE6fEXGv4E8tUoEyc3Ti1zqkZ64C1G1szNpM4FORbudSaUxDQZ/A8xiYH2Q0aSu8eh97WIwhXB6MUXA5X3rQI5MmX4Bp78mAS4gmCc1y3zuXynN4squXXTl+N0da0HPz+X+/Dfe+5jMrJCmvT4J/amdYXWo+MPBtGI2JsBp09dDI2qICeiilVnKrKpBrtmXmqHLYyvIayzyPR22mxOGuJD7cYKo6rURwmJh7cFm6KY21LOTWwCZMar0zCZ4dy6oPeBj2bTM3itD3ckxMTbtTZls4YC64ZBCsB75QSCRLBTW1ZCOxojw/GJB7RQzqwi3FZGqNHN5POE7UIfTP2pOmQaXvI3l2vZL0iyFgw79TDHf3UqOJ5uuv4CIFBcAw5pewwg8e0EhGAqdlL/5eiNJL3oSCarbWBTeVIsZt04/Fpwku4xnSwJ6y7RN4gGunxOQXsp+kg/+O+aFZ36By9UmaWZtaaCeQBESovJNmFmlMF71mUc3KE2K0la0SyOkSUmBhysYy9J5SZISZI42wKQURSnefR0hvy9JGnjTBzloTJ9tSMkPhb8i47jKj5v3cdgyMHg3MIGoQ06RLZegNLMWECf/2q0Yuf7TtcGPfNdum7ge1pGbJXkEzRLCAjX+sX5ZvmEW9skDUqYesoIowxmFT52j/0VRxfekR/sjA97Lz+NR9kOhtPfuMz3I/CWC4cEIYrD14xbo9x1tBt4+3P/Ca1D4qGrD8C6+N1MhNcLgw5IMOwfsP9pSFl4bYMnp+f8+BwQKdCmSZmoitq1jgEnbwzlkit0N6o+ZmxTKz30hk9eqm0CKUadEdsCq4Yx23FfcIHuK8MV5rP9CEwCZN0TCMiS6ug5YZSjKoFU4dhSKnBDRLQfGstNrpubG1lGQutb1zahUs7Mx1u+WLUyr+/Sb3nEgftDV9X3BsbwhiCu9EztaEP6EPBs+ZZDfWZIjDP0YrppYTTvRo1S+icPMX7Fnl9PfxRe4Q+vl25hhCex39PVXh4fIhKo9sGUiiuOI3bSWh+AO+ce2fk6Tf4jdgYawGZQadCrxPn+xNjF2/pANWIX0mPV7BZGjJ5oi6keJLkQ/DRI9i27ROgc9BQEJ1PsZipDLzs8TfKzU1hvp2ZdELtjNtK94I3p7X4797WBBOUWSK9ITaUNOR6pidceQ27ci+VmF60NGSEaVc8Tuj7ogbkhhWwpEkwHVEslxuaVMicu50LKrLPALuIIw6kLhlRJHES9xZfGFzQi8khQNyQLYMmtBWHARWPDD8SEvRYcC2TxymRzWc2xTSVHiRPiFGzot0o8f7KTqm9OmTgmXCRs4lrbj0a05jUTF9Pb7rbNWrKU5wRvycSyrVkKOoa/J+goUDdUSCPwkQlPhfuE8UDftrFNZIbe6SqZLNvbmnkHUvfAHuqfLF4Ta/1ljJI+Wvc5eHUIteJeDiYdKa7TjmvnDnz1vMDr063bLcXVle8QMOopWDAZ39j49Gp83CG21vnyz/6Ek8vNzx5/izu69hRB2P4hJLpJ6NQzWF0tuU5RSubR37l3fHIpYBvDRnGbEKzxvNtcG4NXwc11arUTMUn3uuTdIoUJj3Q1Riy0Ik1SVGkOlJ7bk7RhGAYnU7nQGSpb0xFmUSo6hyKsO4iIJX4HOX9qhb5mr0vbP0RbWm0ZeGyDVp3bAVu/YuCvb2/Sb3nMnFWX1n6wtI6fRlsm+XpogX/lCCU5WagWVInYplCPMJkWTQNj6BS2TyqOXxk8651ZHQga52xWCQ1UwAEilRu5omXjwUf95gMpilOT82cKpEKcBmNbe25kBfwFlJ5MR4fJpgOIb3F2NqIEFUNk2rxgACEQ0wvo6FjZAK6RG24V6CH9LdHerL5CEhIA76yUQJWNMOs4D6Y5sLhMHM4zohXJh8cjxP39wX0QN9W+mgsLeAGSd9RI9V5GaAaC/+egRdvWee9ajDFdKAWxLqm8gygjOA7hmq8fiMSMPZMu8ELH5LmydxTpqvmAWVCQmbZPisSSip9wfjEWh8+orFHIuXj3J8D5CSJXXkV3b1dBJ+AxGYx3FO5tm/Wns87BReeQbOxzqAmyc1YbuSCagYTJ6SrmTwee0+ciNWNJgHYOZ1gO/fNOR6raW6WnqZwyJEjHxv6AuKTSDjf65uCUtxhyPf8SZELKbqwlEfEZjXyMxFpE4PgfXdRxSD7zhTEBw2hhKEwbEAGy+XC/+eTn+K1D77M6dz46B/4CIfHD3j7/3jGaWuMDsdRsEmZ65F3n/4mn+QGLo23W+Ez/+nTHOfK895xibT47mToL1hWt1SUbit1VO4vzlRvqFW5uPGqwnSstO4RUm1G32DZnK21mIpTD1FcQwHsjWGOjspUnIMWVkrA6mVQLI+RVrANbI4mhtah90azw27WBNtwKkUELYFsqEbKiuVEK8Px3jCUNiINvrWVU1tZt0FfjW09M/olD3O7kvT373qfk8orppmBNMdaYWxEFh2dbXh6mxpmAw9tUG5Pjqgz1ULVWJIORZjLHL1Rvv/sOPNbRhVZ/t+OP6tMQPQHRQioUmvlwd0DXj7OKJ3CCF7IHUZMS7gFxOE1+q084K6iTqHgWhk+cZwUVqe3mEJqCUOuFI2VnDCSmmg44gn/jqWrvffO2FbWpdO33dRpWCAH9DXVfsT/VhHKPHE81jAXitP7yuXd55hPeFHWbYsYpLHr2hLGenGYztN8JkPIexbe2BoRRqRskPLshAqrhSnUc6HHnXptwdXkfxSVcf0eiI0hjvFR+LbzNAl+oRHgFKWE75msakrMg2OJBPRI+4YIiI0OId27nKiIRjK1a6gHA9JLHkpjU1QjIB4JSDhEFCmPJ1RbVbh+/dWzlBL1Qs042pw+yaeX796ek2nxiNNRypUjiu6raJK98oWZiBJhGUp18jmlaCVfwGuyucbmpS7gBZdyteWG0lHBhJLxUqIh6DAnp7WR9yjMygEdC2hHbkbYNlzpHuGyqrGN9W3jnd94xq//+j1TPfBIJi6fPdFbpx4ODN9YNXjgg69s/YD2yu3tzDQfWNcz080tL989DANwVmugJQsC4nNmpizbYEhhbQa9czdNLOPEeSyYFMo8MUQ4ufDcVrYR1MHAGKVS5yO3h4nDJNmwvKsHjeqDuUqKZCp4Ts9uEZNl4Ys0i5ofHREbFZ+HbFMocWiOt04mheynBR+IxeffzbDRrofy1gaXtoSQojfMt4TE99H59+d6f5K6XgHlndeVrRvbttDawmVtQRpuLZRI5ohPOGue//bCBMmFBLQqmSiLa6SRrwO6d4avNNsrOMCSiwn1V3rL99r1qtzdzhzmjbYI3oN3aa2xDZhk8FYf3K8BQ4QHSPCe0lRJpzudqd6EGVBJyXtBaqRjCAcQwzq0ERxRpD0na2ANOqxLY1u3mLzE0XLAUmSiqjG9WcQqaQEtharHCMsV0JxKu860NmhjpY9QKgkeHVPOld9Tz5N9qSlGiGDfZIcSNkoOy2PhGAAmATkm6bOnm0eu3B5musO1xOtkcgWd9okIkWtuWSRnKKLh8RGPxVtUYwLy9APRcQTr5bqoRyCuMywk2tFMLzs2mBMMmSiguIZqLmDOlMCTykDLgnfxENbQQ8rtYGZx6MgFHsA0OoBlD0Yl/miS7yqSqe6ODGPQQYML07JnvJUrz4WMGI9kNxLHOdcSeHQS7t1/h70oKQyBRzbW5j2Jeg4S1u35Say4zggtJ8s9uiq+T/F40U8Bq7rHVDNGRI8Zhc1gHY0iwquvfCXt9Iz/8um3GU3wkmIDNu5xzt15/XjLhw4HPr0cOa2fxevE/PAhrz+84/TsKe4rLoPXbiZ6c54OjdzNKrTRuOsNzGhj8KFp5vY4sfQLD2vlwaGwroW+3KPDkCGJeCi1Fg5FeThNXEaL7irvYE5JG4VK8M+bAGSrMi3ueK/0yNJltMG6duZjYy578killi2OKnIIlJQ9dzHG4rBpOu4R+7b2jbEZW+v0tmJr5zwaSzvxoB6B+fdmCf5trvcnqetl9LEwmjHGRusLW29oX/ButLFXl4dsNs/QYGFeLAjVwycVC18jIm2isKy6YbbRWsfawhiRdbdLkE0iOTzeu/HT6+Q8OFR8NOiXSCR3C2+DBuGpHc49pOzigo08WTlIMVo9UsQodC7njucHVySqDcLYGovpsIatjd6NMeLnz+4RHTMMW0ds4JfwPanGJucGbaTQQUKyrnXm5jgxzaA6gk/pF4YYllPnjSib7ZICTwioZz16QD1obNpu/ZowoIzQIkOeLmMC0Uxv2N08+0RmlAwYT5e9aG7qEtCnRfRsQFXpw2Ekf5QVE+RBIOcqy8nOPUyRe3IELkkuj5yUPXxrVyl53K8ouRNIlZhkqoJkBE7JDXZYhOmWFN8UCfdURE6l2iqhG1UQs8jN991PlMZo2eXy++TT2Zt84/85XmpyR7tfy5kyFoqUjMed3RWQIR6K+vlMbTfCaHrlhvbptlz9OfvE6zmxIbpr5bMYc+RmRh4BS0LZ0akVVVUaSEDcAPBQnFYp18NLaw2lUWvnvD1n2yJwdoxGKUbfoiLeXbi3wWcvT/nqB0/56peVL3/1wO39f+XJsxM+ouQRhHs/cCGm5kMV3NboY1qdMWBdVybbePTgQOsrOi48ngoP5iOlHCLZQiUj1JJRFKEAsyszQvHKGMY2LLyV2mMaEgVZMDZG0ThEDomKG9tovTN8yVSVDZWNaNou0S1VhAORA7oXhnr6EYWU9/fO1jvLWBjtEptWW/DFGJvj/P5L0d/fpPJyN6w3dHRs86zSGGzd2Xq4yHcp7qCHOc96kOxFMK1IqRxUmEWYClSJqo1hnTE2Ro8csYj833HAPQpWqCaIBfSjBeZj4QOT49tKG3FKxZwnQxmjowZng2UUmu2iC9jZhGma8D4xl4llMS7PnkTECSEqcJmA6cp5uDrzsTAVoUg0gPYmFO+INZqttPVCEWOaZ8ACA9Ioodtl1oWQ29ZphnJApjRaWmcbhTIqqFKz1toQupQrkpBBSMi+KXh4aNSyYDA3IHVQb0B84PucHJUDVojcCMmFNJxP+2sdir5QhSGZupDWHE9OOQ+a13SH0MAIe1xRTCZ6nUosBR0FoWiN5+F7XFIBKlIKPuXumV4s1RDliHcoLX65BEhXrmZVBw3Zu109SAHZRXtveIVUwgtTRPP/T9eWYvGYcq7iCYlA45H82e4VixQLyRQUZ8Ipyd/piKlr5MYWbm4JSb3sBfIpumHn63YvV8CsoXokkQPbx2BCGCMxpUrYC8wGbiPhRgmxD6R83nLjJ5AAjF4UnUMtOGkUdj5//iaXNnA1elkRER4ebjjMURkzAY9ujK/96A2PDxJttxc4d2V78iZeHa0VEWXZTrThdDcWi1fbUBZ3JldGH7x5v/Lu4nz2MvjMZWNSYZ4mpE7ADl+lCEM6l2Fc2oVhl4jEsoGOSLpxd2ZqHDQLCBMihTLk+jlwT9jPOiMPq2rBm86RQRYZnPWAaPg4TTQPyXE/I52EbGUIWmDbPKqJWmdsG1vrjBF5kb+fG9X7cB9A4vXmjT4Wth4+gd5hpIdJAMzRNNqRsAICk1eqD1QGo9yARBNmLE4VvOMdNttoDFLAHtEuDqJ7VYLnKTbMscf5hjoJ1jfEK4OOuDHLBlZ4u3ds30QIKBLnmm83Kagu1OmWBaO8fIO8taBSuLmdmWphayMhkoBVLEM0GTkNTMp0eJl+fptOxTN7sIxGVY/NmwGaHTguyHTg4TwxOXm/BHqjdUHmyrZdWNcTp61nd9GMypYbVs0en5ELUUwpngvSrmtzF0aK6GLSUsoITiaq3DXEGJb9ueIhHy8l/r9LbqhhunQPD0ykdQgj4Vr1UGWSJ3knDJmanpUg83M0EABlSA/rrO9cVvwWz+lJLEXZMUBiCKUQUJ/nVipA5uRBQmh7cWApOFsoE3PilLQmZAZpQm45pWpUooTQIxWgWmJBlCDSYxrdY5c0YL1MHUeC/1DZjceSCeER9wWgI0J9ryn1oauMpUxi/lIPRaPJCwmFS4TQxuQU98XIySs5W5VQRvqkWPecWo3iIzhUhWj0hTqcR68+4OkI8ZPaQNeNc1dMbxBraC189KOPeOc3K0/PnT/6h1/i677hJU7vCL9wrrz95P/LK4fC3eGG2zujeOOzBpPN4W1kUHq8H8Z+wBsrWo90N+7PnQ+MlfH4ltvDkUM1bubB4WBczhFB5EPoPQ66YzKeiTIJAbvi4dvzrCCREiHPYojWzA0NTtWk4RS6j6gxGcrmnT4m6gyUqIMsKsxVmOfCakLpqZRF8J5qVhF8Cg7a3VmHcbHGubdoJN9S7PH7fL2/SUEuH8bWlYtBGxLY8OiYr2zDwq9xhTtArFxHZCylu+KRBJDc7q46szLYskrcBoxR8R49MNV3GbrEUVdC0FBFeTTfoKJctg7eKSqs5kwcEIwNOFvAAvHWGbFhECkCXqYIQC0z6/1CWxthfi0wQTlqFBKK0KSnH0Ugc9+cgrSNpp3eHbNGqakmMkfrTD+tABS1CI1l78IpDFfEHe1wOwvuR6zObJcnmDV87GR+lM2Rp8I9rUEJqfE+dAq5IRGzYoxuMamYh5ck5N7xQY8YpJiaJJMnsIgwEi0xUYkyRME33MJPpqSQwjI/ThNa85oLdiqlAPcaC3p+Xc4OjFQ/RmfTHoVkyeEUkJ7K0PgOuz5GTdUcIbLRHaI8sHurIhmjpERbeJE5Ef4rDJp41MN7j8lPa5ya/T2cuUbVilw3F2WfjvcoqZgk90gcv0KguxNALDYly9bkkGjHRF9Ecjo0vPv19B6AZUzAnqkhe25lLNJ7Xp8mN5g8TEuhur9QTrLzZR482toHTz+rDGuUAmUStm3h0mf0cIsvg5tJkO78gVdv+Zr/26u89ND59H95xmdMuawTZVtjcnzeeLJuSBVeuo1qlHfPPXIB0wbgJpnHafQpDniXbePpcuErP/J6wHY2wJRH84HndaXbhW103JXNYerE65iij/3ZuUftDZ5hxoHn4jLAp4CfLapqRjPs4PTRg7OuE7VLqF6nQVkDBShTQTelqtBkpJArDpMd6Ga0LvS1M7ozthBKXXpna0bvTp3lC7f4/k9c729SAITnoY+V3jc26/QxwtHdalYHxAITpDtAQSW4hqHgZYpeHA1jqRRlqFOBYZVokjWGFRgNxn4Cz3K+EmIJMk2dqrx8LByapWR9MBS6RdcPrpy2wbtrpxErhnmcgCLAdAQEKWDW6duJtq3JRwnn88rahAllSHzQrCUxjkTiRY71XS6sWyjppmNFxxH1yJObZsV7QDguodKqVdGqlEMBCg+Pzg3G/Tl4niHG5iXSMUiCPbPjlDAgphbhajg1d5CBvadtVkg+RXbJQ0dyeojeqzDShifH4x7v7aoayc6pZE6jav48j83CpYFqlM4pcSKRWMjjp4MUCRIfi6lNIpB2eBw0nHblYa5grAwkM/VS0xYwF4aVvVa9h+lXQw7v6YMRovDPpCLDgutin3481aKWEF9upFiqJTP1nT2BcOQGnAeu3QidGx3aMQsYel84JWXsmMZ7OnDZ/VngQk54I5WUoWxEytUflpqUVKfKdcoKWm9HKt7z8bT0rkn0oA2JsNVrugVKDKYesULbU1QH0+GG43zH07XQbVDtOR86znzopcLXfQA+9nUf5DPd+Rf/7r/y9Fnn5nbi9Oln3KFctpUnCttmyCiUOZSHty/dUJ9VTvdP0UyMlxT6tFTW9t75tfPg625m3twabVPOl4WxjvAG9k5kWE7BdbmHClJjM67irIQ5XDwg4uKOaEW1BX+c9694ifix5CDD6yT04ZhOqAqHAn0azKtRRZiksJYC0oAVpRK1Kx1jwsfG1h+wtUHbhNGE0ZVzb8Gl/7evz+/x9bvipP7W3/pbiAh/6S/9pevfLcvCJz7xCV599VUePHjAd3zHd/CZz3zmc77vU5/6FN/+7d/O7e0tH/rQh/grf+Wv0Hv/3TyU3+UVwoPRGtYV753RtjCatk4zD3m37Sdhw+nhNRBlQpg4oCW7W2qhFmHyGifHXcxgQrGs4paeh944Oe+m0GDVhWmq3M0FYaVYAD/eQ66tDLo1ThssvDABuuTG4sY0HbgRp0wT22gxuUiPJVyIaJyRSjnpyM2GzEKtGnJk4gRTRdCT0laIksOUt0+gHrEtpeZC2C3ks+5MkzDhVAHVxtv30EVplzUL13qkDFjcz92Yup/QTQLCiU6nfSGtyUHsQFJOKG4BQ+QJ/tpu67upNiXDIzbSqNLO/LLkntxn9o9DiElGRgBFc6oj144oFMrOk+1hssh1AwNjksD7C5IHgz0NI+BKTS7FhYhHqrHhVNvTFiKbL63JqAg1eSeX/HtNoQf7PSI2eeG60cesIdcqkBCSkO8ZycXfrtJq8eB2pDiFqJYgM+eucn4hplTRNAs7plHQGNNjStIhDgJ7qR99r+AEokhx991YiQNgySgqzw1ZMsrJvIYKzUM8kRq/eD4yrtOeiARfXCoffHxA6NhwjqVw8/CGr/iDr/Dxb3qFeZ75l/+PN/mZ//uv8eStM+35wvPPnnEXTgZPz43PPh0sI3S8j4vykUc3vPGVj3j9pZqjtlBKxVTopvhI/tGdp6eVQ2vMNZ7D6o13LvesbYnWhHKkCJEKQ77fRxijK8ZMlEyO3fJQoe7TG1MewkLEojRMjG14cNc9qoWGdxhhz1ANr9RU48ClOy/rirheU+IxDWGGrdA72MI2LjRb6GvQC5488O/X9TvepH7hF36Bf/AP/gHf8A3f8Dl//5f/8l/mX/7Lf8k//+f/nJ/5mZ/hN37jN/jTf/pPX/99jMG3f/u3s20bP/uzP8s/+Sf/hH/8j/8xf+2v/bXf+bP43V4uqGmkIIyOjQF9w8cCdHwM3COxOCJvEl6RWMC0CuhGKRNoZUihSMVLnP7dBz4KMuK0tZKLS/IY1YXiI3A0GkMGZYq0CbWNRo8F05UeAkOWbpzHQHr6aQhVVygFB1MJFVGZlLYXFVqJ05oqB0I8oWKIV/zZQNaOt4A1pcYCLx55YjZavEmHISNO+aUKFE35dvIPPqJPa77FKRQzHjNiiimVrQecIaNiptTcdAI+6fk4CcUbxKLlGSDqJe5/bj6KYyUy8BJPi8WTkMgbCiMm01iYw1NT9/y5q2cp5e4+0jScggghG2VJ2bCnT43k0hKK8xe/f2RHUJI8RB7giykKAdWAdUv64RSNyVoqvhfTJVwMBZM9DR30VkEnYE8f3+Fdec/v3ANXYcgLNd7I389VFh8Ts7tgGfMlEiIJLKbXbjHh7s6nfeoSj8dvpHViN0m5vuABjdTmlYydIqfG5D8SYozJrKBeMTwacGVXUKY4IsUrMTWnhysnZrFITHDP5mUx5lnhZuZ+2QDjI1/5Af6vf+hVvvIV+PTTwf/7v5546zMXfv03L2CVW62oOZs4azesKHdz5bUHEw8f3rLcTbxVJ968v3B/OV3DgNG4L9jARosFXJx17fzH33ib8+nMqXVqES5iaDEONbyUU43qmKFRJx8fBWegdImKeEvz7sEjgzPq4PM9ki83PmNjwnqjmNMaWCt0DJdQWhbV9JEpOoUMX3MyRWNSZZC0hjJsYfMzWx7UzRomG+tY80j8+3f9jjap+/t7vvM7v5N/+A//IS+//PL1758+fcqP/diP8bf/9t/mW77lW/imb/om/tE/+kf87M/+LD//8z8PwE/+5E/yK7/yK/zTf/pP+cZv/Eb+5J/8k/zgD/4gP/qjP8q2bV+YZ/V5Xx5FgsvG6sbqE5tXsCkz5cY1Fn8wGDIlPBUf2iJRB60MyhTG3h0AeaFyypLEVAXuuX8lA1/2RQ8pVDnwaJ7CIGhxyqlidIk3G0W5eOHcLYrvMl7BUNymOJ2V8ImoDMbIjUGmiFqpR26rhlpINGuoJ5onGFOPUXldK70722j40GhEVWW++yB3H36JMUjfWDxDLRXKxDR5yqSVvm38xttn1vvBQTxmzulDpGA5phhygaMG/JmJCS7OkIRYXyzTYZwNfCcVgfH9clXxVa6fo1QhuMesZhJOJt9Ns1KS44ipggi1CyVZnurDHiC4Dw77tCb7pAYqE0KN06jEppai7aBgVJCSk0Y0VV1NubHAR/Fk3Ib4O9mfnMZGqaLUAjRy042vqQnpxhSaSSWpPEQqqhNS9cqJxd/n1BGxJqhmiK0oPhVGjfO6SMjf0V0mLkmcK0jJMNSNPU/DPAQ07JuK7qtohu5KwkqETzC6tSw3zA7XnrB4qRXJxAmHFIZIRjuZa5pW4zn7zuFYZBHWKjwsB8aodBsUObNeBu886eH/6cJqla0rdZq4FOV+7Vh3KM7t4yP19sjdfOTV2wNfNt3wlXPlcm7c328x1UlwUvt7JGDiOFD0rfGfP/OM07POu5czFeOBTExjZkoQFhe8TgEtjyhpzydJlaiCt5FtCaVGnXwx8nQTMCPx3CMNpNBN05SfxZCqlAoUoeiEm1L9EKKLoljN1yZRvIFFTqk53iIWDjZ83egtpsX++6yd+B1tUp/4xCf49m//dr71W7/1c/7+F3/xF2mtfc7ff93XfR0f+chH+Lmf+zkAfu7nfo6v//qv57XXXrt+zcc//nGePXvGL//yL/+Wv29dV549e/Y5f75wV3wA2BqrbeEHWJ02slJjXMBGTAsep3nx9DjtiQGh7Q0uyAAfcSLGUYsTYUjagw/x4VfOx/aTd+Qn5UnHeDxVtIOOC5qldUMGE86p725zoVm+2X0O1c8wpMSibKa4VVrvmPWQOkvB28ZzcYYXrAQMVUssGsMAGn3doA+0KNsSU6WzMdrGdnnC/a+/wxgr22qMPmLh1n5tBDUfwVe0zrIZppXLtuDjOcv6Jo0GsnuiDKzFfWM/IQY3YRZtpJLJC7ucnDR4hnihBDjklajSysI/SblynjyNWG/dYhoLkUZwHZYKtFjowPcCRySgWgYuhbNY5hvmH4dYXvJkLzmJWiTUk4o5T74iuM3Y4MLSsPupAPOsqJDccCREAWq4tLAtDEO9Z1KGB4eQU4q741YJ4y/AwEfDsn9r9+T5flPqruarmQiheJ+gB1yYTw43xS28eaFAzbZdAlqVEZC2JkwH2VTt74EW3ROJ4Cp+YIf7RIl1smEegqC4HzGVFctgXEsoOCmR8C1nhiChAtR8bstaeOObvoav/0N/gC97dKCOhWf373C+v+e/fuaeJ0sP2JkRwgZ3WplovXOslaqVepxAJ0wLz1GUjfun95y2eM+6SW7SIcvuFhstRGPvs2f3tOcnLvfP+K9vP2GcFtp2oa2dy/CoArIG3jMpo9B3IYwHD63JC5f87/KepP54/w3MtoAKWbCxMnoPIUUnWrI9Nk6kIWXQ2DLc2PJgHIcw8/BeyajQC62PFE4o24C2GkuL7M18E33BVuH/0fV5Cyd+4id+gv/4H/8jv/ALv/Df/dubb77JPM+89NJLn/P3r732Gm+++eb1a967Qe3/vv/bb3X90A/9EH/jb/yNz/eh/k9eDt5Yxegu8UazMz5WzCO6MzqMiE0kF7t9ES1URJxJ0psCFAlsXZQQPQyJCBQ8JO1cD/jhf0hDqhMHqVIKdVLwFTOjuKcCDaasThjJ/cAuHx1YCjeqwsF7bKI2QmIqkcVXS0PKjEiUM6obW2vXxAXvI07aPlh7cDk+nG3bUFV6H+jcaIthUmJhxDEqUynMdaLUAw7h5TDjQqjsxmJ0E7YWE9GumtNg3+OPZH6eEURxZJt/jkpvsMfG7DliKQzYPUBScZTi44UggfQ6EUbXzGEgpqmRqeZkhJIm9BUHkCL7rBCro/pglx5ITj0WuyiYZKJ9TIhqgpTkARlQdrd/ZCfKrm5jXLkvvTJuwV+9t34jlIBZW68W3ObYN+zQqYp7pugrpL3BXAgFuqe4BrwHX6JSwXeF6JqfC83nmr+bBnpMj1NOM/mSuXOFHvcI2+jxzPBksezeCsJRJHIpw6id/sNdUs8LreIOXTrBdUXSyZ78Hl91LWTMwFnyfbD1lf/865/lj370Nf5TO3BZ83Fsxqefn3l6eZGovrbGeWuoFnQ6cjjO3Mzp3xrQe+fuxjldNt583mjDUpeZVgIkQpit4rYbY4XtvPLmaeHVRze8eTrTzhsMj3oaskGAiTIHZ1hccKsRMsyIz7QJQig0I5WmILu3kZb3PTYu8SnUfkMY1himdCpT1xCg+ozKinql0FDXmLbSPO1WoRWYG4yJnt7R1jeW1sA6bYMxFCZ78Zn9Pb4+r0nq137t1/iLf/Ev8s/+2T/jeDz+Xj2m/+76vu/7Pp4+fXr982u/9mtfwJ8uIIWLRTreJspmnTGM0XdMPsAbH54QTkwqIi84HkvMRUtl9pkDBUmM3WJXoRt0WvAESS47lZwfQumlQi2FOlXMB30EzTwJHFURrZQbZRvGuYcvwsnkg4zQES2UEhUakXgchYXq6YHSGWfCZQoaW14o83SaQtVomQ4w8vGXgP/q4YC4MYbT12g1jbUkvVlHQSaHIog1pqNS65RZb1Bqwj05bUi+BEYubITJNsj6mD52yDQ98vEc9vgJ9sr09FFJLBjqgAglVtBArCzFEiIZoJqOexNkeHJhkbFHJkDgkQGoppm2nnZdKfE483HhjvqUCwk5DRF8pWQjs+/xS8QEXp29MFBzs9pr3SMpYqQtwK/S/OiYsrwXFR+aGw2gGhtiKTghpw9xRXBcoazUUCx63EeXKbIXPaDQPU8vYCxIMAmjMnz3NcVhQdl5pvg6iHDdUOv5Htcbr59E47NKhpu6Z+J79BsJ8dhyJo/PRvp4RAU5ku/znAflxfLoaqADJCZM3Blt8Auf/BQ/9f/8FO+89ZzSN1pXpnnibMK6DmaDo4aass5H7ubCS48n5NHEaZrpF+PJ2pgewK0MPvWZS9Rr8AJehjgAxG49aD3biTUg/FODB7cTdzfQvNMiAyxtJxXRGhChl1DZpvcrNaqB83iJDMAS5m4lYsceiCTUSaIynvxxiCi24URTGAxpjOxCkxKG3qoBKca9jik/er08JypjE6On0dxY4vfZfmj7vd+g4PPcpH7xF3+Rt956iz/2x/4YtVZqrfzMz/wMf/fv/l1qrbz22mts28aTJ08+5/s+85nP8PrrrwPw+uuv/3dqv/1/71/z316Hw4FHjx59zp8v6OWCjo70hdo26ghIr40RPS4C4FcPB4RZU3JBrGJU342TwqiDUXd+JDY59ZGm24A5mGORshQhI4oVwSUUVaUcuNM0Z1YBtVAtITw/O89aSMvNG46Fw5xQBnqdMFemOkVv1RioZR4bSvTqbihKH4N1yYZgdyrxGGuKKoYPSpk4HI/MVagIY3NsC5hiqsTkUJT5MOVCHgZLsQ0ZLbw4w4Jc3iw9RClA8ZRRJxFtHsV1JPRoHud4sx1+2vkJyQ/6yMUvjvQqxiixKEe2aU5QaRqFLK0kW2X3aQrYTbluIVW35G/IqCtPTxYSJ13bN0uvqES+4LCskBCiVXUmxCeEH2kXHmASzn6xFAdEeKy70HaxgwffJ54ChLQHFM9t23ZFbOQ84Bm55LHZ7tOceUlJecYekfUbvrdZ7jTSe3qk3uNbk134cJ3vjD1uaefXhGzdTbNuavYSug2BSfewQ5uAaTQAAJiVzCHMySmnM/a5ygXdQyokuJhkBgNkNc3UfMnXLQ4T9+eFt99+m3dblgCWmc8+28AGt0fl+ODAXGbmSXl5LhxvJ25vjxxXGKdOnSa+9qMP+PBR+f995sRnni4hCrEOGd3lY7cVNES4mntD5QfLYhzrkccv3XJ7N+Fl5u5QM2w4up6kEBU+NhgSIqhCDW2EOz5aTMG2B8bGpnG2eM8WInfRzJM7b/gYFINixkghkUhQFpWRbdqStET8HsSzR3NEY28P4ZF5Zx3K0gbeW4jKfp82KPg8N6k/8Sf+BJ/85Cf5pV/6peufP/7H/zjf+Z3fef3vaZr46Z/+6ev3/Oqv/iqf+tSneOONNwB44403+OQnP8lbb711/Zqf+qmf4tGjR3zsYx/7Aj2tz/cyhl1ow64RRptFnUZzpTfBRnpn3PEepHpwJAMsygNF4wTkpowuOEuow0ahEwbh3g2GwzKQFkkBoWyzTO0GLRNDKto62h3phW0oPQ3GI+Xw3dM/5HGyTJMMVKVxxMxoawdrmApaYn8keayiWY4ggrmzjZV1e4/hdEQ9yTRNGetSWPpKa50yV+phAimoKtWgX8jTr+I9DMttbdhUGD7RPIzHsiMFAB5xSKH2AqclDk+q7QK+CmFAwlOp7tulK7uuYq94j+Ds3VUUK15GzwIlawrylC8B9/m+OKKZuhFw316m53t2nSTY5ZYfVMOk48OSq2l7DkHwiFtMRCUXryEjJO6EFUH2xy9csw/jZBtQ0sipYWh054bNYA+Oek/hoWhK4cOPJwnX2TD2Ms1YQlvAjmKgYeDOmxsqP7eYchPqMsJUbJKpH7l5DAK2jIE1NpOYaOV6sMAlDyKCa6dIi9fPYmNxL+xNxddFz19Iz4HMoXR6H1eJefyufn0TWSIJOAyRfJ7BlfoAZeLh4cCHHyrPmlOYeXisaOnYZMzTgWOJjbibsdrg1dvCH/3oHbUv/Pwn3+I/f/qe1ja6hycvOLN4vJnQiogxqQdl4I6Pznk50xA++sFHvPb4hloNq5X5cOA4zRy1UEtGJiXaEPd35ClrS0tGTFWRsB/9YUNfTPIRAhybnKeXaZgzhlMpVCtUV+by4jVhxIJgzhUKFrXIXNwr6Zsxts5oDe9w7mdOrWEsX5CV93/m+rw4qYcPH/JH/sgf+Zy/u7u749VXX73+/Z/7c3+O7/3e7+WVV17h0aNH/IW/8Bd44403+OZv/mYAvu3bvo2PfexjfNd3fRc//MM/zJtvvsn3f//384lPfILD4fAFelqf3zU8izeGs5nQPTwdIVmGaLBRioZiRjWVYUSeF9WhVCZxpqLoVFFmIml7oYtloI5GknZCRsXtOgGQnFfRwV017qoivQfvYI2RJ6vhwmk4a/PopFIBb2EUdtDiHAkj8aiFvsSiKxNgNSeDAtMUWLSAlFDLmRdkzhO7C72XOFEPh9rCx9WjTkASmuuMWJy1gGaT6dihugNNLlhzGNtVWRdS6D2FAXbDpwFXcyrpHwPc8j5RY1H18OjoPi2JRQKEk4q8CfEw/qKGDdh7nIQSEm6PxdtUKExY1huElyhl0R4+3X3iknQY7zwUWQyJ7n1NwQ+YBCc0xIleyYDIIIOEZcJ9y3sez8vwDHe1ePxoquNiByuMcF3lRuYEtHllBSTqO8g6j5ESfk08SPJ0b57wDgXVLQfZxAIZ7BFUOfal1GOEgIEI5t0NuZEG4kROYqS0mwT8KEkpWfJukceXKO3VLO3JUWXShPt1cw1Oyq5CC8lFek/Dl9zcVF944kJIEq+BJrR62gaH9Z7HDz7Al7/6Cv/lMyfUncWE9bwwHWd0DsWouHE6Gy+/Ct/w0sz/679+ll/91BPOl5G8dEB8wy3fJ6mY9Xje0aJcwqYgIBLG3tYbf/j1L2NpzptPP4M14eE8sfXOoVQQodsRKY24Ay35upJg64S5U9XD4CuCMFHJDXE/LHlBRh5i1BkSMGHA2rt5HEqVbCkImFsw0JLqPo0Wbh+UMoJyMMOlRNK6BdcrXn+/0L4vfOLEj/zIj6CqfMd3fAfruvLxj3+cv/f3/t7130sp/Kt/9a/4nu/5Ht544w3u7u747u/+bn7gB37gC/1Q/qcvd4kTkhnYJWC0XtABNgbdPcZfyzcCglmPIiEJTkpcUuPlIf/UiNxvRAvvsIqz0QS6CC6D3YpXSkIYCq6Fw3Rg9kh4iNrvgrrTXDmPQu2dU++JFTuwK346VZy74jwZgo+C9c4woXSFKTYXR6LeYjiXJdp5JUUfuNMt6tdlFmQ1qE7fIiHZCTEGJZR/voXQoOhELZVSp1ywGi89OnJZXqadLmz9GcUN/ICzUTygioB/ekjWLRffNCvGeuaUrMf1XcmYjzUFaQARmpmEtEqkaPi+iXmkVqjsZHt86IBQmOlAijDGRJXMQcyFMwQWybdQcBl0N9QDZjTk2vcXMutsvc2UilDcxbQ2RFJO3lJ0klyUtDiUpyIuHU3skhSkRmySx71y1zgguSEqqIWQQwCTKc87oUIMIViMrp6RGm6C08GI5Iacxtx3+X9OqhLflRZn5P/P3t/E2rZl+V3gb4w519r7nHvfR0RkZETasqPIoly2KZAlGnaqsEpCCBey6OCWhYAGLWRoYIEQEhIWSCDRoZXQQtBCLuhUAywEpoSQwO6gUpkyVcY2LlLpzMjPeB/3nrP3WnOOUY3/mPu+AFxU2hkPpIidesoX795zzj5rrzXHGP/x/0grWvPSbWnnJSajuv2Jlbatmo7aoZl5HZizfrM1TakB0QQULBcKU0emoM0wGopE0e6OIgKFfP1q+ohU7lKGMVOZTS/Hned3nb/w136VN5vSDF7eDy6bs+PkbFx20arHMfjd3+hwbfzf/pvP+Ou/8Y4xauio/aZNxYcMk/ZtpTSnORbaSaml0G4nz+SLl3d88o2P+N1z8ld+8Qd89oM7m185LTmHxqfJkOayCT6mqFYzodkJ7AWuOs2aGsQMFJsha7UYUQhLkMPwOAU9+yY3lVOTbrNOW8VrEYjCtKskMNuYKSurGWLYjhEcOQopEcokvd6P/vW3XKT+s//sP/uh/329Xvn5n/95fv7nf/5v+DXf+973+DN/5s/8rf7o36ZXcs4XMk/GvHPWIX0ypBlohyx1oiAgsmAdkXnDDY+UP5nL48+mQRPDz0PKcZ8HTMXSr51KPCxjhKlnwGbGpTfOOJnHZJsH6Qqkm9XNz5AoenXUOado1STunZlIkxQBOUuTo7iD7CIN+Jic6Aa0hOZD3KwpKyJrIlLEZty/PDnuMgftPbjfZ+HbWurL5WLSrxe8SffT45Xvfpp8fmx89nIjzXj7fOHzuzzlEJrECtEjNmY5cMs1MEqYSyni87EXCeKxMF6WR5yzUnSLtUUsitnqM7VFqmRVR4JqRfO5ipWdmpxSLM4VLTEQvCvt7WLBVW6wiXVYo4UWz/WvazqWEW3xEDPxp8ReqM+vDjtmXUeHnHjb0CZrMR+jilbtXzxraqw/LvhNw16ZuBYOKpq+YlksdJ8uZ3QZD5im6tD7t5pMvJikZrrPZcQhSNDX7xd6Kqq2PKBcK3ak0p31ey8Ib9k1UTurcGOzUTs+alLLejzjYTW1CDSZNalnI9ezmKY/nwiCB8A5R0DrxMvBuH/Jx3vwQnKY83zZsJ7lFjH42TfOb76+8hf/ygvvXmfF36h5WC6L0xz3+v1BDu30R/EVYWdg1ugGt5H80g8O3h/Jz/6On+YvfPOv85tf3jmtA3fu8xXHicohvFjQmRgdOBm4ZCUbjFznBgyPssqa6+OvHWKZ1tpgsPaSQXion1Z7I/1UFVg1EaKqexhzTrZsxFS0z8jGnDd8aqpiVrxNBivh+Uf5+ol3H4VjzwHeYezMKEw8zorOGKQL5/XVlftD2qQlOcZuSnrt5UeTRRPPcopIFDeRaVjBVkaSsQHaabXmbDu83YLtHGSbRWV3Rp5wwq+fsPwlzOuoznstnT8wpCwq6yfVcSoTZ1f37ca0gfdUxo419hkMR/Dg2etrtM+Y58R3mci660Cb3kk7ZSxbeyFzgMlxDv7f/90PeDmMwy607nz329/g+5//GmP5Fj4OIhUTFajq1KAgMhUmHdgqoL7guFixHV6u0dReRNPs2rXg0GLq79gk67bPWFi//svu0onEaixD8JbT6lDUUl7OC7WbkD8Ak44OKR3YTiJCxWJxLve7Rr7Tb5k60arodSp0g1b3WrBQN5EN9KY15QYhpDG93oeW4tYoLzeJb9O97q1ymDCBh1TQot5IK+hqwW8n8n2wxyFnvkjX65MrzVUVRe01KXKKfCY1FQbTpR80K4uetUuDgquTGfqCZhQsaSWK7jyiUtDkKHZnyDsvynmjEq3XVGtWxXkqwuKzeeFpv/K9jw6++ALattH6lZkHTxmc++Av/PKX/Mrno+JsEAnImnwpKei1NX2ujMKqk6igS11QOdWvpqDjfP7uxi/+xmf8n37/7+Vn/3ff5gfvDHsVxP56DCKhoZTs1dB4OXq0rB1RTrrpGnkaHp2ZguWXlCNKL2hhyrqPfFxT0pgest/yZKPT/aS7PEu0xzyhXYHlBiK25piH9vUn2F2+pgLO/6Zktr/l19fzU/5X/vLoxGxkHGS+MNPliF1LYJtOn1YyGEETAzHzFEEuBkym4da0Kxon0uvUgZjJ5Eqa1N6Wq+u0B/wWOM0N63s5STgzRR/PcF5PJfvOOAjkuZex0lNR4WvGHX3zKINVKOaYN1pLFZXWiCFCSMqanYyailBW1BzBcQZzKOMoUvi57IQ2zvOQW8WpAD3vjlknM2lzPajaYYwj+e9/8Tf0YFXHTC3kWVSJ7OrWKfeIKdsbCTj9Q7kqn7HlPqBu31g2U2nyI9PPEWS2dlhBI6JJoJrLaaFWMkUEcGq/U4XlA/Re8e/U12AkO2ntcbiUG6IO/jWtpNdqqYE/iYxgZ8HLi19Yh73P0h8VBFf6LQmF/bEL0WFYv2cu/VEWjb5Mi+t3iigPXNe9sP7RDkVHwIMVV99bDMZU48ZWInSwtcese3LpqUYWhFethHaKRZa3U7HwNJJtzRyiXbPuXYqxqUh4MQBrYq6p8EHujHj8Pe0KxZykfAdr4aLdYqipfP7om7y2T/nF105sO9Z3yBtPbXAcd/7Sf/85f/2zV2UmscgyBci3hDzx8LJFm8wUsjF9Oco4rdimZ87HxJct2D1ou/PNn/6In/3bfhc/+zOf4Lv2uJe+0SyBXQ1m7RNHjePNG735h3sd096xrcZOEHgU9BwRnBHSPKVIRMnEG1hvirdBic6i/ktf6fV8kMoKCxozvNCHxM7JrCn1sRpZTeaP+PWTIkXidqObXAimXZiW0glNlxiWRngJ8CQgwJGNjrsWym4ds43MnaThaZwkoyxHWgYtDpSThIpXr0plJ2pxTYd/OMfxWhBCEGfniOR2OvfTOYfo57prFHNhNaF1tNPBjJjlWsya2pAeiINV2cyc3o3eO7NViF65P9hmvJ4H436ydU1m55jVVZ+i54do723b2br2QhbOvj/x9qNn2vakCdTgi1OFUKiPKSGUKejtQ29dGp4qOjVRCF4Jao3OstSJh/reavWydFjxoGFrYNHXtrQ6aNfBhhLRk5q0gFRx15S1CqreYysT4DTBg1YYfksergBiQxe8lbIOippSMl71OWSrSVGQmrP2iyo0gajnGWqH9FkJ+hJxZzyYcYZ8B6M0SFjJvIqp0KpokmvPVPR2snZWxUarrSqPAxoyb0AUJX1UwbBioakorGwuyNLb6JBm1w6lT2kptN/TJKe3KXajLYjWIN0Z9VkXsZ2VwgyCLbP2UlGwpBo1L4RCbcWygdL0lYzjHf/vX/wVfumLk75tfPoUWE5+6dde+W9/+Qte3t/lBJNGiw2LxnSJ7OUCUloveu0e9Xk+8tJycpiaATUIowb5Rm8NL8bmd7/3O/nO975F33csnef9Cm3H4k6eiQ1Bzyrfi5hS02uqUZG2CnqJm6GeQ4Vd1XU6YA45hQDS+7kIXS0rwBMe3pEAc2JxKGdsDslmaPXpwLTBiZHjIKsQfx2vH/silSj+4jbgGJ04T/q8kzk4fX54+KYDinBuqS7Wl+CzLGw6WcvPRrDXAll02HXIhi+WlSCzlk5jr5sYLtvG3nYdVK7k0NacI4OZyT29ulbIZTzaJunrAIKMcr8YtfCv0d1w+vWpev3AemK9EdkKIkyaCT6KlA3K+SpIwbssmx7dcxT0ltL4eE62zYphldj8kuP9K6Sx751PvvtNrF0LDtMyXfCni5K8rl3tdqK2RQFFshAqGCYWnPYxIgFM9MRZ+aep+/6qiDWJVsQQS5otH7hWjufq7FkwYkGA2rsVg64MXAcyBAWvnUjWFI2+zgU1ftjTLPaa3Bs9U1lWTh12+r56EEUGKJuHggo1YYSl2JmARafZ5THNaUKSZ+OKAs/wx70rVtqarksSXb+jXvJMbOXaEJR+KrQ9Mgvca5NkPDrtcgnU58aaBnUNzCBvXsJPYwm4RUX5YGTbahKi/pwUXT+L6o01+VU+jG0THp93EH6qyyjBNEVeUfHUb/vyOri4s10+4W//xsazTf67z+78tV/+kt94f+d2lslyWk0q2ttZHswc2nu5sT31It/U74DVs6gmwbM4+6k8sTDd0/c7/L/+8i/x2W/e+d9/7w/wf/7Df4D/w+/+BNs2rk9X3r55ou8Na5UunJqmBJ+KQTxC12aVdBnQ9EIURjVL5R1fE/3CACRIkKuEm6BZb0Y+N7EIU8zeNN1LCTwsyEYyRyPmpOX5+AzPkJzh63j92O+kPkRxi+p9JjA29pn4WNHVtQ0ufyvirJta9kGEGG3RgHIWzhYFkQXTg9MKHkQaE7cqcKw1clYYxdowlLuCa4S/1z6EEdxC8OAsGrfYiYnlxqXvnC724BGyIfJIlBpizNudrQNu3O8S8bYmsV/R0TQxEHzxeuAe7FfBeJ6mxekpEsUL+dgpeDO87QX3dEbunHnjdiYt7+yHNF758NMTlTb8ZPnrhOqFYLnyPNQ0oB0KtevRQVIkBFtJu2VXtRh29d8xsFAnj6/D0FdteOxpWjpoTY35V+15AOwxqZo5nfXZaQJZeqA6PilTAUGdCQIQtdPQVFQH87IsWnCnR1GYO0aFUObaUXwoOKItDv1eNRXmA+as0tPGYwIQcUv3Ys/22IVJE1ZNWNSUkyADxFYL1yKtFFPxcZtQhJRqFvQVVp1/ZX5VvhYV3lgznD5/op4roQ65YLOMKmwp9h41Gduuz9lqF4RBib5t9dqm9ivnCU1EpHEa8/XGb7w7eM+X/NX7O87bIJG28eNu3E/noJqxghSNQlFM/LfeG9+8wK8PFSIP/e4NWUpB0rru/xyTMb2alY69DP7b/8+v83//C7/Iz/xtP8fzJ9/kNTq3MXnzvPPtt0/8ZjNur6fOnDwLdndanlDeezoyQvE3iKkr4HXW9VewZc7J9KwzB+7TeXLAT4V6miuX7UUSiczVvJTkK41pndODM4+yhwvpP6cT86BFyTm+htePeZHKR1fn1h9dxmFlR5QVgBF3ppXjQxWsaZOWWgCbizmWDMIlnG2WnEPd3Jyi93reIabgmbrB0npBXmU106G7oBmfsFhOGcZug89SfoAR+rN015iOLPz3lhwxKmqjY3mrbrgReWfkhlun2UYw4DzUDcbEc2iqmFNGsqfgg24X2mbSbJ3OcU4ORd+os7RJsjGHpshuJ9ZuD2up+zi4/crBPGad+oshtoLw1iSjA1NXQ4JT7U2q4w8dHl7MSGtRMJbi4JsZc0/yGFUIHPIN+GuxooqaYF3u7T5rwtCkob2S8yDsrWVUCRy1vin2nioiS4bqZqIBZ8GXlg9tiggXgojsOeFdba4ehIq6j9DPnNxl42QOtg5BCq4r4shyYMBgNqL+g2V5ENa+Rlq/yiSKmndi0/9Pgzg/FLFZpBJbiU0qgpgRIcq7jr3yz7OCfBKMXoa8+YDvcIF5M7ME2PEgWGjOWx6ITq+PeGnonCgfRf39ZLAse8jULs4eBE69CYwK4+LBxLXkGDe+fPeeeUgoPqYyk7o7r3c4QlAcs+7xRM+LJT71Z8cR/Op51wdfk45MWcFa483euF6vnMedL+UzRXZTPE+c/ODXB//X//z/ye/4236G3/XT3+aXPr/zcrvx5uktv/PjT7hcOr/22TvOlzvHbTLjoGVwVgFpNE1n+0aesBicao6kfYt05hTUHYczLslgcjFEzspDRczVEMcouv569ko4rWFxKl0hjcghin4e5Lhzz485485lXWPWg/Kjef2YFykIRi0ltRi0HPXwZC0dBUF5OQTosJF40UwPvqUV9CcoIFmU2cL+UxNLRpABM7cqCIm68Q0zaDbpDpZTu58pVbmb002T0JjKq3HX0v2cdfCndEvmosA3grATetQEogBDc8E5HpB73ZRDi33fFxuwS6TLK2NMLltfHAQVl+tFbvHDmTm5eOPN9RmaBIY2jfl6cJ5KyvXmslhJFR0K1rPax8h1QVqarOsl0Whd//VhWXXzdQzO8hTLHNoHuv5SFOQnMsS7D27cIWJLrO/16EazJt+K6OYAlD1VpEF6HXuBCprVYNbrcMi6H5b1qHZMJ0rgbVDOGf5S/n9eTuyUTqsH9IbdEdXePkCBIH2KV2EJq0NlTWpF2KGYYIIpHfPxgP48v+rdvv7tqB0TtUxxFgiYD01MTaTLscNqZ5VQnGbEvDy1w6XV+6qtljVawbur6dAll+g2LYm1p7Umi601p6XVvk5EibRU0bZixRakSnkyKrvNHqSa9MSZnBmc8tiC2nnNajij4NjIqPun4plt6HewmhgskSp8bWgE2W9b45OP37JvEr6/HyJ546NIQCfhzhjB9//qr/Gn/y//Of/H3/c7uH/+OS+vL7y/vHJtP82bb38X9t/g3Wef8/lnE+4THyc9G/ecMDflQb2m/Ak3sLHE4WjSztr35tJhnmR2FfKe9MNEwih92dYbZ2+MuFUAau2+fDAtIQZpg5mIMHEapzUsNrbZULxK2Vn9CF8/9kXKadgI5jwJDogKIOSoh8PFLEtFVms5HTwC4HyZnzrkFZ/1kNWBXpLGoq6L6p3cmSgBd0lspiXNm3ZUEezzXl1idacJl0juKREooYWx0DZBEM+bcXneeXkJpuhRFTHetSyNDTLZ1nA/s4LmTPjyEWDJ5soDnUfDfHBy4PeubjaSrTvZ66EFsjnbXnh36yQbIwb3GRA3SOOsMDjQLkK2OZBPMG+ILk8WhKP1Oohin0UGWAfsyLlmIu18CpoKAj+yClHUISEth6WYUGLL6WAq6aKKYMkLMsvQVqe7KMhmcvxgyhE9BJGkydRXUMsC+6q0Rgef9Fx2Snq4tZtfepcp89ScxZ9RQ5J1YOpAF+xjrH1L1vRuNQwlMCU8tyVJmFh8JaOMACbNlB0mrV65ppvO7h+mbmd56alhkO2RnNot/JGeTIZsekhGCcrDRv1MTaRRn9vyxshyC7H1/KACJQbqmoKyRln9LnLBz/ocTftaUzFusWDfoQkyjGDUrkutZWaTpVhlJ2UcJCsSpMkX0lNiXSDYSlRQO1aL2iuqINfbxNPYN+fN2ysZjftx1r0i41ZvteNC0OPxcvAX/+Iv8ut//dfYJuzZOc8bn93v/O3f+gbRvs2bbSeB198cxCipCiqa55p4ovh5tr63mkvcCw7Xh5nRYHaGnWz2BmzDPdj8grcD94PwWU31h4Yo7Imem3anoh2Dd9KNNjWNnd24LE3dj/j1Y1+kovYLy3F5GpzAyQ5twnIPpn3wXMtgujMNRWM0HfZYiTBNeaRmm1iDdtOHWdY9UTc8GC2ahL/mOni6wQadDZ+iIQeQPnneO58ewZdeB00RBZoNTtf7Ps6TN71xn6iAVoftJg0NBsPL+Xyq4+1dh/N5qmuMedA82DdnzI5N7d6i3t+cScyiByd4M84wPJSpM15eYU7O1AwiBmKraS/JK/CqicLugrXciibdVNDTZYrq9WDKCUEdvflWExUPBlvVL00RdfyJYr4Od/35Yg02naOlJdJB/hD5ZjUatdyfC8DyIiC4SC5zQbRrD5SpiZcUu6uEplGkhFyLb9O+RnYPWox/KBKrCAz8UUYL+mvLOkhzXdRpaRj6mNckpEN3+dlZBZJbniSz9FWCqrQLq+IURWtYmiq8nOkTKyRhPSdp9ogwWa4c01wJxyYq+6yCt5KswxCdGyMmpWXbwEvQvbRuJhCppZJkRQeXY4hgWVHBtYdT8Upb71nTbT72NR0i6RfH337KePclWNCy1c+btKZUbmJUnzHpBRd/8vEz9/6G8f5zxvHCy/1kc+gVNXJtjTfPV+Y0rtfGdXd+8HSh5RPmA4/gLFZwpKbKz18H177z9PEV+hM/OCd3Mz796JmPGjQmfz0G93hHjlc89oI5B+5X3FERL5PoZeibliKtlPWVuVCInU3zfXN6Oq2l8rJc8R/dJue6XiVJWLPqyMlkcObAOZjtZIYiRB7Gxj/i1499kTKcuyWnGbOmmB7gbgJ9UtPNLMpumjQcWlxuiiIvoWLPYDDZcm2SzgfdOst9GpObwdKjSITpLL4QVovjGLg1tqe3vL/diHwv2G8TTOgtijLrzNSkcMTkdlckSNsaY04W22m6gTubFT05NjiPsmPZBOMheCRCc8FlM2aeWCpHJhrYdHIMFYPesal9zIwsVlEj5k0R4BjWgxhFE7aGzSBfkuURl0VnzmIMZsGbzCKKeKmE6gAK31jKoQwtz8Pk7By2rIO0F4oKNqSKVfHe6nstKUDpjIwH284WUaPBnFbxE6G8nwVXUnTv1I5LNkv6ffRtxIJUcMPKs1pzkWj7VvZEK0Fq7SczF8AIeO3IZoNWTh9zgifdvFyvsw7lUWxtK+1N1s5P0+gsuj5Rxamo4wsAjMef1726mJiGSBD6RFUGM6tIyw3elkWXiRmqiXkRcajvp+embHVrfPOlLyBchdtG/X30TMKpAaKEu56ht5jBylaKhThYK3hb9G1rekbejslzDL4wyOzaedYBb+l0C9i6Qj9TMPD12vjffOMtvzmTPOD7p3Hdr2Tesb3x/PTE08dvefPRpzwR9N0YI/ndIxjZylLt4IwkRlaRFc2h9yuXPWj9Cg1++fPP+fSjt3x8vfDT3/opzvvg144b80s9Y+k8ptZumprMjRkFVaLzJHBmKg+KOZhxEnEh2l17wYRurjgX30hOzZ0RD2G7z8BjyVYkdyDXEkQeiZavkJ98HTXqJ0VqEjA6PuTHpmnJyXnWeJ8Fw3+V/bM0PPLpisLus0U9MIMVI649DIUVqyMldnW5DRYd20xxD+7KKYpsZB7M2ztyJh5SuW9ZkRypxbMj8ad+Rh0gcepGxCBC9v6o2wzXTibKAdtqx7AOXQ3/miyvPXm5SeCb5sxpglWi4R60ph2SI9ZYAwi4bI5lJ44o0Z/hreFjFASFDrdE/m1lJLq0NzN1DZrLL8+JB5mBogkH5Y2HfA2X4PMhwqymYoXmAWDqbLGdtCuTU0fhsutJ6jEM0XpXUUnqOm1674BmvCjDVn2x9mDV0Zfbg32FXKBDVKZPYvvV71xIiw7utX9q+veauCXarPe4YJ7UNRSxofZNiVyyU1DMYh1mnvU2rajt5eQw8wPhISuHau1kTU0LRSyITJyu/+4FK7GuTRmuulfTscJMHHJTuc6mxsNmwc9ArM9WcRzyOSxm5TKzTWeWQ4sX7b+2rHKDqAgTPbrzK6xKWFYo78/B27eSesz7IcG+12SdSWudzTtvfMiyqG30PPnLv/YDTm8iCVwaH12ufPL2mzx9/C1+6uOPMR8iWI2Tl7vg22YSsR8TIhp40LcSiod0Tn2/ki6vvRgv/MacnHNgn37EN7YnvvXJR7y+e+L1dcAcWHxVn+UKS6WTPotctO6fssRC96GanoNu+nk6nwpJSASTW4ppimQHUbtfz6QNyNGUWxdOKz+/o4BFvvJE/KheP/ZFqpE0vxeg0ckQRr0Khj4AB9swFAkuCKTTTLDHWtb2uNDpNBT5kZRhpznTJIBzK2wfoPYlqwtXB6yvf+ROjYp0qD3Afc4qRAbITkmq+kHzi27AvjPNCQbhQ5DHRL563nA6wUHbnHnWUsIDtw3zQRbMNtpg653bGcTe8fNGzi4RbhfkQu+0zWjNcO94Cy79iRGvwIsOiwZ5gHQeJY42PhzWbnU4oXFtQVZVHLIOPaLJuSCKPUe51Bd7zr3g22KSWcE+ChVc32cRAYrSbkXaSO2oMurzsYZXcq2Vg4X2NYMxy6EcF8z2QPQXAWTDivgR4UU6EaMv0SGG3jbLpFYEhZOwjcxBsHZzi1BSFjh1p1ITYCsPN/1JL1bhgjk1G1Ozi4qYP643qEkw3RylV4rHdbdqCNY+bJp2hwByUolaIUqHJnit2v7kUSDdZu2iaoKjqOeuHWhkKwf3k6BXQS+SDQX1en3POUlvYhva2ultQiAKXiwaqBqUlNvK++PkYrB98sRntzscB6MZ39mML6JjWyfGK5ON5+dntg5f3o3nNzvf/vTbbE2BhPvlwtO+LIymGKz3gzl0X+jYLunKDI6Urm+zagam4z3I2ysC0kYpziZ+n1xuG0/duD5duLx9on3+Dj+CaJDVWDQLOsbhKnrC3HWvrCswBEaQthUyINbwYY1oxd200mnmxsyzJt4OEYxiSbr1MnoaGMV4Tu1N+eAX8ttyFv+NXj/2RSop1ld1jmnByC42USq3KbwcBnKWIkHH6EyJUaMepBEF1U3H98acB+dc+hkpvmc6k1F7CeHyrc06kBzsDXs29qzoh8LhLTvvjpN3pxb8OmhEXX5g9qmDfh1ZjtFsAwQLkUmbQfcPhYGQeZIbWJ/EOHG6WIKtQ3PmK0VxLqgiyg0BUZnHGfCsQ3FGcLzcuOTg6jtnnDW51SFXezSbgqQkal7GoeUmUH53RD1/ZWJZRzOYwi0KUKzOsdwJWE4FUqTJHqmgQCsdU5hqYdSeK5fmQxPLrOKhp7YSS7vuk0wx2tajaWXD7lHRIEUn12RSsRfrwJ5Zbh2OeR0Kue6OqP1K3V85tMcqqypZIk05Wocm5GDo52VBa4/SUYXEjExpBbxE2jIorh0j8YBWNcEuegPqzuszeRj/lFWTUMGivFMEIVs2XcUEQjqj5iUURUOAWH+GItHLvsmz/PE0DTW8WIpLLF17uczHTsx94iFxtVCAmhK+4p23PiXL5P3L4L/7a7/E7/zOp/xvn41fwLhsT5w+eC7X9PdjMnC+2YJuneef/ja/53d9G29PvMRk3G9k3DnH4DwMn2JT3o8DihgVOcgRHCMZU9M45gwklzCbMBvnnMwMpg323ui+cdmvPF87bYMYcqAgGo2tGmPImMwsmBLtObWbnEJSClLMGUXeEoRN1tdlWY2ZXNabDZyh58AXtd/lzRmtziuRku4EI5ytVhpfB2kCflKk9OC3KPsSdUfugaNY6dY0aSxIqZsRM4imTle+V9A8GDYY0VVcUhYkrb1io7biDWxITCcjtAR2zI7H7ssJmjtbt1oHBD1kOnrG5OWsTBekn5iI0aXGPrT7ikGLyrpKpXC6bTQTyyw9paQPwZXdu752nHg0bOv4hGc7sAYvJDNOlb6YjJTEsvdkTvBd+qAw49I2nt6+4VsbbG/e8dd/XYXHH1OLF+NuZRMBNrEodhdUN6ri0x6w2NRCPFdwhj2Ksf6nCsyDCWgFyGmxU9+xdhz1XmT6LSKCSAGCQm3tSEJQiBejylLO9lhNbPtU4RkuLpjp4Ezswb7rxmOPaS5bJty0eLYSbaemA+1aWrlylI+i9WpUxH60um9EdKhr4TBDniEzNUHqd17TVHAWK81SdOVwNTVZv48W77UCZPXGdT1dn01UZY6aPMVpEQ7byIqX19c3JPSuleDjZ1CwlKDp2nkV5CvdYUHOhv5s3dsLtoQiqiyFjlR1aS5tWbrMoAvtWNBvxuTdDz7jr3z5whefvuXputPnSThsmxFHgHc+vUjv9evvXvn2deN+JvN85XUM8j6Y8UpYCfnnwTFO5iEnmXEXXDsc5pjEKOgvDs76rN06pDHyJDPorTO2je165aPLR3y8PdHPwS9/9iXv3r1nDlmpNdvQVrDrfLBR2yRpJUeEYEU75bFZ+8TghoDZC91FXGn1yLiVY4bxwYgYaGy4G24nzoHbZMN5msZuSto7rcgc6/n7Eb5+7ItUZCPP5DwHZ06swWZDoZXIckf015oUqAiJkH2LZdPDG0ZHwW6zGDp4uRsPkQI8HOZZB466W1tbbKsFZXuH97fkseI4ZKF/zODLUd542WkZckVHrsydk95a7TCKdRPlb4dJLJkLptL0QolN3WuUd4etV4EYvDuDz4etdrlGfO0KZoKP2h14x/tGS2Mvuu5vfpn80ucnY8iUtfXEbuOrulQwq8mvmF5euhjRtvAsmyBkA7O0N56i8pNDBeStwftax5vo/L7o8eXK0SwZISqD4zDscfC6izGW9qHwGXXYFcGi1SJ+sJzOdQhldjZEFU5r5ZKg+8qgSArq6t2VGyS25fpZtTeKIpHYBO9VUDUdLAG5GI76d4qmLpZV0TG0sGIZxxqzikmn5SzCSbH3AND1DysVWMrgdoRXQ6E/zxXZkcV+RFNxC8A+BFaKGcnjuuo3DDEtEfwssoZgTzT/qxFIiek/fJ98+NZ1yxU0zzLPLV6Imo3aWSqd4IOnXOSHGIuMYIaey4xJt8nedEXiDLI33uw7l2683oLLtvN0vfLu3Y2xHBnOofvdDo4Tjnkw52AbwTmMY07OOAF5SvZszNmZOfBHQRcMONxpDtYaby9XPn3zEZ8+77S482u//hv84q/+Ju+/eM88bhXX0YpU1B9QJt44LZFMBlaRcQynMXwRVBpZ2secCmCVC0u9J0Qyckw6sGwwdR8NU6rCmHITPL0CYKNIWV/DNPVjX6TcHLONNox9Gv0Eo9E4MEI0bZvVIZ51sGxK6S3ShBb/8/HYaZSWCWQg+yJ5up2EF1sqIW3WVCXM3SyZ6bwMY1zgaRqtnKKPVM5Mb3Av2DEzsZDocBr8rm/szP0jfvPzz8m4IGudALbS/egdhpfLQxjmEDRyhApipc3O8yRPJbL6vtPyPfMI3tB4Se2VzhFYKz/DLhPed8fkiRe+8fEz/f07jvHKNZJ3pxd0V1177X2sMLwFMfkS/EJRaOvAQnRvYhS5ZdOeiAEvGlNnjRW+viFZ+qjGVDxvwZwmh+0pCHA55y0euK3mwTaMG1kRHlrML5cJq0lmOcdPmCZ7vVG7NJMTutBLryV+x3Jo94JkBL4gScr+KBSQ2NACPopunwUNGqG9aQqemS4I+EEWqF2OGgB/OM9nLcQpJ++s9FpDkFDUfZS2kqwqCZkgQkef1mnq4MNaQT5e1Pysac10PTKLLBE8jrO0B13cKacH5CpyVtF67KxgYapqsOq5sYoZ0Uxe39mqIH2oSiWKpijZ0Dr0bcO2XYdxiDAxG1x6Z+tOi+T2pvEzn37E83bhfn9hIJKK7s3kHFlw3klM2Y/NYzJmMOZZ02eXZixHMWcF4caUtZi3nX7Z+WjvfOOjt7x9e8Ej+JUf/Ca/9P3v89kP3hFnELO2eCZz44hyMeErpryECC5pgrArZbkHYFfA6amkaOsF48YoIow+L1mRLThd54SG/hLee4F7MTSXJzw0LT/i1499kUoCumOtoJhNDK6cLkqsG8QFi5fSP0XpQ3rlRxnNi0xhtTsIJzrETGjK/3FrOvRMDDcdvtqsqDHWAdSyM8OYN2TzU8JPd3XEbqfwbzNBRDiRcnD+4mXSTNoJqcYdoheBQPs2si+nG93ToZgNdVyCUuZMxvtXRuvQgt0A33nlzpGB916wjNHbKYjlfsAbmdfejxtfvn7BcdyRteGuhfspNmBWYSdr0kE7vnzsOSqCIQV3Kd9pgXxdRaEmscgLFsop0sGsaUxO6pPmShJeU4sO+mXrUxNK5sMRvdxp6/AcmvZS8Jqt91oCXzmDR7H4tOcR1V6ZU0t0K4ZaMOowtqiDGsXBpy83cBBbcW3YPkT9aXpY9kmaFqKcEMSgK4AuyyXBCsrzRZ3IoscX63RFyJg97mkV0jp4rL6qDnmx9kr4WVMatQvKurrKSmv17laLtp4h6Qiz/ACtqO2L+pqXhGN9BF4CWsQsLEZrBJo06bWHWYVbUwW1Q6yURcG6SRFhkjfbhe2ycWmQs/aeOHvbuPad04z+9sLPfvJM885tQPqU5Hh2jjgYx2DOyTgH5wwlDdwnY5yc4SQHRsd8Mqi+J6UfmzFEcXfn4sH1svHxRx/z5s0zLSa/8dmNX/zV3+DLz98z74NWOGmagQ28iEbZkjnW1jnkK8ms80Wfm4fTkkIUNqyskMbjU9HUlK59cQztqdKFRETBABqWdP2mK+YHu9Jdspev4/VjX6RAdE7rG9E/0GvNdjIbmxmjGdMb0yYz6uEgGKnOI0I2JMOCvQ4NOxtznvLVSy+jTQT7IesexGpmiYkHRnPnak40kQsijCMFo2ya0B/smmaTabNuVucHN+fNdhDRP1C6S+NjuWHWy7RdS1G3xkCLdav9jfZUq/MLPDfSD7JpoTvnfNCRzZP98oS3nRGpzi2dravQnuck0rmdg1GuOumCt3pA2hDNoQSEGRRkV4SQOqotky0fWnpsOW0wcFOEtWdICxYfWH/huyAjG4iILl1JWpNTgdXOoLpQXwfrokCja2irO/8KnCXI9itFI41MEUncGj4How7abE5Mdfwt5UmnkhI/dNBGTU9Z9j5mWnSvRsaKQEEJx6Po/wplLHNXBIFRO7ZZ+yJfU5RRAllNVo1REgpYab9LnDytrklmTZZUI/NBF/aB/6d7+gEzFqSnqVj7EUkCNK15Bj15mKC288NkpDyprMNXNY4orZyXf1+JsAMeLEKrhVqjMV1RJhInixH5zTdXtutHvByTL2zyzesT33q+svfGmErq/cY3PiJbcrslMWRE2xiMQ5DsOKRHHHdB2XPcuZ1DEoB6Jo1kjDKInirqOVINIUm/bFyuG5++ecPz22feuBP35Nc//03evXsvTZV7mbjKIW+6WIIfEplXEoCAUFkxJTTtP7O1yiMLwnRNyORe07f5IsTsWN7qIivvayuIWWeCM4tx+7C6irN2mfXZ/ohfPylSqIuPbTBsMkPwTzcxpW6IDjxLnq9ZSp3Fw8ct1WlZ7Twyne6psN/6CZMm13KXlmYgd4JMKyq30PjJ4JYJMThSN3WzRrPJN3vwg5a8FgRUKpVipK2HJEUnhyIr1IHTkt0mxkUdUEwt+sdUZ+X1Plyjfb55wiJ4PYL7i3zZrhtwfXrAHJaTSxMTsHm5LxDgDW+NrTXuKUX7HsmtYEKvQhC59jLFxKtY8yJvP8gq7jUBpQ7EcC3r5Z69yBell0p120vYKyWklaHs6urFRmsF61lNalnFWruccp6uh1D2S8FyrM81Ya3tSsCivRMVXFjwar11lvZI7XUrv0crt3DtChds6fXzZKBbe62KKFk/synFkUgV68d1fJQO5RLNx2RW5BVko7NYcG7l3J7VYVMMPhNZoxGcfIg6ecCoGQXDUobBgpQyF6HFMS/NVXrtS7N0XMlB1k5LRSsysCa4arm+e+1cNE0YnkuukShUVO+l4WoWXe8FK9af6f2D8XLCT33jyrc+EcT/rY+fuFzkQZfmfPLmLX1zfnC/8/mc7AEt77yPyXFMjvPO/aZMtZzSqM1IkSRmkT0wTkb9mYxhoxi6uOGbjGg/ft55ft54skncDm7HndfbnZhT/pdNY2CGoEYxHeOxn5QsZdaNNWmRBBstJ60QGq/p2m0lJSf4kI+fIXTDgrRZk39hfmx4T1qOaiasSE1CJdTsvZJ8/Nt7EP8NXj/2RSoLBrE4ME4tcCu2oeWpD7HcwdXN1gEVFD1Ynbq6acWoL5fusCn0vA5Mmb5u2kXVwrIV1Ryc7o5NA4NLFcQmNyGZtppxr9beaLUYFpU1Paqrf6MbqUEzGLmRNirrRs7V7iDMr9yxTTHRDcjs5LhDh20Y7+83zvtJ6xsjgm0Ltr1zf6ep8j7u7DRu90bfB2Yye316+pj+3LA8+Phjg5fg/quD5VRALaPlu5dktA+6nGKc1cwprQvSRgk9+qAJkdB07ZVmKfM1Bcbq8Us/FQWN2IIyioMgDc6HKWAx3hQhVVHrucxl7UE7t9qnfJg0FH7peTJLtxITsUNLL1dBLVUANLHJd1CdrA5/TV9yy0DXNJumRAsxFN3wEBS0HMWVCwUy8suaJPJBfmh1fSWwFlkdK1ZeLol0K9ryfNhehX3YFK2JMuqeNUTsWdIHm01NnFMFBDqro6/uf4rwIiaqnpNZfFXlbYUaibJ/oiZj86Jeh9X+tvRgeke0lLxAtbDUa2UgmO58PuBnrxee3zRa39gR1H25vOHpqeFtI0m2vvHxaJxx4/05uB8H521wjFfGMRmnkg0EzsozcFHQyeBMyFDDEq4mq22N5hu+O09Pb3na37JZ8Prynnfzhftx5+VFBtabG920LzwrfTvLR9KAGY3MUY2z7pHptRfNB26tCSq3MkrWvspmRfeA7uM0LFxnyFplWIPY1AT4VixOx71h1hRD31r9nB/968e+SDUGmw02a2xtl5LeJtl2ml2wvGN5iHlkqbh1gOqK9dh3fF8PR1Tnb/Q86TUJmN+LCHBoKZ61AAeGKTiOWjBPNpSue5e2xyVUHWEsT63mjTmn9hQOI2ZNJgfZnWidgTF91n5HTgCE61AiwHZZG4V+ts5j0fFtDo5Thah1x9uG52TcBu1po+8742ii47sc2EUsURHfLoN9vOf9abw/J0fqMNSl04yigMWiVtNrCnBYJLaGOtDywMtV8MnHRGPLbcDmYxe1YCqjWGAsU9taxOmnFJsssDA5dCSapM20f8xRrgllPmuVsfSVSS/qW8p/rwBKy5pUJml73Ss18UXgzepzBmI+yCRe0yiLBBFRiEpnxVQscsWCXrIc+XXzTVqmHEHW92R+0JFZq3WN4GHtxUqUvZaUhIpB2U1ZLlp/QT10wcxZ94yB+aSn7ivrgumcMkIuB4pZk6RTO5CCFa2MYwnB4pnL9V4w6tKIySNxFHzrtZe0ev8LbgX3yhWr3yfrd3Mmt/srv/7rv8LTbeNpe8vzR0986+3HvP3oLdeLINn350nMYMbJMQZzDKIMqOeZmqLOwTl0rU6LhxtEWjCb4bnhLYra4Eqz986+N56uG0/XjrXk9X4q9uY+62cqS2oAven+aSlCTnY1BdhWZCkhH+eKYcle18Whl5t8NQKyjgLrRpvJVuxRSf4m2VxJCJUmHGX2PMwwNtw1/VqRtxQ1v0NB7T/q1499kYIgcsPmrge9CUOOrAOjNbIZMQrjt0MPR3NaNGKq47UT6LpJFr2adsXiJufU2IGTFkbGEC5fLJ2sLn2mc+YAu7P3pMcu1pZDb859mPZnNrHUjbpgFOdU1x+zpjuFFFrOUolrU9AoDP/B/S5HbEsiTBAkMNKZ86R3OI/E+kEkbN5kpTOCZQo6cz0QkpfG/cbIG7TOeTs4YzDSNQ1Qi/bUkRUWBUssH7ZFiqC0NFqyZygTy/ODZc9jCkbL6ahC4HVgiGXlRDgNuRMIoBKjcjqCDQumwZLwNbUF7NDuPPRTiwJunHWQoz1MetkWNaZFCWvtsfexTXVWxcAfk5qV8W+uIhaGNYF0bllIXyq52KjP1bWXofZ3UazA8qwzm+ruUzCsAghr32dRU72RU1qiWQ7gCypQQV6Tace4afpK09o+Z8kCssgUBSdTLMeg2KaazDwg7APktZb2ir+YIlkMQdSt9moaIGuKSq+loEyRlRxc8TmpxkDTc6tnivo5Wc4tlBMJ5Dm53+9cn67YG3j7yRNvv/ERT88bFsF9TsacnDE4Y3BEMo5gnIMxVajGOZTnliVufrSaamw06WuKMttq1ykiS/NgdzUQ53Hyft54uU3moJIXhJK4Ja9TtmBMOKNphYBiX4TbHEo6KBur5QeaSIhrda+FBVFwuaA7x23ijcc7B5h2sjwo3VwSj6bmOvy5LMSS6ReilRb0R3gqf/XlX9PP+V/xa5czdxuFxgfeOt0odhx4KE7bEnquKLlREIPgqwUFCVsamN8F7eR4sAQ9dSPPxxGz0VIuCB4LXg6UiJGMLDcFm/QmvcjVjIchvynvpaG0TuMUXDRLBFswl+jQ2hecrHiKjRwot4rO8usT5OX01tl6l6DVG+cYHIciPBLprbobMaRHGTPqINMrfCOmS+uF3nuadF+6yjo4lDJa+VzI2XsuaM10nLHErVmuDKn9oJUuLV2/X8/QwcUqbnpYWxXeZZfoVHxS7T2y5rkZVOcuQgL3Eu/W5LfiPjBpdWJBkgWXUVHcRK/DO6qpsIeBRdoHMXLDSoMnskX6ck7Qkb/89yZRBVhJsM14TEKCbteeTD9jaWZEuCiIrSbKNZVaTVrmYpE+Jj0LZlNj1LjX8p2a1kpEW5NYmBGeH65FJm7llPKABaVfUnNUzvcpyDGrORJTXPdgt/YVONWFQqScANc1hgXPVrYWWxXOydJztVyMRyOKYUdL+r7x/NEbvvXTP8W3P/2UT95sunpncj+CL28H99ur3B4OTdaRgzEGx2gqDGZ483IYAe9O20QwlPBZhXRmIAdm/Zm1TlhwnpOX48bnLy+8HjfG/eB2ntznwRiDW0xiTikUAmDgIXpU1rM8Qjw96ckoSByFNlJoSIPNkp06M7yLlDJdxKa1O4xRTVPqZ5FCb0AkoDobZu8VCunMbUHyP/rXTyYpIC2Zrodmq0NQ3XXFg1vQYie4AYhiboLXtF4fjNiYKTJBuoSt5gP1P+KB6ZDSUl5QySCsg5lgmjQyUMfUHR8DZ9JD4tXZDjYPlAS8CAeCSEY26etnPZThpQFzIiZ9Bq0X5h91gJsWsiNn3YyzluB1yDdnzmDfGzGMcx5MTuKQKwarQEylBU9PPDawwbYb1431DnkG3pF13tdaP/XPLNGpuSBQFSc9oMt9wGpSm8XsC6zIHwUDZhS9+SviWOT8YDELhtOBKRhw1t/V3iDLxbulPyIwWgmhPVdBig+HPVZ0d0FeKj0n6VvlXdWOJg0OuaBPWgnAz7ojCvai9tUL+nqQRHTitq+Y5EZMHflWgmyr+xcxsmaCs7HiMaZR1zZqYkeU8jIXzrTSQM1qBNQwRJEoVMfX77kkAl6FRHEf9vBKXGQeVNCKFJEp7Z3OtP4oTpkwUlAsoamqs334vAvz1b+vArXI+ZpErSbqpRELqwknP0zs5kXAscYnbz/id/7UN3j79KSPc4BH8noEr/eT8zi5TSPug9t5Y45k3pLzLsuwLIRFQGO5pBSjNwpaXOgpyF2mu9N6p7mg39u4E3cYw2S7lqfugzIB8ExGV7FXYKRkLJB4iIqeJjukZCfsIFFj2qn1gp3IyJoqlhuRo+yUXO4nhZ5ogLMPd2jCSicoe0WFJZK0CDxCBgVf04zzkyJlTtoFywsWHW8X7ZRMTKjexCgKE3smF0QRgiGOlF0IsQ4IL2aY9FJuB9nkiu7VRa6diyYaYctmRmcwfELf6SFYaGQnQjsdb523z0a+vwvuKJ1MWMhTr8YF6WMGy2EdJmZ74fSaQno7uZvRqaWpl1chizuVpeZH/l4eeN+Iu1hL3cuXjATfmHMw3x1cPtpEgmg7z8/PPB0nuQW391XwqZGxFrs6XCpqINf3FIxIsuQ/OhDiw+/XrH34eoPFbFthh5YJbYV6UBCb4CidlrO+rzMVcyrygNVcsuBQqPf2gdHHQkqjfh+T4NqtzGuLFCOex0Z4uX7UtKLitpbOa9emf5NezqH2A1leaqLWp3YutbssII8Vw565P34vFRcvin0dJzUxSSBquofdsPKXlJ/GhscyQi44r35eVHFbUKqVGeyCX62Ka6ilf0yTOtjPmo7Lb/Hxm8/SZpVha022q0gvunV9yJBGR1leSyfkyJdOWrVD01XVtFmU6/Vh7t3IefKrn3/BJ8/PXK+dMZwv7gcvx40YMM/gOO+M4+D1fnDeB2fMB3FkvaduVlEfN0GcS4he2jN3w30j+4a3nbSdc7wwirJuIVuxWQ2R+qZOmsJFF/SrQiP4frLiRJxRqQcPMpBVcaFJP5hWTUcxX4toFBmCe+u/DXPB/rnjJjWWoOHGdMP6FRy2noymfRpez8XX8PpJkSK4eND3Hd+1R2jeaU006nAjrihDaZxkE7tI7UfIUDL7o5u6e9DLO8w75Gkwypu5zR8SOvr0AtELzkJecGGi0/bmpVtyfMqmx2ORhAWTRAzlJ5msTcbqOFOYvqP90jAtptXgLRWLklQdk/t7grUs6FHmulYmp0zjelWAnI9GziG/sKLAugd5vRKzUmrjmTeXL5hzg4Se2mHpQVGExeZNDxzlW7A65wVf5WLiCXZpRRIIFwVf8OlgJAWxaO8ih4e1/1oeeF4ecFawZk0mGYI7lgMGq/Do5y7WXl10uVhXcYzam/iSI8QqllGdrSjRmOamFUcfaQ/YahWPpQ9rnHVvJWTXlIUSgcn/wZ5uva/yPTSvUELRzcgUpd1sFAvShAVmwT9ZbhblIC7ITYLcKAZdronKlod7uW8QwKgJL7Eovzwz2mIV1pVIg0D3AeVib31COC26GLGGLH+qM1HsiSYx6a9W8Z4sqyvjxGOV68naw+rvUxBkW6x5RgS/9NkPSB9c337ET33yhjGTL+933r8O7qf2Tsdx4zgOXl7v8uYLwcgPog2t9FqCmyl2nIDtg6Th3pW07anJhhMiOEO/z1wWSbmmYJGh0htuMualpqI2dG83KHGwJvqGMexgJSfzgAOLSGRXzE+wg+GdGMZIoSEzT1m8edaeF6EOLiJUVqZYK2nEHkI6Ln1waZ1LW+jBj/71kyKFDqw+T1qG3CEQtTWL5tuHsWPca+ktkkFISJsOPgga5ifb7NWJapcwHXq3qkWd5pOJOq+wJGeZvqZiBUBmrrez8Wxia7XmHGfChJbac7jxeDCXiamjJWwUQ6w7HKYe1VKRHSueXPeXPbD9ZT/ElC5dFv9WqvfAtg4O/dLI07gfgziTmFkL7Qtt22Q1k3AwiHNyO042m3zj7ROfj5MxXgS7JUX5yhI621o9lcOEKbPKsvYOSTBkpot2dkm5eBQMt/rlcBfkkhOzXp/xwLJXl18jWk0zzTXxWEG7YbWUzyRqobXgJCwrtEDvSMPkBzc6NRvVAkTQUAaSju265stoFpRHVPRgTSSVx5SLw5jVSdcUjhqHR+eMdm5idi7PQjlbeDjLVX5W6GbWHBJF1//AkmyPCWbtoBYpwmoyUcGuBi3bOjGLfi6ihaA3/T0Nhf2heTKLMtY1BRsuAk9Nki1XAlV934DwpsliTaZWO5QFl+pmqCYkmVYFe10vE90fm3jA+9ck/MI3P3rLvl344n5UgTqJc3C83Lnfbrze9N/GCDra53o6veJ7pg1GnOWBV82hypc+E3YZuvamaTYnBIyhnLqMg3igKYO97vHmJ+a93reoTtmGdIhuNFdxytnkBG+oaZuiknsKBtfbGQwujEy23DUpmzFtY4b2UjYnVGq013tsaK+GKc9N4urOlmIyRu3J+EmR+jpedVDU/oXeMRp936A53kwbzzTSpOi2UKdCU/+mTiqwaOQwRkqr0bseuCb+qW483wk7UQ6UQJgo92u3xLNxBJwZ2JQDhW2wnKxbwnvAWkVpk8X6Ej08DUZz0jpy5Q7gAtXXt9x1rvR62I2CjmrHUdcj0WE+LfHNiVHQyWz4DnZpnLHJNagluON7J+cgt52ZweeffcluN3oxoD6fibmuD66Dm4Tp/gi6MxOGH6UV0mGrAhAaXTSJWsF9CzQqOi4k6a3Q+Tq7ahSz3KobFy26zQJC1xTDIsR4HaaJhMCtDm7poTT5FEuuILgsx/NmVgSZqee3l46rCZKJB0UEirkA02nVIj88BEF7lNDU0FzGwg97JLLeX9aBNr+yj2JhfWKlRPshSChWvDvVkRfDkdoPWihCw2TJ8Zhks5h5VkLZFbWhe0zQuOp+FrQtf/IWCxLSnEHtG7NsdRrGtLW51O5OEDj8kFHtA3qVbVR6Fcu6lmbFKEyrZk97yFzNQ2rC2y+N7336MW/evOV1BF/eJ7fbneO4c7+dvLy+1wR11kGfYpDSpLVa86SlLLOUG6cGwNB029v+mKIM3YhmghkzFOcRsRKKNaWFd3bf2FwTlULdNMVYKuLn4g3vnR7J5TyZXvDgQ1Ki6/PgyZDspgRnm+JLzq/ctyJezAeCkV5aPmvKtfOkdWMv0of1jm8b3hvernWO/ehfP2H3AWB4u9K3C61LKOdTsFdzdYCegQSGRdusZfLM4IwkuQOTMxWgcZqcyFsl02rZod2O2vyo7jpRwuhOpNh2hDPcOXwwxyTjZGswbfC2GGSZc9G4SnleUGFC2tCfm9778nE7q0A8qMjWVz4doKJsfZDoxu0d9taYZzDHhDgZ0cho9LbJv8uS1hrmIo5EHkyCMQfkyXVHePh58ullYGyye0KQYs9QdtXa0NYj32yx/goeU20qtp1YeMuP0CzAPyz5jVGHXVdHbRBeVk5m2CbTVFkbVUFJ2ctocGwsH8aSv+qv1CHK+ggRBNc1FhIMKHfoB1vSC6bDipVXhZKhn2m1ByvB7AciQBEzau/jNQFmK3JCTUha3+l+ao/vncgd35mRJP1BPjBrPAIjMawMlCU4RlBwTbpi1AmWKntZHiOcCVoCvU9sHZS1X5TcreC+Wfum+oyq0KZ5RdrrWnhtmgwVhGm1byukQBZZhwgctZdZEowsCNPqEF5WW3IP0Xg+XTuqk+Blnnzx+p6X+wuv94OXlxvv3r/y7uXG7TjleB7let42mnW8yEJGEDPJgUIya3p1k0mtN1MIpIvEYSW0lc5xIQflHlJMk8zAGnhzrCV70zweo65x/Xc6mhZ7FJNyo7nRt04vkkZagk+ZErjurS4aLRCcHMwcoqpTUgoazcoSrq6p4bRMrMPWg96dzZzrvldO3dfz+jGfpPRylybBrGil3mmaqyVwNcgmVweLE/HRlBcV0fWwsKKxdbj6WmKa6Ne9GZabHjIZwtQDxKPzmVlUdr+JihvCp7OJdfaCc/HB5sbWnIHMYFsG08tLLYKtQR4nrRdsU0vplkPQomv6ah5srTOH9lOZm/RIbeDWOMfGtmsinONk2y/M8072phylBu4bZMpgczT2q2H3J6y9x3vjen0m3ib+Xrs/t3KFDitIIQriq3eZy1oIqL3RsmuKgE3Hlg6nBbWVZiNcGhAVqK1mVQdOsfbqqnNXCN1WThNWHb4Oynpww6uglxtExGMCkuFF076wzmxPWJH1uViKCVUBWcSCUaSQRUu3pAL/mq5B1PCGqzgUcSEty0xAP8zp5dV3qIg3K5pyRctkYrNEzEuThnwQfUFnNE6TzY2c1XUfmyUtNxURqpnymt4eZbZ2o49UaU2hOtxkNiuwUzIM1bEP+zJSAvXFxnQTIccqgTeruDym+0SNSHyAKPXc5CPGRTu/qOiVXk1P7d28ExhnOp/dkmu7c5sn9zvcX09e7u847pM5F4TV6l7UPTpXOGcYMYcYeTVBKe068e5YE4PT2yg0XZP4DEnVQQxVaewA6zQfSraua6pmRXonvKyiunSGMhk+mNkwJt4CRWvIwaXnVLGsuB5Px12C55jOUL2EkKO6pVAdy6FdJEa3SfMJTQbNbhutOREXml8kG2kLh/rRv35Lk9Sf+lN/6gHLrH9+7+/9vY8/v91u/Ik/8Sf41re+xdu3b/ljf+yP8Su/8is/9D1+4Rd+gT/6R/8oz8/P/PRP/zT/7D/7zzLG+O35bf5mX9ZI77QWXDborWOtsfmF5hvmFzw7zTYsd1HIqcOjYIwxBWXlwmtDe5J0o+cGQ1qRwIjWHt21RR0cmRDqtsaEYUlbndLsPJlG7xUPYnXzL4PREpgzI9m2ZFThVHcctBTbL+Ykt6T1SWsSJZrpgMwshhsOeeKWtO3C/nQtuqyRE8ZUR++bidEwE4+DeQadxqU3rG/0pw3j5P6DV+L+nts5cD90d3vCMghN6LEez6LiI0osZdhJUbWn6ZCaOgF0PVcxyDVgJO4nXjETOsoKaqvdgecmmMSKSpuQ5jIDrd2HyBjV/btXJhCwQ5p2B7L3EZSJrwTaqLqk750pQs7agbktMbN2h1lO3zyYh5rSBQOVBVH2IjGIVTjXwGTbY6LAmyaXYn0Vu0MEE4qkbCJzZPsguF0rymTUPV0avPL3o8guXpdZur4OvtXnVO+lpiAzY7q0XfiSFrTH72mmKUNXQxPfYJZ7xxJrrEuxPh99blaSDZaguKY6NRO6n8ZXDIq1ka3aiMOAz19ufPbuxsu7g9eX93z58sLtfjLHYC6vzh76fOszd3SvjzmIIjwsVNVJWoOuHHjwjvmO+yaj40QkJAYWQcRUbI/Jbi3aps+RDnTcL+S2Y9eddn1iu1zY953rttHpQgBGCfpNVl9qXhrZtGLQLdNEQnZNxdMOZh7MeTDjIOyuTLosuCErNboorr0ZW9u4uCQwYUMeo5vg2q+rSv2WJ6m/4+/4O/izf/bPfvgG/cO3+Kf/6X+a//A//A/59//9f59PPvmEf/Kf/Cf5h/6hf4j/4r/4LwA5aP/RP/pH+e53v8t/+V/+l/zyL/8y/+g/+o+ybRv/yr/yr/w2/Dp/cy8DdheO3mwTbbRtYvihjjpc3d4og1KvA9VtwU71zapr8imh5QJgrBnuk+7QEmUU5dJOiXzgmMSvM5i+cR/O1WQk2byzD+fFhVXbUi2uBXVK5dDD2D24uXYvxgWKpOFoie2vwNYZtkIVE8tWE0no3MgmCzgvWr1f1U22/phstJRfxqFa+B8vAZsIHV/8xg+Y58Gck7MhZ4oVXLOSWb30NcaD2msLuntE5BSJ4BJwtgdlP3P5DQpKwmT+674/OnpZAOn/orp2de+iavcCB3kc4pMVnLFgtaz1h9UDnDcEo9QeMENToJc2h9olCQSK+k4b01SY00Q1T7P6jFbswaxeuhzhTFOW6rnuQUF/uqskdNb+KigIMuXj5tGY673XBGlZ191Lw2Rehf4ruzCTA3lGPA7gRJZH0t2tb5dkdpJR9OasQhzV5EhEbiWfthR8JVg2WF6IIssse1PThF4ohEyPR8GVXdBjTSNyRaipJ1YRQuShBEWiqxg21Cxql3fy7uWFIypWZco4do4gxiC2xKOYvVYTSgSjJCRKQM7SmolMRG80d7wb1l0p00w8O2e69ld1QMyi5Vsqta5bQutsTTop643WjW3f6VvScsd7p+2Cvu93hXeSzpmNmLPslJS0YO5Y6ySNDaf79mCGjiKuzKyJfZGizCSbMZBP5Y48yboga5KO89Q2WT5lmTcXMPGjfv2Wi1Tvne9+97v/o//++eef82/9W/8W/+6/++/y9/69fy8A//a//W/z+37f7+PP//k/zx/6Q3+I//g//o/5b/6b/4Y/+2f/LN/5znf4A3/gD/Av/8v/Mv/cP/fP8af+1J9i3/e/9d/ob+KVFPtu29iaYtFbky2Nt6mDNCX4pE3ogb/W0jicnIKKxjyYw8m8kK2VhmIQXVNRK+ZRIxgZZZqpm2WGMSN5mpOcJ9PecJvB21aLZIN7wm7wthnvG8jXZ/mYFTsnG5tpFzMtsQ3aXMVvMD2ZWRHRmeWIkJAihtTqjWWWmdM4hkS+OcU2ms2IMWjZFPsQkzGM1hoxJrPpUBVtvA7VCXM6MWtasvlY8uejiNTK46Eh0sIfDPfGHAJ/JJLVpJILeks1BWvCrK8qYouBlxA1W7k/mBbS6IfKQajslyj9CTx+Xta3kbmp8noiNFGa2SMOPksHZ1gx+Irq7nKvsIp1SZZLu35P/a5WxWtob0HDQsqhabWLRJOk1efutVtwEw26ZVPAXRVMr8I2FzRWJAW5OMh9IorMYEWptlVsazLxLDF6quC6idBSZl6YjuTHobWufdR7tmKuLfkBpoRiz8Vo1KSlnKqjip/e94Jal3nutKDh5bru0uSZQZ66Y1KfmDK/1pqzYRH0TSLuMZN2G8wIRmg6GmMQUwW2NyvmachNJbMIEpXQmdCaCm/zLjd9b1hetFczCbBnFcKp8Zeo/eeqtUJKGnuxAPdtY9uNvRt7v7BfOpetY12FYd7uvI8XzpiMmDCyJv3EOBFDFYltPdgsCz1oREzZOZ1qVLQTFgSuiXCK+EMn3SohQOhSb9D6E1vf6b1pb/Z1YX38TRAn/vJf/sv8jt/xO/jZn/1Z/uF/+B/mF37hFwD4r/6r/4rzPPn7/r6/7/F3f+/v/b387t/9u/lzf+7PAfDn/tyf4+/8O/9OvvOd7zz+zh/5I3+EL774gr/4F//i3/Bn3u93vvjiix/657fz5SbcdrOgu2C969bYXfTvzZvcyA1Ix4c+4BEiHoRpn5QlSsxMJfrGwKJjTFGgTXBFNsEkk1NO6jnxFN19zMHrVDf0ZUg1M8wYIV1Dw9lNcegKfFbRc/OysBm8O7J0Ljvm4zEp6JaW2DaHfOO2vqtrzAFxStcRxjZX7Lfx5rLjdtI36bYYet8SATf6dqnl8B2zKVZQa2BXeu9cu3Z1vd241L51NeSaOPSgraL1gT48ofRPEbNgjfmYOvSgUX+vKPT51bKivZ8mw9Io2WSFK66pZsUQ5EPUGgtXq+U9D2hHE5jsi2Rw7swYBVUtK6Y6KF3y4kSf7YpZIBuLLm/hxbVwZhNT0MqrTYGCTcxSNtJkDLqunsIs1fHL7XzKZ3LVeFtQk2jhVt382n1osCqWKICfKHtr7UU0jeZDFG5IuFy8ubUzitJTWRSJoeyR6msjTx4kv3Le9zIXpg7Ix5+V6DrMSDZJIZyvkDRULAVlJisuhWpIpH0WTd+Rrm/arOnVmDM57q98eXvP+/sLL7cbt/vBOZZbRiNCDirEIbPVlOVWhqZms00QuknH5C3xq2G7nOYtKXGxpj+VJ8lWRgyWID1LDNywipLXqqFvT1yfn9if3nJ9+8z1aaNtzo3O/Tw5bpPzPDkZZTsmsa+usbLFmrUH4WhUI0I9NREnczpz2kOnpTT5uoClD12ebdad7TJgG3ABb4nZ/rXBfb+lIvUH/+Af5N/5d/4d/qP/6D/i3/w3/03+2l/7a/zhP/yH+fLLL/n+97/Pvu98+umnP/Q13/nOd/j+978PwPe///0fKlDrz9ef/Y1e/+q/+q/yySefPP75Xb/rd/1W3vb/zEv2Jm3f2NqG2YXmgXsn2wXYWamfXsFtGb0O5UraDIipbj4Szuh4dsyeS9jYqkA12GRZIy2KdgRisoX0OgH3UyxAs11L0TBBdQ3eJ5w6PWhWNx3U4Sgb/2MgvZefdJPVfpqor5T+Jj3xjhiNTxtpxmgXETC810M+sbxxuTjdO71vpDfiVH7PHMh0c8o5WqLgQ5Rq37D9wvPlieulMXE2S57efIp1QTZrTaw9hj9s2TQSbWBrp2YPqnNkexQ2q+KEWU1N0oksnwnppwqWWMyxrP1Kgj0FWPnk+QIFE5bo2dd/iQ/FszrTtF4CVLByR1vaq6BcIRJsLQttVv1U7hLwgLuw1GeD7gm3fMCEbiktThEuFvvOqgiYLSHy+ND41Bz4cHwouOdBoc5iOlKWT1DXSXIAKWBa/axatFi5tLM4qZq0Rw6mKSiTEgCby0Gb+v5i/pXQ1BcrcH2uWfcC9fXrWUlWTHyafEEe87WEZCqQLuYgNRmvwdRyAqcIJSXkXrlwL6+D19vJ7QjGhLRG7/uDGSdu6GTkVANC6ZCQATNl5pxdicXenD47vey3spZ3wcB9inJepIRV/cvBC2tBeoe+c+nOvu1s+5Vt39mvnc12+mzMCbfxyuuImvqSnNIDSiMnwpbEw1sxbhNaAAfJJCaFHih93GYU1HrFqEgOV/Pg5nRz2n7Ftyc5p29Xeruw92s9Y1/P67cE9/0D/8A/8Pj3v+vv+rv4g3/wD/K9732Pf+/f+/d4enr6bX9z6/XP//P/PH/yT/7Jx//+4osvfpsLlRhI2+bkBuYXaE7rRmtOh/LR2hiVQZMcgpUekI1YUh4TYhJ50uwio8bCivUgRmlKrDaaOoCiecUoTF4mfMcmvSUXN8wlGrxM4/MIrqjD9aXet0aiRX7mZMyTnhs5Jt43urkKWx1jnp0IHZbHcTKOoAMjRh1e1KHSdNha0vbGHFGhkIHTabsTixnYO9md42Zcr1MU3HYhIvH2ivugAbf7D2hzMIoeTm1EMkxm8anIgFYUeh100q8loinLeqZVUamIc9PvrkdHnfWiTmbqRs8SYyfJyCTfaRrRS7Y9XiJKqhCQimdpJNFWlAdFylDRWqGBbpoQBJeBmQyIs4TKMvkUfCU6uNfiu961GS2KkNP03qMaGp17SxkW+v3TtL+LKqxG7bnKdaPIBgW0AWsCqaJnoh9Lkyb2nj3ExPMrk1aRgEqP41lU+DKCzVrmP+jvV4fX8s+TOIsFoCZZhUtQn343wY6FvCKadtb7WxlT1SCEpuu1i7U1UdX10/NYVkKIWt/cHnuXOU6Ge1G3B+5XPjQ0lSkck5w8gjC9nnFHiQjdKGGt07qsp8xqJfBwVQlmSkIyI4tZ65IhGPqM3Nhap/XG1mXJtm8Xnq9XLk/OxmSGcdxufPHyyrvXd9yPwTgXNb3OLjr44mgm1iaGXOU333DbYL6oII+TmCdjSt8lktIhhEI8FzodmmPbLmayN7rpGWqeRbr9LYNwf9Ovv6Wf9Omnn/J7fs/v4a/8lb/Cd7/7XY7j4LPPPvuhv/Mrv/Irjx3Wd7/73f8R22/97/+pPdd6XS4XPv744x/657f3pZvF2qYU3O7s3rm0xu4uBXZDnXq4iA+sPUqSI1nefcKd7zrJ4sZkstXy3s3YzDCDrWABLGsykL1RRHA/XoADLheiGeHObMbeDyJO0uDqmmZa6vu5dWH/GeSUeW1OPUhbk63Mwp4lLm7FWHO268blo++wq/TURJS0nvRdKcV7b2zXzr539v1CzAWuo78LnCM4xp1x3jC74y3Zric/8zvfcm2NM43nbjz3q666xaOQiASg8uiLokst8E2Oz5pW/AFHPe5eQ3ueomp/6FSXA3mWW3eZclqryc1ltis3VeHwxbLzsPpcKWEp0Mt8RpiWEMHMmgMEdS0ytqavKJKn16J6fTZWhAk1GdolVNbTilaoE1vT0rLFDerDrmnEIVo1FYKzfIJNgYmySCrMr3YPUcLwsJS+J7PEnIoyKTVU5TxpArRYMB7634/bKGjUfWd137CRB/p5D+0aNZ2aCg75KGrL8EcQoZ4H01KUzEqeRfCYlbmuF4xVgg3MvWDVs35V3QcN6X7UcOj7nCkWriF0IE0s0IhJ5KRtJ9O005tRhJS0umeqfWtGb112R01g47BTrvBlszVz6N6tBIWJYjaSDbOOt8bFXfunpn3U/nTl6U1ju4qwdY7g9XbjN19vfPb6wpevB+f9LEq9oGwZQycwRLCqfbBXobf63QUZT0Y1OnoaBslJzyiIfqO1mmb7la05vTv7Dq07W288bY77E9q1fj14399SkXr37h1/9a/+VX7mZ36Gv/vv/rvZto3/9D/9Tx9//pf+0l/iF37hF/i5n/s5AH7u536O//q//q/51V/91cff+U/+k/+Ejz/+mN//+3//38pb+Vt8OZvvwoQvzuXS2FvTsrIZsTdonfRB+qz0z1bdVRIxwKNIB0ZECtfO0oWYmFrm6hqtzuNae2rCWsawE+7nxAe07UpmgzPImWypZEx3eG7t0cVnyoMv0hhCXWgYV4M3bSNbl7txHdKRoaV5NtKcqweX55sa7OZsb55pV2mJzIz96ZnnNztbM572hu8d3yvbKQZnTo77YByi5kYOmDrM5tzx2dlcR8r1zYWnNx9pf2JZBA8+YPzCah47Dy38tSuRc7ccwTMnOSYZvajx8YCVdLCEiAiuIvGB7i/Rq1fHLrFpZYjFhIjaKYAVfDuXU8ZdzcgqapmKj8iaNqn3nClYbRZRQmy/qAEgoEXtUoJFhcgK65sVCWOxiofBVPKPmINBeMgRIrNiKD7obiTyLrgxkuXftzQ9tVgpmEiH1QDFwoRo4ypIBcOGF4vN1CxkOZFY/fyUGWouYXnWZJglqiWlfapKb0WWSF+sMitobkKFGmri7SKx1Hu1uqbmgntpBh9pjlC8+prVzroOmh8tBV2vzqa5Jp+0WazWZERKPrIZ8xVypJSQWYvoKb2aG+zN6RRZAhXU5RoxQ5DkGMEYrUhCil+XUFn33sVV5Nrm9L3Tnjae9p3nfefaL+w0Yhq3Y/DZuxe+eCea/HFL8jyIqQa07hzBfcW07eaCy5vhXVo6H4OcB5hUb6POKEWAbKydHtmYDtFOuo2CNzcaW2mjGpbXmry/vtdvCe77Z/6Zf4Z/8B/8B/ne977HL/3SL/Ev/ov/Iq01/vgf/+N88skn/OP/+D/On/yTf5JvfvObfPzxx/xT/9Q/xc/93M/xh/7QHwLg7//7/35+/+///fwj/8g/wr/2r/1rfP/73+df+Bf+Bf7En/gTXC6XH8kv+P/Xq3D0a2/s3un+hLdOtkbvm6LYswGb9DDtxKcgnIhGtGAOZ2whxhDJzPLxqx2L2ybYrlnFMGvBm1OMOnexwEbAOZwcg7Y/s9WeKkisO27ys7v0ztZuxZaSk7Sv5WjIPf3LCKJPmjudyZnOOIE28dFhM7xtvL8dzF/7nBnB1lyHbIAdyEm8GxzGpV+ZNojbSWbQts5+eeJ8vZHjYAyJJs+pBzMS3k1nfv5C2sQseffFC3cOtKBenR7MkGdbFqyjdOMVjCfjU4lFy15ndenk6gEecJJlQ84HS6C6Pudi7lV771neb1Y6Ii+D01CnjcvhQiQUsTHDyhcPWEEty2e8Zis1JYiokfXmEi+tDMQp/0fRBWuPUQXD1wWJ2qylWHIdZ9IJBnYUjGfyfdRkgv5behV9eUd6SQQsnGQIzir5ruLbNdGI+ddU2Ave87JeWn7xFIvO12QjGqMOy1jT6odCtGjX+lwalK4nUoiErtwoTEJTDVmkhxxqHOqazto7Zk1gNp14UaFYwm5j1/PJrMlNdme9TfamtGvz0hhWyWhZrhqOIOpDwvkTk+aohtdoxt56PbuCWd3lCG6rQcCZcRTD8NBvbk64dkbaR3a23cntwna9sO9XrpedN9ed593YmJwzeLmdfP565+Xdl7x/PbjfT3Kqu3Wv5IJF/bezzHm1d/NiSxobK7/szMZ5iCCSdlZD3UmE9rSUs0kj6Wm0DLw73qG1jvdn/LLje2Lt6yNNwG+xSP3iL/4if/yP/3F+4zd+g29/+9v8PX/P38Of//N/nm9/+9sA/Ov/+r+Ou/PH/tgf436/80f+yB/h3/g3/o3H17fW+A/+g/+Af+Kf+Cf4uZ/7Od68ecM/9o/9Y/xL/9K/9Nv7W/0WX4IMoFlnt52+g+/G1jt7l6mkb0m7S2uQyC8tw4tOvBOjCo5RVimtoKeOkzKKxTHfRVtup2rLYzfgeJSrRR68n4OnLfBhZG4FzXQy7swh49RmHbcgRsmE7dS+K5NhO96DeQa+daJt5KG9S4jyRWTSGxwptX8DIpzX10GOqeA4S+brfOQ43V9PbEt2b+TQNBktOU7IOYiR3O+d/ZJc2p2WO3E/eLo0jlkalpBBbkJFlMuaJ1fBqV3UOgi9HgiVlh3xlbyKTsWjp9y+zZN2dexmzNywPIuG3ii+f30upXUpwWrk0ihp2hG3USqqWqFInxIosTTjoc2yJdPeEs7ldmDFQps1sQpmjYJ5BWNS70k05Wbav6jyVfw6iZe7uXEv8kbBe0iDszKCsq6hR/2epNyszUqL51WDF5uy5qtchkQ1YVMEk0IKrUgQ2lN2/cysnCtbJrvaAylPTXZQFlkFq6ApQomv+rcPjYXVJID2SmLptYI5tWvUZ7OiThzo2JAeTVBEQZzUZSXxMlRt3ujtKl2ViXAj6FgaiRYl4H4tHZxDr+eytQpSdGmn3F1C+HW9rQTNsSDXJYfQPUla7S8d653WduzSuFw6fd+5XDfeXpPnzdi8cc47t/uNL98HX9xeuL0c3G6vxBAhohI0ZKZLF/pbllBuDbcd5YkZ5oNmnSyPvYlywHKIICM0teyZPMg2CbuIONUb3Tt77+y94fvGkzf2vWPtAL4+udBvqUj96T/9p/9//vn1euXnf/7n+fmf//m/4d/53ve+x5/5M3/mt/Jjv4aXHpD21OlXdQ8X7+xbuQGn0dCiVR5ep9JjTSFlEBLieVNnGkNFLI0+O83ORwYLKOp5UZBxry54hdkJqvjB/eSnLMnujJnEDOb95IhgunGxyWU3LkMJwjpIGz5qNxOv2CEH8Ov1wu39UZTiCaMxerCTdJcOw+rrzILNJaQMP9WJhWLjRwT3+53Ik/3pSmvOHHdNaltnnDpMx+tg9Bv7R1e5b/ePed5vHOc7vrxP9vKZO1uWMBfsYSu1uno99FrUVMYO0KxYXo8Y+Ukrxp+Z7HjytjrpIgIEYE37HkqfRWq6S1kSmYuYsYgook9niSS/kgNFpb66VUFZC/7Ez6/oq5bDhDUJvssPzSsywzwFwRaV3etwDqTZcgoSrik5ALdGK5p2VhEzBG1Wd4R7Lf9JFiRtOcpuaDEfo6C3aqrMofYvYqN2pgetqN4R2oG5Gz4FGZlLOJ1reEQ8TdyYxYIV0+/DpDVZh/aaitYcuvZGguf02aDP0FbRpsTEyyFjeVNWI2g6uCNWhIlIJ80kck1OpjmbdV1H96LJTwV3xlK0NcKTbdu4NpkzH/NVOx4PBRi6F+V7FrS5SS4Q54dpu+DZZhCXTUYNvbNtne1y4XqFy2Xj+bLzvG24wTFuvL4evNxeefcyeHk9uB8nca7ksJMsgtAq/UvPjInG3k0wXrddfyODkacsvGYwp1h+quuHoHEXYaghG63WYeuNy+Zs+1vowe6O9ye27YJx/W09ff/nXj/x7gM0S220sXMx4+pO9otuyFYR1r4eCB2Mi823LIQiOzGHlhmzwRjEtjPayRzqhs1dVil2095FzWGtf2fRljtzDt4fd65utH5hvN5oHgxXARsRXB3eNOOdFl1FU3ealRv2UOGMmWxu9N45jzsrssOiF0roYtg3wU8tKfhpkiPxpmwby41Lwn7ZeP8iWm0zsQRlPqvdR45g9uSeg0sqbkM9e6f7TmdiHlw34zhhKRujIDjRi/U1K7JB2pquzrioxyv4ItyxnMiVWwy6WYy+9fy6JZaiaDccctb0IZ6ip5WQecWAKA5FkdxS6FsVzg80df1jOi4XCVpQY04VQJoIE3z4jMj5YNDNsvZxEOOvWeUy1XRQmUJ6TVa+rQ6sZfpj6xauHVqnoaLoGYLMTPRoClbUX16TrOI9lqvGgtdaPLZghMEWo0TeqHj4slUqsktNltpj1a62invOTb8zVVDVKqHsJfsgDo51Nes9rk+wCDqzrqdhamasnOvtLJhT2jSvqWtN4xOXFtES92UUW5PmOuxN05qhJu1563y0dWaevB8bcyab2FOEhmLZVmUSnOWxWDlRNuihqHizZMuNbTP23nm6XrCnnUvvvLk6lw6Zg+NIXl5fef964/3rycv94DjuQApSDAMa0eTKQV1FEU5cER4CFxQR0tQgTVzNRn2e+J3IgxGTGMgubU1Y1uldLOa+i71rBptdaXvnqaeCO79GqA9+UqS+8nK8b9h2wXvj6RJs+4Vtf8Nl+4zXtuF9YMdAhORTx0M2dbYxGXlysrMXBTbnwFunN2OGHIR3jLvLNdwrvj1QJHSJZphj5xjgbLhfaCYWT7iRHrzEHYUzNhXSlBp+786wC7dXRQKAcSS8MWPrG7eWxJRx5QxNFp5Baxc+3ZOXaYzjFYaVwfaGmVzQqQPJ+5X9aTLvB3EOaEooPdK1U5jGgbEdxaLryph67vDdfuX/cb+T1njejfcZzHFUIbIF7H9ldyS/vLTQwZ+J+6LFy+HbZqM9pi7ISS3Gy67Jq2P3B0FXO4O6PmuPZwkrdr3oGzoia7KbpmwtDyR0rPPTTMWTbI+iKFfwVpPMWTsK7VPyK/XKiy0mWHDJEdbPVVhfPCQP7UG2+GAnlJzZyrlauUDkMkuQ24ToL10g3pIn+bo+Iomsg9qrIs11DTLItmN5MtywuaEDXfefZTEOY+2EdI8U/weysoeWTqtg2UUYgl1FZumbKFo5VYjSpI7y7fE55bqAaPelhX+RkUJMP6XRjg9NpAXNenlxStukQErhuI1kzIvIT8iseSYcKaIRhjRUBU2CmlebYssRKpZpqZ1Y9gdT0ruzdTlH7JcLvm9ctwtP/YJlcDtlEHy8Bi/vb7w/Dm6vd47jrCYIPRult/NUthOZmB36nMxqUu+kdbx3vG+SnzSEnEwj5sm8G1mx9Y94j6RYgg52ET0fQX62J/1J2i3bd9g+wmrm/LpeXx/Z/X/VL3WWrU/2nrK9bxfaDt4D9qYlolEhhDqcCqOQ6K8o0jOSOY0ZYkwlXTRyGo6MJN1lzSPvNMW2Gyegzox4ZY6Dl1vStyvZN2Y0NoctkzMa7+S1wmWfbF2HdlRSrtkgYiimIaQw7xs034sJpndjo9Ey2T34+He+YXt+y8P23TrjvEPehVf7Ca7rs+9PpG2McTDOyYlhW1TUh7QU+75x2QQpWWt8cb/wuWuRO0IHf2+69g+xLPOxf1psiKWab6joZdHWLVPdLBKsRmmg4rGr4qFzoiaf/Er+k3sdcra+Q20ysphrBArMEnSniUjGv1kzQ/rGIMnstFwu1qOYk5PMo3Y2mlYWDDg3/bwVkSATVU0HkA84a5ZLRBbqyZpVSn9l1bVb2e2M1OGxWITJqvtLP1ZEhuAhds2i0tf6iynQh6Wt8tCRZJthPjE7apKyB3lF/IiNJUEGuW+rmesFXZaZMLOiNFRuxRQLvhrxsbBwW/DTI5YmWS73FDtNsJpgbVGtU9Cwr33vDSNqn2RyKl+XIvV5ZCqBViurTqMzI3gdwW0YEdolzqxsLibnhCMdy4uakKXpQ42jtVTUzdbYdiEQ131j7xu7geeNOA/mkdzenbx79yVf3u683u6c5/mBFITuVWmxvP5d5wfVTKlDaDQXkqBL2GkpE9oImRhHwBFeTikBtqNir7vDLaXf6kFrzoXO1Y29MqQuFnQ7P5yZX9PrJ0WqXlaLR+sb++XCvgV7b1zc2F2ZLcoE040hj66FqwfEJKZ0HZlSq8sNW7kum1F5MIrt6E3uDSuZtPp1WsLMYNyDX7t9Se8Tp3MycU/eXrR7IGRn8knpFyyNnDLMFPy0mFOTOQfbpT3gKvKUNUpMOWY05wff/5L7yw/A5dNnTQ/dKNZAt3oAe0jfse8036QZm8rX6d7Z2kbfpHu5vT845yDm4B4T4s5Pf3LVoZWDayw3hGLJmQpkkqU5E7SWs+jcueIvivUVPISzGWWlY00eZaF8p1yWPWtCK8Q2M+UakgUpRi3mTZNIPL5OUFb9FEFsuZFU2FxNIlGsQ0XLqYExaw/bmelW+ifDTgouXDCMPv1c7g+m76tud01bJ1a/t2RNXju8LMip6BtFvWfBZqmp2KIjL0AV7pyNiC7CwhKYQ/1+s4LxTE7m2eDoBWXqyLA5i8SxsXaDWUWa+oyUyXU8iARuromgokR6YY6WBqOYejOxmQ/oMTJk2bOmZUprtcgci+FGQaBz6vsl5Qax07edbd/oXQ2Bt3of6PMNUqa8zfBmdCgLo5MYB5GDZND9rJ8p8kjGQaRy5DK6Ymvapue7b+yXJ67XC09Pb7ler2x9Y9+cTnCcxv0+BPG9/5L3t1futzvzrmQCXb9dsGRuGF3FKQ2z88HmxDrpjvVDxCkfNT8eWMq9/ESZdFRzMmdp04rsIXO+YmD6pPeGdadtHbad1i98tDl9vxSL8OvF+34C933l5QZ732jeuOwbl36lXXb63mhtV9fdHQayBcqQAahpb3FGsM1S2qeCCC0HW1zIZuwtuWwwz8Zmwd0grFh0hXhlKb8jgs9eX5l8TPQreb4yLPi4O2+98VrY/rUHH+3wesAYomxbU5JrDwlBz3vyvDutddkolZWNo9jrPZxkh3kvN4ygt84bSxWy1E1tUyyl2znwLt3WeTqWgvn6vmMkc8Lr68E84ekT59KvZG98fgta3PQQzInvkz1hzHKSj1asL10MlY2C8VBHNb+yeBfOp55fS2Itt91ky2OARiDjQTNfJzF6QGW0WnurtQta+yZD+zGTiFjwiOC5GcUm5IFQAmoCLAL3eBALhOFrFLNYkFAW5AekfZhA4LHLERUbFd+mA9kyH673uOHTFKGALLJKIqxfsooYj/RYqnAgd/U63r0MYHUttGt9BBKGaO5Qw8s6n7JrEe8V7bFsoKwYnyF+pBfcNnP5K67fteOcRVgpuklSZEcV1kdohxU89fjZgmlPk3CVtCrmJqNXq2aiCea+bBfaJsNUpf2q0K18Lgm7O60lm9U2y5zME8XddP0OVKzkI7BUk6G3DdC+Jjfjap22b/RNk9O2b7Qu5qBbcj+DcQ7GuHPcgtf7nXNO5imyledqiKZ24SmdXXerGBbJC1SgB+6NxhVrG94vxUyG5kab8v1MJmNOYIisNCfpgzmdRlfuVHeaNbwb22Zse2PbrmzdaNsmxqJ9vVAf/KRI/fDLnHYRA6fvO/vTxtNlk3B177TW6U0w3XAnmSznzBkTuAgSiiBilN1NMr109VtjP66K22jQ2mSe8TiUylNBi+9IXu6D+5w8N8FYLZ0nd97sk7irYxw4PUu53xxmp1sy4pX7NHaH44SP0nl+2jiOA2aHoLJy1FX2zfFjMEYFOqZjfcfGXW4WiFJ9nAXPTdnbWhs4HdsN90FOwY454czB/voCH+3QgunJm934tHXefX7yNhvTnS9timWFrGL0iKpQ+IPHpMmmUap+DLmfKzejypbo40JRHxo1K2hU3wVBS1852PTPB2ueNJcpLVGFy2nF9IuaLozjUQMWSy1TWiHzeDiAQyqEMBLR5A3ZLpWQ1VyFoIqziCCJdEPlDpDSFtGLXk7lmBXFeU1YsscqJMtMprzJBzgqaxbMJSEvDNNWSIjRs3YviICgv/chCTeRfiqtWImJvp+VRipSOzsqQ8sW11DfQuokse0sdW00RetnZT0zi+loFf+RZmJxpqjso+QE0EW3tlWETRCoiU2375sYrHgxEpf/pkhG9Kb3ZIuqD2LgZj0gTfvgxXICETwySJs1gQa2Gdk3tuayOdquXHajdaEQrQnmnsdknge34+R1nIwxOebJORxmki3w3kt4XverN2grF1oNkz7vDxIA6S6l2+qVZwUiG0+MIxQhdA5jTE1rmeVOkYiK3xLzne4bl83Z98ZTd/0ezbHLela+3tdPitTjJUGht8bWL1z9id47rWmq6h2sQ9qGmw40Zd7wWFbPmYxxELsx4spBK3X6yZZwMyPb0AdeDsN4wKxDM01Mniarm3EMfvn95FvWaL7hxx1rxt4dDuM24fWEW6jj8loQZA7oxjEG120jYuPMk8u+0/29XCniZMTGPlMwJaJaJ8lmic+Eppvd5lkPhvwM/Qju46D3rrfvjm+NecyyroF7TPKcvLwMLs83rD+R7Ykv3r0whhbZY0Vr22pfSySacnnXkRC1u2gygc3FJFsL85VFpKKSmAqUaeJa+ic5KGg302pXZfUzbZHSEz4IQ6lCvqCktTSXyNhtPhbbXnsd4fsIvoz5YOd5BVtOk9Ho0v4oYTiAXv/fsZDtzTSFZBJZlObExyq0a8IQwWF5+jUms6jogoKqIBmYDzJ66cVOHrOpSTcnaE/RDpOaHkFTX5xV2ARriYwCyyhWPBRpxbKy5xdjteW6LvHYN67P1YqfnuSDCPLhcy84ruj7Do/FWfhDHiz2YqqQelHm00Umaa2ViL6aiBUOWM+vWcetq8WxdT2053JXACFIi2iBqOrpeCbDvFwnHG+N3pJujUuXk8TWG96KIOJBjGBOY5wnxzG43Q+OMbifgzkq0attaHtdOkIzZvYSXCfTVeqXxC7XLrM+62awPbSApd/Lk4zJMQRfzjyrHTwhxuMzsfJK3Hqn953WPqK5s3vD+8b2vPG0PfFYGH6Nr58Uqa+8DGen0baNvsPuTm+N5k/0/o7ehPs3JH7zqaF/pgrEWFh6JDEPIst4M5+LJjpp1rjY5EaN1q0z5wFZLuimjjtzcpzJr7wc5PXCJZxP6sB704JfT+M2BrfpRPRyMEjtwMyq+5vcjzvX3Ri3J7brG1p74jwhzy+JdhD5hKXYTt03zihqvGk30PekXy7E2TjmgbGx7Sk7pGOQs/Hm2Xk9hvyN3MEnW69AtllRE632NW3n6s7t9Ua0zh4HF0+O0KGGOWlOuFcktss4N7R3Wm4KH3A2fXIRH+jZmLQ2I4s4kUZvJUzFJEzWMqQg1jJLNWOxGNOkW5vFOvQ00saHSW9NYlauAuv8A0VFxAeKe85WJI86ZDNqGqy03cpCclvFpT2MbtOWwNkeBbTmSRWqOrhFsJDTBjW7WMJY1RY0XtY8w7o06HsbshbS1sUel3eL4I5+7tLxRX0EXi7+jBPvlYSbgCc2krqhH5MQdQ2x2m+BCn01H0u0+0BdWTT7WiSu36ygV5FoZjUGOpgX9Nr6TmtiBYo2PzSF1uGdXmnWNsv3UuiFrt5W1x+SU+qKKosqyNrheXOcxtYbvSslYNslojdXfL2brKPOoXSDcQ7u9xvjPDlPmCH2Z1ixDgs2jUV/MB4+gGENm0bmiag9punJ8+Gk4U0ISPNG8yBHkrFj85WZwZkp6BUrSHNp6eRJ2hx6a1w6bH5hax9xZadZI/PCah6+ztdPiBM/9Eq8b+y7k5cNu248XS70rZyA2xUTTU7sPltK/YToOqgURiO/rjkYRfluZmzNaLbjfee67+ybC+L1Vh2xqKC2uvsMbrdXNrtwzsYLxnC4VsDtnJ0R8lJ72oxLNzFybdPkZZ0ZKdrFMYDB9anj/gJMPKImjer6u+I70oKwLl0W+l7Z0O++Nfatc708QWv0bad//ESarJKY1aWubjAm5+t70ibDBv6889EbMf/GcQBGb7OGqV0ZXUVvXvGDOlPzAccIAlNG09L9LE90Jfco5dgDMOXrnLUD0uMfSNwrGHVRxEXnVbeqOI58QI9ZUv9Iaa1EH9f+Ue9g4rZkCYv8ocbBasJSMKLXtLtE3LX7MsFsUQXB4oBR1k4+anmvZNeoIypXIGKKwGO136o7uWjgcufI+FB4PhBJsnYeawJcUR7S11lMzgTtj5Y7R5n91t6HDLJpR2O1JyG8/lx5XFFEEIzq7nXFRHSxqu5V7IviTc2Glp2gSTKxZkh7bKBUTjOkczOhIeaVqYTVdW2Q+rwxo2/Qu+PeqkDpOmYDWsO6koA9GiuSwqpoWe0Ce2t47+xXGS9ft8621c/1TezJmYw5OM/guN05Xw+O28lxTs5D+16m4TORP+Ud8tRvZfonl/2RGUS5Wyz9XIq8Q0GM1tT0qiMKptbn0i5GEiOZp8MQMWnq4ZGTe7E1zbU33/vOtj+z7U6/GJet0ftKJvh6Xz+ZpL76MqeTXLfgDRee9o1+aVz3jbbLEbg1deVnCmppCLsOG2TCORtjOmNORnb6lF2Om7N5Z9sm50ixiLosW1p55CsjCB3GTevR9/eDdwT75Q15v5N2sHnjuoEd5yPKfWsbI5Pj1BSSxQacYbwEXJg858m+yb1ZKfUp7DsarQWbNUYbShK1s7D7BGtc3z5h07gfL5zZyDPpNhnnyW/+9Rcmy4BTYlYdHJqm7i83rs/PNN/pT2949/mX2A5+Jsec7Na5W1QBEB3Zq+ibr8woWIpTr4LOw5LHHvu8BcGlLcJDY1G3PWVfo7VOsAjF2NAkmoJwkkVHzkoGLpFxFRkJQ6urt0X7r2Lnxp7BYSmDUqzo4CUTSPnztRSLLmoydOwh7vbUZBH1vbu53Nsfx3LBfGunVIf+oqxr/2RFEf8K/Le2QuYVCbIu6WBZRgm9rt85hBjUsFoFCLDGyBCMFjwmDNVaOXwkhVJZCY69SBPhgnjDoM2a2VqRAPSZRBFdGh8E9JmrFdnJPASVFkyZuCj5jhigVLPXek3mBfGWvqpXZhr106PUqc1UgKwlLRZb0zl9Kkeq3EdaMfi2YsB5f9IU5BILWySjTSEB84QJtyM5z0O085jkrNE+R13XrQyWe93fcnBP1/OpZI5DBryFTFLWUu47TtKZNEuupgl4CzjTiFRg6jknjmQRGV6NmCZVa07fGvt+wa8X/LJzvTj9DVyvT1wuO27X9ZR9ra+fTFL/g1cC7hf65cK1X+mXjbZfuFwuXJqo5Nkaubmmi3WASvRSdGCknRpU8m4CDfdO3zZ1YU2Jo6K2q/MJ5FRQMDZ5TO73g/vxBX59y9E655nch2KpW2tsbjx146MOl4acij1LXV/5NRFsGcxh9C4NU9il8mWSMRq+X8jtCe+99EtiGc6Eszrj+7gzhqj47SoFfWL0vbzBIrnXgvYB26RxD+N+u5E9uc/gbhuXp7f81De+gRX9/HmXvirrek4CajpTONsqHA+PA02gWbh/1lRTHbyl9i4KEOQDwcEWLJgP4ag/WFv1T3rtXZZgpxKXvwLHK7G3dkQWJfoUhnYBunUW312Bk2Jt+aLRm5eZLlVIi75d72sSJVYtu6i6OxMlu86i23smfe1iUlCtp9yvSbDQ5KIJrYuWHQs+07XCFnwZqsOgouJF785FsIhioCsKghTZw1chMgV0BlQ3r/cnikUW7T+LYajPdEHLYk4uw18V4TJXerAKRVpZ9ligN6OpbtaE6ltn26+0fpEhcy9o0qQT7G0HFGzauuFd6dvdN/Ads04fiotJV+Bhq3utt07bdSZsl8blchUi0mHrgv/kHAOcd/IYHLfB/Xbnfr5yH5NzJvMMZoxFFZLoPfUZWCX9ttbq87bFcNLplLruGdKDdZPtcPMQuct3egNrzkyXnmtO8tTDPFJTlCHbq96c5p3WKWd2MQS3rdEuzpt95+oXett4dCtf8+snRep/8HLb2bdntqvjF+dpu/B0aVy2jm8X2rXTmujcbuqoJZVqkCkX9JhEDI45mENmrZYTt0lvE7bEuzpk961sWjYxjOZqjcWGGzP4wW0S1422XznDOHPSLegGW9+5NONtR2a4sorAwsu2RUvbmHA/BYv0pzc0H+roisZ63m90Lyzdy/3CTpKDGa/c37+XrZJPRshayS9gPrg8wbarx+ppdNOu5bxJ5EwGx3Ew5ik4cm94e+bTj3+Gy/aWRAX1uUtGyhBGLgfnncheRamW3xSDjuWJpwBHczlAJ7s67Bww9EDLGkkPmNzp2oMRJv64RJ4+ZS7qGR92M1lfm4ln6eOC+n6C6Vaabkvj3dpLpqI3Ai34Z8E2C7YST02wLqEpI4HuSTP7oA0qszVNePKZK8yTQdkR1fRBVFKtLcq8GGGWyo/KkEA2QJOmCcpStpd2U1lT58PIlSJNlEDX6n3r67JgKSNmqckedPziCBasuiJZPkBG2k1ZxcBTO0N7FNCamFEz2CQQq+lX0KxVkeprR1RNX29NAl0odl3SLOTe4hP3jd43eu/srdO60d3ZKu15os+kFf16843L7lwvXfKUy06/GlvbFViYg5yDMybHvHE/nNf74HbeuR9BHCeMIblFPpZuZKoJmUtUjWJjlPfWtALqq6koaykzohii2Te677hfaaZprnmwhLqZCtKMnIRNzV4FR1s5p6tpMLxd2dqF697YL85+6Vx35/pstLbxvxTw9hO474deOsS8NbbmPF12et+4tCv7dmW/SBTobaPnYNCYxZRKh7RJxM4YyTGDbeoYsgg4JnZRSujVd+42xArqk+HO5GTmkKVPBJEbzGTO4MsvX7FvfMZ+vXB738gxuOzJdiZUbDgJzQNrG5Z3sYZrt3WPQZ+D53kHe8Pl6vTWGefBHBMfJ3Em1hveEhtrN5G0gGxBdBekOIY6m+sFj4H1G0unYg2sBRFW05SW0XM653nw+uV7Lt/ZiPvg5YTz5fu86ZNzKJDNt45P5XPFw27mqF1UseDQFKUJJD+0yaUfklHFBOui1rq69VxTQJ2ik/nYMWj69Yc+ZWIfXBFq+hLlVzTz+YD3UgSJh4tqkcNN7uS6m3oVVsGnhIslZqIZr4lK5IKmP0cauyyKdaRRSl39/qYCQEWfP/ZRImmysqAWhUJfPPFYhQK0rWjMYqvJ9URNjRxuZSZLEcZnLvspSB/1g0Akn1UMKt9phQUWQEloQl57rSwYNHOxy/TBeOp3EHuvdn6EYNrH9BsoTH5d9/wwTdfd0UxQmeB4Pc+0SpWls3UrOy/lZI0pc1ihq8Fw7R83q+ax62u2EuHLEd3oWrrKIM0GTDhnSgMVQYzBPKVPUtJxJxkF4xakmyrKVvvshEfigIx6ZSSc1cCsYFMN6dVEtRNzTUWbO826NI05GHHjGCUtySEj6SnijhKLHRy8O2xJ3zd8a1y2jWfb6H1n8+2Rn/W/xOsnRep/4tUteHp6ovVn2tN79qcLl+vGfmmY7ex+crZTLuCzrHhiqRhkQDmnojvOMZn9ZGzOJTa2vjH2g8voHLtznJ1zO2mzyax1ekVolDjwDF7PyefvB9/9xifwdKXFgWN80ZKBkW2SPWiH00y6pdG0MHcbzEzmHMTYOE6ENV/eYMckGYoXCKNbY3tzlaiwN8axCaKio8jPgvc2QR1EchyvzJFF2khmDu6HisfDv8whwznen5zvJ50NrjBs8o0N7uPg3V2H0JPDl94gVLBnFWAz0ZCzoMDVcUemGE/l5qBVxRTryaorj0VuWCf0OtSKem4VMOhNqa0ZNF9GsY4/wTxRUWD5/S1NjYSvmWuqzppODAs5aiuN1irbSruANaVhLkLFEjETVYuW+qkiLWK99+UruPQxdZinnAkEcU6WnoYsiMwa3RcsqCV8SZ+YbmIWruDCWeJhVIeUTrQsfb2cC1RM6s0BjZVoBOALy7Raj628qWw8PJgeRJUPuzZFeYg8tCybwnvt6GZpwaqwsnZWRnqjtSYo3bruWXfBVs3xLhh88yY5A/L3yzL9TUuhlWlYbnhXQdq3XenVPWlNkhSzzhJ5T4aQ/iOJIRHzOSbzPBkzsRjFopTAf2WZRWpP1tY968XoM+kwI4oIYir+2RozRoUVeq0I5OJhfpHtE7oOjtYIWjc0zoSZTdl3MfR8LMKPG913NhP5Y+9w7Y1t29iuV9r+Edt1F8LyvxDw9hO473/y5fjWeb46b66d/eJcemPfd8V39Cya6dQ05GKjZXQFMk9ppo55cE5525GKa7YQQWHvRaRw0/lvpcnJUw/NPJgBMe+M+8GvvH/PLSbb/sxzdz65yiLJM+jT6dbYUWfXUrCT7viiIs/glsFxv+FmPF83Npft0RiDEYN5HBLy+a4HqKUOqxjkoQcvXW4L9/d3GINunWYpdtFlY7vs7Bcp+DMNt07Htb+aCXvw9KYTE47ovHtNnq+O16HYN+iXrajeZ51zuk3DZu1cPmheHlh+6sCyup5mUtdHCOYQXEZNEaLtZk1irdiEtfXATJ7jYaXtv4WYdrH0WLrOtiY0FPcxC6pppV+RDGtNctSHLLjN7dDPn4usYCyzYnXIrRwO6uuLsyBRt5wE1FkvmI6Kc0fTWU0fWTHwHoP2yPGaYFM+cLUrs4l2OkW4EMegkZj2X3XtklRDYAs6pa7boFWTZmaVTRRLiiWNWxXh5Vvp7iomVJw9ahC8/CzTBFtqbSX4U5PT+JD/Zb7oILSWdDe6rd2OCr/iWkoYHNqRBYMZMOPQdFc8Pm8bfTOue+d63elPG5fnTt8v9L2L2bvg+DGJMcnjTs7gzOA4B+d5lKPEwT2AGNgUKzMsNTGbCloRQHFrRaYpD3dL5BlZ8SMF1TqtPPmchhh93RtbS/rubFsnfCdSpKQ5DmKcghPPVpZIBsjkOi3I3rDN6b2xbzvP/1/2/izWtm07ywS/1qtRzDnXWnvvU177+mIIwBibwIQty5ggIxKHsJwZAVKKDEsm4YHEEqIQ8ICEhHgBGYFAacEDTvOAIAUEUipBFimMECjCpDEuIDNwCXbY2Lc65S5WMeccoxctH1ofcx+TEHDNte+9yjOkrXP2XtWcc43Ze2+t/f/3h4EhJqY0MCaHTzaT/VzMo+DDSurfcwWSH4numsGfGdKeFJ4TwsSYAiH01oVpkXAozQtVK6F1KbRasBh1IdeB1mL32mRTHuEIvXfuvAWJSS59UxGk9ptZgSIcz4Xj6UyMA7sYkLayH5XnuXFqjqyewTdGPNlVir40K1LFTmFlRUog58qQwCeo52InLG2kg0XCX90EyjNH0QFXG1ItsrpQqbKQ3GyYl+hxi0MkotpIodIk4mrFV0tWjV4QBzUXcs3cvfeC+fWAn2eUMyVPRCkMvvDQlOiUiUwNnlbqZRFsujWPek4U5m0SbJ7ixBmHUEz2jLau9vLQPNtgfiNwaxWb17SXxPONHGFRGpuqQi+nZrCY8K2ioWEKt47maWKtKPvSfjpHrL0i9LmVETO0UxqktySN/1Zffm+wx6sGOnKiKEbXL/CymutzNsSaYLoF7bHNvoBOdmjEy2yrAV6710i7TBtrk9nKuTHEbT7Xtpkc1qpsDov4cL0OUsjSDclbtcbmIezCkM3fRm+NS69mPtCqs6p5Qzv5blAvZvDu7TFc7bQOuw+idz1VwBZeQuds9u3f5PsR15ptpbK9fquVhOKJzhMEgo8mIoiBmDw+eHwIuOLJYoaT6gItZ3Jt1pqvhZYzSymUbGy8hiX2uHXbTLv6Q+keOfu7EwuJlI5IsdvS+tbigwmwLgrT0kNCbdMIHqI3KX0I5tdyfZaZtVG0sLbVmJ6lUtvZcvBaRyYJiFjHIUbPMAyMoxKTZxxH0jwxTAPBez6XW8WHldT/z9UH0K4SRmWahGkMjLvAmCDGAZ/ShQINptwy/4bxvtZyJueVtVaWAq0WpGSoFpImrpFcI/qID+bBEpcQF2327S0q3E7PiUamrisfXzJHEY6MIMLjIDweApPzlGZvBFtXbabi1BiD3nlUHKWYi6idF6JzpGFEnSPjaLlRnheW+xMyPyaGRHKCdwHxkeQhqUKOeHVWffnFFi6vJO9oxRZw5wIuDIaK8UKtjaUotSrn28J7n34G9YyIoyRHLpCCRZo0ZzztGLTjmDpjDauW+sgfERsIO7UTp/YY9EJHDuFw6i8zegHzLJkrGNsUepXi1A4HnWRgoofuUdnSSz/4Vun+ns5qtfadbGDTSqsb5bwPxHXzcOmW1t5xP9KrpNqhAlvFaK2hl4+9G0u7udcyl2wZNzFFl3cLqGY2pJSoiWi0mdCjobYY6nbrKjS5QHjp86LNQ9WEXp2+lHKrBqQYU1B5WeIprkeBtK6NsNam636wXvddVIRWtbVeOfQ8I9xFCblFvL98venlaK84pZuzpYs5PPiuKMTZPb8dFptC09W8Qs4ODEZLj+AiEkx+HYeES47oA+ICwRmUNqg9L21QMpSykmumlkouxcgRq1KWZrOf1mwO1TZjePeEbZtwc0jp7etmyd2WRQWtVXKz2V4pxTQz1V3EO9IMH+2k4KVau9MLIskkLdpwrZiCs3dwS1uss9NjUnTzrklDglwq0Bg9YUiEMZLGRPSRFITgU28rf26uDzepf+cleEamYSCFPfMQ2aWB/WRxz8MwEsZI8KGriaxM951MrSqsQC6NpRVqXVj0bHOrqjYD8rETJyIuJKILSAjgEopFWlgktM1FWoUXxyOpwr2OeBIpCG/OgV00svRVCtyMJu/dnoc2t52RKaXR8kIp1u+ep53JTlullMxSKyIRODLvkwkpggFraxggemLAWGNNaSVYm09hHCM5N07HB5ZTpZRms+Rsb1oboHjmx4+gKufTkZCAFJBhx80bB67nPX5nKqVffr3j8ZN9HxRHmnprP+lWPVhEuYr0aseG8V7E3qAom6/KMDhdit6ctXe8t5hz2TBJIK0nlPbfqSnkjPu2wQBlI9fLtnnYYUU3f4tz3SALW0y9xaN3ToRzL7/+AyovukpRNiJCT/Y103jo8wTbFEzKEDZhN7UbP0V75L1Ck9zFJn04LibIUO2VX+ubdW+R2sZur5fFy4PrFV9tpc/2Xm6WdrK3is0Sc60CUhr9iN439kKT0tFE3YSs0DC5eq8v+t3af6+GXLDOg7OKSR3d/9c3R8yz6AK4VInRTKkpgg8R9cGo5s6Uo1Zp2aEtOcF749EFby2umCacH/ApIMnjg4L3tAqtVnIzpW4tmbIs1AKlVpa1cl4yp3wma+2CiUorBbduAKu+cdNDFzvZRJu9J1pXmko/OKhWqF1k0l8zUY9XZ0IZZ9RyQsT5geiDrUXBzMSmIC1oNcZnLmYPQYvNcLf7BZPehxiRMOFdYHSBcRhJc2ToSkbzlH3urg/bff+Oy7rnnpA84+wY7hLTFHBTYEgDU/CcQqS4AXWVkziqa0C2cbAIWoQiYn3gRdCgtFhIGD3dOWexzKUxipKDI1ZPqRmtW+pvA40Ym82TF+U2Nw4xWhaUy+xS5SYKz9dKdI7d7EjnyrHYMJ5gfftQTDV3zoomJdXMMCZiGGi5ezZKoe1mxtOJev2EF/dntNkp1aWRtpxoOVPKyjh485xcJeR+RYYRuVvQk/XnRaA5j5YM3l0YePfvP0O8p744WZuTkRZ3uOXI5FfOLwrH1nhYC2EecWGmLCeiM6VZ63JZZBvsa4+A6DOPftpWbX2wvqnXeiWA9EF+j7bAKg3pFZiFnmqfZcilZXdpHmnr7aI+lwLQZoo/bKPQvvR6bNawSc6lKaELFVDfU4u176cv0UE4M40WrTiFKgER35WEm6eodPOno9XNgtsuFccmE7eq0+5q7e1JMz3XPgPyff4EhhUStkxH7WcLoAsVes6U1P4zjFrf62c7BjiljYIcm1VtvKRtbD7jbZFu/TXZfoip6F33r3XKeMM2POk+QmetSJOZCy54onMvqx7vzR7iMRUeYgcx1xWEPiJecN5axF6Ctfacvc4u2KLovFUalg2n1JrJClqtWpJWKTVTlmJCiSY0tVga1LPFzW8rCr3xos0Yg83ZwcfOb11hh8linFizdjPuihoBZtvMDewcL+30GCC6/ny7VH/NjWMT1u51LFh8jbQNmaVIDATnSS4wp8g4RNIY2A0eHz1h8MSQ+KUOOfy3rw8rqX/fJRCdso+BYd7hp2uGcSbG0WSa3oGHFgTx5lLHCd4JrTpqMePc2jKlVs5FuC+wqCnwEmqyTrHToA+BJvbmE5EO9wHVYnEgrbGWxvvLQvAT9+xQBpxTXj8I+wRVHK+kPVfDRNyG3aMtHuKsJdByRdYj5+MKThh3Q2enBZa18vhLIr/+v/1KpsfC4XC4PJ40DMQwEbxxzYqCeGuRTCmQhsZucrhhoDmh+N4+8zYjUZSQRsR5WhWOZwNtzruAhMqdeuLsGPempnpYKno8M4RmgbPysk1kjDi7dWUTPUivALp/6WIG3aoFKTZ4d7Yo2Ia1CRysGmm94jEY6jYBM/HE1p7b2o2oDetFhaym8GsCjsJGdDcpeZ/ziNHBq/YeTF+Amjq2oEEn1uprm1LUbcGaNju6dFwEpBnHrV3mSjZsN3NrVzqC0UzY6BJ9JoJQCVaxdQVlo2CR99iMBEPkWICgo3qPOvuu5pHChOBqNIy63bHNwX3ppBKh4qnSTdfN99e+w2PZjM6uz20E0Yo3noQ1NJ29JlhfAd+8zVOCmdl9iPg4kLpJ3qorxYsniH1cQkBjwA+ROARiGkhxMkL64HExIDHYTEcduSm5FPLSKMXEEGv2lLOynBvLopzWxnmt5FIpTS0Oo2qfFzW8l47dSvZa2mKBqiPrdv/a4c2L3QeNhHZze8Nal+IDGjyOQiX2O9IjzhNcxPmEEwsldGr4p7Up59bQkmlUSjUBUWnG9LjY4V1fF/p8Oe4SYUhoTAw+MXqPCxOfK8HEdn1YSf17Lvu1zPghM4yRadgxDwfG+cg4zsThFp8G3JoRqTRMdFCanaoDycILq+esjagnUhW0RlbnKWJRAjEkfIS0ZEav1BpoPhu2f3ss4hBdqdVzPq8se7u59gpOA4MIr0yR29IYvPBkjjxfCm11lMVSSTNqLaAmHJLnoTpyrsRpIsQj67JQK/CzD/zy/81/zhruaa8mTvcrS76n5SMpBdY1MkR7s4gLSFVkUpa7FdLI3ltf3QmM0fOw1G5GFcRVxFlmTlsry92ZeH2GeeB8jJQVrm9O5FK5Xxq+wa+ePT9SAmu2qGxB7M0mptbaoh6MAaoXg66lRHSiQT+Lud7KctvckT73cRZ0h1p/3ygh5t0S6cGMFWiyeSqtbunKs3CZuETbcPSMI6PiabSL6VV7VeA6HaNJ7RihjQoBl4j4fhrfBB2uCx42Srw9SaA6kGptMedtZqG1vz4b9qkT7gVEQyc9fMAU2zbjsintpCpIvXh4tA/yL9EdarDT5tVUpF1jorLNnOzU33oMhIodGPyl2rMugRfrWjQ7e6DarMvQK1J3EZZE24y36sQLwQ+mbBNzR+C7yMEHvKOr+yJRImpZhB2iHDrXchPdrJgnzXcotKNpZu1VuSg2Y6yF3NQ6HWrk8pIbrQpVO88Qy2sL3YzsJViFqj2and5m6+hxkW1SSc9BE3vdcXi6IrV5e2xgd3mPtREcQeLFuByc0Wdw3VSt9pjX1aTwpdjByQFVKiEM9rXBEdLIMA3MYWQe94zzyJRm5mHAGb7is7m0fsbXh5XUv/eyhcz5SAhCSso4wDh4hgRjjEZ46Gmfm9HRFiSbF7TaT2KrshalZlPZgMnWozNwo6XZBnyY7VQ3GI3Abd4ZNbICFR7ymWf5iPqRB2ARa+HMydm8SFZe2yvXV7b50QfcjoCEREwjV4/2jBHWuxODE6Z5wHtobeGdZ/e897N/nzd+w5dxMyr7mxHFk3MGFwyqOQwGm9QjpWbW3KyqrIVJlGlMxHFieDKDWotBm7LqmaVkVFeUzN3pzPvv3xL2CT82zrZG8uYre7wTlgXO08hujATne/ujt990o0RUm+VowzW5yHwt4tx1lVuXLzerIVDzoZiooFo0hvqtwMFkgRtlHJsH9cNkucyQ6KKJ2hdVaFpAl76BRXoWC9sOpLKpAB34Bn2eZ+1cpV54ag0vF5yq2Rs+8NxFgs2DRDpbb5NX00UF9rON2tHDBvvCuBlvjQ/noeplJmfzLXtOW8tQifbZAq5teKROLGhyQX7RDcWb4VPc1vLtLVEnVKkWpNgrTfrrC0BzXf5On/O1i9pym6OJGhHFOYMeBy8d/eW7rJ8+kzGPlPP2+gxOifS5jcfuv1Zprvbss0rJRmRZ60JuxfxE1eJmal6pdaGuRxNErQtlNQZfo78mTUALsVfAnmTU9Q7aq6oUhaZWOSFG42Dz8mlFtdisTj1bCKYdXKyT0sj9kNXbl9Gi5IPriDUaWgtaVljP5GxdnIaitaI19FZxz1/zDh8CwSXGMDAMgTAkrtLIODnCOPSDS18PP0fXh5vU/8olCD4MzFNiNyTStCcNkTSlXoEEM8Npd3n7YCBZGo5KbYYQgkYrSpbK0qC0jNeCc9B87AmiQgiBqI5xTQxic7FqOmq6+NfEGOczLu3JfrYNSJUkjZsxEPBM3vHLRmFw1d68uI7acdS28ol37rhfC+eyIlrZTwdiGHDOcy4r/+L73uH6sScNE49fm3BhpDWh5CNRoC4L3ifa6qlaGIeJGCaSEx6WyLJWSm4s7y+IRprrYX+lWnRA7bOj3DieKsdnz/EaEQ3keYdLA48PAz5UPnX3gGNh/3hPTMFaTlIRKeDqBd9j1VHv54vg+wLnkK6C8i8l/fTARqG3mPh5hIm2EQ7EfENOX1ZfdmrHVG9b20ZssbH11SJXEPu5l1VY6N9jsxIrrvYZFEp0hkNqmKG0WmRvH54rG/XI/tgumXu+kZ3QX+6ePTQDw8CbWk9aN/bSLszIy9epWvtawev2iCvOV8NNddRWdfAyv8t1GTg2vFLbTJ2jz9q217mhUiz5VXrUzdai1c3Ma+1Y78z7Y4eDvkG5jj6i28yk4vvmY5uShy0DyQW8OJxYDpJHetu2V3DV0YoZwHMrlGWhVPM15nqmaOmRMIoWaC2z1oWlFE5rhlKZa4asSDVsUit6Ebyos5auCWOCjQF6cKJIxegpvZKUjvK6bK7OcuYuk1LQHo2C9CyunqYg0RO94ZyGQUx56wLFbQb3QK5C6V46rblX4QVxzQQjwRsoNySGUUhTIM6RMCaDFww3DOOOz6U/ars+3KT+V69+Uhk9MkXGFNhNA7thZvaJFO3NIaMz5auYugo1v8IGNa1dVlpyNb9Rs3lVdBClGfvLByQIIVhabRExMy+ty08tIym0xnktnFrl3CbqCksBX5XR2fdqmOJvjv4iNRYxia6Icjxl8nklaOP0kHHJk8aEOM+aMx9/632efd8P8GVf8eU83u+4ud4hKiyrGWS1GFIneNOZtfOC95Curpj2g5HWtVCcGaADdMWbrfCtQWtK0crplHnx1gvDFMXAkhPPbyF6YR+9Ofeb4teVOLgeYd2/33YaZ0uwla326DSERgELjuszIIfFizdRqsMkywCu42qkqwTVfCTV2ULqIj2zxxmdAtssVBR1FjWibgso7HnCus1wtg3EviZol85vYgWB2jfD4CoeeqvOMoYU7YI5O5lXtZlNz/LrG02fsTmrKkQbztnyrrKd6K2RhNuQSfa48ebtAr2oG+1rNukzfRPqLUk6lkqkR4CYQMFAtH47GthGT0CImFu49pmfgusqtcsCuJE2+gGgq8nNb200CBF6kKG3zcjb79JsuPWygbsebYI2cqeSuGrz3apKzZVWTUhQq2GLmvZol1YpFXJt5LWy5EouRpF4qI37pt143C0Fm1hF+mu0eePEQiS3jDdtFvMiXWbv+msLJtRzXT/iXbFqVMwiToXaLL3bZpsB70LHFXlLZohCjBUvXdHXih2Ga6EUJVfDKHlxoMH0qh68Dxa7EwfGNBDDyCGNDMNImvpc8rO1lP4nXB9uUv+BS2RlkgPXacc4JFPEpYgfHSlFowZ3RAmu9PecQivUJpTKpbLQDKUoFGyA2iw2YIiJcWsdBivjbegqtBapKogWgk2/WXPhvDxwdAMvmgMvLJ1VNogx6aYQeDwmYlTzzii22LqE1sKyHjnWynJ+QOrCbj8Qg2epjnfuFv7R932cr3j9Z4njgddem4jBGHRrLjSU03qC5Al+Zv/kwH7yaKmUdTHQZ4ispxOlHsk0kIQPiTSY5N55U72tObPkwnp8gKisurCOiVONzINj7x1OIrEpV37glTdewYWxL/uR1k/eF6uvQutVrLXYKkLhEkLfRRa+Yfif1qsRdeYp6ym6G93hUm0Mmw9JL68lWHWk1dm8qnVahJqAo/Yc+42KgdoJXGkGzW12u2wCmopuMP3eVrP5hFPbBLYv0N4KEt0qyGAtRGwOpBWgWUuzz7hU1t4+bL2StaqvycY07nJx3cbzXSKhLxfc1qdkveNnbSSxrqF6Q/JY7diZeZsVohkZXLfFW9XSoDtJAekHGHVmIu4KRwaTx18CJr3HBWe+Qm8dhu2QYVjdSmmVWhxrray1UaqyViXXlaqVUiqlCa1ZmKGoxzWxuWlTm8sWs1AsSyavhVpWtGZaU8OgVbGcrT6L6uchHMNFjk9Xf+qlC7KhuIzl2aShmFCjNvsdor5/HzFV7VZpit0/zTnbvF0XrkQIeJwKtSWaOiPH5BXRs834mpneS98v+6Jm9PNAJ7oPxBjZDwNTEIbo2EXXUUif+23qw03qP3AJA955wuSZB88YJ0KIpBgYomMMkJx172kWRW3jAcGxorqa+7tVSlstvrlajEeVPtQGxCuD8wyhE5w3dRzb3dV73xTWWrlfTwyx8VRGU4zZTBV1GTDa82uj4xA8znnD9fT2g/STe1sLtRUejidS8kzjSAyO7CNPn93zw9+b+Zo332Q3B64ezQiYaEEr5IyPAW2NXArpkeutroHBC6N3aKvUpUIphm/ytvAF74jJMaTA4BvnnHnx7guW+wc7YeYKYY8bB9547ZpXv2iGMfCRq8A1Zya3Yi0iQGyeY3MqG/hL374cjaDRWG3NFmWDderLWQCtt8X66VpeCh16JCvg0QcMqMtGhdiWa9i2NEV7VPwml0+XikQun9m9XWL3iac/ntoQLZfF0hSR29d1sn5vDXpRe7z9LE+zWJXuWsVmPuYHExrS1KrJ/hhAL3MerRWaRaarM6VeoZMjWqduYy0rZAs3dJaErN0U3PE+JmI09BfaUT66bUJcTubqHN6ZNcD1iA3TGGakR5G01tDFpNJOzMtmkewRHzZCRCQq9FKUmpXcGqWuHXIMrRVKXa3CWBtNs20QEizEU/pjKo1cVnI+WYLucqK1RumsO9UGbbVZVbMAUdlakvQ4Emd5TuasW+xfW4OW+yFpC8ns2F+nqIsGwN1afFvRC4jmLoRJQHspdAiKD/Z6WHK4J0gh6EJthVULa3YsGXI5I7UYSKCrDr0z/mBKnpgi85CYhsQwOtJuZI4jQ9gB8fNhj/pwk/oPX5amG5MnjYE5DYzDyDgcCGkkDt6Gud0LVJ2p/US144js5JRbZq2ZNa+sdaW2Far1mp0XfLDSPUgiircoCadd0uwuswnXHLXC7ZIRXZmmHWtLiHMUbUQ1ZVCWytXgeG327ELnzLWGUixzhkDNlZwL5+MDrSj7/UiMA02F5w8P/JN/8c+59T/N+Xnh6tENMSRz36tQqiXuxiGynJWH9yBNE/P1wHiYkWQw3oJlGDVqPwVmpD3YwuQ9bpwRHOdl4eHZc5SMnwJu8Cxtx3z1iFfSDZTGu8/vub8/WoRA6GKCLjkHLhLrrVVWW6Nqtsqmz4M6jY8qBZMc2KBa1NGcVTLaAtqkh+G1vhEarQPtgoVeMW1iDnWN0InrmxLLS+mtoC30sBt7wYQAVKpu7aKCum0zsDmXLVD5UgUaqNZ/4ETcJ1CCKQVpiGSrMNigSH2WZi/QRVEm2qz5JyZnbk7NcNraRU5+oTNov5/7/EnVXj87FdnPpfUDlQ1BOtXAenabprKp73goenuy17/SBSPbdi+bGbrP+oIz304IvQJQa/WFBDFYe1RcF4dYK9W1hqdcTNTqjHjuxVtCtjf4shkbMlUba62UNZPLiVwbtdYeb2Lm5lZ7RSwdE6QfnABaW89uyEKVnrzbDE/UxPV5lT1v1ICtIrYJmokZa0uLtVtVwiVdweZawZK9XSKlwBAiPpoxWVrjtDqWVShZWctKLiut9MDETWiDR5LD+UCIiWEcGfeRaYqkNBGnPWmazaQvn/t5FHy4Sf1HXPYmH8KOlA7EYSSNk8nS02B5UMEiozdzZRXzPBWx4eW5KDk3cnVkDONfSrYTrApBPcFZFTMO0QjEKVkMdR8ed3ToZdGrufH+uTENE2eSzXgaDAJjVFZVYhQe7Ty7IRD7HMeqNo8PluDbqKxNeTjdMYwD45iQnDku8Mm3jvyL7zmaxtAVrl99FQ0RiQmHY1kL57YQYjIIaVNQS/fcTTOHOTBPwYjissV6A9EqTh8cJSs+enwMLFm5fe9ILRk3VJgS77w4c7w78uSQaNFzlxuuVaarRAiuL7B9OqWuz+6cURi8Q52jdH2DnUZtYiQtvLz51QQY28EAt/aqoc+5LmSELvPWPnsSa7/YorJNyLRXSX0nado9RRiZYnvfS/fGOIvq0P77bdsmtiX9bYN2HCK+pyb3vKeOBxLpajBRm//0NqXiu9DBGpebAGSrNUW2ushEINrpHkrsMy93EaWIPRRb5FBj4zk1ebmqzb+2mZ5zPeSx37DizRQtnXXXg0AdfdCEgq+XDdwRLtWTC46QPCkODMPMEAdSHIiTJ0Zvgp8UccmC+kIIhDhapIZsNIbBZjDJNjbxzliIKuRqc6elFkpZWJt8oB3atW2CzeqC63DdBrpaBS99U5SAajSBUXW0bPdY79V1RJLvOWW98pfN6uAQX3FabF54OVD2u067yRcl+EbsqjwJsXM/oXh3AQGvtZCL0upWNYNia5I437OxAtMQGcfAEAfibIKJqyGyn/znTasPPtyk/uMvEeaUcJOVyT56YgiEEA3D4pwRkvviBkCzrB3TozeWtrAuhbaUPtQsaG1UV0lOid7MvN7bCddhG13DhrU4DGTrbbF7kS2E8DYdWAl4zWSUQZTNgvdocOxjIPUWPniiNwFBa42SBddWloeVUlfmq5k4RMQ7juvKT/+bn+D90zPO77/gcHBM49RPrZ5ahXxabeGtDe8hjoO19VKydoorfSG11pkUjyOBOLQ2fGo49R1LE6itcHe+p2gD76gxclvgi7/4EV/6sUdEceTqcKuQ0g5E+4JtVWLt2TtyYXJ/gIOnRpCwt79NT0Rs4yxCr4psOdiSbemTBFP52cerOLSV3m5TtsiH1uxjTsCr+ZSiiJlu8Wjz+OYuxlrTtGxVoOuiAwD7XeumgKPPe8SUZAbbbV0w0NV7CBCs+lM7LIkYoml7Pk2Mem/SedDmoBtnhWBcvt7CrHwgJoU+dEFe+s6a9FlpT8ZVY+5hHWwLHBTp7bxuBJCuCuwqgUqnbPT5mqkz7cZtDpyPpDgypIk0DqQUGcaRNIykEIhRehChZ06B5C37KPhg7x/dLMBG44/SSLJlNimlGnevNO0iip5m0NWHTj3ORZsN6aXOQ2uDKrjW/ygWfyFKAYpa+9MCUG2OSbMY+VY3T5xVeQZ4dbRm2V61mQHdaesHz62G74IRp7ioBFfwXs3KIEIpSm2FXBZKLtRaqK2RmwkwVKvNXL1ZM4bkGNPAGCJhnJiHHbtpZppHXBpA4i/WSvoZXx9uUv9RlxDcQBhgmBxphDgGazuNAzENRIeheaRHa/c3u1OHSmOplVqEXCDXlVwbSxWUE2ALsnjFRxh8JIUZH2zxaa3TFkQIKkRxeFVcqzw9L0zTyFNmmkv4ao8jjpbUm7wwD45piCTncN5aMd41kpcuwXUstfLixQuGFJmvrlEVnh4Xnh+P3H36loe7hZqP3Lx2Y7k9KeCcLZrBZ0o9sZYTQqFoxrdsyqFhJA6jLR5DgJh6q6NRitCK0LRSRWkVMoXzizP3T+/RkG0zm/a8+6Ky5MAheYKDXAqzu+N6CpbK6uzNZ5lX2ucF1v03nZICHqLgknTDJ5dF1zlbhLaBv3QzrHM2N1F6ym6fsaOhz42s1RSoeGkEtVaQw9GkS8mdncpNn2DCli2KSbA2W38g3fskXaXWW3PdeGzxGrbwqljYPA1Ea5/3mIIOpz3WolErfQ5iVRAb5kmaVdZiX2lztEbt0SMO7Y+xizmMz2N/dxZtgXavz2V2ZpdVACYFl1Z66842U+e2Tct30om1QlWk+9zshQk+EVJkmAZ288xhNzNPM8MUmFIghIkQhm4ITrjaYzB0i+LI1vrUlUK3gTSlFiBbJ2ItjVa3yJT+HDqSSsR+Sarb1Mk2f6+1W0fcBw6m0Txj3YDfxCJ37DDRTdxshtzuUZKu2nTZfqeixpLExDHmyzO7AH2OZDSNgRgTIQ6EEImi+NagWaAh1ajstQpFWwfSmi0iOPA+WsJ4mkjDyDRP7ObE9bhj3u1J02iiFJTPl+sz3qQ++clP8jt/5+/kyZMnTNPEV37lV/JDP/RDl4+rKn/yT/5J3nzzTaZp4hu+4Rv4yZ/8yZ/3PZ4+fcq3fMu3cHV1xc3NDb/n9/we7u/v/9OfzS/aJTgiPs7s/MQQJsYY8UMiJE/0DRc83gW0DxvFbfHVvefcPK0srDlzKiYbL7VRikVpSMNUbCHiI7hULDZAfJffWo5QQIjOyOlOG3e14YfESRKnEikoVGUUQSlE53hlDlwlmJPDOTu54SLeJXCdRYZyf2ensMObB+KUEAIPR6jnMx/zyrQm9kNgmmc8ll3jWmO5KxBHgj8wjjv2N6+Q9nvSnLh67TFpvMZqNyVEh8raB9aFoA3no6GAdGV9WMirUJZCKw0mw/M8PwdePD3yysdueHK1N2Opj3z5F/8yXjkYfQB6S9NZt+zyVnPeKgxRI0pnEwa06i4zLFTxGBmB7Wtdn0VsYgARaNsg3yoZ6RQKA8F6cFCpVMViJhpon/GYkbZvmipdINEXJuwkrp3QXlFUmrUV+6DLqb+IPVyvnezvtglXAdGII1xmSBu/0Fa7LmRgG873soXO0aMhGnoKKzZH6Uu05TC5rYloHqT+k9FetSp9s3uJSiqCma/EWoNb1Sdd9SYE+3cP6h30aIxhiEwpsUsTu3nHvBsYp2T4I2ddA9dWSiuUupBrRZZOJs8rSyksRVlLtzvkjjdqjZwLa2dZmiCi4skGDBLFy2C+OjBTMf2wSaD01qdXoGOvTENuBxkytHOhZEsF0FzQlo3r13Kfb9JnlM7u+57lJU1xje5p82xHLKcWCx99IngI3tIJovN9vGAimlosbSBXh9aVxkoV6wIIHg3gvSNFs4aMk2c3OXZDIk6BeXCMKRLcwOea1/fB6zPapJ49e8bXf/3XE2Pk7//9v8+P/diP8Rf+wl/g0aNHl8/5c3/uz/EX/+Jf5Du+4zv4/u//fna7Hb/1t/5Wzufz5XO+5Vu+hR/90R/lH/7Df8jf+3t/j+/5nu/hW7/1Wz97z+oX6RqcJzorjYdhNCJ6CEgYkCAbBAHjGhsLTZ0tMKqNpURaC6xrpeSVVhdqbmgRCEKKAQlcOGLBGzTTBgACFNSBoxJdIDib7dzXhd1uzy3eQJet4ivUAktV9qJ4580w7AMERxjEhq4CLVfKUokN7u+OjHiurveEMFCrUk5n3m/w7u6KF8czj147INGhXnBuYD2tKDbcXtYjx+e3pCSkMMAKKS7dz1LxzuLlBUu/VVVqKWizRGGap+aF83nh/vmJevtAGkdkHsjphvv3QSQzzSO1ZH7mnZ9FfeVqnkhj6qoFwXntzDe9GD9h88J0nqH0l1Ws3SXbPIhN3GC9K8F+B1ZF9M3OOegcQ1Frp1Uq1QBUiKvWFVNTx2mfCdoB2QEWn7JVWdIZieCphG34iOgHCONi7UFHP8V3wzfb82DzZLU+J/N9kdNLkq3rhxvXTU/a+iYopmBTtjagt/uNHpkiRu/WviHZZrP9bAGx2crG5XMYLspfXt9+iakKW5+M2WGiU+qd0VfGYWAYJ6b9zO4wsB8TY5iI0QIlC0puyloa61o5Lpm7pVwM6utqERr2p1KicqqwLrDmlVJLDxRVqvYNwUXEe2STirvW523QMOaewfVdh8J2k3WrtLJgsbyFQqFoo5ZCaZmcG6V4cmnd7tDRVi50m4leqnzpcTumiuzBmzQzBaeABCUFx+CtInXOvk+pguZCbiu52PxLG2gJSOn3kHdIDLjkSNGxnz3TnAjDNdO8Z7ebmOaRMU04Pve8vg9enxG778/+2T/LRz/6Uf7qX/2rl3/70i/90sv/qyrf/u3fzp/4E3+C3/bbfhsAf/2v/3Vef/11/u7f/bt88zd/Mz/+4z/Od3/3d/ODP/iDfPVXfzUAf+kv/SW+6Zu+iT//5/88H/nIRz4bz+sX4RJzaO+EMAghJJIb8T7hQsBJwrczEX9J4t0kt/ZmNC7Zua64YsDKJVfEFXxYcdUWuySRHABXqFHJNdgpHvocR5Hq+5pg+a2nc+YwX1MfJkpdCVQ7xSOs1doTg28E1xidx7nA1a94wsM7R+rtM9an2QzHXqnHe3ankevDzOl25eGhcH9sfOrZPVF/Gq+OV157hcePbnj67rsQoHWiuEfJRfEUlrPa6VICIUViCJaP04fVtfZMKG+Bi3pqZhVxCkVZlkx57xl5NzPs9wxT4FSF5WEmtcZHv/Sa43Likx9/SsmZIRSu58Cdmveq6UvBgGrbQnGpTY22IJWtCWa8vG6eFPt8E0QpQXtbzYFUC94zhZYgLfffrrWCcIYKMkJEb5e4PiNqdM8ML2cb2r8OZ49B7ezsFdsMtbENkNRZe86m6lYhigOt9jG6aEebs1aX2rwNZwQN78Ae9Vb1Wdu3bv4uLx94uH3gLtKNy/a4fdOuLPQm27cyEyUSRC45Ta7PfVRjjyq37+37Jlux5GiLVMc4e86TvCfESEoDh2liHiNpMOFN83LBMFkHAs6lkouBXVUhiIfqyRS8M+FMaw25P9u/999hE4djQcQ4gBbqaHNCOuqoq/x7DlTp91BmmzjbW9L152evUFN739WGydWrQ7RSFEITSKHfb4HWzLB8IU+K3RXaK28zPtt72GEEjRAi3icThLgu/mjgamFtlayVTGZtjbWq+eW6dcB5R/SRGBxxGEyZPO5MLJUS+2Fgjsm6K58/+xPwGVZS3/Vd38VXf/VX8zt+x+/gtdde46u+6qv4K3/lr1w+/jM/8zO89dZbfMM3fMPl366vr/nar/1avu/7vg+A7/u+7+Pm5uayQQF8wzd8A845vv/7v//f+XOXZeH29vbn/fmlvuw0G5hiZBx2zKNhesLoiYMnBUix9dI/GD+tn4wNvKm0utowU4W19vZDWTnXTG6mbgoBRmcKP++DqZTUTJprq+TWz6BScN5sgmtduC8P+GnPg9pAu6LgDC6pKPskjDEwz4EYHF/xlV/Kf/d/+jr2/srAtmW1wMOlcby9x8XE4fEOF4RFM3enE+tpsVOoKtevzAyHw0UwofmBKJkUlOYHyuooKjjviQ7m3YDDU2tBqpklcymUVtHSKLmynozCbTEJQimN08PC7VvvozWbivIqILsnTCK8PglvTJGkjmVZGEvh0X7k0Ekb2wKL2rxrA5nW7QTbDZPS5wWbEMKW8mRfxzYu6ptEr8ikt+5qp4Cra32xslYYGGvQtT4Pky0io6vZCHZ/9Lac2Zys+rPQQ2v9WTVe7CbcyO/959uMp3GRDIopzxqub7Z9nqkbHV7ZdDzmTbIlEAFRTxDbqrcEYdc3ze3bV+mHiG0RFzvJixQKC02MNllbp4po7tUoPfvL/ogzu3Cjz/joXp9gLeRxjsTRCPshRlxoOFeMbacN1cJSFpb1TM7FDLp1JeeFsh6NUlILVGsJ5iVTysJST5RaqTmbPaH704zqUGg103Bk1e4HNGm9asY5i+AIhG48Dr3ytDqoVKWWyrpCLc0IM9XI46bUqxdGoGo2T5yCNE+pjVwzRTKtmV+vttZxSz03C0cKniFaZlZ0vWVcK1Wd/fxV0NoseUEKrRP5g4BzBt9NaWAYBoY0M4SJwxjYx4k07RnGhEj6JVhNP7PrM9qkfvqnf5q//Jf/Mr/yV/5K/sE/+Af8vt/3+/hDf+gP8df+2l8D4K233gLg9ddf/3lf9/rrr18+9tZbb/Haa6/9vI+HEHj8+PHlc/7t68/8mT/D9fX15c9HP/rRz+Rhf5YuARohRobRM3hhiIlpTExpJPoZ52aTGdOZYeowMnawYW6z/JjSYC2ZNVfqItQMJSvSYaXBCz4EYm/7eZ9o1VGap0pFWwY1fIsCNOV0OhNi5CHMrGoto8EJ4gP3q7AT5XA98SW/6nWePBn51M98nN/86349X/3rvoyrADvnKAjZOZbzynJcORxGdrs9VRt5WVkfjpQmPHv7ltu3nnF9mBA/df+p45wzSqJxxtMIsRJSZLz6GPEws786cLW/4urRK5b26bxFmuSKeiGOQgyONE5453Heo61xe3fP+28/o2rFFUVj5VNPG+8+U25eecSXPNoRQuTeOXyKvHqzZ0w7YJOFh76A999jaUaZd47m+kD7gp7axApGmmaDJnSvVdMNR9SxN9vGpXQFmOugWtvqdDulu9o3MwXxOLflVNlpu5+nu7oMkzmL1YKt+R6maZtm3pSAXR5vcjGbr7m++WhzoPkidjDhANTeStqUjNIVdZcNRAxvVPoMraleqobtfSB0P1gXjiiABjPg9lmXtfmkU+qrqQD1IkGgim3m3kVLgI2RlBzjkJjGyDBGvI8IgeYCol1w09QwQU1wdaO+r0izGJTaOqg3N1qunCuciuOcPTULa+26zlbxWqGqJeGqGK2hGhmm5WYbVc1I81TkEiiI87TgKNsMshS0ZGpVwy753Bt1HcOkiap97uocDd89VBltharVXnN11GqbY9PSlaaAV1xwuBjww44w7onRZP0FWErmlBtrWam50ZqFpLrW26/O4z2EoKRhYppGxjEwjxO7aWJ/GBkmT0jT54036oPXZ9Tua63x1V/91Xzbt30bAF/1VV/Fj/zIj/Ad3/Ed/O7f/bt/UR4gwB//43+cP/pH/+jl77e3t5+TjUrEk0I0qOPeE/cT6cVE8gE/ADEQl2ByZmngKrVYEKKKpYSWUgniEC+0ms1sWgWyQ6PvZOJMqIkUKyU7UyGp0DRbf9sLvsDgCtoiQqVGockJTTdwWswVL44pFu7OyuA9H7lKfPl/86v51Luef/Y/fj//4q2P81/+H7+en/7xH4F6yyILZTnhmDndPmMaHnHz6Irz6cRyOnK+XYjxSN55bh+EA56bJwfefdfQRohjmAuBgVUKvnliAmnPkJDQQySXAZcbLnqWh1vuHkxdZQSBgLZ6EQTUHkmw5Iw+u2ddK2lIzPuIDImH80BdVj76xVfctcDT+ztWOZLxjLJSxfA1rRW8C9QuSbf3oe9tnM6mk4pK6MpMj9HShdZRNTaHAnGVdlmZWweiGlkdMUTNhgsys6Z5qyyFFatgtMviBepFKt07hi+HN9ZyRMAZQcKmYtnmSbje82NTh3c/V9seXFcUVkQso8hytuTyczYM7IWM3mcw9rN6S5Nqsyh6UJ50piC9E9mZeUo23xMgjKAP3UfUZ2tNaJv35uIHEpw3XmVwRpMIQ0D8xr/rJwR1IFYdlD7HQzDSenW0zXukAt1acBF9tGzPy3ZGo3X0Lqtqs1apYpTwJmiFogv2W3QmptDaf972WpWurtW+MfYquDWQTG0mQvH9t4HUPhdNoJXacr8XAqKNqmKqXN/pIw6L6HAQcWbg9cLklOQqAcV5O2yttVDKSsuNWpS8NmpWpDR7JVwldmr6EAND8qQU2A8jh11gngbiNFhkkHx+zaK26zOqpN58802+/Mu//Of926/5Nb+Gn/u5nwPgjTfeAODtt9/+eZ/z9ttvXz72xhtv8M477/y8j5dSePr06eVz/u1rGAaurq5+3p/PzeVwLjGEmSlG0uSYxkSYB2IQUgTnBN+ZaGxD4w0AqqF7J8wj1daVWipLtX5yq2tvSXmCV4K3QDa7gbS3UYLxw1q2BFwshyo4eLdVpn3kNu47ziWzl8I+GoH9xilf9Mjz27/hG/nYV/5q/uV3/xO+/PETfvNv/i1MqfHYF0514ZTvOdXK3e3COCWuH18jIbKocvdwQpcHqioPpzOqwvWTK7QJpYAujTQN7G+u2D86XE7PzXnUVbxXYlXG6Bn2O6bJcm1EG9ELISXEa0fFmOCgVqGWyvn+geP9PcvDCmTaCMcSeOtF4fGjideuJp4c9uwPO5wocxQeTTCPgyn0yKBbmKS1s1zrK57Nyu3AgA23cSa33po6bpsRNbrvqnuY1PeF2hYw1z1WHrEMrbpcWn1ONzKDVUO+mS/HOoKdidNp7ZK8pciqY4O8qgZ7nD2E8UJJvxh2a2+kmXJOdMMPdWK5a1u+rtU026LtTL6whWjUXl1t0nn6lmkbDvZgxCTz9I9YewrgdDHrSt8RDMJeUMk0k7DZ6d6DC9UqhRBxIjgNaGl2j3ehRcUziCM4DIfkfDeJ2yx3ey4ipjPy4m1OKtaODZ26IVrxzQ4mTUzI1Jp5jFqp5FaNLNGwKghjSpiyE3wrllOWewu/FfudId207UgtErbUX++McE8wf522jcJlHZSeU1aqp5VqVVW1HDN/eS5Gfncu4FywTUqNMkIVI7aXs73nKYYjw4QzSSIkj6RIGAaGITLuJuJuYpgnhl1imj27McDnYRUFn+Em9fVf//X8q3/1r37ev/3rf/2v+djHPgaYiOKNN97gH/2jf3T5+O3tLd///d/P133d1wHwdV/3dTx//px//s//+eVz/vE//se01vjar/3aX/AT+aW6BGWYAuMwGfNqiuyGxDhNxOh7m66n7pK658UUWipm0qNVWhUWhaWt3YjnqNXuXo9JTlOMzN6R3IhjAC2smmml0VZT8YQNkJqB1jNh5xvOTNZzJ/B4gBHwxyP1Z99iGoX/4rf8Rt6/Ff7v3/s9/Jr//r/iI7/uPyN6z06grA3uFu5uV2rO7A83TJMdDOpSWE5n82KUyvl0ZD87rh7vaWvhvKwcjyvSKqIrwZkiMVjCA3MYmHeJmGAMyhgaYQwQBsomj8QREszzQPQJFzylVHKurCXzcHvmeHeisMDgeL4mnt0XdvPAr/3lr/P64THISDUbCyk4ojNlmOUcbSo+U0fa4t3xTZtvqKOPvNgi0frEyvA2XNqHtesjdJMk0/pCa/MfNuzRZtCUShW6YhNrK4pVb3Tll8nE1YQZF4afmAS8R45sbTNT97leXXVmn7MKpTm4pBBv1Ax122jLNpDWxRxVtgIMUfPj+a4INBOuHcAc5kNTtbZfa/bYPM6UqZOaXxCDo25AX/Bd7dcXb/GEIJ1TaZDmiOAq1GzzIS2NNRs0lmbtwtEpscuwxTlTuXmPly27K3QKjKO5YAZYtYBDS7rt8ReuWqutWWyHmbGNs2dqTavsnA9477vpVlFntA9VpdIsX4xqr4CzTdk78M5QajHafNmFYHsAvWW48Qql0bRnW3Wfl+3LZgqPQfAxGDkjQBIz8apWahVO7cTarDVZu1jCpp/ekhmCEEO0HLzBTNFzGpnnHbspsRsOTOM1IY18Pm5Q8BluUn/kj/wR/tk/+2d827d9Gz/1Uz/F3/ybf5Pv/M7v5Pf//t8PWHvhD//hP8yf/tN/mu/6ru/ih3/4h/ldv+t38ZGPfITf/tt/O2CV1zd+4zfye3/v7+UHfuAH+N7v/V7+wB/4A3zzN3/z57Gyb7sEJBL8hB8d45gY0sB8iKR5II2elCzfxvvAxjS7KLS6TLU1yLVQNVJLo1bzetSO2RcBFx1DGEhhJAZI0eFdwHWhM1q70qkTdFCCVN5vjWEQbtOOqoFcGoMUXhuEfFr4N//zT/Ps/R/gv/zoV/JV/9vfwD//vh/l9u0f5Bt/x2/j1Vef8GScQOChVKo88Pz5LTGuPH5yxRAi2pTjeWFdzjQK67pwul15fNgxXe/RYs/l/nzmITdqsNejroaKOZWKxkQaEiENiB9taYnNKq2h4Lr50No3heBMBu3wUKxqWM6Fcq40p7gQacPAuQm3x5WPfHTPo5s9zjseVodoZkih5w1ZK8+8JUrz2qshelYVPQXWFhDX23VbmqrJufusQEzAsrmMXE+rbdI3OVEq8bJQty6A6LVanxTZz8PVPsOxT2hiJ2SnzagY0gUTdCPsprLDzMebQAInaLOQPSvLu2rQ2f0jPf/C1IuWl2v4o9Z/Rr/UugEi0dqYXW5+MfVuhletnVfY7MlkNVGA75umWJZRk2a5Yi4QoycNI0NMxBi6YKNRJbNUk4ify8JaVkrOlLXRsm0oVQ2tK64SvM09XXCof5kvZa/vxpqgb+ACBCjOZlZVaSVTcqZmRWu7/E7FgQ+B5L2FGCL9tWrQulBGegJun0uKt9fPd2pMCIKEaHNlD4ODwTuilcHmDcNbirWqIdJaV192ZSLBAZHQK7LgAkg0daZi9pBs5Ixci2XWZYeqHVrEma8ueEf0VkXt5h2HKbGbHcNs86lpl3Ay9Urq8+/6jB7V13zN1/B3/s7f4W/9rb/FV3zFV/Cn/tSf4tu//dv5lm/5lsvn/LE/9sf4g3/wD/Kt3/qtfM3XfA339/d893d/N+M4Xj7nb/yNv8GXfdmX8Vt+y2/hm77pm/hNv+k38Z3f+Z2fvWf1i3gJgveBq/nAfkwM08TgJ6ZxZhgmXEr4GLusttp/AQNtWqbM5orP9WQx1CvUnDsQEmiNuAWeBRii+ZuiN39PViHXzLKeWOvKWhpZG7oWWM48b415nLlviZoLa208jkZNfvrxI5/4oR9GeMp//bVfx+v/2et873f9S375x76E3/Df/R9I+z2HZHHzeVmQcuLh9sh+Fzlc3+BcoK7C8W5lXQsV4XhaOd2duDpcWwTHmqnLGX04QvNE2Zh9AkEJUXpVY4ipEALkhhaoR6iLQ3QgJDstt2bemNoqWRvn1RBO62khn+5xwxmXHKcw8XNvPfDuO+8yTI1ZjFm4ZnP4z6N2sKjNRqr0iG46TbxYjIWdZKUr4YyJKC31FpszJV+f0fgtLgNrEdmpvVdqYuGXajp4i4To0x60dZGFAN78Ss51JShwoa0Xm4moxbxrqyjFPDZiBxrU4tpR7by87WBkcx3FDK26KdZ0y+KyDXrLRDIUVNukEQBdju2gG5dt0/PQpfYbes/MvILm3nzsJHQudZap1GJwDCEyxEiMAyE6fEq2wRcsyTpDK451KSznzLKsnHMhLwt5LXZQUbM3iDi8VCOPO0eMYn6n3rmw5+TMKNsTeWtrXVFnAGjtQgwVk/4774hBCXR+oHh8Zw5WzdQeDII6vBrCLKJ4r/jgOtnB2SbnIXoDUHte0jZq81St1GZpz4qxGOmzMNflVtEp0Y+k5AhOEDKtwJIz63qy+JxlZa2NXAvFVVqzdOgk4L0xLtPgGceRNEKYPfOcuNoNjPNAdIZBkpdHlM+rS3RL3voCum5vb7m+vubFixefg/mUolp4OD/w6Xc/xduffJ9PfPItPvGpd3jnvXd4772nvHh+z/n+nvMpU3MzxVAfGIuIBZU5ISWYxsSQJg7TYMqmaSKkSIqejGNdxAjhxzuOx8xdXsEVRhqDLxz2M/NuxieDcook1hh5Ywwstw/MD+9wJYW9T+yk8oljZX7jmv/6//xNvPHF/w3/9Od+jL/5f/0f+JL/4mP8737rf8X/7f/y/+Bnv+f7efd+4aSN3bxnSMKjJ49oEnjn0095uHsArUz7mf3NHhcSAuxvBrQEnr/zHIkNgiOlgBdhOVmo4DyNVC3k05m6wvn4wIu7MzUXog8Wi4Cd8CVCXY39V3KjZAtbdH2tN+e853A9M18f0OysxXk6EeoJcub5fbbMpC5/91RyUU61UNqG+jSRRC8SEMdm6bwo30R9V+/Zz/bN1Hdmbq0Xrp/l/9iybH6jDY8TcKo0Al4qPbMWsJbhVsW03tiz6U9X27UOGVaD+G7zL7oQxJvDm9a9eYpDW75UXzYW+sDW0wRxBVED1pq3yRZQWG0h1d6WwvBMKhftulkJNrxTCx9oPVp11h8gVU2Q76NaNRAjITgG73HRKjR7HNKLPgtqNDSRPUczrIoZedWENTRh0cpq3VVUc58VOrwIVbS3XM0QqwTQ2g24QiOagKKpMQK3FdDZHDGIICH0FqL5lYpa1HxVrOrqs8na5SKOgnYuXmuCj8YvaWKm5g8kvJBbl+NvKtDeYjarmkXZuCCkccduHNnNI7v9wH6cSTGCCst64rRmzqfM/YP9/7qsLNVEOS44hjSSxsS82/Hk5pqbJ3tee/URr7/2Jl/0+pu8/saBV155wmH/Cs69LCJ+qa7/2HX887O++7y+BCEQoidNO+I8Ms0j027HPIzMaSD6AQlxS1ywk3rH0SCWDaRUC2Rbzed0zCulwFJXcjd9BvHEKIzJE1PCBUd0AlUMHNnEHPWt0pqSs7CsmeV45tlxYR72HGXkXJT7vLI4eCUqt2895Ue/+59QTj/Br/6iX8uv/MqP8K/+0Y/yr3/iX/Lf/++/gd2TL+K1cSA14eF4ZCln7p7d4p3n+mpHihGnwvn+yHo6munQNZa7Eykp16/vUaohnsaB2iAF68MvubBmZZ6u2V09Ju0mxmhO/6KG7VFVxCvkbKqrKsYpSwPqTFHVSqWsK8t55fTinuOzO6M20GAcWMMVZ0k8enTNo+tXCc68MOfa8M5xGAJzFAYXQUKH4FpiqfRZDr3NFlo320pXBqqgPbp9W8jNl6Yd+Kk2e9KChfgZcV3E2Hna7OPb4u78FidIr1T6zEId0rasMpDWOnykcwUxUU6T+nJ43xS/LfZCby11RBMgahEMtkHZc/KYMMPApl3ssO2a3ePH9jicp7pNSSc018HBQp+vaNdUCN45YhDjNsZAiIEYIzIEUoqM0THEkZASMTlSiATXsVHVKN65GAR5PYvRJErlXDKlZkOqlIKvmxLPsW3TVQulz4qKWtBhyZYx5Vq16omu7FQB99JNUEX7e7bYY9DCunnOajX/V/fGhdAIEVwMOO8JLlh1KGAxMJ2zKNaO3YJXtogZ+zU5XBRj9AUDyQYZSE4MAeVcP0RAK2ptvZI550xeupG3Zoo6syCEgHdGQ/ExWGt1mtjPM9P+wH43Mu0T07xjHCZEhl+y1fMXcn24Sf1CLoHoPfvJ82gcOOwPHK4G5nkgDYkhRQafCN6jPU3TPJMWA+BaQYsZTEvJ1FwpRVnywrpm8pLJ1U641j5QUnQMycLeRApVGtk5SoW6LJRTJueFJa+s5zPPjmfuKMjuhpMkijbWrOyGSBLh4z/6Kf6XH/tnvO7v+cpf/5+TpPKP//YPofvI1/y2X8e62+OGiJbCcgvnh8bx9gW7qz1Xj24I3ojNdy8WHk5nI4DXwN3tGe+UaZzxUhkaXYU1ggaolSEkCpBzZppmDo/2jPOIqPEMoxeevHrDOBxwmiwuOwZ8FGsNOtAgVGe4mfs18/zZA/d3z3DScDEi0eMP1wxXidmduRqVNx89YgojuRVG8RymmSc7z5w8Y4i9VdYuLUDBJMHWnrX5os2ICjaCsbmLVRt9ZtRsY7EQXUMXuY4K2io1dbZJKBi1XYWyCRzowoMeBVL76dqhfXMBV62a2nx1m0S8SwRtZtJbS6jDNbn8fWvwwTaA6oQMm6r1obttQPT8Md0I6ChSN9OyPW+6etMoHfZc1Xk0+H6wSISYOnUkkZJnCNbi9dGZCMIZAkyiw3vf/fAO7ywnrSmspbCuZgCvWii9FYsHFWvnVVZqs+BIi2e39OcoVqWoM29ZE5v/OR9wDmNh9tfPgB4mjuilVa9Z1ajw0hMKNPQZn4Mu/gghIl4I0ox44bpnracO14pVdK3T+6RYdtbcNy2atRZ7q3B0geSF4AwObZSSzLksLBnIK1mXHojpTAUpjaBqyskY8CEyD4HhMDDOV1zNM1fXE/vDxNW8MzXtL9Gy+Qu9PiOf1IfXy8sxMMWJOE7s5oHDtOdu2DFNJ+bdwuk84M8PiF9xxfVhvA1cFW/EZKl4J5dwtVobWs1MafBLUAm0OBJaY4jCGhq5Oc4VO1ViUMowFFyYgIWiyloiT3Xhi6733Ppr0vl97rQSk+fJLvDpY+Yn/l8/zptf+iN8+S/7Mn7Zl3+UH/+hn+Fvf9ff4et/49fwxR97wvJTJzQXTnk1yeuDI4wPXD+ZafkR+cVT8npmvbXFRVPAFYe7Wxh3B5Zz5rgcKaeKREccgr1hpZGXjGrDixDCnkevRU7PT9zen/ChkIbMkUa8GqmnhRgcNTuTXxdBghlRVR15wSqYpTHMQvGVFh1SMnc1UVvDO+XVxxOvvvoKt/f35PM975zP6LGwD54C3IUeLY6ZdqXPamwt79w9kcv8xYnRHkydXDsqyF2Ub9rj3+3LN0p5J6qbPfQDSq/eqHPwwdhx1ZeV0OZjEq8dflv7YgqiESXTXCdcqAX8GeDJmlIWUaW9a2dJvFY9WXutBUP1tMWcUE0MdmUBibaA9n0NT7QKC+3VVjMFnJMuKzeJuHeJ6D1hgNhTdUMM1hEQpRYxWLAISkBcIaoDaR0BtfHzbJZmUvOIVzWDML29R6WpbRqOaq03+kFBjeUozbbgJsbE9P3+sSag7603xTvXQxIbTmKfE9prqFUsWVhtzup9NQgwwdiMrYAY6sv1ra9WhzTzSzZp3Q9lpHwVYFW8CrHnXDkn1iIN0g+nlqsl3lFaI5dGrivnKqxd1VeLiUqMIiu4IIQUmMaRcZrZDyO7yTPOI2O84ZCumKYRJ/MvxXL5n3R9uEn9gi5bUqYwcHOzZzmdeD6/z3g1sT9O3J1m0nxmOSdCzqxifiZVi57oZ2+kQWkDviklZ9YQGGpBijd1j4+EAM5b5ZBjJA4JX0doNiz12milEKua38Qr4j2NEy8eFq5HT5qveft0xxvlgYe88toYuA6RT/wvz/ixf/o9/MZv/Bi/4Tf/Rj7x45/iEz/ws/zgcia++QT/8XdIU+OkmeUM0Z+4ewqPXnNcv7pjXU7cLoXleLY++uGADAOlNqQcGcaJ451Hy2qtNNeo4mlLeamWk0gMgkjEN49zwv3xxKd/7oG8ZLwPuCHiiaQEa1lwwVFbwymoForacbeETBsiDy+e45InDBNyqoR5h5aRp7dHPvrGPW/+il/Bz/7kT9HeWvhkg5Iz4j1jFAqB6eqa/LByezxiNRUvFX2d9NDTkICGa1tkoeVSvcRU+C5Z7lV0p4ujm9m3n2F75L12sYMJFRTf9Q9VLERkE2MY0olLwUNTtKfMdqHnpc1ndAnp8y16qKOHIv31Mwl+621IVbEZVL/P3Xav8gEeYadqGMmjdm+Stbu8t6o3eE+Kk1UWAbxz+BhJ3n7H0XmayRepokh9qRgUFTYMvlUAALrfSURBVBBPlIxrnuwbVG8zJe0kF2+m742BJ2yMSwHncSEQFBwVUUd13mTt4ggIQRTnkm2umi8bsIiFCppn2DwMTiKuOqOFxNC9Ua6rHA1MrOLxaunKTUGau1RKyGp1mgOpgjJY1eQaYTugBJPTe5TgEz45/GAyfRcwBWE1YVUtgpZGXUonY2RUC6Jms3AS8H7oybszwzwyTbMp+w570i4Sdg5CQC6V8+fv9eEm9Qu9RMBNuLgSp5l5f83+sHJ3e2YaHxiHwJoSJTdyPeGqozqHNiitEZ1hYaqutOIoIfY5S6aEgcVXCCvNj10GnUipMFTHuo6UouSyclQQqaSWGdqKD5FYG9Ub0udTd/d82StPeJhvePfujF8a71N5NESengr/nx/4BE9e/X/ydR/91fzwr/pi7t/7MX7y//0OrzxKzPNEyY19U06nBc2QJuH2/QeevHrF4yePKGvm4eHEi9tb9gq7a0FTIt8XpuGB8WpPXhdKPtNkxua+jVIVFwUZod5lQoJxNyCDp0nl4SS0swXFzbMwR+XhvpFcQdLAsq5oW0kxEBbLl3r/U3fcv19QMiFE5kNjnEeCK0hqqJ/4xHuVp8/+DW4QplcfMSzPWE5nnK4gnilG9lfXLPGO43JGazbaB71iUmslgYUtbnMfi/gwwYC51aSf4rEN1HVDcAMTf5hYg6a0YHOfLYpDugijSg8KlNA3lNorrM04Kl3B11uJ0PFDXJR9XZcNWqwK0NArCnus9MMSfbZE20QWfbbTRSDbIMU2U0G8kTz6tN8W9jQwxoF5TEQPRNu0PIoPXW7uDUEUFWoNSKhQHJkthNIqAaHhW8TRoEonhvcKC4usd91857TL/6V1+XXFuy7acEJV4yh6TJofXENcxPdMJ6cmfRDFfFdiHMHQI3KCMyZhLqasrM1a3a5HbQiNIA3pXq6sleYDtI68UkW36qrjp7a5XZNAcl3IIs7mT1FJzpOCKR9xQismuMiqlJptTNAaNRczoKu3DX6wNusQLepkmhLzNDLPE1e7HVfzzJPdnnHa4eSXXizxC7k+3KR+wZe9OXcpsuwDh+OBq7t77nYTh/3E6ThwnBJhXYhLYA0FKduw1rhc1eialCL4tbJINplpybjs8L4vytESOasLDCGwjo1SEjWvaLE+vJRGDZE0VCRYu6qJ43SsfPzunjevd9yeZpbywNkpJ5/5ktHzo0+P/IN/+BN8038b+MibIz85J5bbhbeeZeKQcH7Bjw2XKw9rod6fGGPkxe0dh90VV69cs9TG6eGB0909ra7sH13h08hpzez8LYdHM8/f87RSaF6IyW679dxY/EorjWVV4q4yJM847yn5gToPUJSWheNaydkI5sOoOCItN/wwsWhGUEqt6HlBcTi3UvTEmjMpBeLgCG6kDgPPy4q/r0QpvPEo8CLsyCWTm6PUzMM7HycRuY6Oo3iyZcnZzMrTRTDS2Wpqc5jejnK9nSvbgiqY6KB9oBLZNjVAnEm1fTPcUMN3g699qi2utnirWsXlUVp1PSPLAuEtpbcB4QPkBzElH2ptIGlI30C73vRi7NU+I0M7BslGY12KYBVjkwhq8TOarJqL3ZsVwsAwTOz3A/thIkVL4G3Om9LO2UbiLiVntfDEIkZ48NLl/AouWEi9gMjSk5cdrlVTXaqgRMQp0QWbM6ngxCDNXqztF/rBwiNGlvfugjNyPRrFhBKxo7EU5yGJcfJSjwZJzpHVUXwxvmUplGZEi4qznKhqdmXzRDcTEykYUakLU7BK0UlFJHaqhCkznUTiBRM1MAaP8wNe1IQ7TiliKQO5LuQCq1ZOKrRiNb0E6R4tTwyecZrYjwP7aeYwR3a7wDAkSzeOic7g+MVaID9r14eb1H/CJeJwPjDOif00s5tm9ruJ/W7gfpoYx8J6fMBHh6ueKqW3eexUBeCKUKLDFVOGSam49cFSeYsnhob4Rtp8RiSG2sgps5aEzys599yZus0xQKrHuUqpwotn8IqL7A43fOrpkY9IAREeTZ6bYeDd94/80P/003z0MPPVv+ZL+MGf+ATvPztamKEXIoFpF3i4rayLtdvaKSNy5LA7UG4a59PKMWeGYeJ0nBk5EdLA8djY7R2H13bcvvOC83JENCGDtXPK3baAFXSJtKmxP3i8euIwcX9/RrzjfDoTgiLDyLR/hfPDM5BKzdLJPgb1NQa4ZSGt5YF671lCJAaYdo00CeKVIomSI74o+7EhYYCUWJaFZ8/veVgXRvHM3lG85Q6pNs61m33VlH7S6Gbd3mWrFlVR3aZKMuUjxRYQ+oxoS1t2XWxhpAi1TUSMSmIqQ0/t25f2ysrynrCNaYvSEFC1dqL5l/yFeq6uS8MvC9JGJrZ+oWzSAG2wkRucdmm3719rm5V4C+GTbPy4GBI+eNI4ME2Rw27mahjwwfLGxEWcrzjn0CKIa+TcaG7tSCeb01yog86CPR2RKgVcMl5i3cQkvSIVbDMSbKP2AjmBCBKE2N1rF6Mw0FqgqCLO/HKQQYLJ6KUz+XzCe6tgvFhKNq7itOLV06oZfVszO4OrdlBYUEon1zsVmhZTobqK5Zc1tKswbKpZ++u5tWGlt8QdwSsaPC5B8PFyCDL8UWXNjlPJ5GxpwDan9H2zE3yEsEvEXWScRg7zzG6/Y5h2XA17xt1AlMQXwgYFH25S/4mXIDIyhSsO48LVbuT2ZmZ3vma6PzI9LKy7iWXtSZ0VarWWQqkK0qjOVDlFV1QhVk8ukbQK1TtyyMQQwQWiOGpQhuBZkycVR84RX2sXXzSWpZFbIXklRGun3OcTP3MK/Mqbx7jpCcfju+yCcr+uPJkDy9nz8Z9+n4/++oGv+FWP+MlPv8fx9sR9tcXLDQMBZZwd54eF9SHjD4mH2wcGidw8OrDmytNnb5Of3nLPkdOd4/Frj/ExcX9/Zpwj05OR09Mj61LxDbQ1SrPEYbo7nmpg0CYTafSMam9MxZSMIoXbp+8jseLjQCn2GAOBlgXxvaIJwaLTKyzrylngfK4cDplhvzMu4uhp6ZrzcSWtR5I4Hk0T7bjyrFYqgbUVHELykIaRm6s9y+3Cs/t7ajUhBFJxzWoZXOWypGtFiPa8XOvMu21LeOkDohqqSKnG1RMLtNtC4YXuORKsRUjfTKQrvrrfayPNbZthE9v46GZcRXpqsW1l0sUHiu9Vy7ZldbmHWsxME+mR6mrqO7rcOka8U0KcGOfIbrbW0jiNNN/w0TO42GXzjpZt4F8brGUwT1treAmo3/K9QscqST8AWL90C1b0WIaXE29UhT4PU7W2qROP+GACBKn4ZobpJmpJ2er6ZmCvo24AXASvg5HGQzC0kbd5TVUo2s3f3V8WE7jVfi8b3d71NiAddKtsAZ/0dmTHFzt7fYMLFpopakpD7wneInXGGEkSeshpoXTbSa4nWjG+X60W+SFuQ0RZzl0YBqaUOAwDV7vEvPccDjPXux27q4E0DP0w8uEm9f8XlyCEMLO73nM4H3lyXLmfH7iar3jYn1iWifNxZe2mXpcrmRWkdU4btnn1VtLqM6E65rKQs2PxCReODG5EvCehtBAYUiI3y2OqtXKq9iZ31WTD9IC6BYgId3dH3vaJ165veLpUxvUFgjKsjY8Owk/dO/7pv3qPNx4deXMaeTYF1tqIQfiSj36UT33iUzwvR1pRTscz3N0xxJFnz55x/dprPH7ymFwyT99732gYXojuBYfXrhE3shwL825AbiYebi0DKKi1anxyOB/BQRxmVCqpVfI5MnpovqLZczydTFSQM+IdPgmVjFc7hfrokeAoxeCcIoGiq1U+zfwu9y8y56UwzTvmaSQMjbYfqQQejivn2wXnHa882lGroy6FuyWjXji8/gbT4YC8eubw9IFPfOpdSj6besw1E8V4kOx6m8yhl8iFDnnt943TYO2fpi8VhH2z0GYnfzBEj/mDXa+UOorHemRdrr6ZjA2XJN0T1agm2jC1hrWAu0lX1OgKCr2dFmiUXhpucnJrEWo09l3yAe+MtxfciAQzpg9j4DCPTENiH8zPF1Jg8JHoAzGaenCJSl4d1DPN5a6mg+CdGXidh2qHNtnUfnh8K6i3rd1Mr80AxE36Buhpri9mTkguGK6qha7A3HBSnZdX1X4e0V5l2QQSll7tO/MRETKFkpVaV7Jay7exIC3Qqge32j1M7PEaFk3SrETEa1c/ikOl9k3S97mbMwGHCMEJKdBbdUbmiK6zJ7SyVov2WVcoTSlVLvE9xi90DC4SUmIYduymkf08sZsP7PZ79vPI4XDFvDsQJPH5Spf4d10fblKfhUtEGYYD++sTt/eFqxd3PBxW7o8PLKcT59PCsqzULPhYaNnacgXL+EGKzQxKJuPIErjzlame8QVSnil+ITKacil6YgvMGiglUIZEq5Ulr7RaQJSMIV1CBhVPOVfeeXHPHB1XNze89fREKid0ydw4x2s7x8fvz7ytmTFNHFIkp5UKHB+esTSsmpsGaqusy4MN6dvI0/ef8uqrN7z26iPW05mnt8+pTXh+d09FuX7lESklzg9HwhA57AaOdw80zUj04LuEnYrmI35KTENCNeKTo55XmBtZkxEF/IrH0bJtxiKN4L21vpwYsWP23D8/4mJEc1djaaFUJd+fWM4rdT8xXc2EZPLiOE3UIcHpjH9FeFUjFc+Tu0wbEofHr3I6PWcInsdf8gpK4tOffpuynKidXefbNh8RoyOIYYGQ3q7rxHPFZjtUpW2x8rq1g+TCyNOmJqfeKore3nO+b2aqfS6lXdzQfUviTcDRLJLELgdqrUMaRrNAbOXVtSsYbTlHHOoE7xJhdsRq0nHvIbqIdxHxxoUboiclR/RiMvbWNz6ppBgZg2OLDYlZWMFmWxoQX4zAAiQXKMHmaEsxe4YDirOWoNde1TlHEkf1rh9QtFsSzA9l3irXc7EU0/MZrVwAid5mVoK14MSetfcN39l/1bTjdghslSVbhyJg95irGa+GN2pAK6uhyRAqhdqBveLMNlEpBAKO1kMlu0jGY8+BSvDmHTPihM3UatUe0GiiqqVUcrWcq9pW20ydx4mpKqchMs2JYT+xm0euDhP7w57dYWQ4jIRhhC+gVh98uEl9li6PF2Ee91zNR+6uDlw9nHmx7Dmfz9w+LMSUWZaKuNX6/RW89rRXhFUrvlri5lIaLhd88MbuCtlMrKq4vcEqdfU0NzKFwpqaxcS3bCywBsZ8s6C1sgriK6dl4VPPn/MrXn+N6fp17u4+gauNh5w57AKvzcLzc0Drwk1U1ti4W+Dpu09N3OFdh62OVK0cjydWUdKqvPfe+7z2yqu8/kVvkFvl+HAkV+XuoSD+Fv/kCc5H1qUSU2XaT5zvK62eWVA0F0KInD1Mi50cK8bCC+OAuIYHzutCFtDccMlbO2fJBOdYVovJHsaZ/VQ53nlqrqQpUFugZceWiNqacn9/ojZlmI3BGIKAj0QPO0auX9uZkXRf2I8zugssn3JdGOF55XrP4OHd919wf39HXTNNI16M16PdoCsoRKNZ6KnDbOkeJ2ceKBULsfN9ozEyurmctPWKim2U5KDV/jjqywZdr6JEekEkDufUjJ7Qv2dfnsSqNjo+CGnGrXPGkHNO8N6M2LEF0jgwRqvgzYOktKaWlhyCsSads/2u2T0sPqLOQ0h4ClE94nrlKEoMgguJaTQvlnOJqJZw23KgrBbuKSngm1jKsSjBGdbII6g3KoMZ5o3VuFWhKh7VQC3G0PQSep5UIHrzddWmFDGslc0HeztVoWpmrUqumdWSETkLFujZNzZpNn+sNMu16jEmIlzasM11cc22OZmsps+aQH2z91ZwZnyOkUQEHFVhVchVWFr3Q+VMqWuPUnFE783oHmGMwn5KXM8zu93ItJs57IwtetiNeBm+oKoo+HCT+qxdgjANO66vdtydzywPJ+5PR5b9meuHO9p5ZC12+imthxL2xcWpSWelQhYBl3HZMmSCb/jVeGKMynCytoGPnqCZWGfGXGkhUMNIK30xU6W03BehhvcFauL26Hj77siXXD/i/fUK1ucQlbmsvBo8z86ZYwncjJG1KcU1dB2onMmrSaOjS8w7pTShLmeyrJb4+v4DTx7vefMjb/LJj7/FutzTcuH2toE+5+rxNS4o5Qy7vXB4PHH3otBypolybs14fXlFi4FZd1ev8EVfesUn//UneF6PUBKSHWtZoABJ0BZsnuEba15xkrhdMi54JBfqAlePHOsykHNgXc7UUizYwptgoJxPhHEkjSNDSjx68ohhSpRythZOgnq3kMQTBk8tDueFw35kGgJ3+Yt57723ebh9j1rMFGqZHobAcqZwZ5MIuE48d81UmC8JFZXmtnlBsdbQpo+gGaEAB11b1sSCF0WNNG471RZN3zV8PSqGagbehokHmhq+R0VwPhIB7wUvERci4go+JFIM7MaBISWGwYN6imajnTRHUVgLDL6yakFcxrtkz18r0TnABBDVefPz+AnnKjFGDlPEOwdEal1ZywqusTrstSyFgKVGRwfR2wa0yeTFC1GMRI4IUR3ahLWLQZzH4tOdM1SXM6KDve6ZJQulCrVjnVwTLFUXtK7kXKm5E0bqJnsUMnaoKGvrUfOlpxNvKhpwYqKYINWEVsEUk07MyO694AOXVrXFgpiBOAuUWqi5cc5KLo61FpZWqdr6fZDAB2I01d44T8zDxDzNzIcD87TnsNvxaL4m+Ru7n77Arg83qc/SJSJ4AuNhZHceeLiP7M9X7B4y87xwnpV5Xah5omXFt2agySYm06XhsAyd6iLZJUoorEUJPnMMoMXo6iE6UvRUBnIrDDlZ3EfzlBpp5WxJsMXc7hobUkLPMyq8d/vAYZh4fPMqd+8UDusdJxXiXnhjF/nkQyNJ5UmMjFc3vLo78Ol3P8n//MkXpqBrQoqBq92O23UhHzNhapzWpzx/es/jV57wxpe8xjvvw+npA6XA7cM9OOVwfYULjvVYCYfCfjfzcDxT2hk2R7+8nM20cofUiLhASDumWKilIPeB5XRC10atlZKLcf0qZDlTXWM83OCaknM3nAaIzeN3kdODIZjWdaWWAgjcZYbhSHrtCUMC5xIiFuIYJFDkSIiROAyUteK8MdWcj7w6wjC/xntvKc+e3dLKgrXnjLN3iUFwXMy6shHVm3l7tK9sjkaR1tV73TvUKxBqsBmYmJQ8bDbiUXC5iw3Qy7ynb339Z0s380oXqwR8H1qZ9NlM02FLv/WjUbxTYEiBcTT/UGuNVlwXMzRq8yxNkSoEjEXoRY00ERJEI3JnAiLeaAg4RAPTGNhPA4NPVK0UCSxrRP2C80LOjuoyrdrm4ZxROXwXoKiYItCF0UzD3tOqRajrWq1FGGyWFuNgzEDxFr9OoxRPWxp1faDWFWnB2JpqGKRWPVprJ973OaAa0kworFqtClWhNQPZKo3aX2ORRpCuBLYjKU4MBRV9gRBIIeDCSPJWFUXXNaC9nVtzpuazUWqaon2e6XqETEgHUmykXWSaZ+bDjt3hht1h5ubqiv3+hjQdDOH0BXh9uEl9Vi9hSBM311ccjys395WH63vuTgPLKXFcx670MwySkV/sv7VLkZs2tFZcbRyXAlKNXACEmg0U6mPPuvGkINQ0UEslFyGGhmqw4XeD5htJm8lv+9D5fF741LPn7N58lfj4Fd5/uiKamU+VxzeRU2m8eyxMHob2jHdvX/CsVKLXS3qr9fQdu8OO29sHTncLXpX7Crz3gqtH17xy/QrvnZTjcaGumbvbFzQt3Dy+ocrE8S7jY2A8DJyPlZpbp46DakMVzmflJ3/0HUopuDiSnKf4BjJBOZOd57xkWrYqwgdHdcp6bojcIVgb6/5usZaPE0IcCYMiRSm5oXU15ZiDmhsxTvghARXnhCRCrnZin3aDgWxDwzdhLcEiVpqyQ9GbR8xx4P5h4f58JK8nC7PsyjxH28R2XNxKnZyuzcBJBhjoJ3JxZi/oQ3vtQoCm/vLveEFqxwY17blYnSSgQnUGnA3S+XIBPIpzA+oaPgiDDwQJ4D1Oa28r9hDPoAzRQLxNhdrU5mGt0NqKutRF1QPBGb7HeQeDY3CNwUoZcJXRe5r3tgcGzzRF9ruRFCIryloK6mEvcNJIpLA4S7B1TZHmwfy+pp4MEbwwisd522zxjVYT4hfjYirM3uTY0xgILjE4aM1zGxZiPXMuiZbNIF5VoFa0OXLRixjFkgyqea6QTkU3hJK2gnQLhKjgmu+iiG6LUIf30ZxwYiIR57x1OVywSk8GvHQSvrkQaBXW0liLkqslAWixilc8JB9xoSFTJKWJtDuwmyf2u5mr/Q27q4FxGhjS+AVZRcGHm9Rn9xIh6MDVMHO/3/Fwc+Txw4G7+YHz/sR+PXE+KXVZ0TpYa4DW0zQbpQ+0Xak0MhlYXSSQqc6xSESqEIudxkPw7Ai0QWgtUlplbQFtgdzMpyGtULNHpZEoSLHYh/vjiY+/94xf/uorvNi9wrOHT8K6InfwaEjUCZ6eVq6cYz2fKcfA5ANNc5cwg/pKmhJzqdzVzPFYmTVzH460Z42bR4/QekP+9LvUVSkZXjy/hxJ49NijIbDkM0NxxGHED7AczzgsHVVFCT5Y+J8zQ+zVzQ1NKy+ePyfczLTqCUPk4e7Eej6z5kryatElXi3jySulmdAiOFCXiWLEi6BC1kgplWGcmcLEF33xNbuUqIv5i6JJyAgMZK+s9ye0VcYx0XwkvHiBYDHko0a8g91u5E0OvPfigSUXSl5opXLOGa2ZrgJH+mxpC0pUzJPVurJO1JSKVmFiAX6yBcDbTEub6xXXBrTdZNtmpBUvlivkHDF6y3JyNn/LKEMShjiARhqNWjKtVZNVe090ZiF2CtRGRVl7sq0TT/CeKUAMSopCDFekUI2kEAMSAsk7dF05eWVMkbU6Jq/MA+zmXuVQyRrwJzPzOoXiFkKFtWYzc1MgpN7e3GZnNiuLYqSKljM1OkRHTj4zqBKDgYT3UyL4ZBt9dcy10LJnOWMsvLKyRWFJE1rrG48ze4RKM68VtcvjjbeptaISjCOoIGJS+dqZfEEarmPW1VmkiMeyqwYPPtiMTsVDLRQRaqscS2ZtjVqUnBul2CHF9TmjD8qQKuOw5zCN7KfEzWHH1WFgvh7Z7QZ2O4d4y1D7Qrw+3KQ+i5fx2QIxTjw+zBzvAw83ex7f7VmWMw/5gem8UnIiV0fs8Wl6V3DNKh9RoTZzkSdpZBoL2U6JMRKysjhnRj8SwSXmmCxSoDXm2hVvQCPTqkFKW1FaqCCOUgNVK+++uCcFzxddPeHZ+Y64PMNxxrfCK7NtAMdsqKWbwZGrUikIfYirHhc8095MjM+e33H7InPthHrTeP7sBbvDwKtvvsp7b73PshyhCHf3z2lkHj++wUdPXRrqlWneQ4R1OYOHiFJLwQXPIIJzAx/98ie89dPvw3PFDSOiniuXGGPg9hg53z3YzCFGtFRqEapmWi2dUt3Q2sB7ErCOjlAdzi1ELeyuIoerGec9xXfaeRRjzmWHlmpS4FpMmu2soaYJfIUglYBnbRDiyKtj5OB35PyCZVVePJx5dvuUdc3d42V0dcVUbRv6yHt6ZW3KQKdKc706knaJeVA1crcRuatVSRpt/uUE7z1BNsRPIA2OMdmcSbzFv6cQmVKgtEgpmVMr3TCsSFupLhFapWDD/1UzZHsM6q09GMQTXSJGYYhKiiNjNMVfEjskNVEiniVWkhem0NjFxD4OuGjKwuLAk4gqRLEqymWPVEf0zVSwHnsNJNi8LYzsksPRYzaCt82/VHaSoGXbKBIGbXWmdHe5MDRHCY67YC1OaXbfaMsGDGnFKsguX+8vP/QcraYFbRt7cQuNMpGPiVC6kEUi4kxWjgPnTcwRgtA66zB0Q2/RBkVZS6XlRs3VInlq6fNEGy+EEAhpYBj27NKeaR652u/ZXw1cHxKPdjPz/sCQ9sAXZqsPPtykPuuXDXMj03TFzWHhdITzkz33ZeHqlMlHqEul5ltacYTFszpLPXXSc4mqYW7WIgQai3fIEvB+JbqKCzMhV+OCDQvBwTQ4qgbqOlIKlNjwRRFWKg1XMpWRVSC0CqKsWXn72TOGUbh5/BFu360M6x1NCwd34rXxwCda5PlSmSPcTIKcksmps7I0M6H6YWSSwHkt3N/d8eLuSAwOHSMPt5nD1WPkFc+777zNeT2TC9ze3UNR9q8ciCnCCVo+MoyB+bDjfDyRMwSsL19UCcPKWz/5FqeTI4XAqoKUBQkwjQMxBc4x8XB3b/EYKUJslKMNtmvdmHUFvDPVVwgMk1DLRM2N/Twzh4iWRggVzbZplKqID5RjYe1zudNDprYzLhcjInhnceFOKA9Aq4wpUF3lar7h0TjwUCqffn/P87sT9/cP5GzR36q2qDqJoErxim+R2jLaoIZGcA1wZoxtniiWo2QoVAsQtPjyZIICtyGVrCWUxKIbkrPcoxpNzeZiwjlP9EYdbKXRXMFpABRtlezEgKsCToz4rRvrLgDeEaL5lpyDEFMnqTtrNyLgRiQ89C6AAVadd6bK894IFdUxDw3RGRfPRnNaBV2hrKVnjUXjMapHvCc4ZReEgidSUPGca6MxYIoH1wkciWx2aXytIIWm1loGwekI7QhVERKlR2pAb/epmRkrCmLtQKOzuwuTzyQtZuBWxYDPznethUelEB0WKROC+cjCiPcJnLVwVYVcG7lWcm2cGmR1do+pCUAkelJKDDExjgP7w8Du6oarwxXT4THD7oZpHNjNHiHZ/PAL9Ppwk/rFuMQRfOLqauZ82nE877h9WDnsjpTjzqgQ65lWCporzTeyVtS4J3bzq8PVlSwByVfkkFmLsJwj0WdW9RaWV7f+NsxeqQlKXanV0aKwdpSLUGntjNRAFddhpnAGPv7eLeMbnvDkMU/fX7jJK3JcOIjnjRRZmuOYleukBOdppx6EV5Wz2JA6OM9uv7fI7/XE06e3XB926C5x9/wZ1zcHxD3mnbefcl7OSBHuH44U4OrRgTQlcim0+5VxPzPOA6f7hVJWXLV5Q1nPPH2/EfyMnwLulJkOAwIsR8MUaQI9TKx5IYlDxogLyvksuNrjuVtGm7LgkFwQF2m1EIPnar9nvhngtHB3bIxp5CE3yrIisnI+r1TFvCq5drK2zRZaU0pT89+Ish+UN/YzzzMQII2RguN194hpP3J8EVhOhXMxMciaba7hQ+weKVjXwrpmtDWc75xzt6GkXtIZDJBqtgXvzBLRoIcTWogf0pFQzk79dTE6uUihmvbd5k1EmwlKNRk7AXzAi0nSLfm2UKt9XxFHcz3eRCM2bctkCZgDFoLPtog722TpLMNaC0s5E2M0GK2AFmEcjBaeo0BzlBLw7shaC7HPcQTFaWUQE7iELu0vPc/LYVHxRitRTmuh+WIVTR1R8azrwjk3tDqcZFxYCCqsGaNx9IBJYzNauGhTI4oUNeSRw4QUzgtbsvLGBnQ9q0oEnC5dwQnORbxEYvAdA9UVgU0t/LQo54L5onKj1kLTnlMVwIWAT8IwJ+Y5sN+PXM8DN9cWC3/YX7PbTRbAKl+4rT74cJP6RbscgThOXO2vOD6cubtaOB0PLGtmPt1zOiXWXPBrJalQ20IramZMMdWfilK0oOUIa8BJJTY4i5kfs1QCk0VrO4emyFVrqI7U1mh4WjtRVKm1UdXix1lbj7q2vvrxfuHfvH3Lr33jEff713j/6ad4vCwsyz3TfuaLxpm3pFKa59VoC+TbNFpt5BptAwyOcT/wqF7x/lMllzMvHk5cB4fsHU+f33J92PPkjSc8fe8py/2ZXDJ6vEd05er6hjjtrEK5P5FCZE6JkgLLw2rSYO9Yc2Upt7ij4iMsxwjYqbU5QX0gjBZp4kKEXFlLIbSID4qPkUbg9LCQa+kIHcFRubq+4vFrV9w+r5yPiy0sfuV0u7DUhscAn0s2c6VqYzzsmG9e5fnb71PzLZLh3GwRO66Od1Zj8YXmuV1W85mpIDESxxlcZqSiRTjljPeN3TBTVYx2cT6T42ptJg+qVqqMQRjTgMRAWVfOeUHrwOAcIXqq0NtGJnQoWqydSKM2m6s4TEaWpdjGh8VMxGby+dbxPUpFqsMly4ZyrhpFw3MxK4sYADU6M9xKg5IroS0UgTB4OsKW6JSKydHX1si6PSYjgUuIOAqIIzpPcQ2nK1UKIuZfIie8mIou15XV2SxQq3SBQSWXQm4rriYQpVahVoUQCe1I00LOjSUv1LWYgq9FMx0LZFGaaofFmsrPANGb6dpk5V4shl7VmejF+Q6Pbb3CNcGOd9WUlS7gvFW1Lna8hVRaNaVkKyutFEqx56G1oK11/JHNuMbgGdLIPEd208xuP7Hb7znMB66naw77iXk3I7LjC3mDgg83qV+kyzg3yY1MV5XpvOPJecdxued83LEcDqx5ZV0qOdkNGYPNHkpWy8VRNS5YaaisSN5UzMEWOm9U59ErgzPwmo+JRiNWYayKtEwbMg21uHmF3ArNeM2dNO3QrNweF378vRf82kev8PZ0w1vPjzwiw+nEkDwfnQY+dWosRXkcA26GT1NwZ2XJwpGGBM+4n9iVwt2LQm1w++yBq1aQYeD99255/PgR4dXHvF+fcTwbf+zhCKU+53Co7A4HnPcs54wURWbPdIisx0JrFl5nACixpNPQMAxib6/EQMsmz/bek8aESMUtDcme4+kWkUIMSs6OVkwGHLxjHz3RCw8v7nl4ODLNM03g/nS2dp+N5XG14VVpJL780chv+pon/O1/euaTn77vSB9jzdXK/5e9f4mxdNvyu9DfGHPO71vvtSIid+596mlfA7JLQgLRqWohIcBC1aNEE4xMyypoUJJlIdHgIR6iQ4+eVR1EBwnRgA4UjdsAIxC3c3lc3wtcuQx1XnvvzIyMiLW+b845xm2MGXnK4IvtoupQ55ycUql2nsiIjFgR8Y05xvj/f38+3lbmXGhFqdcrWRMd4c1uw2M+8u79O7JXmhqbZOS8ZbvZUM148k7yTMoaD+wCKRV6UvZJOGw2iAhL3fB0e2ZtjuLMUqgIpS+0LEhbCepwpOZCi/gNMpSQcEtShIx6p4UFCyXCHdNA/WCGe2LSRDdFJXxcrsKcC1MuJIldWfOGtZBklyn+PdFEzo3kmeZGbR1JcK1GLgvzOjNloWXQxbDeaKtR28rqnVadpbV45KaFrEbpYDpT/UYWqA2sNlprrHXsntoSl5xsrJ0Ym7pBh05lbY02InRad1qTKAq8sg0Bj5+zPnSMyCBFCKAjSgWLKBYhFJs5zLw5Z7IORZ5MaImd4zS+nyqAK9UaayPGfF5pTakVWgtjeJGElOi007Rhs9uw3Rw4HbZc9ifO5wub44nt5cB2fwwqCD/ZXRR8LlJ/pEeksJm3nC8nltsLl+sLz6fKbdlzW1aW20prFWs9ZK+jO2kW7b9RI4SugUmlVWWRlZesaBW4NRI3biJMKW6WKSl9FjoF6Z1qhWYWpsu1hw8LsORkEokA28rLxLtu/I+S+cXLWz50uK1fM5txu14575wv5sJ3m/JoxjFvsf0zP/SGasNrmCdbVu7PR1SUl8cnWq18+37hsHekzHz7gx9yfnvii59/w9c/gKfnJ7o5y1Lp60d6b+zPe7RMXGtDHhu7Y2K33VGtsdxaIIUYLLxOEBrcqBY7gIiEUEQ6zQzXiU25USUx8UBb3+G9kdTAG9ZvuMxMhyO1Ks8fn/DZWOj05xqJyRZ7CE2K9Y6R6Bj/z68f+Wv/97/K+3dXrAeVAHFUCi01pq7kKbGRMcaxzlyUSQpf7YT1pvgK1hPdHS3K5rBB18bH2pi9kSm4BxV7n3JkU0nCkjBPYS5WcT5e14hZ94qOcERzxQbqRz2AqEUGtCJCqWIvookkRvNACMUOI0zmFUetB0suRaFSBNGESyGnTs6ZKeXwjiWFpmQ6dZuYuqFdKEWxVCJLLIWox5pRawtptYeB2HuMAb0vVA/RQL0tXG+N2m4hUlDI4ixWYGpoKkh3mnVaa1gzmoNrkDFS70gTTCzGbimmCm4jjn4NNR0enij7lHAVY9fonAWQkfM1GHyDKCIEtZ7EMOqGaTerkd0oJpBmVILAnlOJz3mMa7spvUVX2Hpn7R5je4/vY5ZBpNBgXc67icNxy/G0Z386cTweOB0y98dtGMw3CeUnIy/qb3U+F6k/shNu+MTEYb7wdLhxODaOF+d2a9xulZfbM0tdaWun2wvdhBwGEHqzgJAaGI22xq0UydyoZBFUg5qcUkd1zyQJzZHlgwtsoHqnNaWZ0/tCs4z1hWrgVjAPYKh7JVfh6/cfUHW+8/CW56+NHyw/4K2HhDrpxCbNPLeJl9Q4FaVtI2yu9cGjUacV5Xw5kJPy9P4967ry/LQwzYbOG55+7yP7hxP3Xz3A15mPH25Yq1RfeXzXWG4L+/OJUjKahJenldPdlsnAN3C9EbEnrWDeIUeQnqQOnoM8UGJ0It2QlEgWptJ5b+AXlmVheqkst8gDKpsJLXB7eeK6dqQZLd1wywSid8XJeO/hjcFRb9jV+PpaSZI4psRTtzAhayc1DzSU3LimiqA0F9Zrp7dHZnWWZR2heMG0O4pykIlrSRxKp9GwuPTjIkFsUB0YI6OSSBadm6uHQdkddR8U8RZ7rBFkmFTJpTCrU3V4sIZ6UL0jrePU4QmqBN4pg6Qw2xLoIpeRTJx7BAiWgk4hkNDe6BZRHtZDrYrErs7STCkrbpmujnfDmlOvFSsJH4R1Whog1cbaVq7txkt32hr7xISwqCBeoYVVQIiuw2xFLAzUPrKxRB1vK2YV8xB/uC8BlfKGt0zrDXqLUXvwiujWA8praZiywSXQWSKDz+eCDRBwGvgqJDEF/zdUe2qYRAJ0kuBvpqwxQvSE2ULzEOi02qlrp/WIhAkEFGQZZIkpRuGH6cBxv+V0PA5V35n9ac95Uyjy6ov6ye6i4HOR+qM/IsxT5nycWa9H/OmGH56oty0v1yO9NmxZ6C2BZxYTsEyXWzjqLbJ/jI51Z10b6hOLKEkaiUzWGL0kCSPmnCbyHEFr1Xb0/kxjwluDXuk9cDWt97GHEDyBsLBQ+PrDI7spc//25/n+9+EHL9/nQSskI8/G3leem5C2Z95uhrjVGs8reMvYEA5sjwdymXj/4RvW5xvLUsEXStrx7tuvOdwf+fLthaJXPj6+p9WV1Tr95UqtncvdgWl3wtz48O49mhKH7Z7doURScAPJnamE72VpMWrLJGhOc4AQVOR5gl4JOUGmSManAOS+3Iz9NiEUPj7fIm69x5I85Tk8bCPWokgGaSxmFPFwmQ76+SRKKkT4ojtNhLkkSs5MrphAHTTt21VY1KBViihLv5Ed1lp5d/1AyYltUV6sxHBTIBenzDMihlcNzl+D1p1b75gbUwprQPsUsBlFKI9Idc8pzLYIsyutd5o5izXE4WpG64p5G8BWIcuIhReBZtgYWaJKsqDRqQlqOdSBVnBWPgqk7mh38IaUwpQNk0RbJOwX0lmrR7ggHe+GJqN142Wt1Ar9Ft1MW2qIHAwyNVJ4VSMey+LzjTpi6CjMDFSUtXjgd4v/bxi1h9IzOs4lcp9eAb0mdKsYGbUA1Yp0RENVmTwHLYSZzG3EcDiKkTRwSFmMlEJQ4bKhpEaZEnMObJVY/P51hEqitYXuRsVpY7yoEGSQokzThmmk7W4Pe7anM6fDgfvzlsP9ltP9lsNpQ5n3Qyzx03F+er6SP5ZnoBylsNldON9XlvXIZXnmWhdua6UtlbpUavOY89cX6I2sTrUR9OahcKq+go1xTBK0xhI7LTv8NV8gj4fKJEFKNw2mmMeuy71jHiMRt0b1jDmBfCE6ExXhr3/7gU0R3n55z9e/t/C4fMvRjNVWNoNE/aIv5N3M3ZypHkMP9TXI0ePmPO0KWR/4ob1nvT5xvRp9WjimPY/fPHE4Nh6+ODNvlG++fg/LFTdjXRa+/bazrY39cc+UEq7K0+3K/jxz3B2om0q1K73Btji9p8DZiFLEwiuTEmJGszokxNC145Myy8QknekgnC5HksWt2iJOlY0XensBD5yNm9M1WGyJoDuIBvjXl0rLE8cycc2B3EkSS/OymckibFUoPUeAIw3ViWWtPFZDe0CRbmsU6rlk5jRxKonnLJBgv9myKZmXZeVZK6l3Mp21Gre6Yn3QDHBIxkL4qnRkHm3FKfqaXSVIkxAs9Bo0dVLI8vvY76Eh8S4RlU5zTCpdguKgOR7yLRm9zmFAxUNFqqEWTCkPhWEikZjUqOpoclJ1bs1pOL2tlFRJmskpR0z6atTbSxTSDtJbmIlbeMPEKyXNIA00+I1ZotOUFKgrtzHyDHoRJhm36HZpRiOAw/5Kp7fYeYpH3EYnFJsiFsVYYg8lI6ZZNf4d8SG/9/wpuDBSgUN6knCSTiRJIVlHh9Rc6X0J477FmHPtBBTYekB7k8ZOa9OZ9rA7zJz2Oy7HLffnI/vjkbvznvNhw2G7ATaMxdiP9Wn3R3U+F6kf09nqTNofWO86L8tHHvqNdYH1uXNrK+taWZeGlfK608VWiweqx57XXBBzGo2K8sKCSAFdUVWKZroSnDtN5KmwpdP6jh0pCOk1lHdmDW8Wv4jeKRaKLCnOsjS6C/8TH/kzb2fuv/xFHn/glOUDxRr7bWbWCavPfPzopHnDw1aYcuLrVNA18XE1au24NOY588X9ma8/CMvHJ9bW+Li8sN1MPF5XWn/kcD6Rc+b9D9/z/HKlWYs9VX/EeufwZk9G8ar4t8+IXymbzDxnltp4vhlgKIU8K+3WkZxiX4Xgw1djtSLao4BMGS2F0zRxOt/RHm8s9CDUq4wo8GDmdX+VIHeyxO1Xx1isGnh3zGso6kQgGw8l8wTsk5HLhlQyR1M6mdIrtQcCJ0CwShsPQjfh1jqSOlPZMCnkBHebHTnDra8Bi3VwmTFZAtCafOwyIbdMdwvcVo/4dXdFLOjmzWG1ldVqBHCahSxkeIZkfBx1p62NlAyn0EWAkOEHpmgmlcZNnlk9OgS3jmhmsxV6cppEtDpd6SEMj66lxc9gtcatt0+y7aRzyN9XY+0LvQveLNSWCkk7QiKniZTCv0YKq0EZxTD2ZcrqjdQzvXd6b6Ru1G5xUXMIvISCK6M8YQNPJmJkC9pL0hCvkGaERoqESJLGWFmHElJ7KG8VQzVGtGgaENmR/SWZ3hX1DrQQbJhGfll1egNv4a9KiRillkKZ9mx3R3anI7vzhePhwPa043TYc7fbcb+9Q+X0UzPmez2fi9SP4QS2TSll4niYOZ3esrzA4VbZ37bc2YF+vXFbbtSeUAtYLCmgmj72DzH/a7Q2bnQ+AKZUCgXVBVC2eSVLJunElDu7WTEKrRZ8W+mWqR7EaRsPXjxjVAoWcQlqPD13/t8/cP702zdcvvg5Pnzf2NUPPDcn60Kpxm298nK98mZ34LwV8sH5+iY0zePBnmkOZZ55OB95J/Dy8YWXZaW2xv6yZaXw/usfcr4cefvVG969f+Hp3bfcesOa8/Lxmbos7M87ps2MkXEt9JdGXxQpsUy2NXhqMxrjF2nIK4ncwi+Uk+JaxsLcA/+DkN250ui90ns8qBzIMjKWFGJstCJF40Yc/QiKUyWiTEwat6WRKvyva6OkjEriUkC6fEpTbRbZVlmUbp2siU3J8WC1GAEmlN4ivVlEgoDdQwGaOszagw03KaaFWWemCbRnXq6G3K7RMWsCESxlLCmdBfcJGJxEIaCpxA5LPKTpniLPSNQG7LSCdJASqNQkVGkIicYNtSCkG05JC55mcp5IpeNrx3KlykRbG7V2lrrwsjpeK9d1xdXIklC9Yhb0d1FB+xpRHUnJPo/dWngDk0Q8fZkSOQvSE1MSTAsinQ0CLXPrSl8iv7h6dMVCwwnyuRGyevHgIUoniPM6Ib2h1oMCIn1cBIRMWEZUCWWkxCUhUn0nVCOnzEe4ZLfw6XWrnxBY7p3FnFblE+2j9yhuqqBEcGSeC9O2cNjN3O1njqcTp/OF892B8/kLtocDmrdxaf0pKlDwuUj92E782OzZbZWHS+X5duS0PrO+XOnrwnK98dJWam1xzW1KTCQ84KlmA/uSwDprX0MWvDqqTtINpIZqJeUZITFPGVVjMynuCduseJupUzycn3sLF//In3IxVDLJCpIDWPvh4zP/n6z8PW/vOb79Ob7+fkeWR4oG1bm3lVaNd4NRdpgVCiyL04uxthSenBSAzXs9oyI8PQq9rVzfPSOHziZdePf1I8e7PQ9fbJmmt3z7zbfUdQVz6rXxsT0zHxq620aaL511dVIXJp2YD3vs1ni5rqjZ+DeVRuRHJTcoQkkn6vKIeouHTNrSeqc3AiNlFrMhVXoa3pZh4hSEZpCmTeQetU5PPXKFzPAWKbfuldYq3pWrv+B2RaYNU5qQ7izdcW8s/hr6Xik+BXfPE5MUCoWXdUFLYSoTa19ZLEyprI1bDoipA7tcuOwKD4cDtQn/a/oQylDNdFOsWwg0tJNlR0/Ea1QTqUesizMCG7sNQ290FtVsjMrioiRiMUatxPsVG/ifoSJMkRDsa6cqYUQvC35ThBdsvbIuL6xL5/qy0NcQDVT3EPAMPJDqxDRICY3I5S1JKHnCJZE8Em01l7AbqKNqiObhX4o4j1Uqk2R6D9jwJNAEugq9hlpTHLw3mrRQLqY8IL+xYwpyfexyXaYQphDNVZA4gp2Yc/yeIg0n01MhY5gY0htdhEylEZ06XWldWNtCb2FxCCxWIWlQ59OU2W42HDc7jvsdx/2By2nmfJo4748c9nvm3Q5JMz9tBQo+F6kf44lZ9qQbzocDX50rXE/crp3bGoq/l6XRbzF+W73HTdpCZi0WNy+x2CnRMtUMtzXUWfIeZTOiAF4QNebUSFKQXJgdKjuqKLvgkEZsvSmtdawveI0E0SoOHxXNiZqc9x9u/A/+gb/n4cTh7kt++LXwVXF8eWYmPCjeXni5CqoHdkX5hb3wvaeJD96Gfynxp/Ynvv/uCU0Xcp55/PCOulY+Pi7UzTuOhz0fn2+Uq3M875mmt3zzzQeW5yeahRTZPl7xpbHZVcpuQ07xGvl1ZV2NOU9sdwlWZZXYJ2BG0RyfZ3Jc35FySL6lxgjJlpAQp5Tg5p8M1aqCNMeTYBa+sn1xbvU5iPUefhlyxqyztI6aD1zQTDfnpVaua4dcKdOr8mos8HunekMs462ig+hwbT08bTJArhhlLmA91HC1k9pKTYB0Si7MU2Y/F25SSRKCgJJh8kRVjUW9SJDKbaXHNogBUMcG2LcjJAlAce9j+Pe6xyJoI2IVF6H1oJtjEQMSqkfDyWwauAUp5bquodYb48PrrXFdG8uysrQO1ekSqsBFgrE3J6gpxchbSkRyEMxBYex+xNCiqEdmlkvsppKP/Zg0VISiHZmVaQ1w7UJkt4kqvPrlULCEWbAo3QhJ/O/7uPG1ddIIMHQPZqARYiFGxy06dpbmmIGSMAkpu5HoJjTp9A7dnO597I01mH4IpQh5yuy3M7vDgeP5wPGy43i343jcsT+ER+ruMlFy/omlnP+tzuci9WM9YVCZyp7DuXN/XVnWldoXbsvCde20avQWoXzeDLpAT/EQ6RaAGw9FU7dGd0UWcF1GGFsmaewQbmxiL1Ag5yB0yxRgTW/G2htNjNsNuhfcOosJvVVcM1k6yZ1lcdoj/A+t83c9nHn48ivef/yI3p6Yc+IoEbh3awsvL4pPO6aSeLsX/JojWK5XPkjBJ0H7xOkcHp9vHz9SPz5zWwy3j2xPG6wV3n39kcv9ji+/84YP3254/PA+gg490nmXdaXcGps5sd8fMKCvC6bGxJacjM0xRjzrU4TEKfEwXi1Gpd2E3ZyYp0RfG4bQ1oZY+GB690EPAO82jJ2xPwBBm9JH2m2sojJJIsBxu1F++W7P//K0hKm0xvjzeqss3pjTiA3pCZMViqFS2Khwq52rwZwbKSm1G91WsPDwtCUW7N0d71eSC0/dyJoxu9J75+Ot0tunfD5kqMWkBXsQhFYJgy6Nbor4HCIQcTprGEFf9+8SAgB3QHrs90bR6l1IaeCaHIQUIpYUXp/Wpvi6k7E2o91WlnrlZV1Z1k6t8b3AnddtX3NFekdyg5IiQkSn2EuJkZIHYUI1Rt8aXUhPIfxYSWgzhBb/7YmqFXKMcDVtKG2lCdScqauSRyZbgIlt7CRzQHwJk/JrX+eSRqyK42JDWJFD9q9x+QtIbwtJ/UBI0Q2Xweej0T3jXcZonKCbi0JWZMqxk9wcOe737E4H7s4zD3cn7i577k9bTud7pmmLyO7H/jT7cZ3PRerHfELvNzFtdxzvT9zaI8/LlpfjgVZXar1xbTd2vdNqoXUj9QUbsdSt6uDEGSrhRK+tw20hORQKSSP5NVzvRmaDpswsGSkd325p3jEvseg3WL2xro428OyfIhs0l8i1WVY+9s7/LMavvLmH/R3fvHwkceWclGYL1Y22PNPMuXJglzZ8tang8LJWnj4+s3YNPp3AdjfxS9s33DZbvvfuPS/rwvrOOWw6ZTPxw6+vnPY77t/u2R0L777+lnpdqAPr069X6hrFpOw2YXRMhaWuwMz6jTHPzmY3Y00Cw9SHmssyKWW2+wObfeJ6faatnbauMTKyCUuG9opOoL1jSRGDeusgQiPjDhPOisdNP8U+4drg3ccnWoMsghRInrAKvRtPbYQmulLyxJQ6Uy5Ya1iP1GbI5BSvP72xLM7ahaWueB+A1QEn9tao6tRPwo6EZ8dpVAvOXEPpvZO7DAvCSu9xg4eoaO7xGvaeQ0adZRAR7FNshbmGaINOSgajS8huTLyG3odScmkg642pRpGr3unLwnVVlua0WqndBsxWQONhbyKYWrzmScj0eFhljeI05PGrhsdL8iv2KOI1Iu4ixnivhUG6I1rCkF06miGtgvYoXGsVtC6smiPJ2ksIKyS6Gx/jTiTiVV6D6juvXdeQqXeQlOheoxu36Da7DUtJaD/pXsPEP3xkYZD2SOQuiVIy2/3E5jBxPM7cnyYup3tO+zvuj3ccL+eYGvA65vvpG/XB3yG//U/8iT+BjNyb3/9/v/mbvwnA7XbjN3/zN3l4eOBwOPAbv/EbfP/73/8bPsbv/u7v8uu//uvsdjvevn3LX/yLf5HW2h/eV/QTcESUnc7sDyfOly+4P++5ezjy8HDifNlzOR7Y7w7s94ndZoeWHOY/SSQt+Mil6eJ0I259tbMujeflxsut8bQ2npcrzy8LfXG8BhYmbzLTJrHf7dltthw2GzbzTMkTKRd6kihenUi8bQu9L1AbtXU+Pr/wP33zLZKMy5tfZNE9j61TMQ7AQZy0viAvz9yWF1DhF45bHvY7NgmSharJJW6M213miy8vXL64o8wbrDvP14Wnjx/p0lker7z74Tfk2fjql7/ieP8FadpTSiGTsNZ5enrh47sP3J5eWOuC9YXl9sS6PPHhw5XnpwU3Zd7smTd7NJXorATW2xMffvCBpS7hl6HglmkG0hbwhuJscqaQUI27fuvg0kPk7YEayKakPGgXHb5+7rS2Ui3GYRklF5hnyClo9+YNMLJOdIxbJ9RlrdNrx9qC0kNK3XuYTbHBc6sRohhzLvpSWW4Vt8Zmp1xOJ46nE/OmkFLBzakVrjVyrWpzvELyiIrQLKQpJOCpFHKKCI6cFE1TQF2lAKA69nZD1q8WYg4G3BUJrFFfVl6ebzy/PPP8/Mz14wtPt8qy3FjaQvM6CA8d1x6ilteMRC2gU3R0OSEbJ6uSNFNkxnMhSQbZ0AzMWjAqq7NaZ22d1oxqie6AF1TjdymnKRKH58J2SsxFKTlIEDI8ZaqCpDRgvmOsKwnx7fhNVm7uI8lXaC50V7qHz6u1TmvO2ipL7SEWacraJCwnvWCV2HVaCWl7EkoKxNS83bLd7jmd9hwuB+6PZ07nA4fzhuP5yOF0IKcd/JSp+f635++ok/qv/+v/mt77pz//t//tf8s/8o/8I/wT/8Q/AcA//8//8/zH//F/zL//7//7nM9n/tl/9p/lH//H/3H+8//8Pwfioffrv/7rfPXVV/wX/8V/wXe/+13+qX/qn6KUwr/+r//rf4hf1h/3I4gUtiVjpzXSeluC1ni6vrCuK9bqkM3C2jeYhew4W8NJdFrIZj0eXmFTra9q2sic0RmhIvKCU5h1Q06FVhIbDPU9fSi5xMdMfWk0W+meYlvtRtKEq6FtYSHzA3vhxeBP3t9xfvvLPH/z19H1PSl1ijuHZEz2TF0raz6QysxXW2GbZn7PVx6XERI3xLrixn6fET/x4cPHkOIvhvUbOiukif7dj2yPjcsXJ3aHmcfHR27PL7Rb0NirGb3eWOvK7rhlN+2imLuzXp16s8g62iWmzZ55Z0iHZWnUtpA9lFumkYxcLEOaosDUTh7y4dQtlJcS+4ZgLIbKrktEtWcTyMLkcK1O6g6lMWthaULSwnaaMWssreIOrWdqb2HKZXzcbtzWjkoaHMcewnBzzDImGkQN1jBlt8TzyxPdJw5sOWw6kxQei9LSSsNYu1PbGt0kr99fIWse8NIYLXcJBZz3HqNAiG4EQ+jghSSR0KwkinRIitmKWUGqcxOlSEMHfNaR8Dg5kcP0+rugeXi7Au8kmiALST0uZuMykE2jOKoOZV4al4QONUZs1jwUq32lWRpwoxVLkSOVjRBFkBGfWcVI2TCT8FylRLErzfIYDy/gCe0++qZB8LCBR3LHNeT9va2x7E2RAyZj4iFAhTGqDyqHj0iOEFlojEqTonkiTzPTtrDbbjmettwfz5yPe07HLZfTPfenM8fDhk3eIrJ5dWP+1J6/oyL1xRdf/A1//jf/zX+TP/Wn/hT/4D/4D/Lhwwf+8l/+y/x7/96/xz/0D/1DAPz2b/82f+bP/Bn+y//yv+RXf/VX+U/+k/+E//6//+/5nd/5Hb788kv+vr/v7+Nf/Vf/Vf7SX/pL/Ev/0r/ENE1/eF/ZT8BRhO184O4ET7fKeX3mtpywteFLZWnGrTtzW0JK3BPJO70p5gVsGQ8boZlgvaNVQZd4/IuQRscAQk59yNKnEchmbG1Ij7WE1Brheb0O9lmjdyHXMBeXFpEE1eCDP/M/m/DLdyf2l6/4wTfObv3ASSqiwtYN8Ru+QkW5anQZP3+YURY+LM5qcFsrVwfI7LYwTXc8Pd34+HRlbSvrzZj7jd1ceHl65lqNu+OeL794y/PumXffvGe5PdFbxw0WE9alcdtUNrsd85yG8bLRqtIfGyU3pu2G3byh1iXMkxqR6okeXh4LtaNLcOiaWnRTSVBaYKZc6drpa2BxenJUYhzrHa4WxdPd2AAvPfKLTJ1tNtynWJp3wzQEKLmF8ZaU4/tawzBbhzRcM6F48UyzoExkQK2TvdMtutpq4S1SEi/1xnWt1F6pPVKK1SO8MiUha6Io9ASOogmERtUQg9Qh134dfSkdEQ8FmxS6Q7NA/LgBXlERTDJ9xN3Hc7iNkSFjCtNIkpEc6tMkMmLuFc9hYM3Z0Bx4KxveJ/dItZXWQ9TQI6up4iTrmE3QV8TWT4KGShrZUU62SBGObi1ymkwFp+NSI73ShEyiyxRTSAlvVYjYJS52NqJM3MN3OOTsbgkn7CDmFiglM/BC1xiZjmQzILKmSI6niJQvm8zxsOV02nE+bTheZi7nA4f7B86nHafjke3+hMo8CtTnIvU3Peu68u/+u/8uv/Vbv4WI8N/8N/8NtVb+4X/4H/70d/70n/7T/NIv/RJ/5a/8FX71V3+Vv/JX/gp/79/79/Lll19++jt/9s/+Wf7CX/gL/Hf/3X/H3//3//1/039rWRaWZfn058fHxz/op/3H6AwzYNqwPXQu6wnrK3VV1jVu0LUJdU0h0a0eT9JBP8iEaKL3sQMIxyk17PDxAMhXhB3iCyqZqxYKK9MUo8NpTuwtFFNqH8FnRGJevvpKbWuMmazF3D0lUjdUGsUbH1F+151f+uLIF9/5BZ6/LVxffsA2Hg1sUG5rY2mP3NIGcuGYCj+3K5QkvK/G8y18ISoNL8KUJy5ZmeeZp8dHrtfryN96Yred2JaVb77f2e6fOV3O7Ddf8f7DC+8+vKMtL0OVpdxeXqjLyksubI+Fab9DBufuWhvVPrIuC9SOSB7y8mDoIR4sQIzUFVWCnp2MbXKSKtcO0mIfRvJgtCHgGZfYKd3CqoubcfVOFsMEmguewl/V1aEb1zaCFX0QCSQegpXwsZm14c9RVDOShdKJpTs9ojmsx+OqCXW9ctXgLa69Ys1xj4tM7+EOV3XccxhbLSj8q6yIhZLN7RbKSWKsZxIUhsyrgiB+XvCILhFJY3Q14K7io0M3oKN5oqgiyck5k3wmJYkwQFUcG3vFFGMvJUy5OCkriYR9Gm1FFIYRGCh3wjOmYaT1iCseUF2JZAFzehakeqRXa8d9Gp3d+P6jCBNZJOToAlgaY74B5uvRA64SF83moeCToeD1YW2oHmnEmShkXerIn4KUGq6bcSkwkhRyUeZpy26/Ybc/cN7vubvsuRwuXO7ecjldON4fOBx2FN3BTxH66P/o/IG/yv/wP/wPef/+Pf/0P/1PA/C9732PaZq4XC5/w9/78ssv+d73vvfp7/z+AvX69te3/f87/8a/8W/wL//L//If9FP9Y30E2KQt5/OR3q7U20Jdj9TV8bVxq522HrHWB5dsQ/NbPAy9gRttLGRNwNcV98C0XM3B1xih3AqkxE4b4jN5KuRU2E05DK+7kNqqC+4Wv+i+0rvTa49xnyeQOvBHitszH/rC/9wXvnN/4ou7n+OWZ54fv8vkN9QbM8K2r/ygNW7twMdJKSLcbWFKwrcuPC+Jaop4HWDPzPEwMW9n3n/7npenZ3qD5+vC0iqHaealFpbf+yG788z5/sju8CUfvn3k+fljULA9oueXurDUTHm6sdlu2ezmkId7wWqIAfBOUuja4rUL7OpQ90VXEg950NmZk3DWzKp1dBENCcZAjFfVEC2USP2KgMHXh1YPU/GzNFTWGLOhaIuxVRvBeuKC+CC+v4Zg6ni4SmXSQhe4SYwnXUKQInTUFaudRYWk8fMhjB2Y9eF/0hHmF/8eOOKd9bVYeJAvzEN0kbxjo0sECNijQw/fVMeQPsIww7qKWKIZkAzViKvI00TOkamUhvVoToKr0piZVeiiJDEyiiTF3EcWlRBihYSbsuIDuWTBuus19kEuUTCbh0EXBmhXqGSgYr0h2mNsbkqzSl/7GMMRAZKSY3ROCEo0tSjaooiH1SBGpmPsbjGONdHRb2lEd0DgtDxT3KJrQnACA5XIlCzkKbHbF/bbmeP+wP58Zn88crk/cz7suTvtOW8PlDIjf2dygp/o8wcuUn/5L/9l/rF/7B/j537u5/4wP5+/6fkX/oV/gd/6rd/69OfHx0d+8Rd/8Y/83/3xnOh8DtOBflnw3mk9RAq1HnhpPTBGfcGs89IXpj5m7R5+EWvEL48b5jJ2F+uQE7+OAq6oO8X3iFVUYdLIE9pIoGVcSnRNPsUC3Du3tdEWolhxw6RQvCCWYpa/OM+s/C/2SD3DL97d8ZgStw/fY9OvNDNygpM06vUja1uxaYt4Ypcd3U3M0nlcOrcumCYYD5SscLnbMeXM08dnlmWlrY3Hasy1stnseXm+sTxf2R6PfPmdE3U58O23j3x8fsGxIbeHpS/0tdJqoUwzZX+KkdOQE9ugJYg4iTRAb7BaQGtj5+QsFYqEeGUzhT/mw01HKm3IyHelcLXBfyMeYEka5mkAg8NP1F2p0lDpZHJQ7RGaWOxsfPiXPApK7+FBWk3wFIBVd8dECMzr6Hi8xc3fnE4bwoT2CfzrFqIPd2juJB1KtdFSGC0KgOUhr44uTL2PYiIR8TLGw8Bg0cVr4D5yyiCiK8pEKYVpCuJ+yYWpFJJAH1L8hDNJiNqLKEkKkSQcFBEjxnrmMXY0YrToDtYar4R5M8dswdEYz7XxtWMkT6jFiDAKesLlFnvLJuGb60Q3LlFGIKYSGWFlXBxc42cGBtgWhPi4nVCummfEx+Xl1TsFdI29m4pEnEdK5JLI25ndPnM47bg7HbmcdtxdLpwvZ+5ORx7OB86HPXPZIGxj9/Uzcv5AReqv/bW/xu/8zu/wH/wH/8Gn/+2rr75iXVfev3//N3RT3//+9/nqq68+/Z3/6r/6r/6Gj/Wq/nv9O3+zM88z8zz/QT7Vn4gjCEmU4+ZIPzntButaeWkrL1WxKvQKtfXYE7kHSNWg9xsR7214X/HuuDZ6M1YHVHHpwA3bOH6DrewD1ZIqRSckZxRlY8Owqg6aMO3YyJsKpVnQo1frdO9MKCl36tKwXvmuhTH1775/YJkOPH3715mvH3AxJnG+yJWPtfJiDaY9txJBeG92wpyVb66VpQdVow81R1LY7Cd0mnh5euL6fKNb42WttPaOab/lvNtwe37k45NyPB5483N3HJ+PvHt8CSHBsmImNAx/7rTbwpyfmTd74iEkgXDzGPW5JpLnkFtbMOOaLCATaxeeqnCcY5ewV8dy5rF6FFcByYIsYQiNMEahmow9V45hlcUyxQaXscsaYzxJUZQCmjNGSI02/E6QMDNubjF+co+Cyo3uU3QW4rjUCOVrQTYQ73iP4hGi3oDo6uhO3EO80O1HD1MZEREuGU1RmpwhGnld14+fxVBr2vjcibuXQE6ZnCc2c1Azcs6UnCiaKQk8tShGPo3HuIccWxShAA2V8KaZRL4VNnBeLTiAZgMm7BFeKBZwV5rTLD6+DbZiUsN8FApaUB/MI17Fx07OI2JEUkdwWrxCY/QZhlm3irzum8blwD1+lsLzFFT0eE2CxCESP0uIfMI5pSTkOTFtC5vdkd3uxHw+cj7vuVy2nO93nB92nO5iDChpPzxrn4vU/+H57d/+bd6+fcuv//qvf/rf/oF/4B+glMJ/9p/9Z/zGb/wGAH/1r/5Vfvd3f5df+7VfA+DXfu3X+Nf+tX+NH/zgB7x9+xaA//Q//U85nU78yq/8yv/Zr+Un+giZIjsuB8NrZ7Fn1lapq8JaqW2NHCh/dQs+jziB0VF5oUnD1cCEJmP5vQoqK6ob9IOguzDeiu8wd3bblVS2bJOQtlPsRABhxa0CgnjiJle8xlhFfUUaVDYj8bTHXfXmfPe9c+vC/+3hzPHtL/H87e+Rbt9+Cts7T87eF94vlVozMu25lcx5CBw+3iofV/Cun/YNKEzJKYcdcyl8fHnBbkHuvj7fsNr4YrfBsvH47omnDy+cT1u+850Lt2XHx28Xnh8/BG3aAhZrPW7Krx4h9RQhgEQH1SUe5Sng35hnzIIsvlqQEY6TcyzKaRJmEd61EFw83YaQQYw1xYNVuqApU8TJZK61xrI9PLCYx3ix60r2DHRcHJXMgwvfCESKEqh6dBe+IowOZ4y9ugtoR20o9DzykV4v3kKw+JCxa3pdvY+HaTzEY5eDRFFLEkBXiaREGIwFAboEue+TV2gw/cjCBOR5GFKniVISmzmYkhGvrhgTmoYXyYg0aZHBK1xG8ZAhPqgkYB07IGyNceLoFr1FkWs9xC1R5EdgZXGoYSYWB/M+CBXgrrQ+OmZGftTwwPFJLMGni0xywzSKUvc29peZUP4NX4/I37Ark3EZElVyEjSlIL5vJubNxH5z4HQ8cDpveDgfuLs/8vbuyOl05O5w5njck3T7UweP/ds5f8dFysz47d/+bf7cn/tz5Pyjdz+fz/wz/8w/w2/91m9xf3/P6XTin/vn/jl+7dd+jV/91V8F4B/9R/9RfuVXfoV/8p/8J/m3/q1/i+9973v8i//iv8hv/uZv/lR3Sn/bR4SiO04nZ5EX6mpY61CvLM3Cc+PGB2ygW26YG51Oa51kGXSojIzYpfQKt1jmi66fHg4vpLFkLswkNkmYNGE5Y5sdiiE2g2e6rSHN9o6vDXcbD+5l0LUzyaFbxXvi6/6Rda384psz91/9Eu3Djvbxh/j6PHYN8EaFb+vK09LQ7YmnUtilznafyOo8LnBrOdRWgGbHU2FXJqapsCw3Xl4a1p5Ybp3fvT2TZ+Htz++5vThfv3tkd7tyOG74zi/cc7sdeHz/kY8fn2htjZtuk3F3z6D+yWjpvUPOcct+Tag1jUe6RTZTdeOxx0jrtBGOm4Q14XlpXOstPo4mko1gQYL/14nARjQejhkwr4hEMq4M0Un3jNBBncfBDgQLOTqxV1L3eP3FR6x5jYrnEVGh+rrHiQdqcAGjyHQxlEzXCOfsouNtATa1YZYNCKr8qLsZ6COS4t0RVszHc2DsxZImUhZKzuScmafEXBJpymhOQXpPGgBXGxaIBOROaxPigR8SZfAXjdYEk4T3WzAjBytRxr6t9x74IQd6p7nAQBjZp7iOTmoxgrVXQcggn/vruFRl9K+xC3QRkoUQQ9QZfA7ccuwLCQGMj6ga8YjXMf+R7i6JRjeqEt/jJKQCU5rYzDPb44Hz8cj96cjlbs/9+cjpeOJyPHE57Tmf9hQ9gUz8rBUo+AMUqd/5nd/hd3/3d/nzf/7P/+/e9m//2/82qspv/MZvsCwLf/bP/ln+nX/n3/n09pQS/9F/9B/xF/7CX+DXfu3X2O/3/Lk/9+f4V/6Vf+X/3FfxU3IEwSUxlR3n7RnZG7501iUkvnjDzajdR3xBo/tMpNG02Au0MBRK6XiBfhujnkURrmBb4GWYGyF3RwGdNuSs5FmYkiDswnGfnscDq5GscHVYWw/Jd6ssrkzukS6qSrIF75UPdWG1lX5/4Rcvb7mWLR/f/x67+kyyTlHhMkFfjOeXJyzPMBdOU+Zh40zF+ObmvKyJqUNVGYw5J02ZXTpQppXluuH5dsXWSl0aP/zdZ7IqmylhvuHdt898fP/Edr/n/ObA+c2el48Vb7fABEmQqeOB5qgpTQSxSlJBew7/mEfhRwv4itvgr13B3HiznTgUSIQ6rXZn7Y66gOXR+URXFlsdicW8r0HEltgBRuBeqANdJDo9i71UCBciciIKR6gSsRBIfBItSKjU+mgM8bjlRx163S8lTGp8fYPlKMXwHkVOk+GSUBLq0aE50VkZFe0Sfi72oA19lZlrHvtOgwIpCVN2Uh4JtTGgA4usrU6odiNOJHKiVA0dfD6sIcRYzFq8b7dAhDWzULxKFJRQGSaaN+jxbzXxEEHUNPBDOor8mEiMkuQSZd77q1+OUPVhNFKMhAdw1s1xKj7GeN11GJsziI9LieLkyJvS2K++WkFUJcae24l5v+O4nzmdjxwv95wvR+7vd9yfDlwuDxzPB/J0RPjphMf+7Rzx1yS4n6Dz+PjI+Xzmw4cPnE6n/6s/nT/kE9+O7iuPT9/yw3fv+eH3vuaH37zj+9//hq+/fscPv/mWb779lud3Lzw9f+R2W1mWSqsrvXV6a/GL7MELU4JCnnMJh/1m5rjN7OYdh8OO3ZyZtjvmKZFTxincqrFW51Zf+Pj0zPVl4Xq9cl1uvNxW6rKGmslbEACyIqqRfZMTRRNpSkybDd+52/Gd+3uSGcvX3yPd3pP9RhaldmExozZ4LhO70x23xTFdmazw9eI81xtrc6ynQetO+IhVxxK1d9brC8stpPq9x9hzk5Vpt6XohHmknm7nPcfznnkuXJ8rtTVCgGWoa6SxipCcwNyQcBfyGJGBD8I2qCckCynDMWVOuwi7667czFlbplpjrU6rjNygRrikU8idveKz4kuYZ1+NvCG6eH2wyxDGOFBj7CSvXeCrei3gsa/9gY09p7vTLJElPn+TsKTG1xAaMZHBKJw8aPFWokBodIDKMMqOUWGAUzskggienESJjzeytHIiKBV5ohQll3hQIzlk62P85aOoZgmpeko5ghlzfA/ojlhjbU6tK7VBrZ211/hZNwt6vUVxs96o7khP5BFg6N5QV9aREwWvHVbGZQR+CmMMHqZmRh/k4/Iiw1ANNS4yziCNWOygGHswRsijgEsjSwopPIokSCUzZWG33bI/7NmdzhwvZ37u7p6HuxOnhzu+/OLEw/09l/t7LscTqq+Ei5+uIvW3+xz/2RDa/0Sd10dP4bg/A0pf1zB92lA2meFeEYN1zN7jFj5u/RS89uigXONtHpotlRQ3ebEY8bwE9XnyJW6Cs6LFmTYaEM8cNLYkmaSvv7ixeG+LU7viDZyKpoSNpW4XyNax1vjr7YXHpfJL9w988fbn+Piu0J5/iLfICdokZaNOodLff58XL2jZY8m5n5VNKby/dm4C1oTVIWlmTsLSnO2snI47nj4WrrfK7amy9JWXtbO2Z5I+Me1mdlNhXRM/+P5HpuzkUihzGruU0a14YHeUHg+lES5UPcZUgsTiPcXeTw1owrVHpPxhLuw2yuYAuxdhceFRgkohPQQZbdy0GR1oCDGHl2goMl87GPcRkfH7uiLXID1ID7ApEv4pMY+xlVgIMHBEMlkbMnZJ6uD0ESCYYkc1AK3ag/agKqA+PD/K6xxNGCM0SXiOsWDWEmbicUl5jcooEgbZ6EAb6zLRklNouMb4VkXi4a2BREqqFHcKNijjMRZs3kcUSEjOXwnlRoeesFZDmNhjVDvuElQXkBjVdgJBJUMc4SSMPiTs4eYWHSR1A1AibiO6LXyoMkVpYyfn4wdHPYE6ljyk+n0UbU1jtymQCRZiKUybEEnsD9uxg9pzudtzeDhyeThwujtzOp857veobH7fc+Fn83wuUn8sTzARExuOe6e+eUPXglOp1VldhkQ9Fr7PFs8R/EpCqbaC11jE90C2mBipO11WVjow415Rf8JtwszJbHFrFBO2JZOmESqnivoydho6sqQaV0n0W6ZTwcZoajxQTDTGIDj96rzrTyxL4/ly5KvLPW2zo737Hm15jq5ElCPO4rCtC08vxlJ21Glin5X9Dt5V5+WWee6DNCAJ7cFJ6+qkkjmkic20cl0T1+eV1mK5Xl+Muq48/MLE9KHzzRIk+Mu0hZF4/Dpus3B2goWnBokHY9VEljrMvpFZFOOneCCnrsgqdIxdN3YlM+sMGkirxSM63S1sB50QbdAZhYbQs3moyfy1c/O4xSeiIAXwVYa5N8VrPvYqaOxEomvR4bmKXZFrMABFSsSRa6f7FGw+DewTKUfQ5qCRu1rYHSSj7kAU8DRM4ykFnEhzCDpcIvzPPH4oPQUKSaUGlYIFLQlapM4eU+E2uljxRFIn52A8xoUr9lYJY/WCaY8u0oRmKRSTBD3cW5T/MBHHOK+74tZinmAjlcp8jLCDDWWeo5gB6RV3BNHRimMavkAjjOzQwTWk/xIiiiCNQETK96CVaEHEY6pQUnRR2w373czusGd/PnJ3OXJ/uXC5P3P/cOb+YcfD3T64fPoqNf/ZLVDwuUj9sT4iSmLL6bhQW6WvD9TmWAWuNToAazBSZjEbv5whphDaWK4P9RjQW4TPd48HiXiKGbvnMRqCnXdS35F2sQSfNMOu42kHCJ6MrRvOAr6yLGNH5Ua1JeInckQ5uJWgVttKb43/cbnxzfMLv/Rw5vjml6mPP2S9vqNYI1ksyr9UmGvn29sjrSee5h3beeaLDVxL4v0183Ft9EDD0z3RA0eHpk7WDYeS2UxbXq4L67JS1wCOfv//+57XpN3dlGm3BCMszjWKZWCHBrrGjDTPZDprj84n06Or0RLdqhi9hyl3Ac4psVhCuvIwGSYTfQ6KtrPiTaidsYsasmpAE1iwifAhfcdjF1I0FIfhWSIeqsonGbrKCDgkRAfqIFrIOpA9KZR84c8JQYBJGKuL+giHTGSJRFqPH0Baz4h6PIA1gXlkOOVEyrGTyUnQPAze2BgxR7CgWdAXnEqSjqtQ6h5JMXZ8kiBL6KBCiKYIIZQxgmsx5uyuiEPqKxER2WjNoHkIdjxH9lZnvM4Ztxj1efdP8vZXNBIyRqivA1MZIhSIUZ2/ysejc3U1ZG0/Aui60JFQfEh4slR8jDJLoLjEokPNMUaf8sRmPrDfbznvL1xOR+6OJ873ey53R+4v9zycdhyOR2ad+GkHx/7tns9F6o/5ERFmPXG3F7olFlOWOiSxuRPqJMX5OggUVEw2FE+ILHSpkWr62im405og1oYyKiLLuzlNtiCQZBsR2EuM1FLOlKLMQGKH5WF81RRYG3VuVajriveBapJGsoSlGoXDldYTqVa+qZ2lrvyJ+xN3b38RfTpxe/cDrD2hbiTgPgubGb5Znaf2RG1OnSZ2Cvdb2Cflm5tRxWjq6KuxsyueKmCkSTmWmdYyy7WyXm8sNfw0Zs7H3rkunZwz2+3EYTPjOepPyJ4bkoXp/JbSH1k/PA2waIqIjXTDNAjo5g0j06txnTrVBPrCOmXOBSaABEIhEemz+zLx7a1Re+WVCvy6o/Eh+3Yc/aQ4i5gRJEZwr5SJpnEREW3h4pEUl4/AIYRoD8dNx0N0mEkdUpF4ziajWCjRegqvkdHJOcaB2UPxp9nRNIdSTRVNTk7hscopRqG9G7234O0Rgg4h45oxq7hXqjtmSvGG5ih+KcVOST3RmEKt6ArmqFWs108Jyj3WQIDgPcI6Vzey5dE1xmiPULeHSX74z8LZ1H+EbRrGYFSi0NgQsowiRo0C75YRGu4p6Czj+6SEco8yBWZLHVJHtaA6k0tmmmfm/ZbDecf5uOPu7oGH+y2XhyP393e8uXzBm/OF437LnLaIjOiSz+dzkfpJOCKJzWbPQ1Lcb6gdYqlsHe2FThk3xYLyiPACrmjNVJcgU6ujXaPr6krtjvmKj7iGgGKuFFeUcN9vHMjOrJmSJrZimHY0C5kRPJdjnyFLeEXWGg+S7E7D0O5Yb3jKEcOeM+aV3pT/1+1b3i43/sTDVxy//EU+fPyG/PweqTcEOEwwFefW4H1duK4L67SFBLssfOeQeVw7TzVFcB7LEBQL/dXvqMqUCqlsmLZbNmulLS9cRyfWmtN9xTSxtmvs7CRRciVPBUdZP/weKxk0o9JDei1Qe+xBUo69kRq06vzwCQrONTcWg+PsfFGcX9jCh1L4dnFuVwOxyG5KwZejvwoqfBg2GyIpgK/d6R5eKfxVaZ7BbURIvI4ClRCyd9RTCNhw3Eq8zyiCIoakFIVGwgMlQzwQdTAxjc4yRBqhokuSoShZHElKztGNRXfq5CY0CZFEoIIkuiJrQxAyaP0mkEKIoRKfq7nglpBsKAsmykpHeqV1aE0Cxrs61gypLfa0gFkoKQPR1KPQjADHuCIsAZMddoIgkA+AsCkmHbE28EVO8gwo7pGHZgKRIRKvafKGkXDP43tlUG+hbkw5/FBaSGVimmc2hz2H48zxvONyPvPwMPP24YHL5cz93ZnL/Y7D3YY5n4fn6vN5PZ9fjT/2J25TIhPbrDyc7mLP0EEtZvlNYuTnreG2oGZ4H4gbcyZXqlmE50n8wpkR0dW3Rm2GTOC2CROkVWwIMmyKX8LNVJiU+DMdmTexq0pOFh+ZOytJCCVejS4vOGwxShSxYWCNwtWb8N218/TUeftw4E/cveV5e2T99ofI8kjBKQpp7qRUeV6Ub5YrhvC4iV3ZdnJOxXi/wMuaaRYPNHGhaXyx0Z90pmzMU8a3Zza9Y0vl5bbiKbMvE9eXJ17aDZVwzeS5M88SGKXpdY80lFwGqwhZnG4dlU6TCCDs3nGFgvBklY9L53/xyl1xfuE483Nz4bsVHq+V1FempDF+1fAMNXOyE50ShvTxmiOYNoQcSkQclc7g/CCeB0FwQIdFcTN0KPNMXw1JglJISUfn9SMvl5mDhiFXNR6Xpjr8WyBJA2GUQl6eUyE7kYFhIaowkYDdvhp2fXi3ukfa7XjId094fyVUOMkE8R7UBhz1OSLXm9HXTuvGbWm0GkRyc/sUcmgSkvOBIRzFODpi84qiIYLxoMzLUPnJ2P+FJU5i1+htoJ3CE6gMWb7XSMX20cUCr2IXcUdzIWmo+LQEVWM7Z+bdht1hE+O9857T3ZG7hwOXy4a3lx2n+x2X855N3n/uoP4m53OR+gk58Yuc2G1OvLn0YKQJuM7cJHxU3W+4GsZEJyMvVyBiqmmFNbW4qRIUAcxpPdhifW24LHE7l05LQxDQpiho1gNroxHKxjYhc8SGPydFVckpJNOssY9oNQzAnVBfJQ0oZ2sTXZXsBn3B1sbL9cqHy8LffXdk/upPYo9fU1++xttC6sIsMM9GMed9FW7XyiKdXjJTUe42wmFSnqtzXZxri4A8zMYOJxRxiKNlIrnRpsK83USUw+2GlIndpJHS2zvtduO2wLTt3JcpBBaAq9BFyCIDnx1RKe4jmpxIwcUi/iK5czPlB8szX7+s7POMY3ysBtWYysR2Cr+SIdRqeDc6BC1hUBBEgoCPj7AH74jmITEMhdlYVAERihmFzelEMcsS9AnNmSmnMO4SHYr3laRliHY0DN2SSQyxggSdPcIQhUkM1UpJGcnQm9JUyN3QDqYpimUPskfzEBjgjidBDApGdRnmZMUTvPSYDcTXHt3qUmOcV3tEu9e+op3oZDzGgsZrkIbgPQjkxuBjaACZO4yRacjq1YyeIr6jpd+XtuuAJxJhQ4iYkOBhCoTaEEI8IoJLiZwrzZ8K/LSZmXYbtqeZ82nH5XLk4XLk9PAQY767By6nPXfHA9N0BtnwuUD978/nIvUTdERipLfbXLD7TOuF2t9j6xFpDbE1VFImJAz1HgZgDjEmfB2/tEDluCSSR9dTtQMV8wm3KczCW8Ft3DM1DJ277GgR5qKoJ3LfkpGgZmtC/YZ64caNq9yozbC2fiIjJIv9R25O7+Cp0ayzfAwz7uPTje/cv/Dzlz3z/k9xff8D9OUDiYViiUPqnLPwvHae+pWnmnixDdeeKdI4FOFuyrxU4111alVEIfuG1lcMYZ+VX3j7lr/6zUJ7eockY7u9Z7e8IKI8TxO1riy3K6vFFE5yIXkKEYoFbFZHdHuzCM0LGkOYTXkFs1oJ71NfSZpZG3xTDayCO2ttLNbIecOcJlSc/ZxopjR3lm5Uc7SP6SVKt9gtqrz6cYZ6MykWDmXwjHoN4cXre5YUO7EkQd3W6AulyzAMD2JDmBrwwYQMH1awCEdOPPgUHiqN3Uwy6JJHIU3Bf2SENPrwYo09V+RBdUQLbaj3KiAenL6OszKB1TA/jxiTTotE2xoEjWo+sE/EHs87yDCWy2ut7tEdaQ9eovyIHIKDDeKGiSIt5PvAJ9KJf+qeQyQRwv6CS1Dhk0THqlLIElH3pUxMk7I77NkddlzOW+7uz9xdDtzfH3nzcObN6cDdZcfhdKHMZ+A1G+rz+d+ez0XqJ+wEqWDiMB/pbyqaViYOcVPWFSmCE7DOeKYolm6gkV7aWotfytpHANtQi7nQavifHAdvmC+oM8YZO9gkdDYmmUklBa16u+J5RhRSmniWRM4r2hS9Zm7XK5VMH/Db5o62FUuJnBNeezDzVHCr1PrIbVl593zlO/cn3j58h747c3v6hvX5KYzJ1pmnxE6UY4XHvvKhOk2VD8BOjO2c2M/GSy081kZv8TC0AUT9k5cNvrvjr/6P76ArvS4hNdfE7jJhTdnWxLqGTDlgohoLcwIv1DzSVPGQYQ/RV4zQvNOYSRmWtfF0W2LbJBBpxCF7X81RjMdrZdeNfZnQnEnFyKJMVqjNWXsPFFWTMBBblBLxhsiMWI8uSzNuS/QTonQLKrl40CQ0GzlJKPOGRL1Lp4vT08AakYPOPcgY9kq+AJSOe8KS0SSRrIAS4+ShPBTxSPOVFh1ND16imGLa0GFP0P4qYegogjbGsDLSdSE8gakzouH5lN3ULboeGUbaZkRX81qdHFwDiOv++jHj76ZBoX/FEIpFJ2raowj5MFpjYWi24ZVCMCnB7pMSez1NY7fmQXPfFKai7Hcbdsctx9Oeh/sz9/d3fHG5cL67cHd35nK553zes5nv0M8jvv/D87lI/YQepXDenNBLpJZ2d0QbnYSMIDy8j52DgHWSwc0EFFrSyKCykK6beNDVa8fshnjhNa/KehtR9o1qMzsztnjczEtiRx7jnzZ4awmtiYyTEtxuiXoTeltDQv+6n1pjya6AJo/QRlV6e+aHS+Xj0wvfP77n5x++4ssvfoEP+2fkw9e028fwvgzczJukHH3htgofm9A087QKJStTcX5+yrxfO9//WKF3vDr/j7/2XXxfmFWoFmq8YMN1tDckwVRmphxKr1kCOGo4zQnZN6GQi+gGPhUhc0N1Rt1p18qtLtS6slrEOITcbHjbVEmS6KZ8vDbW1dHS2JTgKaYycdw4y6osVqjSMMskjIohZMSNpvAqZ9PRkXmPfKS1e+ws6cPIPVOK4qWQioQI4ZO0XJg0EnslhYzbRueGdXpW8iqB3GKQ74a9ISC5lWpB6G+t473RRzF0qQGxxSNGJPDvYdbVhDQbqKUOFn67LlC70SWSqSMPo/5IJm4Mn9ig2WOIpbGmU7QHwsicIQCJxawPMYR84h+GraCLxUhYQyFJl2FiDw1tAGljfyce272kiakktAibTWazm9nvT5zPJ95cTly+OPDF3ZH78xve3J+5vNlzOG3Z5D36WWb+tzyfi9RP5Bl7Bd9y2grlPgzx1hmPrYj8VoA0Rh/WWTzjsoQMWRxpjrlQU5AfzG2IsBqLQPOCE5HniysHF7YjDlzd2LSCTjMpK14mRDKHJEguTLcccva0kEW4pcRtTdhS6WaRVOqN5iF7zhamyOKJ2uLm3VrmunSen/9Xvnve8yfvLuSvfh55esEef8Dan8kWkvVNEvJk7HEWbzxZp7fEVSauObOZM78se374+MJaGy+Pz/SXUCRuciZLZAh1SzST1zALSJBVyZKDlD2mafG0egUcBWEjJZjKhrosMTayztIWWo9AvACyho8nugFHc2LvCVkqH9vKmqDME8121AKZytaDRJ9xkBwZSxLBhGYpiBTpNYYjR6dEjArNnNZvA9Aa3c++ZNAZSTlSdnPs0ZzwxWUdfikie8rGx8l0vAqrOtadokFcWEcXSa2YGdUaZspaZfjHIo6dpqA9RBwG0QuGgrLSSV2Hzws6cakybcHlI8as3nv8hEtFMJoIyTREEsCrB07GLcDH9xUfIpRX8Kwk1BKiLYahA8rr4UoOqrpHR9bdB8IpD4SUgyY0aaCoSkZzYbtNbLcbzqcj+9OZ+8sdb+73PDyEYff0cOTNw4n9/syct4Mm8blA/a3O5yL1E3xiRzVTZufu/mHc6H2ouwZ1+fWmmUDyC/2pI1IQoEooA3MXTBztcbt1c9YqFFdunZD/Wsb9heotkm/bFpsqucG0nSkjnmEnE6KVmkAVrqrkNJFyRVNG9RY4pbYMlWIYJVsXJFnw8saYKvdQdFEbzy8vvH984ovLiT912dC/+rvQ60fWx++j9ZluoRwUgTkljlqxVvlh7ywNbqlgqXC+bNlgLFV4riHkWAHTOqTnwtIMa/pJqJCLIK3HSNILaSzb8SBkM0aA6k6rC93CaOoOmvbMXHHfsnoL+b2PCA1P9Lby4Rqqs7V1FoHNCCL0NLEsSms6ykBEcCSEFQ++IIZkJ8kY0YlEnIU5dV55eV5ZW5AWVDJSJubNlu00s8mxLxMPqK6bkyRh6izuSK1Yd1pv0SV5JP+mHFTxoG50smbaCNwMU7dTbR2ootdMrhBHUF83VYYlyGajk4dXHmPUr063Hr7qkUjMALzG+0fXKJ5jRze8ZIlPgzncZQwSE24yRpWGkcGDqYFDJsbekgYg1oUSnyGaNEZ73kD6MO+Gek9USRqoo7KZ2e42HE8hMb/cHXi4P3C5u+OL04W7uyNfXE6c9vdo3g6V5efzt3M+F6mf8CMIU9qQDg3XhZ7vKTmDz7j28M8ko+grRdm5igaLbTGEEr6iEbng3iLWwxutOpjGmMhbiAC64L2Hasu2FGBJwj4lSopYcM8STDdNZEmkvFJSIiuU5CzTwstzotdIkX2N7A7QgwxBAnFbdWdpgmSjdrguN7553PBzxx0PxzuOX/49+PVbnj48wu0jxSvejdUd9cR9rlSMqxt9vXIrE112aDHup/AcNevUxfnQKuaFiXiGuAhSlE3KkRRUYxTlAxfk3hDR2F9ENO94YEIScJSUwHomiUQ0egdr4WlKCbCJZn0gpcIw27qRZEJkRmnRVQJCCnEBwQ20pAGgVQaqKiFurObc1sqy9iCFE7f+7XbidNhz2m6Y50KSQqeibkS/EybnPnZF1qN41g4aRiEYG6RGR7qhGjBcPHKomr+KbdYA5naPvCXVocIDGfTwPKJLECe1gYEahSjiQ4bXyfqPrATuBEkleIURjskQDNmQy/tQ30VRdQ9qBgGBGDT5hvgapc4BFMk2pPwxNtfX8SkV8GFgzoHxKoRfUDLz9sBmXzgdDpwvJ873B97cnbk8HHhzOnJ+OHC53LM7btGcESk/5qfET/b5XKR+4o8MSsSB01bpXsg+BTcvGUUyCUgSSaNJQ0OkY78sVgmc9Rw3XQ84aXiZJFYArePjYRm/1BucBWZjts4GQXOmzZmUQkCxU6WqkjOUa+ZZGqrCnJ2XtZClsdwWbvmGrTU6D7OxpH9VXA28D0qyhPSFdVHabeXp4zObzUe+c95zdznx5stf5Lpcef/hHen6ntlXREJCMqFBAVeiK5BHnkWpMlHH+C5vZ+4lsWmN58V58nH7TwlNM/gNzU5pStM00EKxVzLxMDSjZAkCSLaJeVs4bGde6g19ulJbBt8wt9gPMfYhzTtLt/C9qTLNE7vdjGZYe0Glj5wihpl0Yh4P5jwwWGJCtZWlVpZWqd2pa0PFKdPEdpo4HHbs9xt2ZSarhKfMo3B+ykJwx7tTPSLaxWxggDrNHEmO9ZXkIcxREt0XrL8CWWNnox6yeZNIvdUeHXJQxRv4EG4QNJRIxQX6646r4lpQh2ahanTr8TMoQSX/FL04YjTUUyRmiI/YGFARGqMD8gHA9U7TMEKrRyevThh8hU8XN7wh6VUmqKFk1B4da57IpTDPM4fTnt3pwPG05XI+8vBw5nI+88XdPZf7C/cPhcN+puQjIj+7kRt/0PO5SP1UnPihz7rj7hChfL0M46VGhIFMmTSVWKqTeEkfY0TiC9YaTgQiqgQVvXuAMjvQu7PS6T1hXiNG3qYRCRKS416cuRubWdCthCS3hI8LF1K6MU/OdU3IdSXna/iqVuWmFVlXrNaRbRoPZfNY+vhQjfkoXu5C6katznVZ2X984eGw5eH+gS/ffsHTcmF5fqIsH7jVZ7SHL0wJoUXCyV5J3njusErBc4acYJrYbeBoRnLjnSc+LrGYV3HIHe0eD02FLIDksCmJY5ZYq+FqlGRscqcxUaYW1HAJ6G+3KPpJE9YnJmuIODlt2O62HPYTXYRiCdl0dA1/VCGhRKHwCks3rrXSrbI0+/Q96T06n1ISm+2WwzZz3E5M04RaY7XMrTV6D95jQ/DeUNOR1xSdofcOXVgJsQcezL82iOLiHgo+jb1ocqONjslFBmXcIq/Jg7oeFPLBmSSNLjLsEW34s4w8zOhxScHrcDBF+JWPSwxjwBfKxkHeIDqyLsPkbBCkjkYDXEsoI81HcQNeRS9iJI9dU/RzE0kqSRRSQUaY41xmpv2Ow2HD8Xxgfz7z5nzicr/ji4czl8uRN+cLd2/uOe525LRDA471+fwdns9F6qfmjI7K95x2BU+R+rqxFqmukoe4N4UJ9AjrDwKFkxZHZaIlgdpiodwaHaf0EXNgROQ2HbE8RBYT1oXaXtjMK73OQDyge47wxCxOnhxJCUkbtBRSytxuiaw3tKyoKGtSapaYCPXrWFiH5yiRxhjNgwCuGakCsrK2QqvGbbnx/vmJ7x12fHG+8J03X3C1L3j5+IH29Ii2Z5ItWOuoKjOJLp2twEwltYbIjSUlsEwj0ctEYoOubWQ4hTdpLww/T8Fzpxv01FEX+kAeqChLa7y/CmsfhmINMoLTgiLuE0hHBYonkMS83/LVwx373R5wbG14rvSPjbUu3GrnujxzXW7UaqzWqW2MA70i9prX1CI/bAqj8G7akpmwblytY73ReqONkR4eqkRcsR57ou4V8zD2dq9RNML0hAgjGiTEINZrjOW84OafSOIyBCZolKYITwz+uw7UUrUh6x+OpOAjxuvJCFN0z4wrE25l7KCCs4cH+TzTyS6EFCLT6KQuIRP3EGwEx9LIEjs0Q6NjHH6zQCQF9iprxlRwycMyUZgmmOaZ7WbL/rjncJo5nk88XO54eNhyvpy5P9/x5v6O4/nEeX8i6R4R/TE/D356zuci9VN1ZIxBNpxmoVwSW5mwlKA4Ko0sm9hfPAmyKo+aWJ+UJAu3NUYpVsNb0k3wRNjvPVAyvQmLtwEIhe6dSqe3CdsuuG+pzZinSkuJTcmkMjGnEFTk1JhT/LnkmbI8c5XCbbqyLBldK602WjdsZRSHjo38K3UltRAdqBhJ48F3s4StjevaeXxe+e52w5v9jre7Gbn7ZXJdeXl8x+PjO6wubMeDqmQltQCUCsbUlSSVngs2bamy49BvSFPoC2od1zai1TO9w0InNmtpFLJIZwWw3kgUJIHVHky9Ef5X/DWp13BVpt2Or9684U/ePTDNibrceF9vfPPhhQ8vL7zcbjyvjbqs1LVGEKEDvZEkRlmv5O2sCZkKeZooKfaKsZezsBPYCiNyvVtgoAK8GwWqiUUGlkfp8IEQckLd6YMSH+PhEZ/eoXtFNHxlsRUCJSjlzV6RQg7kwcuLrs1wsoYYJUTijW6hanwdxZk66tGyuYdJOzSYhnmiOVQNwgfjZ0U09p426BupD76fSRDkpQ5eoxApvzIMvR67rtRIOlGykjdhS5gPew67Q4gkLgfe3D1wvhy5u9twOh+5f3Picn/HbrP/XKD+EM7nIvVTeAQhy8x+A1Nyui5QnJS2pPIxElQVxGdS+sBTyXh6xq8Z4Rpx9JJCom7xC26Wx4iqYz2IBu4L7hPdBZucZoW2KLvmtGli3gguB6YUBWFKma5h3E3S0AS5eOzKroWilVKeuS2wrBErHiq59dOuBAnmn+h4CNogJhD5QtYbdjPqdeX56cr35szDbub+fEDuvsMX5694+viB5/c/pK1Xjm0l98A5SFOEoDGU7Yb58otYd2RdqNdHpF3HQ9ZigV46Tba4dLI5WkI0UbvRyCNaQ8eyP9JmnRaCAELGbyRMEkmEwyZzVHi+fuDDi/G4PvPu3SNPH1cebyu13iLwcnXMLDw9FrHrPhKBcSET2KFEjDbNYLWOWA3TbRtFx8ZOzW3AYCvdRtghHnsj65i0T2Mx95DpR7e2hhRfXgMcictMt/H2+DiR5TRMuxIjP3wdReFH77e6AbGHEtFXO20o/15NtRKdcJh0exRISXSNCYFaJBwjbVDiI3NLXrs0jRBQHaIMDbMTI9JxqChD5i9J0RTYrWmamLcb5v2Ow3HP5bjjfDlxf3fH/XnP/eXI3XnH6fLA/d2Z/XYiyWYUvM9F6v/M+VykfoqPysxU4Iu7SNid9D3TpCQ10qzkuQQeZ0q4GJoIioS+RLiivsZ6jJhxFxo51Ff9Fv4pM8wbrQm1TbS50X1ltg3VJnp7ptbGbiro1MmqSNJALhWl1BBbvOSJ2mC77LjlxDIVXpbOuq70VWi9DixPCIzdGJEh9om+gIcGzjXRmlHbyrpmbi8rP3h6YbN55G6TQ5hw94Z1qdxuV9bbwlO9kXvjTp1NVsr+wku98d3v/YDnb96x1kYpxEgJ6Lkx18yUZESnR9SFFGXJipmhFqbq2J+saEoxGsTJCcQKNaVPo9hizuOHb/hu67xcF2pfWG6NXn9kqPVhxhbCN+USCjtSokvEebikT2BuuuFSaXWGstKqkQZOqI1AzD52R32oP6NZigLYPSjjMoIgzUJ+rmKfxoTjHUh5RMt7p41doqhAj90VQxX46mjCQ0HXJXxKWKjxusAnccGopKYT4mEJ8FEU42NGkZwJCb1Ko3tIySPefahbxseMrCkhedAkkigMBLGMtRZ5eONKRufEdtqymSa2xy2H05HDac/5tOXN/ZHL/Yk3lzMPl3vOlz2n44nddoNygM8d1B/K+VykfmpP/JKLbCi5cLnMZM1MU2IuiV3SMH2mTs4TqLDVxGNe8KRwWxlXS1pLOBWkxL7CDe/QTBAL74kmBZPhq4GteYyTemexFfOZ1GfmUpizUKQgU4KUEW2U3FhW5aYTJU3kZUVz41YyrVTqsqO1F1oPMoB4w1pEO3bpTDirF5LHPiR1EI2xVGsrvSnLrfGcEmkSNmViVmWed5R5y6k77pWnWnmWzjcfOk8vf53bx5eA79IxMl2UqwTl4dZhl50ihltnnWArIcVXjDSCBltvNLcgxOdEdyFrxHQUTVSCVn+7Gc/LM88342V9NT0DZrEL9EzKgCtdQo4uGt2f5sQk4F6w8bA1jNXCiCs1QTK8SXicZOQ8WfQ6sWv6UT6ZNcc70engiGVeMUVGxaSH5P2VLG4drxHrQYsigvQfGXG7xR4TwkBHiCzWwcpjbEzdw6xLjv2YjzdHR+fgeRRIeKWR44K1FgiwodALGXtcWkRsCCfWEBXZGMuSeR3riYbIghS2CU0JnRPzvGXa7dkdN5xPE8fTlsN5w9vTmfv7LzieH7h/2Eb8xvFAKXtexR2///fw8/mDn89F6mfhSGJix+EUrLmUJnDQWePGmL8hqfNBBc0LmoSchKs4WmGlRQxFjZENNg8zauxyajcmU1aP9F23Tu8zrXXm6hTLYMaUDaaK5UIpE2JT+EwmJafCpJmSK8uaoRR8CcJ2K401NZYuLHXBa8cbPxrhEN1cTG7KaKg6yZXehZo8ftDdaHUlr0JNneek5HxjLuGNUi1sy3bI75VD2TOfCms3aq9Ya9S+4g47SagLrQvVF0Di45pRBPCOmpFo9JwoBCE7a3SBVWJH0y3EC9Yrt2vncV1Y1kZvPcao6IiNT/Hcs+ED0hBexNg0kbIiTJEHZTZoI0Gg8A6o4S9jROojDdij9IZBLcZuDSX7qxssYjACfRSXAx1mcex1jyeYBZ8jSnJ8TXh0WjY6l9euywkShApU1xizyShA8SrSNYgcOhJ0VQTX187JAo5sHorC8blFUQKXHFEpLiP8MMy52IjcsCFdl/BcJXVMU2gmVdCiSNowlcK8Lez2mf1py+G45/685+584XLZcLk/83A8cr478XC35Xg8U3Q/PFDC5+L0h3c+F6mfgROTDmVmR95PTGmD6IZcMoWJ7aYwl3fkMlHyM3nOfEiPpCS8PEfCb2pOk+iMpPvgsfWxPO+sbmgzNCXaqky20lun9UbpE7ZmtnPHu1LnDcWdnBymTHElF6doQU0oU2GaCvNmpd8yt1qpm8ZtnZlvhVtbaXXF1ha8QR8EbJzOCjJh0jEriIzlf4+QPxHoyfF+pepEXZU1BZEbXckps03KLGE+3kwzRxGaJPpyDcl3rzQJM6v12JUldaSX6JbotOYB8xUhFSPpxFbGSNQdSwqtRwxFr1hbWVvFa0d7p/soHK+aTM8R3w5oijTdWRXVCdEcPi0R3If3CA3TqkCoXwbmhz7UKFEIAlL+GmHvYC0Uiur0pp8wUJ2Kh4ol8hVVR/HyT5QGdcOtDRr5K5Q2RnjqKWTlQ9kXe7khF+c1MTcAtwLRlb8SytExCjRsvAZoKFOlR8ijSIx+XV+J5cNzNwxY6oJr/lQ+5PepDBNCzqA6kXOmbDObTWHebzmdDtwdZg7nE/eXE3cPF95cjpxOJ07HIw/3dxz3W5Kex3jvc3H6wz6fi9TPyJFheswU9ttj3IjLhZwCNlpSQXOmFGGag+j8qILoQrom6qIsuqJVI+58HUFvTqTgjl2RtbjFuhneCsaA09aZ2pSlCptVmSehlJXWMiVnik3klNgVZVUoCTbZWJMy9cxtEaZpYU0w1cytTtQckvLaalAN3IJyXhuiQVCIwCSPJboRS3fviKRhvG1hUJUeTD06a4rYjSJCSspGE0U2pJTYlMTWN4gZNTm9Gr3faD28RnWM18wbHaGoknSmpcSzpaFa6/Rq1GZ0M2rrmNUoei3o6Ml0fD6Et0g6gn/aocwipDQ8QjoEGsPkml7FGt6IlME+itBrdpREERhxf1HIIugv4jTaUOo1kr9mcjmYjIIWhAxDUQuMg48IkbEwG0TzECOY5+hcaDFMFB1boBBRBAsxROiBOtJX1Xr4aCW+j69ik+4RmJEkiCoyghbxHmGgkoIGTxQ2l1c/lsaOS8Lbm7SQRElaIqSwTMzzxGY3sz1tOB4OnC4nHk57Tucdd5dRqM5HLuczp8uZw3ZH0m183Z8L1B/J+VykftaOCHhisznydoIpP5HTjjT9EIqymTI/nCa0TJRpYjO/58MH5ZoVvTlVFFZF8oJponcfcmSiGAyfjZnhybAl05uzJli7sValtk6rRimKrYm23dPbSsmJTYEsE2ma8JJJpZEr5FxpKyxZ2LbOta7cVqGvPcC1rVHbIGf3H+F2cg+VV5Ug8CZV8DD3ujZcBondWyzUtdF6jJ+WcUN/UiVr+LmyGkVTiCVyJpPY5R0yCZJT+JY6n6jxMoL+qhnVLSjsFlEUL81ovWLe0C6oJXxgh1zHlsbAyWSCRoHmATiNTKvXMZ2O/46OEtx6+JJgpAVHppdqvM26DlttZPJaPONDQTk+jg75ebdQYQzPKy6RsguvF5IIuUxEcYz7ikfR8Cha7j1yr8b+K/eES4+4e+mk16TbT6O7HJ2OpAhDNA9KPR5xIi7xv6vg1iBF16VEynEmLiyYRFGU4MaLCEghZSdJoSRFS46f9W1hO+/YHLfcnw6c73acz5coSHdH3h7uuLscOJ23HM8HpukN+hlx9Ed+Phepn8EjEvuLWS+8Oc0UbsxbZZqFacqkNLMphc20431JaHlk83Hi6UV5flmR3FgXo9WOSkBi+3jkqfThtQkPT7eVnjOajGZGbyniwCeYZ8eYUDd2eaLMSvcZSZWNEJ6vkslqqCbWJOSSqdXQumEzTdRrZcor1Yy1ruGxsv4JsyTDPIuNHYUZbinGUUNgoFYCjSMpcqfGyMkkxALunfYppj0haSGlhiyJpJ1NmigCWoJGkLMwqZNKppnzUjvX1un+OjJL9AbVeyCJLNw+KsG4U4h9kUsUJICcSWKDvD32PEPsGLHpHUgjVyq6ykDhKZYMnw1ehqSf8Tq8eqCGjN2GxPxVEOdDNenDJ2UAPTqhTggbxjthvuIaHVqMFnUAkPsw8wr08bnLGPoNqbv6RENCEDFgrjpMwy5DZk6QU7zHKE+SRifnUbzEjER0VK/MPSCysQQsdZSMphxosJQoOhSum8R2EwGFu8PM+XDkcjlwOh95e3dkf7nn/nDm4bLjdD6yO+6Z0wEk8zmo8I/+fC5SP8NHRNG05XxxynxHLplUCnOemWdnnjNl7my2mXeb9+h7kHTjpgtZoZaV9RqeKiwC7rqDquM9h8vfOr5CSwx4qdKqsbTGdlWW0pkXo+bGpmVus7GdJlrvlDIFtFaEqUxMWWgNakls2o1bm2jTQqoLVjvLWqg1upO11iCSdwuWYa9jOyKIR46WWOCbkjtoi/RWV/KY3ARJuwKC+xiRaXRDTcJbpSKsYnhy0hrjxAjMFZKEn6lWH9Ep9in/KGhBQU4XybTR0YTxc0BbGfsUkVDSaQKULoWkHel9dMad3gTXAK8K0R1GAWlIb9jHEWtv/fXDgnWciPow66OAxufvzif/ko2ihtunsZ312DnJGOr5yIeKUSPxWuXOa431weSzYWRWcdSIQmaxy0SGWMITnvgk1nB13If1YTASQ6rRcNVB2YgRYYgnArEUr5uMSVzCVciqITHPmXkqlLmw32857A+cTlvOpz3H84HL+cLxcuThfOB8d8flcOZ4mTltT8Hfk89Juj+u87lI/Uyf11HIluNOg1ReYJ637IqTdYNuN2ymXQQApkdKeeZ5eub2tOF6e0a4Iq2SO9Ta0CY0T3Hb7YJ5ipFQE5qvmBUQGTSLzPqDylI605xobcNUjT45eWrM3bEUooNUWiy2ExSEte/Y9EZthV1NLNWYm7EuK7X28EjVwlo7vVW0J7oTD2x33AdE1y0yihykO5rBfOx0NMZOiKEy0ljdPnUAIa+uNDXow2ekjdc9kROdGR7KMhsjPKMHOQGBFKM27R0zjUZEJFSKxEpNkVDzUWOHMwpN98i1jY+f6UT3mkSHgCEk2N0V6Ynm66fQPvM+TMZjlyiKU2PEZ68fV4YRN4qdm2OmdG3gJZR12CBshC/JPGjmIjX2WqZDzBCXl5gpJswSqKG04XmKC4KQx45qAJd0dOhKdECWQCOqQ0airYphKiNBWjEL9l4sqHp0TWLkNAe/ckpMObPZ7jkd9mz3mcNpw/l05ny64+F84O7hjuNhw+n+zP3pyOV4opQjQhkd4ufz4zqfi9TP/BFC37RjM2e+yI1NgUl/Hpkf2T69410qIW6YJso8Mc8zT/kKNyc9gy6CLZmsjVUjgErpIwIhugnieYHRWCx2ME0TpU3ULrSu9NUoU6eVK2VTWG4z05SZSqf0xJSFVGKstdEJV4+9UNkz9cbLzdmUiWUNgOq8blhtpa43WlW8NVpVqmXcg6idRsRE8N+ieEIfY8IoNsnHLf8T7y1GWuIN8RxhfN4D99Piod/HvscJAUTIx0Nbph6GVCfoHTb+HjYEYoOhp+6QDRm+m+6CYDEGfFXVMcyoPnBFGM0TbmHUxRo2qOPuPWqE9yFFd0RC4WYj5dbovHqmAwM7iO0mmA1eXpeIhh/jz84QVriDKtadLcqqQz/XHZThgZLx1dYYzTFGr24/ktvHVzx2YDpiT+K/Pb22eMOt7AHcdYv9VRpj4jASJ1QTqQhJAsOVZmWeN2x3G/aHiePhwOGy43Q5cNltOFzueHi45+545ng5cH84cDxsyTp/lpf/X3Q+F6nPhzHbQsjkdOFyPJDyE/N2x/59YVN2bMqO7WZmmzc8bp94t/nI5qPwcUrMLxuuz411vaGykJLTagWJcZ+K0aXSOoMCQIgTMHp1ssPaEtfc2dRKnRO5d7a5sfbC1ArzWmiTkdZCSUYu8UCf88RUGt6FOQtrU7ZzplbFJuPaJ5ZpDgXdEh1WtwjUa73jXvGWPu1pTAUnfQLZxHYjRBfug+o9CpgPRVxw4WK/JB65RyLRIb2ytL07mqI4hfwZ3FK8fXRu7qHsA4fUI8PJArCqJhgFYyXKhwxJuX0y3LopvXuAZglh39BTYB6+MfPIjHIMMxnllPASjc4rVHAxBpQexAnrHfNMGvshdx1RKpFNDBFdwohWv0mUT3k16w7FnviP9mXqMYoL43FEa5g0VNNAGY2cMfFXvkaMYyW6O9X4Oro4SAqVooTgIidBsyI6UYoy5ZlpLky7DdvtjvM+sz+fOB523J1CGHE4HblcLrw5HTmcj6Hey1tEpt/H3/tcoH7c53OR+nx+30mIJITMaZfQqTDthM1+z6ZMbLfCdjuxfdwybwrvt4nyOPEyXZn0idtVuSUl1UZToaVKqkK1jmjclHn1Mxl4c5oGYRwNn5XnYACWZvScmGqnTc4tNabamOcNc4qojjQpxWEuShsBgDlnzKGa0lYodaHWDc07fV6ovUSkRW+0Wmk9h0jAI2sqVAMhq34NztMeQXmmNm7sGfqIE7GOIaRXKbTZp90I9nrvDrm3ESMrJ/BBRg62nvOpGwNDXQcV3IfUGhhy6kHjCzm6K3XkTDlBrWAEKH7ik4/EXSHRbI2iuhX61cZuKrqkEX7xKhrHrI2iEiKY/1975x6r2VXW/8+67dt7OWfa0hlGW6haUyhVkUotkPgHjdy8gMSkpJoCBgRaoYJgUQsarUV/CQkQUwJRIKFIIPEGQUzTKrFJKW2lyE3AgBYJ00aGM+fyXvZel98fz3rf6QBii6Vzpl2fZtKZ8+5zZr9rZvZz1rO+z/ebWLmR56vyWVlSuVXHKt8p5UymLMIgy/7l5CqfO2VRhdaQM6WSluKONsgYsXwRrbUEK649/BUojdHiT6iSDAaTlZhaR4wxWCO7bGUrKudwrWUyamnHE8bjls1py2S6ycZoxMZmx8bGBtPNjgMHDnBg3DDtpmgzvs/uqXCyKEWq8O0oBTjGdkQ9dtR6D2sUTVfTdN+kbubUlZO4gnqbY80us7rl2O4Wbq6ZzxbMjUL1iaQ1Nmgxq0VleboWUUGWp4kjQSQlQ58GQgwMS42vKowLVP2AtQY3WIZ+ia9qjDNUQRFMTfQWZwzGiCTZOEWlLIMxRGfxA3gSqalY+oHOL/GDw4eKhffS5lrFpEefHb3FeV1FTzQiRpB5ITFPDSpHQuTdSoh55qeKxMGAz3rHnDGVVMSEKMILrMzuKC+GuFG+iPjWSZPQ+OwurjRqkALpUCIgQM55fI7SkG6arKtE02efw1zWyOdYKV8ft1eDtPKafJegUEiBSGmQ2SQqUs5rUmllRJvbdXpVzKWAixNEFkIo+SZEJqWy4i6r9VY7URE/yCBvVDnhOOVjJLUavFZZaZm/fgqgKin8Su5FzrAM6IA1GqMMyohJsK1rmqal7mraxjEabzDdaNgYd0xPO8B0tMHGpGFjMmbzjDEHxmPGk9PomjGK1e6pFKiTzQMqUiEEfv/3f5/3vve9HDlyhMOHD/PCF76Q3/u931sfJqaUeOMb38g73/lOtra2eOpTn8r111/Pueeeu/46R48e5Td+4zf40Ic+hNaa5z//+bzlLW9hPB4/uO+u8D0j38laHJbJyFBXFU19jKay1NUO3aiiGdU0bUXTNOy0M0zXsLezTeP20G7JYmYwqif6gaVWhGGQRNSowHtU1HiFPCSDlsA+LW0cZRQ+BnRvWGTpues1va3pm0jlFEPvqGxkqCyVMuiqoqrARodSFqMT1jkqI5LpPmiJKUcRhogPmioM4gGYEsF7YpAE2hDyQG5UVNGTogwxRyfzTwmdU4MHUoKBBMGThpjd2pFB3fXuSB7IKSSSWsrgbDZxJfXSu0zk4VRIJmZjXzmDshEGFY5HrIeEzyIOcUS3sovSMZ85ybpKHRF3CZU0IUmcR0qSsaQ4rtJLOSpDfo/sDhGl0K1UeiKVz7J0ZZBzoSyMUKArZLB2mXeRSoobKExMRCVnTMooktF5pynnSlobQJwgtBJnDTD5y4t9kVZZrafz+RMWpQPGOLTVaFNRWUNVW+qmZdR1jMYtk1HHaLrBxmbDZNJwYHqAzc0NNjamTKZTTtvYpK0d1jYo5XJhLOwHHlCR+pM/+ROuv/563vOe93D++edzxx138KIXvYiNjQ1e+cpXAvCnf/qnvPWtb+U973kP55xzDtdccw3PeMYz+NznPkfTNABcdtllfP3rX+fGG29kGAZe9KIX8dKXvpT3ve99D/47LPwfUHlwsqZ1NfZAS91WuGZCu7tLVxs2u4qtccvRrV2azrLXOXbaBr07Y74rDuTDood+TtCa5Ae0h6BqiSYP+dA9x0GopPPZVcKHHq0t1kZMcHjv8M7QDzvUzmGanso4qsHhjKEaepx3NM7jXI1WBmc9WjuMShhriE1LjI7oB2LwVLGWwhQCYRgIXuEZIEZCFJPVGCM+Bqx3pOAZYiS4QAgKPyh8krA9pRVDWNkDxZxEIc0+jZiw5k1j9sTLO4zoScgOyahEchFrFDlhnnXzTkkbEhXyOVYuANkaKhJRXrKVpFUohS5m+4aV64RYDHkiosZTKRIwEJLMuaHyQG12sQjxuKVQ0uJTEcFq8VUKSudB3kgc8r0mxI0dkYIrVJaVSxlKSYQ0GlA6ZVsjyX9KWbVHHgSWv4ManaykTCsZkMYYlHJY47DOYq3G1RVtW9M2FfV4zHQ0yrNNUqg2plM2pyMeNTmdjc2a8aSj22hp3QRNVTZO+xCVVo3j+8HP/dzPcfDgQf78z/98/bHnP//5tG3Le9/7XlJKHD58mNe85jX81m/9FgDHjh3j4MGDvPvd7+bSSy/l85//PI9//OO5/fbbufDCCwH46Ec/yrOf/Wz+67/+i8OHD3/b77tcLlkul+tfb29vc9ZZZ3Hs2DGm0+n3/OYLD4yEtIz6YWB7tsXWsW+yu93zze1dvvnNo2wd22Fvb5ftrR22dxZsb+2wO5+z2N1jMZuzHAaG5ZLlkN0hBo8PAyGo/N32QPDizRbz+YUiP8S0RmsrQYk6UlcGZWsqo6grh600lbNUthLnitphraY2DmUMlTHSetSAqomqRyXFkDRhVaRCZIiB6HsJ5PCe5FdO4gGC7Kz66PFeZq3C0BNiwkeIMeTCtsR72bXEmB/YSeLiVYgiFc9zZXlfBzm0z2UVIcrKe07IeZ0GlcSRwuQnaciRFdI1zV50KWT1YZ5gyuGDMcoZW4B1SKEKSIJuSuhkZCdFkpBMG2BhMCoSUi5SWaix0t+p++ygUGZt8no8JkPEFFohcv7sdqK1fPODdrKLUjJIHZWcZ2ltScjslAKskZ21Sg6tBrS1GF2BlTavrgzOOtqupj7QMHaWUTdmPB4z7RrG4wkbmyPG0wnT8YiNyQabkzOYHmgYNa18rbJ7esjZ3t5mY2Pjf32OP6Cd1FOe8hTe8Y538MUvfpEf/dEf5VOf+hS33HILb37zmwH4yle+wpEjR7jkkkvWn7OxscFFF13ErbfeyqWXXsqtt97K5ubmukABXHLJJWitue2223je8573bb/vddddxx/8wR88kFstfB9Q5Ihz5zgwrWgax7zdoWsqpo1lMnZsbbc0laVtF7RNRbezy15t2Gtq5vM586XD7C3wvafXBrxBBS/xCVF2UCFqlArZZilHr4cgabGhx2tHPyiM8yytGNBWg8M5T2U8zjlm/YLGWZytcJXF1I5KKyrjMKoHEzCmokKRKo0PkRQcMSiJuwiRIViCB7eKBUkJHyJtGFgGESrEqiJ4zxAVQ0yEsGQYFNZEkkcsmpInBieKOz1DpbAqM6SkCMmQkgM1MMSA1jIlFaI4zUsVUuuH/6BEgp7WEkQpUD4Xu5QdxVdnbeIELjsycmot8fivo3T5cqihiCUUiqBkOBulUfmsTqnVo1ySeqNSaxskMbXNDuwiTMxSeb0+hxJtIOtoDKMCojEXp4w8JJWLlZxjoZ3YTkWDTgbrNNoajK1prMY0FV1XMR011N2EybhiPBkx3thks+toxzWnb46ZbkzpJiM2pqez2TZY16JoSnLuPucBFamrr76a7e1tzjvvPIwxhBC49tprueyyywA4cuQIAAcPHjzh8w4ePLh+7ciRI5x55pkn3oS1nHbaaetrvpXXv/71vPrVr17/erWTKjz0yHfKBqs0k/p0qtNa7GjOdOwYHWsYdXOmneXosV1G0xEbWw07k4Zj20uO7e5R7e6ysI5+MWexDCz7njhohpDwXnzcJI8uEVRArYZkidIeTFri6nVCx0jwgUFDP1QY63Cmp3Y1VaXxLlDbSDU47NCTTEWqEsYNdBiMWWaVWUOlDckmBiopLilh45LgNQRF7w19jDivScGgwlLafVZizE2MuCExYDFJDGujjix9JA2ISjsEwInzAwmvrLhQsNrRxCx5V4Qk51gx7z4iCpNVcSrKGZiOXoaE0YS0ciiSFl8yimRE+q6iqPCCF1PVFMXmSE6AdB6YlfestLTyJApFvjGJceUsrlj1XZTKxkMpglZZQr8KW9R5V7XaRqV8zrNSD652Ygp0luAracliRN1ojKRHawtGKUgOZTXWGbGdcjW2bhm1FU03YTq2jMeOtjuDA9Mx43HNZDpmujHitNGI6XRCe7pj1BxgZFtQjRTf0t/b9zygIvWBD3yAG264gfe9732cf/753HXXXVx11VUcPnyYyy+//Pt1j9R1TV3X37evX3jgrIQVtZ1izYihaqjGx7CjHbquo223GO/07Iwa2q2OqplTtx3bdcey3WYxb9jdGzCLOWG5xAw9vTcMw4AOiRisaNPUgE5BotHzDFFSAwExrk2xRynDEBfYYYk3MhNVeYc3lt4FnA/UvSbYgd47qsqinEV5Q2UrqmrA6QZUxCrwVsQAPjiiSgxJzl9SSgQjEewWQ8jWPmLRk72GlAy4puzgoFZzP1maLvJzaY0ZlDiHJw3Ky05y3apLeajXZD13PuMigHIkEj6KjDwSsztEloTf53MTZi2iMCrvVFQeKCbKbobVtBSQHTaiApnAVSSlMdmDL65nWbNKT7TmokLMrubJJFSykJS06VDyNdEopTFa3CZkx2dFam7lTE8r8dbTyqANGKNktEDXUDsZxnWOUTOinjR0oxEbbc14VNGMxxyYbDDdnLAxbtnYGDHZGDEdj5nWFa7bwOhWOgL5b3Fh//OAitRrX/tarr76ai699FIALrjgAv7zP/+T6667jssvv5xDhw4BcM899/DoRz96/Xn33HMPP/ETPwHAoUOHuPfee0/4ut57jh49uv78wqmCPFKt0hg7wY0rrKnoqhnT1tGNFrR7ielkxLTb4RuTho1Jx868Zmdrl6adsTfr2NvzuH4X1y9YLJeEIRB8JA6K4IIMuIYsOc4P85AgxcSgEpoAQdRfQYstkncOb4wcpvcNc2doraX2A3Vf4Z3GOE1VJep+wNkeozUWI1lJaiB6KSohRvBSpGIYICaW8Xj7z8es6iOb6yIPYJ+SWApFadelJE/4lOXYKXrEElAsh5TKbhayOcGTndBXUelR5NiBQPYDx0OWYktxUioBRoxYRbuHUiL/1wRCjCi9msJa7SN0VujF3PczshtMq5kvldWHaj2/JX/6ZNcJsHnmSiUtnnsqoLSRHZOWCA+dz5/kfEpjtHjvSUKuxKJYwGhp5zlrwYB1Duca6q6ia2qqtqEZdYxHNdPpiPHIcqCbMppOGY8k4v3ARLz4JqMN2q7DKANUuUCV4nQq8YCK1Gw2k7iA+2DMqh0A55xzDocOHeKmm25aF6Xt7W1uu+02Xv7ylwNw8cUXs7W1xZ133smTnvQkAG6++WZijFx00UX/1/dTOCmIKamhZdpqxnVLP9mkHW8x3UrsdoPMq+zssbO9Q7PnaJxj1na0sx7b7LGYK4aFpVpYFsuBMMwZlhCiIwY5r0FF8vgpFomNBy1JtEEk39H04h8YAoPxWGdwQVN7CNbig2WoAr1V1KbC14neKJzROC2+cUpbyKF+PkSGICKHISC/9kGiQWIUpd8g4YU+emKUs6EUYPBKQm+Dx+fwPRn+FQl5yI4KsGqtwapQyBFU9swD8auLAZXnqCBHV2RFNkRR0WUj1RiDCC2U2CHpHMohE7y5BWdizpvKrhhoKXtJpqjSyoVdiZuF1uJKnpLBqNXslMpnWpKwK38XLCiZE0tKAoJNEgd0soxcKYXSFcoqnBIfR+cMRgWsrrHOUjmDqV3OeJKcp67taNox42nNxrhm1E0ZTSecPu5opyM2pzWj0Yh2fBpd09KZ9j6S8lKcTkUeUJH6+Z//ea699lrOPvtszj//fD75yU/y5je/mRe/+MWADPJdddVV/NEf/RHnnnvuWoJ++PBhnvvc5wLwuMc9jmc+85m85CUv4e1vfzvDMHDllVdy6aWXfkdlX+HUQb7jrjHa0bSJMypD21ma7TnVZMR0Z8Fu9w22dhp22prdnZ5jezO6cc1ib4/ZrGZvNmNvd6BfWAYzMPjI0g8oq2BIhFihrCjoRIZ9/KEs+UXZz26I69djnBGCpQqeEC2DDwzOsVSBbpBB4aVOKONQRtJoNZqgEj4kQhQz1iElgh+IIdB7zdDL7snHsFYIEhMhRPzqXpIi+cCQd0Mxijw9oCUkN5/TyBlNEHsjxAZJIXNJKu8aE5I+q7Qk8Ors/iBODNI2W8XD6/UZUCIZTYjSmkx5yFZc2JXs5FIk6dxojCtxQ7rP7ONqCBfElURsnWQGS6IxklIy4Jtbe0mJm4RViqQcioAyskOyamWYqzCmprJanCWcQduaxlXYxtLULU1b03YVddcxHTdMu462nTAeO8bTkSj4RmNOn45oxxX1tGXSTHBmlCXlrpSmU5wHVKTe9ra3cc011/CKV7yCe++9l8OHD/Prv/7rvOENb1hf87rXvY69vT1e+tKXsrW1xdOe9jQ++tGPrmekAG644QauvPJKnv70p6+Hed/61rc+eO+qcNKQQiVnE7WdYsYtbeOZzLZYtguONZbxtGNnNuHYzoJu6xjduGE+65jvzNmbzdgezdjba5jP9+gXAbccWA4DwfcELzEMwUvYXopRznXyTJJI3vxKmS1DwwlCHPBJiyIvJIaQqIxIwY22GA1aD6AdhkhKThwdoiKmQMAzpIEQIjEofFA52DASohcJekDabGkgqrgWKMRgsgRc1HIqidEuq2ZaillCDmJ7pCQIMK1afQYMctYTpRDpLMs3OWhyAAkCxKDVkAUNuUgn2R2BQ5mQ7YpUbh9mx/q09qbI52Hks620PlNKINlTq36khpgGaaUpv96oaC1DuklptIFUWSlASxnQNdZhUGijsZXFGiftvbqicpama6k7xaSdUncNo0nLuKnpxjXjacO0mTKejhhtNIya05i0HadtNrRtgzUTmaHKLcTCqc8DmpPaL9xffX3hZJMFxykRGRj6OdvLOfOdXWZ7x9jaWfLN3R12thfMd/bY2znK3mzBN/d6ZjtL9vZmLMIes52e5XxJ388Ig2cYeoZBikQK0nqL0UMSlRtZpBCVGKjaHCSojEYrcEpRVQ6tFcZqaq3FM05r7CrwMCpCCoS4MmUV/z2fIn6AFENuB0IMXlwmIsd985LkV4mjuOzOEkM+20nZ0DWLCljNSyVR8inxA1es/PVy+0++SI5HV/loyOeCYOTMSEWMljM7ld1bYzKouBC7JxUhR3oQYj4HixANUQfIQZGgsUlagSG7PCg0MUnir9IyBwVR5p7QYmGktbiPk4uVBaWkSBkSxlRYW2OMwjgjzvq2omoMTVvRtR2j0Zh6pJmMGsZ1zXjzAKORo23GjKcjurFlMuo40E0Yjzdo2xHOiCBCKXOfv3+lSO1nvi9zUoXCAyMfzCuFoUbXmtOqmlDX7I5HTCYLxrstu9M9tnY7ZsdatnfmjGY926Oj7O519Klh++icxXzBclGxmPcse8+wDPhhkN3MIM7mMYg7AshuySaZHhKnhmw7pMXmx4eEDpHkI8nmsxit6YGEJ0aLRVp8QwhZlSetMR+y63hCBnJDjrhImhRznPlq9kYlNFLkROAAQUc0OrvDS4tN51adZF1BUkmUeiqJN186rvwTL73j31uqaHKBOH62JA7k0k4UabfCBzF3JfveJQWVgiGHOcpYkoSwkyPkgxLHCFm8gDL5wZ9dJOR8SRR7Wsn6alPJwLFRoDWVNhirMdZirKKqalxlcFWNqR3jpqYeVTRdw0bbMRpNaLqO6cjQjRtGkwlN1zLtpow3Row6xaRtadsJlZ6glC2CiIcxpUgVHjIUDqMspjIcqBrGo4F21DKfbDHdmTPvOo5tztk5tsdkUrGY7bKz0zByc/pFz958zmK+y95ioJ8PLJZzhiEyLCsGL6rAKiRCgOhFoLAKF1RKo+NA0uLakGIgaU1Iijh4lLEon7OUdETHnrmSHcYQI5GBFIwUkKQI+SEeU0Jna6KYxJIoaoncEDVfTuQlW/yklNNzbd6VyPlQjg3M6jxR26UkQgmjTB5HSlm2LdNUYswrZ0VaS3suao1WslPSUpuQpqMkBZMUMR3/5mEpFvTHd3Ja57yrRIpZlZE3bVqLkjMpjVYmO5BrkZkrs96Zoh1Og7IabS1OG2rr0FWFqzRtW+Gqmq6raZuGdtxQty3dqGVjPGJSNzTTjuloxLi2TEcV9WjKdLOh6TbobIsxTmadKLNOD3dKkSo8pMj5hgMclWnYnIzomoZ6ukPYCBzY2eXY5h7be57FzjF2drbZ3huYz+fsLZb0sz229/bo54HZfI/FcmC58Mz7pYQb9j2h9/joUDEwRAhhQKMIGCwxn105UD5HTkhrTZqEGhUhpJV9UVrHzUPI7cQk7gwnzCch7Tud1sawaZXgqqy0A7Mib+2rZ/IALE6cx1k1SBVKR4ircxW1Hp4V0QQyiJoTf9dtVVY7HjlHWiXI556hCB10JMXVP3tPUia370wOQRSpelQSV69VQmfndqsiSldAICqkjaoqlAFlREKutcNqsaSylcI5h3Mj6sZRt5baiX1R1bVMO8uobagnE0Z1y6irGTcd7XjExnRM27aMRg3TUUvdtdTVGEMlf0bquB6y8PCmFKnCSeC+bUBF66Y456AemIxHjJY9p+/OmG2PODbZYGu2zXwemC32WM52Ge2N6XcHZvOGxaJnNvfsLXZZzBuGpccvlyxDxA9L9AAxWhgSHoWOfRZii69cyIOy2gA+kYLOO5Re2llJM4QI2pJCkJRdTR7OFVNUYiTpKCm3q3YaIs8W93Py81Rj0jpmkBizMo4lKy1fSlZMVvPOK8WEUSFbIEk7USmbz6Oi7JwY8g6rYiXG0GbVNtTi1JEtlRI57l3pbPaqpCunFF45lIroZDAaic9QAZTFKIfJnoIohzURpR3WWIwVebpx4KzGuobGScigqRyjuqLqKppRx6Sp6doJbqQZdRtsdA121DKqx2w2kW4yoZ6M2WjGcg7VVljTIPZFRQzxSKQUqcJJRgZFLSPQYNpE3S4Jo5a9Ucdk0bIx79jZW7K33GS+s8dkvsNs5plvT5kv5izmPTvzEf3ewLKfs1j0LBcDvV/QLyND7/Ghpx8iKRhiCKRE3ll5UqMIPRgthUes7yqJltASOpiitL90Pg8KOucf6SDnM1GE4CiVG1CeVaMt5fOwleGDSMcTOiZ00gR9fDekVcyFLknXL7fqdFp39pBp37xvUkFEGGgRLWSH9Jh8zmOSYdqcdiX/rc1iLUatjJWgUlnpB+tAQm1kxsgojVYJrMFo+bWyFuMctdXYymArxaiqUE1L62rqpqVtaurW4toR41HHpDNM2zG2HdOMHE034vRxTVfXjMcd7WjCqFLYaoTRDk2OYC5zTo9YSpEq7AOO7zYUYGkwzmIOjBmFEZNhyd5izrCcsXtszLA34Zuzgd2NXWbLPfrdBXuLDRZ7c+bDnMXuwO5izrCcM18O+IVn2ff0fWAYeryPea5JAg9T0AwpEJXC24BJFlKQIdasqHPrsx0kEyrELB6QFpp47GmSUnKWFAyyPUuEnLmhSUSNeAtFizJx5RubJ3I1KemslFPSZlxlPK3UfDn8MOahep3yLo+EURJciM5nRFgUHo8M9Wot1wcFJoLWooYLKqGVDA0bZdC6lidDkjkn6wBt0UqjnXht1sZhqwpbG5xtqStN21qqekzdGLq6kayxtsE1Dd2oYVw72q7jwKRl1I2omjGuNkzGHeO2o25anGnlGwFVrRal8AinFKnCPmNVsJxIlq2lMpGu9vTxGAfGPfO9MdP5wO58ynJvl+3ZnH7ZszfbY77rmY3nLPyC+WLJfL5kOV+yHJb0C8+87xn6Ad8HBj/Qh4E0iItEirAcepljioEYIlqy40Ug4VJWxSm0CXm2yJJixChNSJ6kJCEXpTBRg5Z9lcjhIxBAiWOD1iafGckckiahjLira5XEqFUZEV4oC8lLnq2WgiNDu5ZoFCaBUrILdFoRlLT9EgabsuJPyayUTgklphoYDMHkz0XOlYy1eVdWYbWicgnjKoxzOKtxlaGpGqqqpWoMdd3hakvTKsZVS11XuK6h61pGVU3XSMEaNRXN2DHuRoybKaYd01SKtmkxqkN8/I5b0BYKUIpUYZ9y/EFlQGmcsjhVkUaRpl0wjj0bsz3mywmPmi2ZzWF7dozF3jGWi8D2YsZi1jPrI8vZnL6fsRg886WnXy7xy8BiuWQYFgx9XO+whmEgDklyrmJiGAIpLPOcVAQvknRyJHxKTtwu8OigQUaBSSE7SETZrRidjWRzOzFaQ1I9Lho5z0riJhFVwhmxPopJYbIZrEaTVC07PJ2zbFV2fNCizNNaik1CYXQOLkw5fUr7PGRtc4fVYA2godFWnPWsxhlLMhHnDNZZjK2prKFua4xx1A4aO8K1NXVjaWtFW41xIyc7qKahtSParqFuNeNuQlc76mZCMxnTjQ2NczSM0NbkYeLjApFC4VspRapwCrDaXYlhaWUqKt3QTmsmUROmUoQmOx3L/gDzfsnp84HZbCer/xbszebMB89iWLLc6wk+0i9mLPqFfKyHYbHED55l8IRlIPSeRYDol2JtFANpUPQpSOxG7InJknwgJnG+iApS9BI1khwx9/OySj0byYrnXtQKGwwpKYYkc0pG58ITA2gRYmgsajWIq2qSDpL4qyTGImowqPxzUepJsLuIMEwCpS1JObTRGCvHPJYWbRWV1RKDYQ2VsejG4ozDNTW2ctRa4ypLW9VUtcGYMW1rGTU11cgyMh3VxGFry7RuaSpH1Y0YVy3jcYVzLU3boZ3DKvMd4tlLcSr8z5QiVTjFUJBjvjXgtMXVjroe0XaBhZ/RhyXLmWe2N8UPuwz9wN6uZ6+fM/eexe6cIQz0iznzeS87qTiwWASGxRzfD/RDTz8k+mGBX3b0wTMETfID3g+k6PFBHNIH7yVPaWWN5GMuWh5iIOFkBxQDQ1r5NACIzRFAtZ59CqCq1ekXJsoZVVJi/aQxOf9J1HpKRYwR8YlWOs8QGypl8EqjbMRogzJg8pCtqRU6nzFVdUVtDcZatBNlXuegqiqqpqapGkxl0NbRWYdpDV3V0taGruuoq4bGVlR1RdeOaJqaqjW4ytJUI9q6yUWJrM67759jofC/U4pU4RRk9YBzkmeEASzOJmlXEeibno3pNt6PWMz2GDYj88WCuU8sFwv8fMFy2bPX9yx9YrmcsVxGQj+wHOb0gxSv5dCzXAZ87xmGnAzsk0TMJxka9oOYzsYUCMuEx8uQcBoIXhFjIoUASsQWMURiyIKJGPOcVRAXcuXF3icioom1v55UN6cU0TjAg3JZb6Fykq2cKSmtMEZsn5xOYCq0yy7vKJzV1HWV23c1phJxhNWayjbUFbjOUdUdnWtwrkHXhq5yNFVN02jqylC1I0w1ZaOGUW0wrsVUDc5WrGMxlMSIlHZe4XulFKnCwwB9/AxLyaxQbWpq3UEFo3aPGBLBJ4a0ZLncY7lMLBYz5otA38/pl5HFEPDDgsH3+GUgeM9i2TNfDoTQ0/eGflji4xI/KHyMhPlMdlgpEWOgH3pxuwg9MYrreogRn2LeNXmCl4iOmEQJKI7kg0TI64iJkHRO041KDFOTRHFYLKoS0YSyBpUMRhsJB1TiV1g5SbFVSlFZ0LrC2oSxY4z2OFdRWYN2htpabN1QW0WtK0xjcLWjci1N7ahrTVU5TF3TaUc9qqjqEc45GhswrqNRNcrkA65VVMfqz+OE/xcKD5xSpAoPM1amrUB2d3BqQ56fFhI9sT0NH3uWwxK/XNIvl6jk2e4D/TyIq7nfJvSG2cKz7Jf03uOXiSFsE1OiHwy9XxL8gtBLwRmGgRglf8r3Hk/E+IEULUMM+BSIPrtCJJHBk6SAGaOzQ3r2xVCDGCoFK7NTOmG1wWBF6JcUhiA+edZiVMwhg4amMmiXQCusbsUFwgWMa6gNVLbBuoTWjtY5dK2xVlO5Gl07uq6lAqrK0VaOunUkN6bVCld1GG1F4q56FA4ZIv72P4dC4cGgFKnCw5z7tJlUQlFjAK1rXD0h1Z6UehSJzegJw5xFHxnClNky0ntP8D3EgeWeoY9j+sHiQ8B7jxqW9D4SYsLHQEoyQOx9IiTJl4q9FK6gVU4VTjJEnCTOw0eTd1SJFBLOKkJw4gpBxGqfnfosBitef8pjjZOo9dagQz6tM7UIFHREW4NWjsoZnFVoC7VqcJU4QThjsE4zMopQOUxtaOsOZzS1qTBVi9EeQ4PStcxvkXLxB3Dfss6FwoNPKVKFRxDHH6Rq7d7gxFuPRKUBM6JpghSNBD5FFqGXualhIIUpiyGRlgN9kFmrpDTee3wf8NHjhwj4vLMaGFKFCQODDujB0HsF9KSwmrUyRBTeREyAqAIKi4oBkBleFxPRWLTV6KSwFnqlqRAT16Qj2mgaW4lZro7yf1XRVUn2O85hTIW2Fm1rukYTnGEUNdp6lB2jdQ4opM7S8JWJVSlChZNDKVKFwgktQr2eJZIsXEVtIhChTqA8KS3xcSB68eHrUyQkD70iDQnCkl55GBJD8ng0KkT6NOCiIUQYVE/wChV6kgYvY7WkJaLWayxxGFAxoWMjybkq4IxBGYVXIju3NmF0hVVapOiNhRhwVqFSS+00Scs/9GArxrpeOVGhsou4kLLEf2VSWwpTYX9QilSh8G2sZBj3Pdsy+cMSEeFUElEhA514CEHrSUkmlDwelZbZFS8QgiXFhDcBHSPJz0hB4yNoE0BrfKhwcWBQYHDEFHEEogpgOkwMKCumuDpGca7QFqsMGInPiEjcR1IWmxt0+UblHrG57Xn8ffJdf14onFxKkSoUHhB516VAHvr1fV6zrNI5KmqgYx2foSNiU5SdZqsNEiKX1/gcKSjptZ6EjOOmPFMVAIXBSSCjUuiU8udrcSdf73z+twJTdkiFU4tSpAqF75n7UxBWPzUnfkRV+ecakGHXVePtW7VyJwaiS/la18lvu+L+3FehcOpQilSh8H2nFI1C4XuleOEXCoVCYd9SilShUCgU9i2lSBUKhUJh31KKVKFQKBT2LaVIFQqFQmHfUopUoVAoFPYtpUgVCoVCYd9SilShUCgU9i2lSBUKhUJh31KKVKFQKBT2LaVIFQqFQmHfUopUoVAoFPYtp6TBbEoJgO3t7ZN8J4VCoVD4Xlg9v1fP8/+JU7JIfeMb3wDgrLPOOsl3UigUCoX/Czs7O2xsbPyPr5+SReq0004D4O677/6ub67w3dne3uass87iq1/9KtPp9GTfzilNWcsHh7KODw6nwjqmlNjZ2eHw4cPf9bpTskhpLUdpGxsb+/YP4FRiOp2WdXyQKGv54FDW8cFhv6/j/dlkFOFEoVAoFPYtpUgVCoVCYd9yShapuq554xvfSF3XJ/tWTmnKOj54lLV8cCjr+ODwcFpHlf43/V+hUCgUCieJU3InVSgUCoVHBqVIFQqFQmHfUopUoVAoFPYtpUgVCoVCYd9SilShUCgU9i2nZJH6sz/7Mx772MfSNA0XXXQRn/jEJ072Le0brrvuOn7qp36KyWTCmWeeyXOf+1y+8IUvnHDNYrHgiiuu4PTTT2c8HvP85z+fe+6554Rr7r77bp7znOfQdR1nnnkmr33ta/HeP5RvZV/xpje9CaUUV1111fpjZR3vP1/72tf4lV/5FU4//XTatuWCCy7gjjvuWL+eUuINb3gDj370o2nblksuuYQvfelLJ3yNo0ePctlllzGdTtnc3OTXfu3X2N3dfajfykkjhMA111zDOeecQ9u2/PAP/zB/+Id/eIJB68NyHdMpxvvf//5UVVX6i7/4i/TZz342veQlL0mbm5vpnnvuOdm3ti94xjOekd71rnelz3zmM+muu+5Kz372s9PZZ5+ddnd319e87GUvS2eddVa66aab0h133JF++qd/Oj3lKU9Zv+69T094whPSJZdckj75yU+mj3zkI+mMM85Ir3/960/GWzrpfOITn0iPfexj04/92I+lV73qVeuPl3W8fxw9ejQ95jGPSS984QvTbbfdlr785S+nf/iHf0j//u//vr7mTW96U9rY2Eh/8zd/kz71qU+lX/iFX0jnnHNOms/n62ue+cxnph//8R9PH//4x9M///M/px/5kR9JL3jBC07GWzopXHvtten0009PH/7wh9NXvvKV9MEPfjCNx+P0lre8ZX3Nw3EdT7ki9eQnPzldccUV61+HENLhw4fTdddddxLvav9y7733JiB97GMfSymltLW1lZxz6YMf/OD6ms9//vMJSLfeemtKKaWPfOQjSWudjhw5sr7m+uuvT9PpNC2Xy4f2DZxkdnZ20rnnnptuvPHG9DM/8zPrIlXW8f7z27/92+lpT3va//h6jDEdOnQo/b//9//WH9va2kp1Xae//Mu/TCml9LnPfS4B6fbbb19f8/d///dJKZW+9rWvff9ufh/xnOc8J734xS8+4WO/9Eu/lC677LKU0sN3HU+pdl/f99x5551ccskl649prbnkkku49dZbT+Kd7V+OHTsGHHeOv/POOxmG4YQ1PO+88zj77LPXa3jrrbdywQUXcPDgwfU1z3jGM9je3uazn/3sQ3j3J58rrriC5zznOSesF5R1fCD83d/9HRdeeCG//Mu/zJlnnskTn/hE3vnOd65f/8pXvsKRI0dOWMuNjQ0uuuiiE9Zyc3OTCy+8cH3NJZdcgtaa22677aF7MyeRpzzlKdx000188YtfBOBTn/oUt9xyC8961rOAh+86nlIu6P/93/9NCOGEf/QABw8e5N/+7d9O0l3tX2KMXHXVVTz1qU/lCU94AgBHjhyhqio2NzdPuPbgwYMcOXJkfc13WuPVa48U3v/+9/Mv//Iv3H777d/2WlnH+8+Xv/xlrr/+el796lfzO7/zO9x+++288pWvpKoqLr/88vVafKe1uu9annnmmSe8bq3ltNNOe8Ss5dVXX8329jbnnXcexhhCCFx77bVcdtllAA/bdTylilThgXHFFVfwmc98hltuueVk38opx1e/+lVe9apXceONN9I0zcm+nVOaGCMXXnghf/zHfwzAE5/4RD7zmc/w9re/ncsvv/wk392pwwc+8AFuuOEG3ve+93H++edz1113cdVVV3H48OGH9TqeUu2+M844A2PMtymo7rnnHg4dOnSS7mp/cuWVV/LhD3+Yf/zHf+QHf/AH1x8/dOgQfd+ztbV1wvX3XcNDhw59xzVevfZI4M477+Tee+/lJ3/yJ7HWYq3lYx/7GG9961ux1nLw4MGyjveTRz/60Tz+8Y8/4WOPe9zjuPvuu4Hja/Hd/l0fOnSIe++994TXvfccPXr0EbOWr33ta7n66qu59NJLueCCC/jVX/1VfvM3f5PrrrsOePiu4ylVpKqq4klPehI33XTT+mMxRm666SYuvvjik3hn+4eUEldeeSV//dd/zc0338w555xzwutPetKTcM6dsIZf+MIXuPvuu9drePHFF/PpT3/6hL/MN954I9Pp9NseNg9Xnv70p/PpT3+au+66a/3jwgsv5LLLLlv/vKzj/eOpT33qt41BfPGLX+Qxj3kMAOeccw6HDh06YS23t7e57bbbTljLra0t7rzzzvU1N998MzFGLrrooofgXZx8ZrPZOvB1hTGGGCPwMF7Hk63ceKC8//3vT3Vdp3e/+93pc5/7XHrpS1+aNjc3T1BQPZJ5+ctfnjY2NtI//dM/pa9//evrH7PZbH3Ny172snT22Wenm2++Od1xxx3p4osvThdffPH69ZV0+md/9mfTXXfdlT760Y+mRz3qUY846fS3cl91X0plHe8vn/jEJ5K1Nl177bXpS1/6UrrhhhtS13Xpve997/qaN73pTWlzczP97d/+bfrXf/3X9Iu/+IvfUTr9xCc+Md12223plltuSeeee+6+lk4/2Fx++eXpB37gB9YS9L/6q79KZ5xxRnrd6163vubhuI6nXJFKKaW3ve1t6eyzz05VVaUnP/nJ6eMf//jJvqV9A/Adf7zrXe9aXzOfz9MrXvGKdODAgdR1XXre856Xvv71r5/wdf7jP/4jPetZz0pt26YzzjgjveY1r0nDMDzE72Z/8a1Fqqzj/edDH/pQesITnpDquk7nnXdeesc73nHC6zHGdM0116SDBw+muq7T05/+9PSFL3zhhGu+8Y1vpBe84AVpPB6n6XSaXvSiF6WdnZ2H8m2cVLa3t9OrXvWqdPbZZ6emadIP/dAPpd/93d89YZzh4biOJU+qUCgUCvuWU+pMqlAoFAqPLEqRKhQKhcK+pRSpQqFQKOxbSpEqFAqFwr6lFKlCoVAo7FtKkSoUCoXCvqUUqUKhUCjsW0qRKhQKhcK+pRSpQqFQKOxbSpEqFAqFwr6lFKlCoVAo7Fv+P8QppQ67qy2pAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -795,7 +889,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 20,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.471919621Z",
@@ -806,22 +900,12 @@
     {
      "data": {
       "text/plain": [
-       ""
+       ""
       ]
      },
-     "execution_count": 66,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -831,7 +915,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
+   "execution_count": 21,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.644440308Z",
@@ -842,22 +926,12 @@
     {
      "data": {
       "text/plain": [
-       ""
+       ""
       ]
      },
-     "execution_count": 65,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -867,7 +941,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
+   "execution_count": 22,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.759913041Z",
@@ -878,22 +952,12 @@
     {
      "data": {
       "text/plain": [
-       ""
+       ""
       ]
      },
-     "execution_count": 64,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -903,7 +967,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 23,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.925019564Z",
@@ -914,22 +978,12 @@
     {
      "data": {
       "text/plain": [
-       ""
+       ""
       ]
      },
-     "execution_count": 63,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -962,7 +1016,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.14"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/100_datamodules/101_btech.ipynb b/notebooks/100_datamodules/101_btech.ipynb
index 5dc3d02ab3..a10fc1e35d 100644
--- a/notebooks/100_datamodules/101_btech.ipynb
+++ b/notebooks/100_datamodules/101_btech.ipynb
@@ -39,7 +39,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -61,7 +61,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -99,7 +99,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -128,7 +128,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -146,40 +146,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image', 'mask']) torch.Size([32, 3, 1600, 1600])\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# Train images\n",
     "i, data = next(enumerate(btech_datamodule.train_dataloader()))\n",
-    "print(data.keys(), data[\"image\"].shape)"
+    "print(type(data))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image', 'mask']) torch.Size([32, 3, 1600, 1600]) torch.Size([32, 1600, 1600])\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# Test images\n",
     "i, data = next(enumerate(btech_datamodule.test_dataloader()))\n",
-    "print(data.keys(), data[\"image\"].shape, data[\"mask\"].shape)"
+    "print(type(data))"
    ]
   },
   {
@@ -192,24 +176,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "img = to_pil_image(data[\"image\"][0].clone())\n",
-    "msk = to_pil_image(data[\"mask\"][0]).convert(\"RGB\")\n",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img = to_pil_image(data.image[0].clone())\n",
+    "msk = to_pil_image(data.gt_mask[0].int() * 255).convert(\"RGB\")\n",
     "\n",
     "Image.fromarray(np.hstack((np.array(img), np.array(msk))))"
    ]
@@ -244,7 +216,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -262,116 +234,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "\n",
-       "\n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "
pathsplitlabelimage_pathmask_pathlabel_index
0/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0000.png/home/djameln/datasets/BTech/01/ground_truth/o...0
1/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0001.png/home/djameln/datasets/BTech/01/ground_truth/o...0
2/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0002.png/home/djameln/datasets/BTech/01/ground_truth/o...0
3/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0003.png/home/djameln/datasets/BTech/01/ground_truth/o...0
4/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0004.png/home/djameln/datasets/BTech/01/ground_truth/o...0
\n",
-       "
"
-      ],
-      "text/plain": [
-       "                              path  split label  \\\n",
-       "0  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "1  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "2  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "3  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "4  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "\n",
-       "                                          image_path  \\\n",
-       "0  /home/djameln/datasets/BTech/01/train/ok/0000.png   \n",
-       "1  /home/djameln/datasets/BTech/01/train/ok/0001.png   \n",
-       "2  /home/djameln/datasets/BTech/01/train/ok/0002.png   \n",
-       "3  /home/djameln/datasets/BTech/01/train/ok/0003.png   \n",
-       "4  /home/djameln/datasets/BTech/01/train/ok/0004.png   \n",
-       "\n",
-       "                                           mask_path  label_index  \n",
-       "0  /home/djameln/datasets/BTech/01/ground_truth/o...            0  \n",
-       "1  /home/djameln/datasets/BTech/01/ground_truth/o...            0  \n",
-       "2  /home/djameln/datasets/BTech/01/ground_truth/o...            0  \n",
-       "3  /home/djameln/datasets/BTech/01/ground_truth/o...            0  \n",
-       "4  /home/djameln/datasets/BTech/01/ground_truth/o...            0  "
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# BTechDataset Classification Train Set\n",
     "btech_dataset_classification_train = BTechDataset(\n",
@@ -386,20 +251,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image']) torch.Size([3, 256, 256])\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "sample = btech_dataset_classification_train[0]\n",
-    "print(sample.keys(), sample[\"image\"].shape)"
+    "print(sample.image.shape)"
    ]
   },
   {
@@ -412,17 +269,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image']) torch.Size([3, 256, 256]) /home/djameln/datasets/BTech/01/test/ko/0000.png 1\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# BTech Classification Test Set\n",
     "btech_dataset_classification_test = BTechDataset(\n",
@@ -433,7 +282,7 @@
     "    task=TaskType.CLASSIFICATION,\n",
     ")\n",
     "sample = btech_dataset_classification_test[0]\n",
-    "print(sample.keys(), sample[\"image\"].shape, sample[\"image_path\"], sample[\"label\"])"
+    "print(sample.image.shape, sample.image_path, sample.gt_label)"
    ]
   },
   {
@@ -450,116 +299,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "\n",
-       "\n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "
pathsplitlabelimage_pathmask_pathlabel_index
0/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0000.png/home/djameln/datasets/BTech/01/ground_truth/o...0
1/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0001.png/home/djameln/datasets/BTech/01/ground_truth/o...0
2/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0002.png/home/djameln/datasets/BTech/01/ground_truth/o...0
3/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0003.png/home/djameln/datasets/BTech/01/ground_truth/o...0
4/home/djameln/datasets/BTech/01trainok/home/djameln/datasets/BTech/01/train/ok/0004.png/home/djameln/datasets/BTech/01/ground_truth/o...0
\n",
-       "
"
-      ],
-      "text/plain": [
-       "                              path  split label  \\\n",
-       "0  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "1  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "2  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "3  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "4  /home/djameln/datasets/BTech/01  train    ok   \n",
-       "\n",
-       "                                          image_path  \\\n",
-       "0  /home/djameln/datasets/BTech/01/train/ok/0000.png   \n",
-       "1  /home/djameln/datasets/BTech/01/train/ok/0001.png   \n",
-       "2  /home/djameln/datasets/BTech/01/train/ok/0002.png   \n",
-       "3  /home/djameln/datasets/BTech/01/train/ok/0003.png   \n",
-       "4  /home/djameln/datasets/BTech/01/train/ok/0004.png   \n",
-       "\n",
-       "                                           mask_path  label_index  \n",
-       "0  /home/djameln/datasets/BTech/01/ground_truth/o...            0  \n",
-       "1  /home/djameln/datasets/BTech/01/ground_truth/o...            0  \n",
-       "2  /home/djameln/datasets/BTech/01/ground_truth/o...            0  \n",
-       "3  /home/djameln/datasets/BTech/01/ground_truth/o...            0  \n",
-       "4  /home/djameln/datasets/BTech/01/ground_truth/o...            0  "
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# BTech Segmentation Train Set\n",
     "btech_dataset_segmentation_train = BTechDataset(\n",
@@ -582,17 +324,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image', 'mask']) torch.Size([3, 256, 256]) torch.Size([256, 256])\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# BTech Segmentation Test Set\n",
     "btech_dataset_segmentation_test = BTechDataset(\n",
@@ -603,7 +337,7 @@
     "    task=TaskType.SEGMENTATION,\n",
     ")\n",
     "sample = btech_dataset_segmentation_test[20]\n",
-    "print(sample.keys(), sample[\"image\"].shape, sample[\"mask\"].shape)"
+    "print(sample.image.shape, sample.gt_mask.shape)"
    ]
   },
   {
@@ -616,25 +350,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# img = Image.open(sample[\"image_path\"]).resize(image_size)\n",
-    "img = to_pil_image(sample[\"image\"].clone())\n",
-    "msk = to_pil_image(sample[\"mask\"]).convert(\"RGB\")\n",
+    "img = to_pil_image(sample.image.clone())\n",
+    "msk = to_pil_image(sample.gt_mask.int() * 255).convert(\"RGB\")\n",
     "\n",
     "Image.fromarray(np.hstack((np.array(img), np.array(msk))))"
    ]
@@ -656,7 +378,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.14"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/100_datamodules/102_mvtec.ipynb b/notebooks/100_datamodules/102_mvtec.ipynb
index 28ef7cc0ff..3a04717178 100644
--- a/notebooks/100_datamodules/102_mvtec.ipynb
+++ b/notebooks/100_datamodules/102_mvtec.ipynb
@@ -23,7 +23,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -49,7 +49,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -106,7 +106,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -124,40 +124,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image', 'mask']) torch.Size([32, 3, 900, 900])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Train images\n",
     "i, data = next(enumerate(mvtec_datamodule.train_dataloader()))\n",
-    "print(data.keys(), data[\"image\"].shape)"
+    "print(data.image.shape)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image', 'mask']) torch.Size([32, 3, 900, 900]) torch.Size([32, 900, 900])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Test images\n",
     "i, data = next(enumerate(mvtec_datamodule.test_dataloader()))\n",
-    "print(data.keys(), data[\"image\"].shape, data[\"mask\"].shape)"
+    "print(data.image.shape, data.gt_mask.shape)"
    ]
   },
   {
@@ -170,24 +154,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "img = to_pil_image(data[\"image\"][0].clone())\n",
-    "msk = to_pil_image(data[\"mask\"][0]).convert(\"RGB\")\n",
+    "img = to_pil_image(data.image[0].clone())\n",
+    "msk = to_pil_image(data.gt_mask[0].int() * 255).convert(\"RGB\")\n",
     "\n",
     "Image.fromarray(np.hstack((np.array(img), np.array(msk))))"
    ]
@@ -222,7 +194,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -240,109 +212,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "\n",
-       "\n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "
pathsplitlabelimage_pathlabel_indexmask_path
0/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
1/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
2/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
3/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
4/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
\n",
-       "
"
-      ],
-      "text/plain": [
-       "                                  path  split label  \\\n",
-       "0  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "1  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "2  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "3  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "4  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "\n",
-       "                                          image_path  label_index mask_path  \n",
-       "0  /home/djameln/datasets/MVTec/bottle/train/good...            0            \n",
-       "1  /home/djameln/datasets/MVTec/bottle/train/good...            0            \n",
-       "2  /home/djameln/datasets/MVTec/bottle/train/good...            0            \n",
-       "3  /home/djameln/datasets/MVTec/bottle/train/good...            0            \n",
-       "4  /home/djameln/datasets/MVTec/bottle/train/good...            0            "
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# MVTec Classification Train Set\n",
     "mvtec_dataset_classification_train = MVTecDataset(\n",
@@ -357,20 +229,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image']) torch.Size([3, 256, 256])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "sample = mvtec_dataset_classification_train[0]\n",
-    "print(sample.keys(), sample[\"image\"].shape)"
+    "print(sample.image.shape)"
    ]
   },
   {
@@ -383,17 +247,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image']) torch.Size([3, 256, 256]) /home/djameln/datasets/MVTec/bottle/test/broken_large/000.png 1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# MVTec Classification Test Set\n",
     "mvtec_dataset_classification_test = MVTecDataset(\n",
@@ -404,7 +260,7 @@
     "    task=\"classification\",\n",
     ")\n",
     "sample = mvtec_dataset_classification_test[0]\n",
-    "print(sample.keys(), sample[\"image\"].shape, sample[\"image_path\"], sample[\"label\"])"
+    "print(sample.image.shape, sample.image_path, sample.gt_label)"
    ]
   },
   {
@@ -419,109 +275,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "\n",
-       "\n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "
pathsplitlabelimage_pathlabel_indexmask_path
0/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
1/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
2/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
3/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
4/home/djameln/datasets/MVTec/bottletraingood/home/djameln/datasets/MVTec/bottle/train/good...0
\n",
-       "
"
-      ],
-      "text/plain": [
-       "                                  path  split label  \\\n",
-       "0  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "1  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "2  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "3  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "4  /home/djameln/datasets/MVTec/bottle  train  good   \n",
-       "\n",
-       "                                          image_path  label_index mask_path  \n",
-       "0  /home/djameln/datasets/MVTec/bottle/train/good...            0            \n",
-       "1  /home/djameln/datasets/MVTec/bottle/train/good...            0            \n",
-       "2  /home/djameln/datasets/MVTec/bottle/train/good...            0            \n",
-       "3  /home/djameln/datasets/MVTec/bottle/train/good...            0            \n",
-       "4  /home/djameln/datasets/MVTec/bottle/train/good...            0            "
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# MVTec Segmentation Train Set\n",
     "mvtec_dataset_segmentation_train = MVTecDataset(\n",
@@ -536,17 +292,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image', 'mask']) torch.Size([3, 256, 256]) torch.Size([256, 256])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# MVTec Segmentation Test Set\n",
     "mvtec_dataset_segmentation_test = MVTecDataset(\n",
@@ -557,7 +305,7 @@
     "    task=\"segmentation\",\n",
     ")\n",
     "sample = mvtec_dataset_segmentation_test[20]\n",
-    "print(sample.keys(), sample[\"image\"].shape, sample[\"mask\"].shape)"
+    "print(sample.image.shape, sample.gt_mask.shape)"
    ]
   },
   {
@@ -570,24 +318,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "img = to_pil_image(sample[\"image\"].clone())\n",
-    "msk = to_pil_image(sample[\"mask\"]).convert(\"RGB\")\n",
+    "img = to_pil_image(sample.image.clone())\n",
+    "msk = to_pil_image(sample.gt_mask.int() * 255).convert(\"RGB\")\n",
     "\n",
     "Image.fromarray(np.hstack((np.array(img), np.array(msk))))"
    ]
@@ -609,7 +345,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.14"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/100_datamodules/103_folder.ipynb b/notebooks/100_datamodules/103_folder.ipynb
index f870606175..6a5ab89d4c 100644
--- a/notebooks/100_datamodules/103_folder.ipynb
+++ b/notebooks/100_datamodules/103_folder.ipynb
@@ -33,7 +33,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -63,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -91,7 +91,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -109,40 +109,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image', 'mask']) torch.Size([28, 3, 256, 256])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Train images\n",
     "i, data = next(enumerate(folder_datamodule.train_dataloader()))\n",
-    "print(data.keys(), data[\"image\"].shape)"
+    "print(data.image.shape)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image', 'mask']) torch.Size([6, 3, 256, 256]) torch.Size([6, 256, 256])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Test images\n",
     "i, data = next(enumerate(folder_datamodule.test_dataloader()))\n",
-    "print(data.keys(), data[\"image\"].shape, data[\"mask\"].shape)"
+    "print(data.image.shape, data.gt_mask.shape)"
    ]
   },
   {
@@ -155,24 +139,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "img = to_pil_image(data[\"image\"][0].clone())\n",
-    "msk = to_pil_image(data[\"mask\"][0]).convert(\"RGB\")\n",
+    "img = to_pil_image(data.image[0].clone())\n",
+    "msk = to_pil_image(data.gt_mask[0].int() * 255).convert(\"RGB\")\n",
     "\n",
     "Image.fromarray(np.hstack((np.array(img), np.array(msk))))"
    ]
@@ -215,7 +187,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -233,103 +205,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "\n",
-       "\n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "
image_pathlabellabel_indexmask_pathsplit
0/home/djameln/datasets/hazelnut_toy/good/00.jpgDirType.NORMAL0Split.TRAIN
1/home/djameln/datasets/hazelnut_toy/good/01.jpgDirType.NORMAL0Split.TRAIN
2/home/djameln/datasets/hazelnut_toy/good/02.jpgDirType.NORMAL0Split.TRAIN
3/home/djameln/datasets/hazelnut_toy/good/03.jpgDirType.NORMAL0Split.TRAIN
4/home/djameln/datasets/hazelnut_toy/good/04.jpgDirType.NORMAL0Split.TRAIN
\n",
-       "
"
-      ],
-      "text/plain": [
-       "                                        image_path           label  \\\n",
-       "0  /home/djameln/datasets/hazelnut_toy/good/00.jpg  DirType.NORMAL   \n",
-       "1  /home/djameln/datasets/hazelnut_toy/good/01.jpg  DirType.NORMAL   \n",
-       "2  /home/djameln/datasets/hazelnut_toy/good/02.jpg  DirType.NORMAL   \n",
-       "3  /home/djameln/datasets/hazelnut_toy/good/03.jpg  DirType.NORMAL   \n",
-       "4  /home/djameln/datasets/hazelnut_toy/good/04.jpg  DirType.NORMAL   \n",
-       "\n",
-       "   label_index mask_path        split  \n",
-       "0            0            Split.TRAIN  \n",
-       "1            0            Split.TRAIN  \n",
-       "2            0            Split.TRAIN  \n",
-       "3            0            Split.TRAIN  \n",
-       "4            0            Split.TRAIN  "
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "folder_dataset_classification_train = FolderDataset(\n",
     "    name=\"hazelnut_toy\",\n",
@@ -352,20 +230,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image']) torch.Size([3, 256, 256])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "data = folder_dataset_classification_train[0]\n",
-    "print(data.keys(), data[\"image\"].shape)"
+    "print(data.image.shape)"
    ]
   },
   {
@@ -378,103 +248,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "\n",
-       "\n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "
image_pathlabellabel_indexmask_pathsplit
0/home/djameln/datasets/hazelnut_toy/crack/01.jpgDirType.ABNORMAL1Split.TEST
1/home/djameln/datasets/hazelnut_toy/crack/02.jpgDirType.ABNORMAL1Split.TEST
2/home/djameln/datasets/hazelnut_toy/crack/03.jpgDirType.ABNORMAL1Split.TEST
3/home/djameln/datasets/hazelnut_toy/crack/04.jpgDirType.ABNORMAL1Split.TEST
4/home/djameln/datasets/hazelnut_toy/crack/05.jpgDirType.ABNORMAL1Split.TEST
\n",
-       "
"
-      ],
-      "text/plain": [
-       "                                         image_path             label  \\\n",
-       "0  /home/djameln/datasets/hazelnut_toy/crack/01.jpg  DirType.ABNORMAL   \n",
-       "1  /home/djameln/datasets/hazelnut_toy/crack/02.jpg  DirType.ABNORMAL   \n",
-       "2  /home/djameln/datasets/hazelnut_toy/crack/03.jpg  DirType.ABNORMAL   \n",
-       "3  /home/djameln/datasets/hazelnut_toy/crack/04.jpg  DirType.ABNORMAL   \n",
-       "4  /home/djameln/datasets/hazelnut_toy/crack/05.jpg  DirType.ABNORMAL   \n",
-       "\n",
-       "   label_index mask_path       split  \n",
-       "0            1            Split.TEST  \n",
-       "1            1            Split.TEST  \n",
-       "2            1            Split.TEST  \n",
-       "3            1            Split.TEST  \n",
-       "4            1            Split.TEST  "
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Folder Classification Test Set\n",
     "folder_dataset_classification_test = FolderDataset(\n",
@@ -490,20 +266,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image']) torch.Size([3, 256, 256]) /home/djameln/datasets/hazelnut_toy/crack/01.jpg 1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "data = folder_dataset_classification_test[0]\n",
-    "print(data.keys(), data[\"image\"].shape, data[\"image_path\"], data[\"label\"])"
+    "print(data.image.shape, data.image_path, data.gt_label)"
    ]
   },
   {
@@ -518,103 +286,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "\n",
-       "\n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "
image_pathlabellabel_indexmask_pathsplit
0/home/djameln/datasets/hazelnut_toy/good/00.jpgDirType.NORMAL0Split.TRAIN
1/home/djameln/datasets/hazelnut_toy/good/01.jpgDirType.NORMAL0Split.TRAIN
2/home/djameln/datasets/hazelnut_toy/good/02.jpgDirType.NORMAL0Split.TRAIN
3/home/djameln/datasets/hazelnut_toy/good/03.jpgDirType.NORMAL0Split.TRAIN
4/home/djameln/datasets/hazelnut_toy/good/04.jpgDirType.NORMAL0Split.TRAIN
\n",
-       "
"
-      ],
-      "text/plain": [
-       "                                        image_path           label  \\\n",
-       "0  /home/djameln/datasets/hazelnut_toy/good/00.jpg  DirType.NORMAL   \n",
-       "1  /home/djameln/datasets/hazelnut_toy/good/01.jpg  DirType.NORMAL   \n",
-       "2  /home/djameln/datasets/hazelnut_toy/good/02.jpg  DirType.NORMAL   \n",
-       "3  /home/djameln/datasets/hazelnut_toy/good/03.jpg  DirType.NORMAL   \n",
-       "4  /home/djameln/datasets/hazelnut_toy/good/04.jpg  DirType.NORMAL   \n",
-       "\n",
-       "   label_index mask_path        split  \n",
-       "0            0            Split.TRAIN  \n",
-       "1            0            Split.TRAIN  \n",
-       "2            0            Split.TRAIN  \n",
-       "3            0            Split.TRAIN  \n",
-       "4            0            Split.TRAIN  "
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Folder Segmentation Train Set\n",
     "folder_dataset_segmentation_train = FolderDataset(\n",
@@ -631,103 +305,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "\n",
-       "\n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "  \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "    \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "      \n",
-       "    \n",
-       "  \n",
-       "
image_pathlabellabel_indexmask_pathsplit
0/home/djameln/datasets/hazelnut_toy/crack/01.jpgDirType.ABNORMAL1/home/djameln/datasets/hazelnut_toy/mask/crack...Split.TEST
1/home/djameln/datasets/hazelnut_toy/crack/02.jpgDirType.ABNORMAL1/home/djameln/datasets/hazelnut_toy/mask/crack...Split.TEST
2/home/djameln/datasets/hazelnut_toy/crack/03.jpgDirType.ABNORMAL1/home/djameln/datasets/hazelnut_toy/mask/crack...Split.TEST
3/home/djameln/datasets/hazelnut_toy/crack/04.jpgDirType.ABNORMAL1/home/djameln/datasets/hazelnut_toy/mask/crack...Split.TEST
4/home/djameln/datasets/hazelnut_toy/crack/05.jpgDirType.ABNORMAL1/home/djameln/datasets/hazelnut_toy/mask/crack...Split.TEST
\n",
-       "
"
-      ],
-      "text/plain": [
-       "                                         image_path             label  \\\n",
-       "0  /home/djameln/datasets/hazelnut_toy/crack/01.jpg  DirType.ABNORMAL   \n",
-       "1  /home/djameln/datasets/hazelnut_toy/crack/02.jpg  DirType.ABNORMAL   \n",
-       "2  /home/djameln/datasets/hazelnut_toy/crack/03.jpg  DirType.ABNORMAL   \n",
-       "3  /home/djameln/datasets/hazelnut_toy/crack/04.jpg  DirType.ABNORMAL   \n",
-       "4  /home/djameln/datasets/hazelnut_toy/crack/05.jpg  DirType.ABNORMAL   \n",
-       "\n",
-       "   label_index                                          mask_path       split  \n",
-       "0            1  /home/djameln/datasets/hazelnut_toy/mask/crack...  Split.TEST  \n",
-       "1            1  /home/djameln/datasets/hazelnut_toy/mask/crack...  Split.TEST  \n",
-       "2            1  /home/djameln/datasets/hazelnut_toy/mask/crack...  Split.TEST  \n",
-       "3            1  /home/djameln/datasets/hazelnut_toy/mask/crack...  Split.TEST  \n",
-       "4            1  /home/djameln/datasets/hazelnut_toy/mask/crack...  Split.TEST  "
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Folder Segmentation Test Set\n",
     "folder_dataset_segmentation_test = FolderDataset(\n",
@@ -744,20 +324,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image', 'mask']) torch.Size([3, 256, 256]) torch.Size([256, 256])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "data = folder_dataset_segmentation_test[3]\n",
-    "print(data.keys(), data[\"image\"].shape, data[\"mask\"].shape)"
+    "print(data.image.shape, data.gt_mask.shape)"
    ]
   },
   {
@@ -770,24 +342,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "img = to_pil_image(data[\"image\"].clone())\n",
-    "msk = to_pil_image(data[\"mask\"]).convert(\"RGB\")\n",
+    "img = to_pil_image(data.image.clone())\n",
+    "msk = to_pil_image(data.gt_mask.int() * 255).convert(\"RGB\")\n",
     "\n",
     "Image.fromarray(np.hstack((np.array(img), np.array(msk))))"
    ]
@@ -809,7 +369,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.14"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/100_datamodules/104_tiling.ipynb b/notebooks/100_datamodules/104_tiling.ipynb
index 6b66860710..949d6f1cf1 100644
--- a/notebooks/100_datamodules/104_tiling.ipynb
+++ b/notebooks/100_datamodules/104_tiling.ipynb
@@ -35,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -61,7 +61,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -83,7 +83,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -112,18 +112,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/sakcay/.pyenv/versions/3.10.11/envs/notebooks/lib/python3.10/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "resized_image = Resize((256, 256))(image)\n",
     "resized_mask = Resize((256, 256))(mask)\n",
@@ -132,21 +123,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "ToPILImage()(resized_overlayed_image)"
    ]
@@ -165,7 +144,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -182,7 +161,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -192,17 +171,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "torch.Size([16, 3, 256, 256]) torch.Size([16, 1, 256, 256])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(tiled_image.shape, tiled_mask.shape)"
    ]
@@ -226,7 +197,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -235,21 +206,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "ToPILImage()(overlayed_tile)"
    ]
@@ -264,21 +223,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "ToPILImage()(torch.cat([resized_overlayed_image, overlayed_tile], dim=2))"
    ]
@@ -348,7 +295,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.10.14"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/200_models/201_fastflow.ipynb b/notebooks/200_models/201_fastflow.ipynb
index 0826e3c51c..4cf8853fb3 100644
--- a/notebooks/200_models/201_fastflow.ipynb
+++ b/notebooks/200_models/201_fastflow.ipynb
@@ -144,148 +144,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[0;31mInit signature:\u001b[0m\n",
-      "\u001b[0mFastflow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mbackbone\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'resnet18'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mpre_trained\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mflow_steps\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mSource:\u001b[0m        \n",
-      "\u001b[0;32mclass\u001b[0m \u001b[0mFastflow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mAnomalyModule\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;34m\"\"\"PL Lightning Module for the FastFlow algorithm.\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m    Args:\u001b[0m\n",
-      "\u001b[0;34m        input_size (tuple[int, int]): Model input size.\u001b[0m\n",
-      "\u001b[0;34m            Defaults to ``(256, 256)``.\u001b[0m\n",
-      "\u001b[0;34m        backbone (str): Backbone CNN network\u001b[0m\n",
-      "\u001b[0;34m            Defaults to ``resnet18``.\u001b[0m\n",
-      "\u001b[0;34m        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.\u001b[0m\n",
-      "\u001b[0;34m            Defaults to ``True``.\u001b[0m\n",
-      "\u001b[0;34m        flow_steps (int, optional): Flow steps.\u001b[0m\n",
-      "\u001b[0;34m            Defaults to ``8``.\u001b[0m\n",
-      "\u001b[0;34m        conv3x3_only (bool, optinoal): Use only conv3x3 in fast_flow model.\u001b[0m\n",
-      "\u001b[0;34m            Defaults to ``False``.\u001b[0m\n",
-      "\u001b[0;34m        hidden_ratio (float, optional): Ratio to calculate hidden var channels.\u001b[0m\n",
-      "\u001b[0;34m            Defaults to ``1.0`.\u001b[0m\n",
-      "\u001b[0;34m    \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mbackbone\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"resnet18\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mpre_trained\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mflow_steps\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackbone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbackbone\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_trained\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpre_trained\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflow_steps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mflow_steps\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv3x3_only\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhidden_ratio\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFastflowLoss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mFastflowModel\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0m_setup\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;32massert\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_size\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Fastflow needs input size to build torch model.\"\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFastflowModel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m            \u001b[0minput_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m            \u001b[0mbackbone\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackbone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m            \u001b[0mpre_trained\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpre_trained\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m            \u001b[0mflow_steps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflow_steps\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m            \u001b[0mconv3x3_only\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv3x3_only\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m            \u001b[0mhidden_ratio\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhidden_ratio\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0mtraining_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mSTEP_OUTPUT\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;34m\"\"\"Perform the training step input and return the loss.\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m        Args:\u001b[0m\n",
-      "\u001b[0;34m            batch (batch: dict[str, str | torch.Tensor]): Input batch\u001b[0m\n",
-      "\u001b[0;34m            args: Additional arguments.\u001b[0m\n",
-      "\u001b[0;34m            kwargs: Additional keyword arguments.\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m        Returns:\u001b[0m\n",
-      "\u001b[0;34m            STEP_OUTPUT: Dictionary containing the loss value.\u001b[0m\n",
-      "\u001b[0;34m        \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;32mdel\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m  \u001b[0;31m# These variables are not used.\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mhidden_variables\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjacobians\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"image\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhidden_variables\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjacobians\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"train_loss\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mon_epoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprog_bar\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;32mreturn\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"loss\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0mvalidation_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m|\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mSTEP_OUTPUT\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;34m\"\"\"Perform the validation step and return the anomaly map.\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m        Args:\u001b[0m\n",
-      "\u001b[0;34m            batch (dict[str, str | torch.Tensor]): Input batch\u001b[0m\n",
-      "\u001b[0;34m            args: Additional arguments.\u001b[0m\n",
-      "\u001b[0;34m            kwargs: Additional keyword arguments.\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m        Returns:\u001b[0m\n",
-      "\u001b[0;34m            STEP_OUTPUT | None: batch dictionary containing anomaly-maps.\u001b[0m\n",
-      "\u001b[0;34m        \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;32mdel\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m  \u001b[0;31m# These variables are not used.\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0manomaly_maps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"image\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"anomaly_maps\"\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0manomaly_maps\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;32mreturn\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0mtrainer_arguments\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;34m\"\"\"Return FastFlow trainer arguments.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;32mreturn\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"gradient_clip_val\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"num_sanity_val_steps\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0mconfigure_optimizers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOptimizer\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;34m\"\"\"Configure optimizers for each decoder.\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m        Returns:\u001b[0m\n",
-      "\u001b[0;34m            Optimizer: Adam optimizer for each decoder\u001b[0m\n",
-      "\u001b[0;34m        \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;32mreturn\u001b[0m \u001b[0moptim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAdam\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m            \u001b[0mparams\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m            \u001b[0mlr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.001\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m            \u001b[0mweight_decay\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.00001\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0mlearning_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mLearningType\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;34m\"\"\"Return the learning type of the model.\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m        Returns:\u001b[0m\n",
-      "\u001b[0;34m            LearningType: Learning type of the model.\u001b[0m\n",
-      "\u001b[0;34m        \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m        \u001b[0;32mreturn\u001b[0m \u001b[0mLearningType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mONE_CLASS\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mFile:\u001b[0m           ~/anomalib/src/anomalib/models/image/fastflow/lightning_model.py\n",
-      "\u001b[0;31mType:\u001b[0m           ABCMeta\n",
-      "\u001b[0;31mSubclasses:\u001b[0m     "
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "Fastflow??"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -312,7 +184,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -351,7 +223,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -413,70 +285,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "4b40cd5a1e094248b521f07ef14291de",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Testing: |          | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃        Test metric        ┃       DataLoader 0        ┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│        image_AUROC        │            1.0            │\n",
-       "│       image_F1Score       │            1.0            │\n",
-       "│        pixel_AUROC        │    0.9769068956375122     │\n",
-       "└───────────────────────────┴───────────────────────────┘\n",
-       "\n"
-      ],
-      "text/plain": [
-       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       image_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m           1.0           \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m      image_F1Score      \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m           1.0           \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       pixel_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9769068956375122    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "└───────────────────────────┴───────────────────────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[{'pixel_AUROC': 0.9769068956375122, 'image_AUROC': 1.0, 'image_F1Score': 1.0}]"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "engine.test(datamodule=datamodule, model=model)"
    ]
@@ -497,7 +312,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -506,7 +321,7 @@
    "outputs": [],
    "source": [
     "inference_dataset = PredictDataset(path=dataset_root / \"bottle/test/broken_large/000.png\")\n",
-    "inference_dataloader = DataLoader(dataset=inference_dataset)"
+    "inference_dataloader = DataLoader(dataset=inference_dataset, collate_fn=inference_dataset.collate_fn)"
    ]
   },
   {
@@ -548,28 +363,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Image Shape: torch.Size([1, 3, 256, 256]),\n",
-      "Anomaly Map Shape: {predictions[\"anomaly_maps\"].shape}, \n",
-      "Predicted Mask Shape: {predictions[\"pred_masks\"].shape}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\n",
-    "    f'Image Shape: {predictions[\"image\"].shape},\\n'\n",
-    "    'Anomaly Map Shape: {predictions[\"anomaly_maps\"].shape}, \\n'\n",
-    "    'Predicted Mask Shape: {predictions[\"pred_masks\"].shape}',\n",
+    "    f\"Image Shape: {predictions.image.shape},\\n\"\n",
+    "    f\"Anomaly Map Shape: {predictions.anomaly_map.shape}, \\n\"\n",
+    "    f\"Predicted Mask Shape: {predictions.pred_mask.shape}\",\n",
     ")"
    ]
   },
@@ -606,12 +411,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "image_path = predictions[\"image_path\"][0]\n",
-    "image_size = predictions[\"image\"].shape[-2:]\n",
+    "image_path = predictions.image_path[0]\n",
+    "image_size = predictions.image.shape[-2:]\n",
     "image = np.array(Image.open(image_path).resize(image_size))"
    ]
   },
@@ -629,36 +434,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "anomaly_map = predictions[\"anomaly_maps\"][0]\n",
+   "outputs": [],
+   "source": [
+    "anomaly_map = predictions.anomaly_map[0]\n",
     "anomaly_map = anomaly_map.cpu().numpy().squeeze()\n",
     "plt.imshow(anomaly_map)"
    ]
@@ -677,34 +461,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "heat_map = superimpose_anomaly_map(anomaly_map=anomaly_map, image=image, normalize=True)\n",
     "plt.imshow(heat_map)"
@@ -724,24 +487,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "tensor(0.6486) tensor(True)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "pred_score = predictions[\"pred_scores\"][0]\n",
-    "pred_labels = predictions[\"pred_labels\"][0]\n",
+    "pred_score = predictions.pred_score[0]\n",
+    "pred_labels = predictions.pred_label[0]\n",
     "print(pred_score, pred_labels)"
    ]
   },
@@ -759,36 +514,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "pred_masks = predictions[\"pred_masks\"][0].squeeze().cpu().numpy()\n",
+   "outputs": [],
+   "source": [
+    "pred_masks = predictions.pred_mask[0].squeeze().cpu().numpy()\n",
     "plt.imshow(pred_masks)"
    ]
   },
@@ -821,7 +555,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.14"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/600_loggers/601_mlflow_logging.ipynb b/notebooks/600_loggers/601_mlflow_logging.ipynb
index 1d37c03592..f45a7a0e74 100644
--- a/notebooks/600_loggers/601_mlflow_logging.ipynb
+++ b/notebooks/600_loggers/601_mlflow_logging.ipynb
@@ -34,17 +34,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%pip install -qU anomalib"
    ]
@@ -60,17 +52,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%pip install -qU anomalib[loggers]"
    ]
@@ -86,17 +70,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%pip install -qU mlflow"
    ]
@@ -125,7 +101,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -150,7 +126,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -171,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -205,524 +181,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Help on class MVTec in module anomalib.data.image.mvtec:\n",
-      "\n",
-      "class MVTec(anomalib.data.base.datamodule.AnomalibDataModule)\n",
-      " |  MVTec(root: pathlib.Path | str = './datasets/MVTec', category: str = 'bottle', train_batch_size: int = 32, eval_batch_size: int = 32, num_workers: int = 8, task: anomalib.TaskType | str = , image_size: tuple[int, int] | None = None, transform: torchvision.transforms.v2._transform.Transform | None = None, train_transform: torchvision.transforms.v2._transform.Transform | None = None, eval_transform: torchvision.transforms.v2._transform.Transform | None = None, test_split_mode: anomalib.data.utils.split.TestSplitMode | str = , test_split_ratio: float = 0.2, val_split_mode: anomalib.data.utils.split.ValSplitMode | str = , val_split_ratio: float = 0.5, seed: int | None = None) -> None\n",
-      " |  \n",
-      " |  MVTec Datamodule.\n",
-      " |  \n",
-      " |  Args:\n",
-      " |      root (Path | str): Path to the root of the dataset.\n",
-      " |          Defaults to ``\"./datasets/MVTec\"``.\n",
-      " |      category (str): Category of the MVTec dataset (e.g. \"bottle\" or \"cable\").\n",
-      " |          Defaults to ``\"bottle\"``.\n",
-      " |      train_batch_size (int, optional): Training batch size.\n",
-      " |          Defaults to ``32``.\n",
-      " |      eval_batch_size (int, optional): Test batch size.\n",
-      " |          Defaults to ``32``.\n",
-      " |      num_workers (int, optional): Number of workers.\n",
-      " |          Defaults to ``8``.\n",
-      " |      task TaskType): Task type, 'classification', 'detection' or 'segmentation'\n",
-      " |          Defaults to ``TaskType.SEGMENTATION``.\n",
-      " |      image_size (tuple[int, int], optional): Size to which input images should be resized.\n",
-      " |          Defaults to ``None``.\n",
-      " |      transform (Transform, optional): Transforms that should be applied to the input images.\n",
-      " |          Defaults to ``None``.\n",
-      " |      train_transform (Transform, optional): Transforms that should be applied to the input images during training.\n",
-      " |          Defaults to ``None``.\n",
-      " |      eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.\n",
-      " |          Defaults to ``None``.\n",
-      " |      test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.\n",
-      " |          Defaults to ``TestSplitMode.FROM_DIR``.\n",
-      " |      test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.\n",
-      " |          Defaults to ``0.2``.\n",
-      " |      val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.\n",
-      " |          Defaults to ``ValSplitMode.SAME_AS_TEST``.\n",
-      " |      val_split_ratio (float): Fraction of train or test images that will be reserved for validation.\n",
-      " |          Defaults to ``0.5``.\n",
-      " |      seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.\n",
-      " |          Defualts to ``None``.\n",
-      " |  \n",
-      " |  Examples:\n",
-      " |      To create an MVTec AD datamodule with default settings:\n",
-      " |  \n",
-      " |      >>> datamodule = MVTec()\n",
-      " |      >>> datamodule.setup()\n",
-      " |      >>> i, data = next(enumerate(datamodule.train_dataloader()))\n",
-      " |      >>> data.keys()\n",
-      " |      dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask'])\n",
-      " |  \n",
-      " |      >>> data[\"image\"].shape\n",
-      " |      torch.Size([32, 3, 256, 256])\n",
-      " |  \n",
-      " |      To change the category of the dataset:\n",
-      " |  \n",
-      " |      >>> datamodule = MVTec(category=\"cable\")\n",
-      " |  \n",
-      " |      To change the image and batch size:\n",
-      " |  \n",
-      " |      >>> datamodule = MVTec(image_size=(512, 512), train_batch_size=16, eval_batch_size=8)\n",
-      " |  \n",
-      " |      MVTec AD dataset does not provide a validation set. If you would like\n",
-      " |      to use a separate validation set, you can use the ``val_split_mode`` and\n",
-      " |      ``val_split_ratio`` arguments to create a validation set.\n",
-      " |  \n",
-      " |      >>> datamodule = MVTec(val_split_mode=ValSplitMode.FROM_TEST, val_split_ratio=0.1)\n",
-      " |  \n",
-      " |      This will subsample the test set by 10% and use it as the validation set.\n",
-      " |      If you would like to create a validation set synthetically that would\n",
-      " |      not change the test set, you can use the ``ValSplitMode.SYNTHETIC`` option.\n",
-      " |  \n",
-      " |      >>> datamodule = MVTec(val_split_mode=ValSplitMode.SYNTHETIC, val_split_ratio=0.2)\n",
-      " |  \n",
-      " |  Method resolution order:\n",
-      " |      MVTec\n",
-      " |      anomalib.data.base.datamodule.AnomalibDataModule\n",
-      " |      lightning.pytorch.core.datamodule.LightningDataModule\n",
-      " |      lightning.pytorch.core.hooks.DataHooks\n",
-      " |      lightning.pytorch.core.mixins.hparams_mixin.HyperparametersMixin\n",
-      " |      abc.ABC\n",
-      " |      builtins.object\n",
-      " |  \n",
-      " |  Methods defined here:\n",
-      " |  \n",
-      " |  __init__(self, root: pathlib.Path | str = './datasets/MVTec', category: str = 'bottle', train_batch_size: int = 32, eval_batch_size: int = 32, num_workers: int = 8, task: anomalib.TaskType | str = , image_size: tuple[int, int] | None = None, transform: torchvision.transforms.v2._transform.Transform | None = None, train_transform: torchvision.transforms.v2._transform.Transform | None = None, eval_transform: torchvision.transforms.v2._transform.Transform | None = None, test_split_mode: anomalib.data.utils.split.TestSplitMode | str = , test_split_ratio: float = 0.2, val_split_mode: anomalib.data.utils.split.ValSplitMode | str = , val_split_ratio: float = 0.5, seed: int | None = None) -> None\n",
-      " |      Attributes:\n",
-      " |          prepare_data_per_node:\n",
-      " |              If True, each LOCAL_RANK=0 will call prepare data.\n",
-      " |              Otherwise only NODE_RANK=0, LOCAL_RANK=0 will prepare data.\n",
-      " |          allow_zero_length_dataloader_with_multiple_devices:\n",
-      " |              If True, dataloader with zero length within local rank is allowed.\n",
-      " |              Default value is False.\n",
-      " |  \n",
-      " |  prepare_data(self) -> None\n",
-      " |      Download the dataset if not available.\n",
-      " |      \n",
-      " |      This method checks if the specified dataset is available in the file system.\n",
-      " |      If not, it downloads and extracts the dataset into the appropriate directory.\n",
-      " |      \n",
-      " |      Example:\n",
-      " |          Assume the dataset is not available on the file system.\n",
-      " |          Here's how the directory structure looks before and after calling the\n",
-      " |          `prepare_data` method:\n",
-      " |      \n",
-      " |          Before:\n",
-      " |      \n",
-      " |          .. code-block:: bash\n",
-      " |      \n",
-      " |              $ tree datasets\n",
-      " |              datasets\n",
-      " |              ├── dataset1\n",
-      " |              └── dataset2\n",
-      " |      \n",
-      " |          Calling the method:\n",
-      " |      \n",
-      " |          .. code-block:: python\n",
-      " |      \n",
-      " |              >> datamodule = MVTec(root=\"./datasets/MVTec\", category=\"bottle\")\n",
-      " |              >> datamodule.prepare_data()\n",
-      " |      \n",
-      " |          After:\n",
-      " |      \n",
-      " |          .. code-block:: bash\n",
-      " |      \n",
-      " |              $ tree datasets\n",
-      " |              datasets\n",
-      " |              ├── dataset1\n",
-      " |              ├── dataset2\n",
-      " |              └── MVTec\n",
-      " |                  ├── bottle\n",
-      " |                  ├── ...\n",
-      " |                  └── zipper\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes defined here:\n",
-      " |  \n",
-      " |  __abstractmethods__ = frozenset()\n",
-      " |  \n",
-      " |  __annotations__ = {}\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Methods inherited from anomalib.data.base.datamodule.AnomalibDataModule:\n",
-      " |  \n",
-      " |  predict_dataloader(self) -> Any\n",
-      " |      Use the test dataloader for inference unless overridden.\n",
-      " |  \n",
-      " |  setup(self, stage: str | None = None) -> None\n",
-      " |      Set up train, validation and test data.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          stage: str | None:  Train/Val/Test stages.\n",
-      " |              Defaults to ``None``.\n",
-      " |  \n",
-      " |  test_dataloader(self) -> Any\n",
-      " |      Get test dataloader.\n",
-      " |  \n",
-      " |  train_dataloader(self) -> Any\n",
-      " |      Get train dataloader.\n",
-      " |  \n",
-      " |  val_dataloader(self) -> Any\n",
-      " |      Get validation dataloader.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Readonly properties inherited from anomalib.data.base.datamodule.AnomalibDataModule:\n",
-      " |  \n",
-      " |  eval_transform\n",
-      " |      Get the transform that will be passed to the val/test/predict datasets.\n",
-      " |      \n",
-      " |      If the eval_transform is not set, the engine will request the transform from the model.\n",
-      " |  \n",
-      " |  name\n",
-      " |      Name of the datamodule.\n",
-      " |  \n",
-      " |  train_transform\n",
-      " |      Get the transforms that will be passed to the train dataset.\n",
-      " |      \n",
-      " |      If the train_transform is not set, the engine will request the transform from the model.\n",
-      " |  \n",
-      " |  transform\n",
-      " |      Property that returns the user-specified transform for the datamodule, if any.\n",
-      " |      \n",
-      " |      This property is accessed by the engine to set the transform for the model. The eval_transform takes precedence\n",
-      " |      over the train_transform, because the transform that we store in the model is the one that should be used during\n",
-      " |      inference.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data descriptors inherited from anomalib.data.base.datamodule.AnomalibDataModule:\n",
-      " |  \n",
-      " |  category\n",
-      " |      Get the category of the datamodule.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Methods inherited from lightning.pytorch.core.datamodule.LightningDataModule:\n",
-      " |  \n",
-      " |  load_from_checkpoint(cls, checkpoint_path: Union[str, pathlib.Path, IO], map_location: Union[torch.device, str, int, Callable[[torch.storage.UntypedStorage, str], Optional[torch.storage.UntypedStorage]], Dict[Union[torch.device, str, int], Union[torch.device, str, int]], NoneType] = None, hparams_file: Union[str, pathlib.Path, NoneType] = None, **kwargs: Any) -> typing_extensions.Self\n",
-      " |      Primary way of loading a datamodule from a checkpoint. When Lightning saves a checkpoint it stores the\n",
-      " |      arguments passed to ``__init__``  in the checkpoint under ``\"datamodule_hyper_parameters\"``.\n",
-      " |      \n",
-      " |      Any arguments specified through \\*\\*kwargs will override args stored in ``\"datamodule_hyper_parameters\"``.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          checkpoint_path: Path to checkpoint. This can also be a URL, or file-like object\n",
-      " |          map_location:\n",
-      " |              If your checkpoint saved a GPU model and you now load on CPUs\n",
-      " |              or a different number of GPUs, use this to map to the new setup.\n",
-      " |              The behaviour is the same as in :func:`torch.load`.\n",
-      " |          hparams_file: Optional path to a ``.yaml`` or ``.csv`` file with hierarchical structure\n",
-      " |              as in this example::\n",
-      " |      \n",
-      " |                  dataloader:\n",
-      " |                      batch_size: 32\n",
-      " |      \n",
-      " |              You most likely won't need this since Lightning will always save the hyperparameters\n",
-      " |              to the checkpoint.\n",
-      " |              However, if your checkpoint weights don't have the hyperparameters saved,\n",
-      " |              use this method to pass in a ``.yaml`` file with the hparams you'd like to use.\n",
-      " |              These will be converted into a :class:`~dict` and passed into your\n",
-      " |              :class:`LightningDataModule` for use.\n",
-      " |      \n",
-      " |              If your datamodule's ``hparams`` argument is :class:`~argparse.Namespace`\n",
-      " |              and ``.yaml`` file has hierarchical structure, you need to refactor your datamodule to treat\n",
-      " |              ``hparams`` as :class:`~dict`.\n",
-      " |          \\**kwargs: Any extra keyword args needed to init the datamodule. Can also be used to override saved\n",
-      " |              hyperparameter values.\n",
-      " |      \n",
-      " |      Return:\n",
-      " |          :class:`LightningDataModule` instance with loaded weights and hyperparameters (if available).\n",
-      " |      \n",
-      " |      Note:\n",
-      " |          ``load_from_checkpoint`` is a **class** method. You must use your :class:`LightningDataModule`\n",
-      " |          **class** to call it instead of the :class:`LightningDataModule` instance, or a\n",
-      " |          ``TypeError`` will be raised.\n",
-      " |      \n",
-      " |      Example::\n",
-      " |      \n",
-      " |          # load weights without mapping ...\n",
-      " |          datamodule = MyLightningDataModule.load_from_checkpoint('path/to/checkpoint.ckpt')\n",
-      " |      \n",
-      " |          # or load weights and hyperparameters from separate files.\n",
-      " |          datamodule = MyLightningDataModule.load_from_checkpoint(\n",
-      " |              'path/to/checkpoint.ckpt',\n",
-      " |              hparams_file='/path/to/hparams_file.yaml'\n",
-      " |          )\n",
-      " |      \n",
-      " |          # override some of the params with new values\n",
-      " |          datamodule = MyLightningDataModule.load_from_checkpoint(\n",
-      " |              PATH,\n",
-      " |              batch_size=32,\n",
-      " |              num_workers=10,\n",
-      " |          )\n",
-      " |  \n",
-      " |  load_state_dict(self, state_dict: Dict[str, Any]) -> None\n",
-      " |      Called when loading a checkpoint, implement to reload datamodule state given datamodule state_dict.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          state_dict: the datamodule state returned by ``state_dict``.\n",
-      " |  \n",
-      " |  state_dict(self) -> Dict[str, Any]\n",
-      " |      Called when saving a checkpoint, implement to generate and save datamodule state.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          A dictionary containing datamodule state.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Class methods inherited from lightning.pytorch.core.datamodule.LightningDataModule:\n",
-      " |  \n",
-      " |  from_datasets(train_dataset: Union[torch.utils.data.dataset.Dataset, Iterable[torch.utils.data.dataset.Dataset], NoneType] = None, val_dataset: Union[torch.utils.data.dataset.Dataset, Iterable[torch.utils.data.dataset.Dataset], NoneType] = None, test_dataset: Union[torch.utils.data.dataset.Dataset, Iterable[torch.utils.data.dataset.Dataset], NoneType] = None, predict_dataset: Union[torch.utils.data.dataset.Dataset, Iterable[torch.utils.data.dataset.Dataset], NoneType] = None, batch_size: int = 1, num_workers: int = 0, **datamodule_kwargs: Any) -> 'LightningDataModule' from abc.ABCMeta\n",
-      " |      Create an instance from torch.utils.data.Dataset.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          train_dataset: Optional dataset or iterable of datasets to be used for train_dataloader()\n",
-      " |          val_dataset: Optional dataset or iterable of datasets to be used for val_dataloader()\n",
-      " |          test_dataset: Optional dataset or iterable of datasets to be used for test_dataloader()\n",
-      " |          predict_dataset: Optional dataset or iterable of datasets to be used for predict_dataloader()\n",
-      " |          batch_size: Batch size to use for each dataloader. Default is 1. This parameter gets forwarded to the\n",
-      " |              ``__init__`` if the datamodule has such a name defined in its signature.\n",
-      " |          num_workers: Number of subprocesses to use for data loading. 0 means that the\n",
-      " |              data will be loaded in the main process. Number of CPUs available. This parameter gets forwarded to the\n",
-      " |              ``__init__`` if the datamodule has such a name defined in its signature.\n",
-      " |          **datamodule_kwargs: Additional parameters that get passed down to the datamodule's ``__init__``.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes inherited from lightning.pytorch.core.datamodule.LightningDataModule:\n",
-      " |  \n",
-      " |  CHECKPOINT_HYPER_PARAMS_KEY = 'datamodule_hyper_parameters'\n",
-      " |  \n",
-      " |  CHECKPOINT_HYPER_PARAMS_NAME = 'datamodule_hparams_name'\n",
-      " |  \n",
-      " |  CHECKPOINT_HYPER_PARAMS_TYPE = 'datamodule_hparams_type'\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Methods inherited from lightning.pytorch.core.hooks.DataHooks:\n",
-      " |  \n",
-      " |  on_after_batch_transfer(self, batch: Any, dataloader_idx: int) -> Any\n",
-      " |      Override to alter or apply batch augmentations to your batch after it is transferred to the device.\n",
-      " |      \n",
-      " |      Note:\n",
-      " |          To check the current state of execution of this hook you can use\n",
-      " |          ``self.trainer.training/testing/validating/predicting`` so that you can\n",
-      " |          add different logic as per your requirement.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          batch: A batch of data that needs to be altered or augmented.\n",
-      " |          dataloader_idx: The index of the dataloader to which the batch belongs.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          A batch of data\n",
-      " |      \n",
-      " |      Example::\n",
-      " |      \n",
-      " |          def on_after_batch_transfer(self, batch, dataloader_idx):\n",
-      " |              batch['x'] = gpu_transforms(batch['x'])\n",
-      " |              return batch\n",
-      " |      \n",
-      " |      Raises:\n",
-      " |          MisconfigurationException:\n",
-      " |              If using IPUs, ``Trainer(accelerator='ipu')``.\n",
-      " |      \n",
-      " |      See Also:\n",
-      " |          - :meth:`on_before_batch_transfer`\n",
-      " |          - :meth:`transfer_batch_to_device`\n",
-      " |  \n",
-      " |  on_before_batch_transfer(self, batch: Any, dataloader_idx: int) -> Any\n",
-      " |      Override to alter or apply batch augmentations to your batch before it is transferred to the device.\n",
-      " |      \n",
-      " |      Note:\n",
-      " |          To check the current state of execution of this hook you can use\n",
-      " |          ``self.trainer.training/testing/validating/predicting`` so that you can\n",
-      " |          add different logic as per your requirement.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          batch: A batch of data that needs to be altered or augmented.\n",
-      " |          dataloader_idx: The index of the dataloader to which the batch belongs.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          A batch of data\n",
-      " |      \n",
-      " |      Example::\n",
-      " |      \n",
-      " |          def on_before_batch_transfer(self, batch, dataloader_idx):\n",
-      " |              batch['x'] = transforms(batch['x'])\n",
-      " |              return batch\n",
-      " |      \n",
-      " |      See Also:\n",
-      " |          - :meth:`on_after_batch_transfer`\n",
-      " |          - :meth:`transfer_batch_to_device`\n",
-      " |  \n",
-      " |  teardown(self, stage: str) -> None\n",
-      " |      Called at the end of fit (train + validate), validate, test, or predict.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          stage: either ``'fit'``, ``'validate'``, ``'test'``, or ``'predict'``\n",
-      " |  \n",
-      " |  transfer_batch_to_device(self, batch: Any, device: torch.device, dataloader_idx: int) -> Any\n",
-      " |      Override this hook if your :class:`~torch.utils.data.DataLoader` returns tensors wrapped in a custom data\n",
-      " |      structure.\n",
-      " |      \n",
-      " |      The data types listed below (and any arbitrary nesting of them) are supported out of the box:\n",
-      " |      \n",
-      " |      - :class:`torch.Tensor` or anything that implements `.to(...)`\n",
-      " |      - :class:`list`\n",
-      " |      - :class:`dict`\n",
-      " |      - :class:`tuple`\n",
-      " |      \n",
-      " |      For anything else, you need to define how the data is moved to the target device (CPU, GPU, TPU, ...).\n",
-      " |      \n",
-      " |      Note:\n",
-      " |          This hook should only transfer the data and not modify it, nor should it move the data to\n",
-      " |          any other device than the one passed in as argument (unless you know what you are doing).\n",
-      " |          To check the current state of execution of this hook you can use\n",
-      " |          ``self.trainer.training/testing/validating/predicting`` so that you can\n",
-      " |          add different logic as per your requirement.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          batch: A batch of data that needs to be transferred to a new device.\n",
-      " |          device: The target device as defined in PyTorch.\n",
-      " |          dataloader_idx: The index of the dataloader to which the batch belongs.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          A reference to the data on the new device.\n",
-      " |      \n",
-      " |      Example::\n",
-      " |      \n",
-      " |          def transfer_batch_to_device(self, batch, device, dataloader_idx):\n",
-      " |              if isinstance(batch, CustomBatch):\n",
-      " |                  # move all tensors in your custom data structure to the device\n",
-      " |                  batch.samples = batch.samples.to(device)\n",
-      " |                  batch.targets = batch.targets.to(device)\n",
-      " |              elif dataloader_idx == 0:\n",
-      " |                  # skip device transfer for the first dataloader or anything you wish\n",
-      " |                  pass\n",
-      " |              else:\n",
-      " |                  batch = super().transfer_batch_to_device(batch, device, dataloader_idx)\n",
-      " |              return batch\n",
-      " |      \n",
-      " |      Raises:\n",
-      " |          MisconfigurationException:\n",
-      " |              If using IPUs, ``Trainer(accelerator='ipu')``.\n",
-      " |      \n",
-      " |      See Also:\n",
-      " |          - :meth:`move_data_to_device`\n",
-      " |          - :meth:`apply_to_collection`\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data descriptors inherited from lightning.pytorch.core.hooks.DataHooks:\n",
-      " |  \n",
-      " |  __dict__\n",
-      " |      dictionary for instance variables (if defined)\n",
-      " |  \n",
-      " |  __weakref__\n",
-      " |      list of weak references to the object (if defined)\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Methods inherited from lightning.pytorch.core.mixins.hparams_mixin.HyperparametersMixin:\n",
-      " |  \n",
-      " |  save_hyperparameters(self, *args: Any, ignore: Union[Sequence[str], str, NoneType] = None, frame: Optional[frame] = None, logger: bool = True) -> None\n",
-      " |      Save arguments to ``hparams`` attribute.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          args: single object of `dict`, `NameSpace` or `OmegaConf`\n",
-      " |              or string names or arguments from class ``__init__``\n",
-      " |          ignore: an argument name or a list of argument names from\n",
-      " |              class ``__init__`` to be ignored\n",
-      " |          frame: a frame object. Default is None\n",
-      " |          logger: Whether to send the hyperparameters to the logger. Default: True\n",
-      " |      \n",
-      " |      Example::\n",
-      " |          >>> from lightning.pytorch.core.mixins import HyperparametersMixin\n",
-      " |          >>> class ManuallyArgsModel(HyperparametersMixin):\n",
-      " |          ...     def __init__(self, arg1, arg2, arg3):\n",
-      " |          ...         super().__init__()\n",
-      " |          ...         # manually assign arguments\n",
-      " |          ...         self.save_hyperparameters('arg1', 'arg3')\n",
-      " |          ...     def forward(self, *args, **kwargs):\n",
-      " |          ...         ...\n",
-      " |          >>> model = ManuallyArgsModel(1, 'abc', 3.14)\n",
-      " |          >>> model.hparams\n",
-      " |          \"arg1\": 1\n",
-      " |          \"arg3\": 3.14\n",
-      " |      \n",
-      " |          >>> from lightning.pytorch.core.mixins import HyperparametersMixin\n",
-      " |          >>> class AutomaticArgsModel(HyperparametersMixin):\n",
-      " |          ...     def __init__(self, arg1, arg2, arg3):\n",
-      " |          ...         super().__init__()\n",
-      " |          ...         # equivalent automatic\n",
-      " |          ...         self.save_hyperparameters()\n",
-      " |          ...     def forward(self, *args, **kwargs):\n",
-      " |          ...         ...\n",
-      " |          >>> model = AutomaticArgsModel(1, 'abc', 3.14)\n",
-      " |          >>> model.hparams\n",
-      " |          \"arg1\": 1\n",
-      " |          \"arg2\": abc\n",
-      " |          \"arg3\": 3.14\n",
-      " |      \n",
-      " |          >>> from lightning.pytorch.core.mixins import HyperparametersMixin\n",
-      " |          >>> class SingleArgModel(HyperparametersMixin):\n",
-      " |          ...     def __init__(self, params):\n",
-      " |          ...         super().__init__()\n",
-      " |          ...         # manually assign single argument\n",
-      " |          ...         self.save_hyperparameters(params)\n",
-      " |          ...     def forward(self, *args, **kwargs):\n",
-      " |          ...         ...\n",
-      " |          >>> model = SingleArgModel(Namespace(p1=1, p2='abc', p3=3.14))\n",
-      " |          >>> model.hparams\n",
-      " |          \"p1\": 1\n",
-      " |          \"p2\": abc\n",
-      " |          \"p3\": 3.14\n",
-      " |      \n",
-      " |          >>> from lightning.pytorch.core.mixins import HyperparametersMixin\n",
-      " |          >>> class ManuallyArgsModel(HyperparametersMixin):\n",
-      " |          ...     def __init__(self, arg1, arg2, arg3):\n",
-      " |          ...         super().__init__()\n",
-      " |          ...         # pass argument(s) to ignore as a string or in a list\n",
-      " |          ...         self.save_hyperparameters(ignore='arg2')\n",
-      " |          ...     def forward(self, *args, **kwargs):\n",
-      " |          ...         ...\n",
-      " |          >>> model = ManuallyArgsModel(1, 'abc', 3.14)\n",
-      " |          >>> model.hparams\n",
-      " |          \"arg1\": 1\n",
-      " |          \"arg3\": 3.14\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Readonly properties inherited from lightning.pytorch.core.mixins.hparams_mixin.HyperparametersMixin:\n",
-      " |  \n",
-      " |  hparams\n",
-      " |      The collection of hyperparameters saved with :meth:`save_hyperparameters`. It is mutable by the user. For\n",
-      " |      the frozen set of initial hyperparameters, use :attr:`hparams_initial`.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          Mutable hyperparameters dictionary\n",
-      " |  \n",
-      " |  hparams_initial\n",
-      " |      The collection of hyperparameters saved with :meth:`save_hyperparameters`. These contents are read-only.\n",
-      " |      Manual updates to the saved hyperparameters can instead be performed through :attr:`hparams`.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          AttributeDict: immutable initial hyperparameters\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes inherited from lightning.pytorch.core.mixins.hparams_mixin.HyperparametersMixin:\n",
-      " |  \n",
-      " |  __jit_unused_properties__ = ['hparams', 'hparams_initial']\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "help(MVTec)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -753,7 +221,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -776,220 +244,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Help on class AnomalibMLFlowLogger in module anomalib.loggers.mlflow:\n",
-      "\n",
-      "class AnomalibMLFlowLogger(anomalib.loggers.base.ImageLoggerBase, lightning.pytorch.loggers.mlflow.MLFlowLogger)\n",
-      " |  AnomalibMLFlowLogger(experiment_name: str | None = 'anomalib_logs', run_name: str | None = None, tracking_uri: str | None = None, save_dir: str | None = './mlruns', log_model: Optional[Literal[True, False, 'all']] = False, prefix: str | None = '', **kwargs) -> None\n",
-      " |  \n",
-      " |  Logger for MLFlow.\n",
-      " |  \n",
-      " |  Adds interface for ``add_image`` in the logger rather than calling the\n",
-      " |  experiment object.\n",
-      " |  \n",
-      " |  .. note::\n",
-      " |      Same as the MLFlowLogger provided by PyTorch Lightning and the doc string is reproduced below.\n",
-      " |  \n",
-      " |  Track your parameters, metrics, source code and more using\n",
-      " |  `MLFlow `_.\n",
-      " |  \n",
-      " |  Install it with pip:\n",
-      " |  \n",
-      " |  .. code-block:: bash\n",
-      " |  \n",
-      " |      pip install mlflow\n",
-      " |  \n",
-      " |  Args:\n",
-      " |      experiment_name: The name of the experiment.\n",
-      " |      run_name: Name of the new run.\n",
-      " |          The `run_name` is internally stored as a ``mlflow.runName`` tag.\n",
-      " |          If the ``mlflow.runName`` tag has already been set in `tags`, the value is overridden by the `run_name`.\n",
-      " |      tracking_uri: Address of local or remote tracking server.\n",
-      " |          If not provided, defaults to `MLFLOW_TRACKING_URI` environment variable if set, otherwise it falls\n",
-      " |          back to `file:`.\n",
-      " |      save_dir: A path to a local directory where the MLflow runs get saved.\n",
-      " |          Defaults to `./mlruns` if `tracking_uri` is not provided.\n",
-      " |          Has no effect if `tracking_uri` is provided.\n",
-      " |      log_model: Log checkpoints created by `ModelCheckpoint` as MLFlow artifacts.\n",
-      " |  \n",
-      " |          - if ``log_model == 'all'``, checkpoints are logged during training.\n",
-      " |          - if ``log_model == True``, checkpoints are logged at the end of training,                 except when `save_top_k == -1` which also logs every checkpoint during training.\n",
-      " |          - if ``log_model == False`` (default), no checkpoint is logged.\n",
-      " |  \n",
-      " |      prefix: A string to put at the beginning of metric keys. Defaults to ``''``.\n",
-      " |      kwargs: Additional arguments like `tags`, `artifact_location` etc. used by\n",
-      " |          `MLFlowExperiment` can be passed as keyword arguments in this logger.\n",
-      " |  \n",
-      " |  Example:\n",
-      " |      >>> from anomalib.loggers import AnomalibMLFlowLogger\n",
-      " |      >>> from anomalib.engine import Engine\n",
-      " |      ...\n",
-      " |      >>> mlflow_logger = AnomalibMLFlowLogger()\n",
-      " |      >>> engine = Engine(logger=mlflow_logger)\n",
-      " |  \n",
-      " |  See Also:\n",
-      " |      - `MLFlow Documentation `_.\n",
-      " |  \n",
-      " |  Method resolution order:\n",
-      " |      AnomalibMLFlowLogger\n",
-      " |      anomalib.loggers.base.ImageLoggerBase\n",
-      " |      lightning.pytorch.loggers.mlflow.MLFlowLogger\n",
-      " |      lightning.pytorch.loggers.logger.Logger\n",
-      " |      lightning.fabric.loggers.logger.Logger\n",
-      " |      abc.ABC\n",
-      " |      builtins.object\n",
-      " |  \n",
-      " |  Methods defined here:\n",
-      " |  \n",
-      " |  __init__(self, experiment_name: str | None = 'anomalib_logs', run_name: str | None = None, tracking_uri: str | None = None, save_dir: str | None = './mlruns', log_model: Optional[Literal[True, False, 'all']] = False, prefix: str | None = '', **kwargs) -> None\n",
-      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
-      " |  \n",
-      " |  add_image(self, image: numpy.ndarray | matplotlib.figure.Figure, name: str | None = None, **kwargs) -> None\n",
-      " |      Interface to log images in the mlflow loggers.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          image (np.ndarray | Figure): Image to log.\n",
-      " |          name (str | None): The tag of the image defaults to ``None``.\n",
-      " |          kwargs: Additional keyword arguments that are only used if `image` is of type Figure.\n",
-      " |              These arguments are passed directly to the method that saves the figure.\n",
-      " |              If `image` is a NumPy array, `kwargs` has no effect.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes defined here:\n",
-      " |  \n",
-      " |  __abstractmethods__ = frozenset()\n",
-      " |  \n",
-      " |  __annotations__ = {}\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data descriptors inherited from anomalib.loggers.base.ImageLoggerBase:\n",
-      " |  \n",
-      " |  __dict__\n",
-      " |      dictionary for instance variables (if defined)\n",
-      " |  \n",
-      " |  __weakref__\n",
-      " |      list of weak references to the object (if defined)\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Methods inherited from lightning.pytorch.loggers.mlflow.MLFlowLogger:\n",
-      " |  \n",
-      " |  after_save_checkpoint(self, checkpoint_callback: lightning.pytorch.callbacks.model_checkpoint.ModelCheckpoint) -> None\n",
-      " |      Called after model checkpoint callback saves a new checkpoint.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          checkpoint_callback: the model checkpoint callback instance\n",
-      " |  \n",
-      " |  finalize(self, status: str = 'success') -> None\n",
-      " |      Do any processing that is necessary to finalize an experiment.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          status: Status that the experiment finished with (e.g. success, failed, aborted)\n",
-      " |  \n",
-      " |  log_hyperparams(self, params: Union[Dict[str, Any], argparse.Namespace]) -> None\n",
-      " |      Record hyperparameters.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          params: :class:`~argparse.Namespace` or `Dict` containing the hyperparameters\n",
-      " |          args: Optional positional arguments, depends on the specific logger being used\n",
-      " |          kwargs: Optional keyword arguments, depends on the specific logger being used\n",
-      " |  \n",
-      " |  log_metrics(self, metrics: Mapping[str, float], step: Optional[int] = None) -> None\n",
-      " |      Records metrics. This method logs metrics as soon as it received them.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          metrics: Dictionary with metric names as keys and measured quantities as values\n",
-      " |          step: Step number at which the metrics should be recorded\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Readonly properties inherited from lightning.pytorch.loggers.mlflow.MLFlowLogger:\n",
-      " |  \n",
-      " |  experiment\n",
-      " |      Actual MLflow object. To use MLflow features in your :class:`~lightning.pytorch.core.LightningModule` do the\n",
-      " |      following.\n",
-      " |      \n",
-      " |      Example::\n",
-      " |      \n",
-      " |          self.logger.experiment.some_mlflow_function()\n",
-      " |  \n",
-      " |  experiment_id\n",
-      " |      Create the experiment if it does not exist to get the experiment id.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          The experiment id.\n",
-      " |  \n",
-      " |  name\n",
-      " |      Get the experiment id.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          The experiment id.\n",
-      " |  \n",
-      " |  run_id\n",
-      " |      Create the experiment if it does not exist to get the run id.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          The run id.\n",
-      " |  \n",
-      " |  save_dir\n",
-      " |      The root file directory in which MLflow experiments are saved.\n",
-      " |      \n",
-      " |      Return:\n",
-      " |          Local path to the root experiment directory if the tracking uri is local.\n",
-      " |          Otherwise returns `None`.\n",
-      " |  \n",
-      " |  version\n",
-      " |      Get the run id.\n",
-      " |      \n",
-      " |      Returns:\n",
-      " |          The run id.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Data and other attributes inherited from lightning.pytorch.loggers.mlflow.MLFlowLogger:\n",
-      " |  \n",
-      " |  LOGGER_JOIN_CHAR = '-'\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Methods inherited from lightning.fabric.loggers.logger.Logger:\n",
-      " |  \n",
-      " |  log_graph(self, model: torch.nn.modules.module.Module, input_array: Optional[torch.Tensor] = None) -> None\n",
-      " |      Record model graph.\n",
-      " |      \n",
-      " |      Args:\n",
-      " |          model: the model with an implementation of ``forward``.\n",
-      " |          input_array: input passes to `model.forward`\n",
-      " |  \n",
-      " |  save(self) -> None\n",
-      " |      Save log data.\n",
-      " |  \n",
-      " |  ----------------------------------------------------------------------\n",
-      " |  Readonly properties inherited from lightning.fabric.loggers.logger.Logger:\n",
-      " |  \n",
-      " |  group_separator\n",
-      " |      Return the default separator used by the logger to group the data into subfolders.\n",
-      " |  \n",
-      " |  log_dir\n",
-      " |      Return directory the current version of the experiment gets saved, or `None` if the logger does not save\n",
-      " |      data locally.\n",
-      " |  \n",
-      " |  root_dir\n",
-      " |      Return the root directory where all versions of an experiment get saved, or `None` if the logger does not\n",
-      " |      save data locally.\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "help(AnomalibMLFlowLogger)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1012,7 +276,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1030,7 +294,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1060,233 +324,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO:pytorch_lightning.utilities.rank_zero:GPU available: True (cuda), used: True\n",
-      "INFO:pytorch_lightning.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n",
-      "INFO:pytorch_lightning.utilities.rank_zero:IPU available: False, using: 0 IPUs\n",
-      "INFO:pytorch_lightning.utilities.rank_zero:HPU available: False, using: 0 HPUs\n",
-      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
-      "\n",
-      "  | Name                  | Type                     | Params\n",
-      "-------------------------------------------------------------------\n",
-      "0 | loss                  | FastflowLoss             | 0     \n",
-      "1 | _transform            | Compose                  | 0     \n",
-      "2 | normalization_metrics | MinMax                   | 0     \n",
-      "3 | image_threshold       | F1AdaptiveThreshold      | 0     \n",
-      "4 | pixel_threshold       | F1AdaptiveThreshold      | 0     \n",
-      "5 | image_metrics         | AnomalibMetricCollection | 0     \n",
-      "6 | pixel_metrics         | AnomalibMetricCollection | 0     \n",
-      "7 | model                 | FastflowModel            | 7.7 M \n",
-      "-------------------------------------------------------------------\n",
-      "3.5 M     Trainable params\n",
-      "4.2 M     Non-trainable params\n",
-      "7.7 M     Total params\n",
-      "30.678    Total estimated model params size (MB)\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "aad5e6a5204a440eb9afdadd6634ec50",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Training: |          | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃        Test metric        ┃       DataLoader 0        ┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│        image_AUROC        │            1.0            │\n",
-       "│       image_F1Score       │    0.9919999837875366     │\n",
-       "│        pixel_AUROC        │     0.973434567451477     │\n",
-       "└───────────────────────────┴───────────────────────────┘\n",
-       "\n"
-      ],
-      "text/plain": [
-       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       image_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m           1.0           \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m      image_F1Score      \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9919999837875366    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       pixel_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m    0.973434567451477    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "└───────────────────────────┴───────────────────────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[{'pixel_AUROC': 0.973434567451477,\n",
-       "  'image_AUROC': 1.0,\n",
-       "  'image_F1Score': 0.9919999837875366}]"
-      ]
-     },
-     "execution_count": 51,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "engine.test(model=model, dataloaders=datamodule.test_dataloader())"
    ]
@@ -1375,7 +356,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1396,7 +377,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1415,337 +396,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "FastflowModel(\n",
-       "  (feature_extractor): FeatureListNet(\n",
-       "    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
-       "    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "    (act1): ReLU(inplace=True)\n",
-       "    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
-       "    (layer1): Sequential(\n",
-       "      (0): BasicBlock(\n",
-       "        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "      )\n",
-       "      (1): BasicBlock(\n",
-       "        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (layer2): Sequential(\n",
-       "      (0): BasicBlock(\n",
-       "        (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "        (downsample): Sequential(\n",
-       "          (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
-       "          (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        )\n",
-       "      )\n",
-       "      (1): BasicBlock(\n",
-       "        (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "      )\n",
-       "    )\n",
-       "    (layer3): Sequential(\n",
-       "      (0): BasicBlock(\n",
-       "        (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "        (downsample): Sequential(\n",
-       "          (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
-       "          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        )\n",
-       "      )\n",
-       "      (1): BasicBlock(\n",
-       "        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (drop_block): Identity()\n",
-       "        (act1): ReLU(inplace=True)\n",
-       "        (aa): Identity()\n",
-       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
-       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
-       "        (act2): ReLU(inplace=True)\n",
-       "      )\n",
-       "    )\n",
-       "  )\n",
-       "  (norms): ModuleList(\n",
-       "    (0): LayerNorm((64, 64, 64), eps=1e-05, elementwise_affine=True)\n",
-       "    (1): LayerNorm((128, 32, 32), eps=1e-05, elementwise_affine=True)\n",
-       "    (2): LayerNorm((256, 16, 16), eps=1e-05, elementwise_affine=True)\n",
-       "  )\n",
-       "  (fast_flow_blocks): ModuleList(\n",
-       "    (0): SequenceINN(\n",
-       "      (module_list): ModuleList(\n",
-       "        (0): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (1): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (2): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (3): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (4): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (5): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (6): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (7): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "      )\n",
-       "    )\n",
-       "    (1): SequenceINN(\n",
-       "      (module_list): ModuleList(\n",
-       "        (0): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (1): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (2): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (3): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (4): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (5): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (6): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (7): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "      )\n",
-       "    )\n",
-       "    (2): SequenceINN(\n",
-       "      (module_list): ModuleList(\n",
-       "        (0): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (1): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (2): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (3): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (4): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (5): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (6): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((1, 1, 1, 1))\n",
-       "            (4): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "        (7): AllInOneBlock(\n",
-       "          (subnet): Sequential(\n",
-       "            (0): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1))\n",
-       "            (2): ReLU()\n",
-       "            (3): ZeroPad2d((0, 0, 0, 0))\n",
-       "            (4): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))\n",
-       "          )\n",
-       "        )\n",
-       "      )\n",
-       "    )\n",
-       "  )\n",
-       "  (anomaly_map_generator): AnomalyMapGenerator()\n",
-       ")"
-      ]
-     },
-     "execution_count": 54,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "model_uri = f\"runs:/{mlflow_logger.run_id}/Fastflow\"\n",
     "mlflow.pytorch.load_model(model_uri)"
@@ -1768,7 +421,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.14"
   }
  },
  "nbformat": 4,
diff --git a/src/anomalib/__init__.py b/src/anomalib/__init__.py
index 1b7a30497c..cd82b638b9 100644
--- a/src/anomalib/__init__.py
+++ b/src/anomalib/__init__.py
@@ -20,5 +20,4 @@ class TaskType(str, Enum):
     """Task type used when generating predictions on the dataset."""
 
     CLASSIFICATION = "classification"
-    DETECTION = "detection"
     SEGMENTATION = "segmentation"
diff --git a/src/anomalib/callbacks/metrics.py b/src/anomalib/callbacks/metrics.py
index 5cee830dad..0dd7cd882e 100644
--- a/src/anomalib/callbacks/metrics.py
+++ b/src/anomalib/callbacks/metrics.py
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+from dataclasses import asdict
 from enum import Enum
 from typing import Any
 
@@ -12,6 +13,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import TaskType
+from anomalib.dataclasses import Batch
 from anomalib.metrics import AnomalibMetricCollection, create_metric_collection
 from anomalib.models import AnomalyModule
 
@@ -96,7 +98,6 @@ def setup(
                         pl_module.pixel_metrics.add_metrics(new_metrics[name])
             else:
                 pl_module.pixel_metrics = create_metric_collection(pixel_metric_names, "pixel_")
-            self._set_threshold(pl_module)
 
     @staticmethod
     def on_validation_epoch_start(trainer: Trainer, pl_module: AnomalyModule) -> None:
@@ -117,13 +118,12 @@ def on_validation_batch_end(
         del trainer, batch, batch_idx, dataloader_idx  # Unused arguments.
 
         if outputs is not None:
-            self._outputs_to_device(outputs)
+            outputs = self._outputs_to_device(outputs)
             self._update_metrics(pl_module.image_metrics, pl_module.pixel_metrics, outputs)
 
     def on_validation_epoch_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
         del trainer  # Unused argument.
 
-        self._set_threshold(pl_module)
         self._log_metrics(pl_module)
 
     @staticmethod
@@ -145,7 +145,7 @@ def on_test_batch_end(
         del trainer, batch, batch_idx, dataloader_idx  # Unused arguments.
 
         if outputs is not None:
-            self._outputs_to_device(outputs)
+            outputs = self._outputs_to_device(outputs)
             self._update_metrics(pl_module.image_metrics, pl_module.pixel_metrics, outputs)
 
     def on_test_epoch_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
@@ -153,11 +153,6 @@ def on_test_epoch_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
 
         self._log_metrics(pl_module)
 
-    @staticmethod
-    def _set_threshold(pl_module: AnomalyModule) -> None:
-        pl_module.image_metrics.set_threshold(pl_module.image_threshold.value.item())
-        pl_module.pixel_metrics.set_threshold(pl_module.pixel_threshold.value.item())
-
     def _update_metrics(
         self,
         image_metric: AnomalibMetricCollection,
@@ -165,15 +160,17 @@ def _update_metrics(
         output: STEP_OUTPUT,
     ) -> None:
         image_metric.to(self.device)
-        image_metric.update(output["pred_scores"], output["label"].int())
-        if "mask" in output and "anomaly_maps" in output:
+        image_metric.update(output.pred_score, output.gt_label.int())
+        if output.gt_mask is not None and output.anomaly_map is not None:
             pixel_metric.to(self.device)
-            pixel_metric.update(torch.squeeze(output["anomaly_maps"]), torch.squeeze(output["mask"].int()))
+            pixel_metric.update(torch.squeeze(output.anomaly_map), torch.squeeze(output.gt_mask.int()))
 
     def _outputs_to_device(self, output: STEP_OUTPUT) -> STEP_OUTPUT | dict[str, Any]:
         if isinstance(output, dict):
             for key, value in output.items():
                 output[key] = self._outputs_to_device(value)
+        elif isinstance(output, Batch):
+            output = output.__class__(**self._outputs_to_device(asdict(output)))
         elif isinstance(output, torch.Tensor):
             output = output.to(self.device)
         return output
diff --git a/src/anomalib/callbacks/normalization/__init__.py b/src/anomalib/callbacks/normalization/__init__.py
deleted file mode 100644
index a502b1aa5e..0000000000
--- a/src/anomalib/callbacks/normalization/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""Normalization callbacks.
-
-Note: These callbacks are used within the Engine.
-"""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from .min_max_normalization import _MinMaxNormalizationCallback
-from .utils import get_normalization_callback
-
-__all__ = ["get_normalization_callback", "_MinMaxNormalizationCallback"]
diff --git a/src/anomalib/callbacks/normalization/base.py b/src/anomalib/callbacks/normalization/base.py
deleted file mode 100644
index 0812905889..0000000000
--- a/src/anomalib/callbacks/normalization/base.py
+++ /dev/null
@@ -1,29 +0,0 @@
-"""Base Normalization Callback."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from abc import ABC, abstractmethod
-
-from lightning.pytorch import Callback
-from lightning.pytorch.utilities.types import STEP_OUTPUT
-
-from anomalib.models.components import AnomalyModule
-
-
-class NormalizationCallback(Callback, ABC):
-    """Base normalization callback."""
-
-    @staticmethod
-    @abstractmethod
-    def _normalize_batch(batch: STEP_OUTPUT, pl_module: AnomalyModule) -> None:
-        """Normalize an output batch.
-
-        Args:
-            batch (dict[str, torch.Tensor]): Output batch.
-            pl_module (AnomalyModule): AnomalyModule instance.
-
-        Returns:
-            dict[str, torch.Tensor]: Normalized batch.
-        """
-        raise NotImplementedError
diff --git a/src/anomalib/callbacks/normalization/min_max_normalization.py b/src/anomalib/callbacks/normalization/min_max_normalization.py
deleted file mode 100644
index ff0afc9232..0000000000
--- a/src/anomalib/callbacks/normalization/min_max_normalization.py
+++ /dev/null
@@ -1,131 +0,0 @@
-"""Anomaly Score Normalization Callback that uses min-max normalization."""
-
-# Copyright (C) 2022-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Any
-
-import torch
-from lightning.pytorch import Trainer
-from lightning.pytorch.utilities.types import STEP_OUTPUT
-from torchmetrics import MetricCollection
-
-from anomalib.metrics import MinMax
-from anomalib.models.components import AnomalyModule
-from anomalib.utils.normalization.min_max import normalize
-
-from .base import NormalizationCallback
-
-
-class _MinMaxNormalizationCallback(NormalizationCallback):
-    """Callback that normalizes the image-level and pixel-level anomaly scores using min-max normalization.
-
-    Note: This callback is set within the Engine.
-    """
-
-    @staticmethod
-    def setup(trainer: Trainer, pl_module: AnomalyModule, stage: str | None = None) -> None:
-        """Add min_max metrics to normalization metrics."""
-        del trainer, stage  # These variables are not used.
-
-        if not hasattr(pl_module, "normalization_metrics"):
-            pl_module.normalization_metrics = MetricCollection(
-                {
-                    "anomaly_maps": MinMax().cpu(),
-                    "box_scores": MinMax().cpu(),
-                    "pred_scores": MinMax().cpu(),
-                },
-            )
-
-        elif not isinstance(pl_module.normalization_metrics, MetricCollection):
-            msg = (
-                f"Expected normalization_metrics to be of type MetricCollection"
-                f"got {type(pl_module.normalization_metrics)}"
-            )
-            raise TypeError(msg)
-
-        for name, metric in pl_module.normalization_metrics.items():
-            if not isinstance(metric, MinMax):
-                msg = f"Expected normalization_metric {name} to be of type MinMax, got {type(metric)}"
-                raise TypeError(msg)
-
-    @staticmethod
-    def on_test_start(trainer: Trainer, pl_module: AnomalyModule) -> None:
-        """Call when the test begins."""
-        del trainer  # `trainer` variable is not used.
-
-        for metric in (pl_module.image_metrics, pl_module.pixel_metrics):
-            if metric is not None:
-                metric.set_threshold(0.5)
-
-    @staticmethod
-    def on_validation_epoch_start(trainer: Trainer, pl_module: AnomalyModule) -> None:
-        """Call when the validation epoch begins."""
-        del trainer  # `trainer` variable is not used.
-
-        if hasattr(pl_module, "normalization_metrics"):
-            pl_module.normalization_metrics.reset()
-
-    @staticmethod
-    def on_validation_batch_end(
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        outputs: STEP_OUTPUT,
-        batch: Any,  # noqa: ANN401
-        batch_idx: int,
-        dataloader_idx: int = 0,
-    ) -> None:
-        """Call when the validation batch ends, update the min and max observed values."""
-        del trainer, batch, batch_idx, dataloader_idx  # These variables are not used.
-
-        if "anomaly_maps" in outputs:
-            pl_module.normalization_metrics["anomaly_maps"](outputs["anomaly_maps"])
-        if "box_scores" in outputs:
-            pl_module.normalization_metrics["box_scores"](torch.cat(outputs["box_scores"]))
-        if "pred_scores" in outputs:
-            pl_module.normalization_metrics["pred_scores"](outputs["pred_scores"])
-
-    def on_test_batch_end(
-        self,
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        outputs: STEP_OUTPUT | None,
-        batch: Any,  # noqa: ANN401
-        batch_idx: int,
-        dataloader_idx: int = 0,
-    ) -> None:
-        """Call when the test batch ends, normalizes the predicted scores and anomaly maps."""
-        del trainer, batch, batch_idx, dataloader_idx  # These variables are not used.
-
-        self._normalize_batch(outputs, pl_module)
-
-    def on_predict_batch_end(
-        self,
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        outputs: Any,  # noqa: ANN401
-        batch: Any,  # noqa: ANN401
-        batch_idx: int,
-        dataloader_idx: int = 0,
-    ) -> None:
-        """Call when the predict batch ends, normalizes the predicted scores and anomaly maps."""
-        del trainer, batch, batch_idx, dataloader_idx  # These variables are not used.
-
-        self._normalize_batch(outputs, pl_module)
-
-    @staticmethod
-    def _normalize_batch(outputs: Any, pl_module: AnomalyModule) -> None:  # noqa: ANN401
-        """Normalize a batch of predictions."""
-        image_threshold = pl_module.image_threshold.value.cpu()
-        pixel_threshold = pl_module.pixel_threshold.value.cpu()
-        if "pred_scores" in outputs:
-            stats = pl_module.normalization_metrics["pred_scores"].cpu()
-            outputs["pred_scores"] = normalize(outputs["pred_scores"], image_threshold, stats.min, stats.max)
-        if "anomaly_maps" in outputs:
-            stats = pl_module.normalization_metrics["anomaly_maps"].cpu()
-            outputs["anomaly_maps"] = normalize(outputs["anomaly_maps"], pixel_threshold, stats.min, stats.max)
-        if "box_scores" in outputs:
-            stats = pl_module.normalization_metrics["box_scores"].cpu()
-            outputs["box_scores"] = [
-                normalize(scores, pixel_threshold, stats.min, stats.max) for scores in outputs["box_scores"]
-            ]
diff --git a/src/anomalib/callbacks/normalization/utils.py b/src/anomalib/callbacks/normalization/utils.py
deleted file mode 100644
index fca2d3f29d..0000000000
--- a/src/anomalib/callbacks/normalization/utils.py
+++ /dev/null
@@ -1,78 +0,0 @@
-"""Normalization callback utils."""
-
-# Copyright (C) 2022 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import importlib
-
-from lightning.pytorch import Callback
-from omegaconf import DictConfig
-
-from anomalib.utils.normalization import NormalizationMethod
-from anomalib.utils.types import NORMALIZATION
-
-from .min_max_normalization import _MinMaxNormalizationCallback
-
-
-def get_normalization_callback(
-    normalization_method: NORMALIZATION = NormalizationMethod.MIN_MAX,
-) -> Callback | None:
-    """Return normalization object.
-
-    normalization_method is an instance of ``Callback``, it is returned as is.
-
-    if normalization_method is of type ``NormalizationMethod``, then a new class is created based on the type of
-    normalization_method.
-
-    Otherwise it expects a dictionary containing class_path and init_args.
-        normalization_method:
-            class_path: MinMaxNormalizer
-            init_args:
-                -
-                -
-
-    Example:
-        >>> normalizer = get_normalization_callback(NormalizationMethod.MIN_MAX)
-        or
-        >>> normalizer = get_normalization_callback("min_max")
-        or
-        >>> normalizer = get_normalization_callback({"class_path": "MinMaxNormalizationCallback", "init_args": {}})
-        or
-        >>> normalizer = get_normalization_callback(MinMaxNormalizationCallback())
-    """
-    normalizer: Callback | None
-    if isinstance(normalization_method, NormalizationMethod | str):
-        normalizer = _get_normalizer_from_method(NormalizationMethod(normalization_method))
-    elif isinstance(normalization_method, Callback):
-        normalizer = normalization_method
-    elif isinstance(normalization_method, DictConfig):
-        normalizer = _parse_normalizer_config(normalization_method)
-    else:
-        msg = f"Unknown normalizer type {normalization_method}"
-        raise TypeError(msg)
-    return normalizer
-
-
-def _get_normalizer_from_method(normalization_method: NormalizationMethod | str) -> Callback | None:
-    if normalization_method == NormalizationMethod.NONE:
-        normalizer = None
-    elif normalization_method == NormalizationMethod.MIN_MAX:
-        normalizer = _MinMaxNormalizationCallback()
-    else:
-        msg = f"Unknown normalization method {normalization_method}"
-        raise ValueError(msg)
-    return normalizer
-
-
-def _parse_normalizer_config(normalization_method: DictConfig) -> Callback:
-    class_path = normalization_method.class_path
-    init_args = normalization_method.init_args
-
-    if len(class_path.split(".")) == 1:
-        module_path = "anomalib.utils.callbacks.normalization"
-    else:
-        module_path = ".".join(class_path.split(".")[:-1])
-        class_path = class_path.split(".")[-1]
-    module = importlib.import_module(module_path)
-    class_ = getattr(module, class_path)
-    return class_(**init_args)
diff --git a/src/anomalib/callbacks/post_processor.py b/src/anomalib/callbacks/post_processor.py
deleted file mode 100644
index a6fc7a9d49..0000000000
--- a/src/anomalib/callbacks/post_processor.py
+++ /dev/null
@@ -1,124 +0,0 @@
-"""Callback that attaches necessary pre/post-processing to the model."""
-
-# Copyright (C) 2023 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import Any
-
-import torch
-from lightning import Callback
-from lightning.pytorch import Trainer
-from lightning.pytorch.utilities.types import STEP_OUTPUT
-
-from anomalib.data.utils import boxes_to_anomaly_maps, boxes_to_masks, masks_to_boxes
-from anomalib.models import AnomalyModule
-
-
-class _PostProcessorCallback(Callback):
-    """Applies post-processing to the model outputs.
-
-    Note: This callback is set within the Engine.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-
-    def on_validation_batch_end(
-        self,
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        outputs: STEP_OUTPUT | None,
-        batch: Any,  # noqa: ANN401
-        batch_idx: int,
-        dataloader_idx: int = 0,
-    ) -> None:
-        del batch, batch_idx, dataloader_idx  # Unused arguments.
-
-        if outputs is not None:
-            self.post_process(trainer, pl_module, outputs)
-
-    def on_test_batch_end(
-        self,
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        outputs: STEP_OUTPUT | None,
-        batch: Any,  # noqa: ANN401
-        batch_idx: int,
-        dataloader_idx: int = 0,
-    ) -> None:
-        del batch, batch_idx, dataloader_idx  # Unused arguments.
-
-        if outputs is not None:
-            self.post_process(trainer, pl_module, outputs)
-
-    def on_predict_batch_end(
-        self,
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        outputs: Any,  # noqa: ANN401
-        batch: Any,  # noqa: ANN401
-        batch_idx: int,
-        dataloader_idx: int = 0,
-    ) -> None:
-        del batch, batch_idx, dataloader_idx  # Unused arguments.
-
-        if outputs is not None:
-            self.post_process(trainer, pl_module, outputs)
-
-    def post_process(self, trainer: Trainer, pl_module: AnomalyModule, outputs: STEP_OUTPUT) -> None:
-        if isinstance(outputs, dict):
-            self._post_process(outputs)
-            if trainer.predicting or trainer.testing:
-                self._compute_scores_and_labels(pl_module, outputs)
-
-    @staticmethod
-    def _compute_scores_and_labels(
-        pl_module: AnomalyModule,
-        outputs: dict[str, Any],
-    ) -> None:
-        if "pred_scores" in outputs:
-            outputs["pred_labels"] = outputs["pred_scores"] >= pl_module.image_threshold.value
-        if "anomaly_maps" in outputs:
-            outputs["pred_masks"] = outputs["anomaly_maps"] >= pl_module.pixel_threshold.value
-            if "pred_boxes" not in outputs:
-                outputs["pred_boxes"], outputs["box_scores"] = masks_to_boxes(
-                    outputs["pred_masks"],
-                    outputs["anomaly_maps"],
-                )
-                outputs["box_labels"] = [torch.ones(boxes.shape[0]) for boxes in outputs["pred_boxes"]]
-        # apply thresholding to boxes
-        if "box_scores" in outputs and "box_labels" not in outputs:
-            # apply threshold to assign normal/anomalous label to boxes
-            is_anomalous = [scores > pl_module.pixel_threshold.value for scores in outputs["box_scores"]]
-            outputs["box_labels"] = [labels.int() for labels in is_anomalous]
-
-    @staticmethod
-    def _post_process(outputs: STEP_OUTPUT) -> None:
-        """Compute labels based on model predictions."""
-        if isinstance(outputs, dict):
-            if "pred_scores" not in outputs and "anomaly_maps" in outputs:
-                # infer image scores from anomaly maps
-                outputs["pred_scores"] = (
-                    outputs["anomaly_maps"]  # noqa: PD011
-                    .reshape(outputs["anomaly_maps"].shape[0], -1)
-                    .max(dim=1)
-                    .values
-                )
-            elif "pred_scores" not in outputs and "box_scores" in outputs and "label" in outputs:
-                # infer image score from bbox confidence scores
-                outputs["pred_scores"] = torch.zeros_like(outputs["label"]).float()
-                for idx, (boxes, scores) in enumerate(zip(outputs["pred_boxes"], outputs["box_scores"], strict=True)):
-                    if boxes.numel():
-                        outputs["pred_scores"][idx] = scores.max().item()
-
-            if "pred_boxes" in outputs and "anomaly_maps" not in outputs:
-                # create anomaly maps from bbox predictions for thresholding and evaluation
-                image_size: tuple[int, int] = outputs["image"].shape[-2:]
-                pred_boxes: torch.Tensor = outputs["pred_boxes"]
-                box_scores: torch.Tensor = outputs["box_scores"]
-
-                outputs["anomaly_maps"] = boxes_to_anomaly_maps(pred_boxes, box_scores, image_size)
-
-                if "boxes" in outputs:
-                    true_boxes: list[torch.Tensor] = outputs["boxes"]
-                    outputs["mask"] = boxes_to_masks(true_boxes, image_size)
diff --git a/src/anomalib/callbacks/thresholding.py b/src/anomalib/callbacks/thresholding.py
deleted file mode 100644
index 14bae0331d..0000000000
--- a/src/anomalib/callbacks/thresholding.py
+++ /dev/null
@@ -1,201 +0,0 @@
-"""Thresholding callback."""
-
-# Copyright (C) 2023 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import importlib
-from typing import Any
-
-import torch
-from lightning.pytorch import Callback, Trainer
-from lightning.pytorch.utilities.types import STEP_OUTPUT
-from omegaconf import DictConfig, ListConfig
-
-from anomalib.metrics.threshold import Threshold
-from anomalib.models import AnomalyModule
-from anomalib.utils.types import THRESHOLD
-
-
-class _ThresholdCallback(Callback):
-    """Setup/apply thresholding.
-
-    Note: This callback is set within the Engine.
-    """
-
-    def __init__(
-        self,
-        threshold: THRESHOLD = "F1AdaptiveThreshold",
-    ) -> None:
-        super().__init__()
-        self._initialize_thresholds(threshold)
-        self.image_threshold: Threshold
-        self.pixel_threshold: Threshold
-
-    def setup(self, trainer: Trainer, pl_module: AnomalyModule, stage: str) -> None:
-        del trainer, stage  # Unused arguments.
-        if not hasattr(pl_module, "image_threshold"):
-            pl_module.image_threshold = self.image_threshold
-        if not hasattr(pl_module, "pixel_threshold"):
-            pl_module.pixel_threshold = self.pixel_threshold
-
-    def on_validation_epoch_start(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
-        del trainer  # Unused argument.
-        self._reset(pl_module)
-
-    def on_validation_batch_end(
-        self,
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        outputs: STEP_OUTPUT | None,
-        batch: Any,  # noqa: ANN401
-        batch_idx: int,
-        dataloader_idx: int = 0,
-    ) -> None:
-        del trainer, batch, batch_idx, dataloader_idx  # Unused arguments.
-        if outputs is not None:
-            self._outputs_to_cpu(outputs)
-            self._update(pl_module, outputs)
-
-    def on_validation_epoch_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
-        del trainer  # Unused argument.
-        self._compute(pl_module)
-
-    def _initialize_thresholds(
-        self,
-        threshold: THRESHOLD,
-    ) -> None:
-        """Initialize ``self.image_threshold`` and ``self.pixel_threshold``.
-
-        Args:
-            threshold (THRESHOLD):
-                Threshold configuration
-
-        Example:
-            >>> _initialize_thresholds(F1AdaptiveThreshold())
-            or
-            >>> _initialize_thresholds((ManualThreshold(0.5), ManualThreshold(0.5)))
-            or configuration
-
-        For more details on configuration see :fun:`_load_from_config`
-
-        Raises:
-            ValueError: Unknown threshold class or incorrect configuration
-        """
-        # TODO(djdameln): Add tests for each case
-        # CVS-122661
-        # When only a single threshold class is passed.
-        # This initializes image and pixel thresholds with the same class
-        # >>> _initialize_thresholds(F1AdaptiveThreshold())
-        if isinstance(threshold, Threshold):
-            self.image_threshold = threshold
-            self.pixel_threshold = threshold.clone()
-
-        # When a tuple of threshold classes are passed
-        # >>> _initialize_thresholds((ManualThreshold(0.5), ManualThreshold(0.5)))
-        elif isinstance(threshold, tuple) and isinstance(threshold[0], Threshold):
-            self.image_threshold = threshold[0]
-            self.pixel_threshold = threshold[1]
-        # When the passed threshold is not an instance of a Threshold class.
-        elif isinstance(threshold, str | DictConfig | ListConfig | list):
-            self._load_from_config(threshold)
-        else:
-            msg = f"Invalid threshold type {type(threshold)}"
-            raise TypeError(msg)
-
-    def _load_from_config(self, threshold: DictConfig | str | ListConfig | list[dict[str, str | float]]) -> None:
-        """Load the thresholding class based on the config.
-
-        Example:
-            threshold: F1AdaptiveThreshold
-            or
-            threshold:
-                class_path: F1AdaptiveThreshold
-                init_args:
-                    -
-            or
-            threshold:
-                - F1AdaptiveThreshold
-                - F1AdaptiveThreshold
-            or
-            threshold:
-                - class_path: F1AdaptiveThreshold
-                    init_args:
-                        -
-                - class_path: F1AdaptiveThreshold
-        """
-        if isinstance(threshold, str | DictConfig):
-            self.image_threshold = self._get_threshold_from_config(threshold)
-            self.pixel_threshold = self.image_threshold.clone()
-        elif isinstance(threshold, ListConfig | list):
-            self.image_threshold = self._get_threshold_from_config(threshold[0])
-            self.pixel_threshold = self._get_threshold_from_config(threshold[1])
-        else:
-            msg = f"Invalid threshold config {threshold}"
-            raise TypeError(msg)
-
-    @staticmethod
-    def _get_threshold_from_config(threshold: DictConfig | str | dict[str, str | float]) -> Threshold:
-        """Return the instantiated threshold object.
-
-        Example:
-            >>> _get_threshold_from_config(F1AdaptiveThreshold)
-            or
-            >>> config = DictConfig({
-            ...    "class_path": "ManualThreshold",
-            ...    "init_args": {"default_value": 0.7}
-            ... })
-            >>> __get_threshold_from_config(config)
-            or
-            >>> config = DictConfig({
-            ...    "class_path": "anomalib.metrics.threshold.F1AdaptiveThreshold"
-            ... })
-            >>> __get_threshold_from_config(config)
-
-        Returns:
-            (Threshold): Instance of threshold object.
-        """
-        if isinstance(threshold, str):
-            threshold = DictConfig({"class_path": threshold})
-
-        class_path = threshold["class_path"]
-        init_args = threshold.get("init_args", {})
-
-        if len(class_path.split(".")) == 1:
-            module_path = "anomalib.metrics.threshold"
-
-        else:
-            module_path = ".".join(class_path.split(".")[:-1])
-            class_path = class_path.split(".")[-1]
-
-        module = importlib.import_module(module_path)
-        class_ = getattr(module, class_path)
-        return class_(**init_args)
-
-    @staticmethod
-    def _reset(pl_module: AnomalyModule) -> None:
-        pl_module.image_threshold.reset()
-        pl_module.pixel_threshold.reset()
-
-    def _outputs_to_cpu(self, output: STEP_OUTPUT) -> STEP_OUTPUT | dict[str, Any]:
-        if isinstance(output, dict):
-            for key, value in output.items():
-                output[key] = self._outputs_to_cpu(value)
-        elif isinstance(output, torch.Tensor):
-            output = output.cpu()
-        return output
-
-    @staticmethod
-    def _update(pl_module: AnomalyModule, outputs: STEP_OUTPUT) -> None:
-        pl_module.image_threshold.cpu()
-        pl_module.image_threshold.update(outputs["pred_scores"], outputs["label"].int())
-        if "mask" in outputs and "anomaly_maps" in outputs:
-            pl_module.pixel_threshold.cpu()
-            pl_module.pixel_threshold.update(outputs["anomaly_maps"], outputs["mask"].int())
-
-    @staticmethod
-    def _compute(pl_module: AnomalyModule) -> None:
-        pl_module.image_threshold.compute()
-        if pl_module.pixel_threshold._update_called:  # noqa: SLF001
-            pl_module.pixel_threshold.compute()
-        else:
-            pl_module.pixel_threshold.value = pl_module.image_threshold.value
diff --git a/src/anomalib/cli/cli.py b/src/anomalib/cli/cli.py
index 323c700fa4..048c948d89 100644
--- a/src/anomalib/cli/cli.py
+++ b/src/anomalib/cli/cli.py
@@ -30,7 +30,6 @@
 
     from anomalib.data import AnomalibDataModule
     from anomalib.engine import Engine
-    from anomalib.metrics.threshold import Threshold
     from anomalib.models import AnomalyModule
     from anomalib.utils.config import update_config
 
@@ -148,13 +147,9 @@ def add_arguments_to_parser(parser: ArgumentParser) -> None:
             Since ``Engine`` parameters are manually added, any change to the
             ``Engine`` class should be reflected manually.
         """
-        from anomalib.callbacks.normalization import get_normalization_callback
-
-        parser.add_function_arguments(get_normalization_callback, "normalization")
         parser.add_argument("--task", type=TaskType | str, default=TaskType.SEGMENTATION)
-        parser.add_argument("--metrics.image", type=list[str] | str | None, default=["F1Score", "AUROC"])
+        parser.add_argument("--metrics.image", type=list[str] | str | None, default=None)
         parser.add_argument("--metrics.pixel", type=list[str] | str | None, default=None, required=False)
-        parser.add_argument("--metrics.threshold", type=Threshold | str, default="F1AdaptiveThreshold")
         parser.add_argument("--logging.log_graph", type=bool, help="Log the model to the logger", default=False)
         if hasattr(parser, "subcommand") and parser.subcommand not in {"export", "predict"}:
             parser.link_arguments("task", "data.init_args.task")
@@ -296,7 +291,7 @@ def instantiate_classes(self) -> None:
             self.config_init = self.parser.instantiate_classes(self.config)
             self.datamodule = self._get(self.config_init, "data")
             if isinstance(self.datamodule, Dataset):
-                self.datamodule = DataLoader(self.datamodule)
+                self.datamodule = DataLoader(self.datamodule, collate_fn=self.datamodule.collate_fn)
             self.model = self._get(self.config_init, "model")
             self._configure_optimizers_method_to_model()
             self.instantiate_engine()
@@ -327,8 +322,6 @@ def instantiate_engine(self) -> None:
         from anomalib.callbacks import get_callbacks
 
         engine_args = {
-            "normalization": self._get(self.config_init, "normalization.normalization_method"),
-            "threshold": self._get(self.config_init, "metrics.threshold"),
             "task": self._get(self.config_init, "task"),
             "image_metrics": self._get(self.config_init, "metrics.image"),
             "pixel_metrics": self._get(self.config_init, "metrics.pixel"),
diff --git a/src/anomalib/data/base/datamodule.py b/src/anomalib/data/base/datamodule.py
index cb95ca8171..d631433823 100644
--- a/src/anomalib/data/base/datamodule.py
+++ b/src/anomalib/data/base/datamodule.py
@@ -6,12 +6,12 @@
 import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from lightning.pytorch import LightningDataModule
 from lightning.pytorch.trainer.states import TrainerFn
 from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
-from torch.utils.data.dataloader import DataLoader, default_collate
+from torch.utils.data.dataloader import DataLoader
 from torchvision.transforms.v2 import Resize, Transform
 
 from anomalib.data.utils import TestSplitMode, ValSplitMode, random_split, split_by_label
@@ -25,29 +25,6 @@
 logger = logging.getLogger(__name__)
 
 
-def collate_fn(batch: list) -> dict[str, Any]:
-    """Collate bounding boxes as lists.
-
-    Bounding boxes are collated as a list of tensors, while the default collate function is used for all other entries.
-
-    Args:
-        batch (List): list of items in the batch where len(batch) is equal to the batch size.
-
-    Returns:
-        dict[str, Any]: Dictionary containing the collated batch information.
-    """
-    elem = batch[0]  # sample an element from the batch to check the type.
-    out_dict = {}
-    if isinstance(elem, dict):
-        if "boxes" in elem:
-            # collate boxes as list
-            out_dict["boxes"] = [item.pop("boxes") for item in batch]
-        # collate other data normally
-        out_dict.update({key: default_collate([item[key] for item in batch]) for key in elem})
-        return out_dict
-    return default_collate(batch)
-
-
 class AnomalibDataModule(LightningDataModule, ABC):
     """Base Anomalib data module.
 
@@ -224,6 +201,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,
         )
 
     def val_dataloader(self) -> EVAL_DATALOADERS:
@@ -233,7 +211,7 @@ def val_dataloader(self) -> EVAL_DATALOADERS:
             shuffle=False,
             batch_size=self.eval_batch_size,
             num_workers=self.num_workers,
-            collate_fn=collate_fn,
+            collate_fn=self.val_data.collate_fn,
         )
 
     def test_dataloader(self) -> EVAL_DATALOADERS:
@@ -243,7 +221,7 @@ def test_dataloader(self) -> EVAL_DATALOADERS:
             shuffle=False,
             batch_size=self.eval_batch_size,
             num_workers=self.num_workers,
-            collate_fn=collate_fn,
+            collate_fn=self.test_data.collate_fn,
         )
 
     def predict_dataloader(self) -> EVAL_DATALOADERS:
diff --git a/src/anomalib/data/base/dataset.py b/src/anomalib/data/base/dataset.py
index f1d2ff3149..b629555960 100644
--- a/src/anomalib/data/base/dataset.py
+++ b/src/anomalib/data/base/dataset.py
@@ -6,7 +6,7 @@
 import copy
 import logging
 from abc import ABC
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from pathlib import Path
 
 import pandas as pd
@@ -17,7 +17,8 @@
 from torchvision.tv_tensors import Mask
 
 from anomalib import TaskType
-from anomalib.data.utils import LabelName, masks_to_boxes, read_image, read_mask
+from anomalib.data.utils import LabelName, read_image, read_mask
+from anomalib.dataclasses import ImageBatch, ImageItem, Item
 
 _EXPECTED_COLUMNS_CLASSIFICATION = ["image_path", "split"]
 _EXPECTED_COLUMNS_SEGMENTATION = [*_EXPECTED_COLUMNS_CLASSIFICATION, "mask_path"]
@@ -152,26 +153,25 @@ def has_anomalous(self) -> bool:
         """Check if the dataset contains any anomalous samples."""
         return LabelName.ABNORMAL in list(self.samples.label_index)
 
-    def __getitem__(self, index: int) -> dict[str, str | torch.Tensor]:
+    def __getitem__(self, index: int) -> Item:
         """Get dataset item for the index ``index``.
 
         Args:
             index (int): Index to get the item.
 
         Returns:
-            dict[str, str | torch.Tensor]: Dict of image tensor during training. Otherwise, Dict containing image path,
-                target path, image tensor, label and transformed bounding box.
+            DatasetItem: DatasetItem instance containing image and ground truth (if available).
         """
         image_path = self.samples.iloc[index].image_path
         mask_path = self.samples.iloc[index].mask_path
         label_index = self.samples.iloc[index].label_index
 
         image = read_image(image_path, as_tensor=True)
-        item = {"image_path": image_path, "label": label_index}
+        item = {"image_path": image_path, "gt_label": label_index}
 
         if self.task == TaskType.CLASSIFICATION:
             item["image"] = self.transform(image) if self.transform else image
-        elif self.task in {TaskType.DETECTION, TaskType.SEGMENTATION}:
+        elif self.task == TaskType.SEGMENTATION:
             # Only Anomalous (1) images have masks in anomaly datasets
             # Therefore, create empty mask for Normal (0) images.
             mask = (
@@ -179,17 +179,19 @@ def __getitem__(self, index: int) -> dict[str, str | torch.Tensor]:
                 if label_index == LabelName.NORMAL
                 else read_mask(mask_path, as_tensor=True)
             )
-            item["image"], item["mask"] = self.transform(image, mask) if self.transform else (image, mask)
+            item["image"], item["gt_mask"] = self.transform(image, mask) if self.transform else (image, mask)
 
-            if self.task == TaskType.DETECTION:
-                # create boxes from masks for detection task
-                boxes, _ = masks_to_boxes(item["mask"])
-                item["boxes"] = boxes[0]
         else:
             msg = f"Unknown task type: {self.task}"
             raise ValueError(msg)
 
-        return item
+        return ImageItem(
+            image=item["image"],
+            gt_mask=item.get("gt_mask"),
+            gt_label=int(label_index),
+            image_path=image_path,
+            mask_path=mask_path,
+        )
 
     def __add__(self, other_dataset: "AnomalibDataset") -> "AnomalibDataset":
         """Concatenate this dataset with another dataset.
@@ -206,3 +208,12 @@ def __add__(self, other_dataset: "AnomalibDataset") -> "AnomalibDataset":
         dataset = copy.deepcopy(self)
         dataset.samples = pd.concat([self.samples, other_dataset.samples], ignore_index=True)
         return dataset
+
+    @property
+    def collate_fn(self) -> Callable:
+        """Get the collate function for the items returned by this dataset.
+
+        By default, the dataset is an image dataset, so we will return the ImageBatch's collate function.
+        Other dataset types should override this property.
+        """
+        return ImageBatch.collate
diff --git a/src/anomalib/data/base/depth.py b/src/anomalib/data/base/depth.py
index 0ffe0b3a34..8f97eb202a 100644
--- a/src/anomalib/data/base/depth.py
+++ b/src/anomalib/data/base/depth.py
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from abc import ABC
+from collections.abc import Callable
 
 import torch
 from PIL import Image
@@ -13,7 +14,8 @@
 
 from anomalib import TaskType
 from anomalib.data.base.dataset import AnomalibDataset
-from anomalib.data.utils import LabelName, masks_to_boxes, read_depth_image
+from anomalib.data.utils import LabelName, read_depth_image
+from anomalib.dataclasses import DepthBatch, DepthItem
 
 
 class AnomalibDepthDataset(AnomalibDataset, ABC):
@@ -30,7 +32,7 @@ def __init__(self, task: TaskType, transform: Transform | None = None) -> None:
 
         self.transform = transform
 
-    def __getitem__(self, index: int) -> dict[str, str | torch.Tensor]:
+    def __getitem__(self, index: int) -> DepthItem:
         """Return rgb image, depth image and mask.
 
         Args:
@@ -52,7 +54,7 @@ def __getitem__(self, index: int) -> dict[str, str | torch.Tensor]:
             item["image"], item["depth_image"] = (
                 self.transform(image, depth_image) if self.transform else (image, depth_image)
             )
-        elif self.task in {TaskType.DETECTION, TaskType.SEGMENTATION}:
+        elif self.task == TaskType.SEGMENTATION:
             # Only Anomalous (1) images have masks in anomaly datasets
             # Therefore, create empty mask for Normal (0) images.
             mask = (
@@ -65,12 +67,21 @@ def __getitem__(self, index: int) -> dict[str, str | torch.Tensor]:
             )
             item["mask_path"] = mask_path
 
-            if self.task == TaskType.DETECTION:
-                # create boxes from masks for detection task
-                boxes, _ = masks_to_boxes(item["mask"])
-                item["boxes"] = boxes[0]
         else:
             msg = f"Unknown task type: {self.task}"
             raise ValueError(msg)
 
-        return item
+        return DepthItem(
+            image=item["image"],
+            depth_map=item["depth_image"],
+            gt_mask=item.get("mask"),
+            gt_label=item["label"],
+            image_path=image_path,
+            depth_path=depth_path,
+            mask_path=item.get("mask_path"),
+        )
+
+    @property
+    def collate_fn(self) -> Callable:
+        """Return the collate function for depth batches."""
+        return DepthBatch.collate
diff --git a/src/anomalib/data/base/video.py b/src/anomalib/data/base/video.py
index 5f04ebfe3b..3bad81efdd 100644
--- a/src/anomalib/data/base/video.py
+++ b/src/anomalib/data/base/video.py
@@ -4,23 +4,21 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from abc import ABC
+from collections.abc import Callable
 from enum import Enum
-from typing import TYPE_CHECKING, Any
 
 import torch
 from pandas import DataFrame
 from torchvision.transforms.v2 import Transform
-from torchvision.transforms.v2.functional import to_dtype_video
+from torchvision.transforms.v2.functional import to_dtype, to_dtype_video
 from torchvision.tv_tensors import Mask
 
 from anomalib import TaskType
 from anomalib.data.base.datamodule import AnomalibDataModule
 from anomalib.data.base.dataset import AnomalibDataset
-from anomalib.data.utils import ValSplitMode, masks_to_boxes
+from anomalib.data.utils import ValSplitMode
 from anomalib.data.utils.video import ClipsIndexer
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
+from anomalib.dataclasses import VideoBatch, VideoItem
 
 
 class VideoTargetFrame(str, Enum):
@@ -107,17 +105,17 @@ def _setup_clips(self) -> None:
             frames_between_clips=self.frames_between_clips,
         )
 
-    def _select_targets(self, item: dict[str, Any]) -> dict[str, Any]:
+    def _select_targets(self, item: VideoItem) -> VideoItem:
         """Select the target frame from the clip.
 
         Args:
-            item (dict[str, Any]): Item containing the clip information.
+            item (DatasetItem): Item containing the clip information.
 
         Raises:
             ValueError: If the target frame is not one of the supported options.
 
         Returns:
-            dict[str, Any]: Selected item from the clip.
+            DatasetItem: Selected item from the clip.
         """
         if self.target_frame == VideoTargetFrame.FIRST:
             idx = 0
@@ -129,58 +127,55 @@ def _select_targets(self, item: dict[str, Any]) -> dict[str, Any]:
             msg = f"Unknown video target frame: {self.target_frame}"
             raise ValueError(msg)
 
-        if item.get("mask") is not None:
-            item["mask"] = item["mask"][idx, ...]
-        if item.get("boxes") is not None:
-            item["boxes"] = item["boxes"][idx]
-        if item.get("label") is not None:
-            item["label"] = item["label"][idx]
-        if item.get("original_image") is not None:
-            item["original_image"] = item["original_image"][idx]
-        if item.get("frames") is not None:
-            item["frames"] = item["frames"][idx]
+        if item.gt_mask is not None:
+            item.gt_mask = item.gt_mask[idx, ...]
+        if item.gt_label is not None:
+            item.gt_label = item.gt_label[idx]
+        if item.original_image is not None:
+            item.original_image = item.original_image[idx]
+        if item.frames is not None:
+            item.frames = item.frames[idx]
         return item
 
-    def __getitem__(self, index: int) -> dict[str, str | torch.Tensor]:
+    def __getitem__(self, index: int) -> VideoItem:
         """Get the dataset item for the index ``index``.
 
         Args:
             index (int): Index of the item to be returned.
 
         Returns:
-            dict[str, str | torch.Tensor]: Dictionary containing the mask, clip and file system information.
+            DatasetItem: Dictionary containing the mask, clip and file system information.
         """
         if not isinstance(self.indexer, ClipsIndexer):
             msg = "self.indexer must be an instance of ClipsIndexer."
             raise TypeError(msg)
         item = self.indexer.get_item(index)
-        item["image"] = to_dtype_video(video=item["image"], scale=True)
+        item.image = to_dtype_video(video=item.image, scale=True)
         # include the untransformed image for visualization
-        item["original_image"] = item["image"].to(torch.uint8)
+        item.original_image = to_dtype(item.image, torch.uint8, scale=True)
 
         # apply transforms
-        if item.get("mask") is not None:
+        if item.gt_mask is not None:
             if self.transform:
-                item["image"], item["mask"] = self.transform(item["image"], Mask(item["mask"]))
-            item["label"] = torch.Tensor([1 in frame for frame in item["mask"]]).int().squeeze(0)
-            if self.task == TaskType.DETECTION:
-                item["boxes"], _ = masks_to_boxes(item["mask"])
-                item["boxes"] = item["boxes"][0] if len(item["boxes"]) == 1 else item["boxes"]
+                item.image, item.gt_mask = self.transform(item.image, Mask(item.gt_mask))
+            item.gt_label = torch.Tensor([1 in frame for frame in item.gt_mask]).int().squeeze(0)
         elif self.transform:
-            item["image"] = self.transform(item["image"])
+            item.image = self.transform(item.image)
 
         # squeeze temporal dimensions in case clip length is 1
-        item["image"] = item["image"].squeeze(0)
+        item.image = item.image.squeeze(0)
 
         # include only target frame in gt
         if self.clip_length_in_frames > 1 and self.target_frame != VideoTargetFrame.ALL:
             item = self._select_targets(item)
 
-        if item["mask"] is None:
-            item.pop("mask")
-
         return item
 
+    @property
+    def collate_fn(self) -> Callable:
+        """Return the collate function for video batches."""
+        return VideoBatch.collate
+
 
 class AnomalibVideoDataModule(AnomalibDataModule):
     """Base class for video data modules."""
diff --git a/src/anomalib/data/predict.py b/src/anomalib/data/predict.py
index 856d1df683..857ddd218e 100644
--- a/src/anomalib/data/predict.py
+++ b/src/anomalib/data/predict.py
@@ -3,13 +3,14 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any
 
 from torch.utils.data.dataset import Dataset
 from torchvision.transforms.v2 import Transform
 
 from anomalib.data.utils import get_image_filenames, read_image
+from anomalib.dataclasses import ImageBatch, ImageItem
 
 
 class PredictDataset(Dataset):
@@ -39,13 +40,19 @@ def __len__(self) -> int:
         """Get the number of images in the given path."""
         return len(self.image_filenames)
 
-    def __getitem__(self, index: int) -> dict[str, Any]:
+    def __getitem__(self, index: int) -> ImageItem:
         """Get the image based on the `index`."""
         image_filename = self.image_filenames[index]
         image = read_image(image_filename, as_tensor=True)
         if self.transform:
             image = self.transform(image)
-        pre_processed = {"image": image}
-        pre_processed["image_path"] = str(image_filename)
 
-        return pre_processed
+        return ImageItem(
+            image=image,
+            image_path=str(image_filename),
+        )
+
+    @property
+    def collate_fn(self) -> Callable:
+        """Get the collate function."""
+        return ImageBatch.collate
diff --git a/src/anomalib/data/utils/video.py b/src/anomalib/data/utils/video.py
index 7a939ea861..330f58948c 100644
--- a/src/anomalib/data/utils/video.py
+++ b/src/anomalib/data/utils/video.py
@@ -6,12 +6,13 @@
 import warnings
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any
 
 import cv2
 import torch
 from torchvision.datasets.video_utils import VideoClips
 
+from anomalib.dataclasses import VideoItem
+
 
 class ClipsIndexer(VideoClips, ABC):
     """Extension of torchvision's VideoClips class that also returns the masks for each clip.
@@ -49,7 +50,7 @@ def get_mask(self, idx: int) -> torch.Tensor | None:
         """Return the masks for the given index."""
         raise NotImplementedError
 
-    def get_item(self, idx: int) -> dict[str, Any]:
+    def get_item(self, idx: int) -> VideoItem:
         """Return a dictionary containing the clip, mask, video path and frame indices."""
         with warnings.catch_warnings():
             # silence warning caused by bug in torchvision, see https://github.com/pytorch/vision/issues/5787
@@ -60,13 +61,13 @@ def get_item(self, idx: int) -> dict[str, Any]:
         video_path = self.video_paths[video_idx]
         clip_pts = self.clips[video_idx][clip_idx]
 
-        return {
-            "image": clip,
-            "mask": self.get_mask(idx),
-            "video_path": video_path,
-            "frames": clip_pts,
-            "last_frame": self.last_frame_idx(video_idx),
-        }
+        return VideoItem(
+            image=clip,
+            gt_mask=self.get_mask(idx),
+            video_path=video_path,
+            frames=clip_pts,
+            last_frame=self.last_frame_idx(video_idx),
+        )
 
 
 def convert_video(input_path: Path, output_path: Path, codec: str = "MP4V") -> None:
diff --git a/src/anomalib/dataclasses/__init__.py b/src/anomalib/dataclasses/__init__.py
new file mode 100644
index 0000000000..4af6acdc35
--- /dev/null
+++ b/src/anomalib/dataclasses/__init__.py
@@ -0,0 +1,38 @@
+"""Anomalib dataclasses."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .numpy import (
+    NumpyImageBatch,
+    NumpyImageItem,
+    NumpyVideoBatch,
+    NumpyVideoItem,
+)
+from .torch import (
+    Batch,
+    DepthBatch,
+    DepthItem,
+    ImageBatch,
+    ImageItem,
+    InferenceBatch,
+    Item,
+    VideoBatch,
+    VideoItem,
+)
+
+__all__ = [
+    "Item",
+    "Batch",
+    "InferenceBatch",
+    "ImageItem",
+    "ImageBatch",
+    "VideoItem",
+    "VideoBatch",
+    "NumpyImageItem",
+    "NumpyImageBatch",
+    "NumpyVideoItem",
+    "NumpyVideoBatch",
+    "DepthItem",
+    "DepthBatch",
+]
diff --git a/src/anomalib/dataclasses/generic.py b/src/anomalib/dataclasses/generic.py
new file mode 100644
index 0000000000..cf5258dc01
--- /dev/null
+++ b/src/anomalib/dataclasses/generic.py
@@ -0,0 +1,313 @@
+"""Generic dataclasses that can be implemented for different data types."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterator
+from dataclasses import asdict, dataclass, fields, is_dataclass, replace
+from types import NoneType
+from typing import Any, ClassVar, Generic, TypeVar, get_args, get_type_hints
+
+import numpy as np
+import torch
+from torch.utils.data import default_collate
+from torchvision.tv_tensors import Image, Mask, Video
+
+ImageT = TypeVar("ImageT", Image, Video, np.ndarray)
+T = TypeVar("T", torch.Tensor, np.ndarray)
+MaskT = TypeVar("MaskT", Mask, np.ndarray)
+PathT = TypeVar("PathT", list[str], str)
+
+
+Instance = TypeVar("Instance")
+Value = TypeVar("Value")
+
+
+class FieldDescriptor(
+    Generic[Value],
+):
+    """Descriptor for Anomalib's dataclass fields.
+
+    Using a descriptor ensures that the values of dataclass fields can be validated before being set.
+    This allows validation of the input data not only when it is first set, but also when it is updated.
+    """
+
+    def __init__(self, validator_name: str | None = None, default: Value | None = None) -> None:
+        """Initialize the descriptor."""
+        self.validator_name = validator_name
+        self.default = default
+
+    def __set_name__(self, owner: type[Instance], name: str) -> None:
+        """Set the name of the descriptor."""
+        self.name = name
+
+    def __get__(self, instance: Instance | None, owner: type[Instance]) -> Value | None:
+        """Get the value of the descriptor.
+
+        Returns:
+            - The default value if available and if the instance is None (method is called from class).
+            - The value of the attribute if the instance is not None (method is called from instance).
+        """
+        if instance is None:
+            if self.default is not None or self.is_optional(owner):
+                return self.default
+            msg = f"No default attribute value specified for field '{self.name}'."
+            raise AttributeError(msg)
+        return instance.__dict__[self.name]
+
+    def __set__(self, instance: Instance, value: Value) -> None:
+        """Set the value of the descriptor.
+
+        First calls the validator method if available, then sets the value of the attribute.
+        """
+        if self.validator_name is not None:
+            validator = getattr(instance, self.validator_name)
+            value = validator(value)
+        instance.__dict__[self.name] = value
+
+    def get_types(self, owner: type[Instance]) -> tuple[type, ...]:
+        """Get the types of the descriptor."""
+        try:
+            types = get_args(get_type_hints(owner)[self.name])
+            return get_args(types[0]) if hasattr(types[0], "__args__") else (types[0],)
+        except (KeyError, TypeError, AttributeError) as e:
+            msg = f"Unable to determine types for {self.name} in {owner}"
+            raise TypeError(msg) from e
+
+    def is_optional(self, owner: type[Instance]) -> bool:
+        """Check if the descriptor is optional."""
+        return NoneType in self.get_types(owner)
+
+
+@dataclass
+class _InputFields(Generic[T, ImageT, MaskT, PathT], ABC):
+    """Generic dataclass that defines the standard input fields."""
+
+    image: FieldDescriptor[ImageT] = FieldDescriptor(validator_name="_validate_image")
+    gt_label: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_gt_label")
+    gt_mask: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="_validate_gt_mask")
+    mask_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_mask_path")
+
+    @abstractmethod
+    def _validate_image(self, image: ImageT) -> ImageT:
+        """Validate the image."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_gt_mask(self, gt_mask: MaskT) -> MaskT | None:
+        """Validate the ground truth mask."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_mask_path(self, mask_path: PathT) -> PathT | None:
+        """Validate the mask path."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_gt_label(self, gt_label: T) -> T | None:
+        """Validate the ground truth label."""
+        raise NotImplementedError
+
+
+@dataclass
+class _ImageInputFields(
+    Generic[PathT],
+    ABC,
+):
+    """Generic dataclass that defines the image input fields."""
+
+    image_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_image_path")
+
+    @abstractmethod
+    def _validate_image_path(self, image_path: PathT) -> PathT | None:
+        """Validate the image path."""
+        raise NotImplementedError
+
+
+@dataclass
+class _VideoInputFields(
+    Generic[T, ImageT, MaskT, PathT],
+    ABC,
+):
+    """Generic dataclass that defines the video input fields."""
+
+    original_image: FieldDescriptor[ImageT | None] = FieldDescriptor(validator_name="_validate_original_image")
+    video_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_video_path")
+    target_frame: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_target_frame")
+    frames: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_frames")
+    last_frame: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_last_frame")
+
+    @abstractmethod
+    def _validate_original_image(self, original_image: ImageT) -> ImageT | None:
+        """Validate the original image."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_video_path(self, video_path: PathT) -> PathT | None:
+        """Validate the video path."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_target_frame(self, target_frame: T) -> T | None:
+        """Validate the target frame."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_frames(self, frames: T) -> T | None:
+        """Validate the frames."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_last_frame(self, last_frame: T) -> T | None:
+        """Validate the last frame."""
+        raise NotImplementedError
+
+
+@dataclass
+class _DepthInputFields(
+    Generic[T, PathT],
+    _ImageInputFields[PathT],
+    ABC,
+):
+    """Generic dataclass that defines the depth input fields."""
+
+    depth_map: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_depth_map")
+    depth_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_depth_path")
+
+    @abstractmethod
+    def _validate_depth_map(self, depth_map: ImageT) -> ImageT | None:
+        """Validate the depth map."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_depth_path(self, depth_path: PathT) -> PathT | None:
+        """Validate the depth path."""
+        raise NotImplementedError
+
+
+@dataclass
+class _OutputFields(Generic[T, MaskT], ABC):
+    """Generic dataclass that defines the standard output fields."""
+
+    anomaly_map: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="_validate_anomaly_map")
+    pred_score: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_pred_score")
+    pred_mask: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="_validate_pred_mask")
+    pred_label: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_pred_label")
+
+    @abstractmethod
+    def _validate_anomaly_map(self, anomaly_map: MaskT) -> MaskT | None:
+        """Validate the anomaly map."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_pred_score(self, pred_score: T) -> T | None:
+        """Validate the predicted score."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_pred_mask(self, pred_mask: MaskT) -> MaskT | None:
+        """Validate the predicted mask."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _validate_pred_label(self, pred_label: T) -> T | None:
+        """Validate the predicted label."""
+        raise NotImplementedError
+
+
+@dataclass
+class UpdateMixin:
+    """Mixin class for dataclasses that allows for in-place replacement of attributes."""
+
+    def update(self, in_place: bool = True, **changes) -> Any:  # noqa: ANN401
+        """Replace fields in place and call __post_init__ to reinitialize the instance.
+
+        Parameters:
+        changes (dict): A dictionary of field names and their new values.
+        """
+        if not is_dataclass(self):
+            msg = "replace can only be used with dataclass instances"
+            raise TypeError(msg)
+
+        if in_place:
+            for field in fields(self):
+                if field.init and field.name in changes:
+                    setattr(self, field.name, changes[field.name])
+            if hasattr(self, "__post_init__"):
+                self.__post_init__()
+            return self
+        return replace(self, **changes)
+
+
+@dataclass
+class _GenericItem(
+    UpdateMixin,
+    Generic[T, ImageT, MaskT, PathT],
+    _OutputFields[T, MaskT],
+    _InputFields[T, ImageT, MaskT, PathT],
+):
+    """Generic dataclass for a dataset item."""
+
+
+@dataclass
+class _GenericBatch(
+    UpdateMixin,
+    Generic[T, ImageT, MaskT, PathT],
+    _OutputFields[T, MaskT],
+    _InputFields[T, ImageT, MaskT, PathT],
+):
+    """Generic dataclass for a batch."""
+
+
+ItemT = TypeVar("ItemT", bound="_GenericItem")
+
+
+@dataclass
+class BatchIterateMixin(Generic[ItemT]):
+    """Generic dataclass for a batch."""
+
+    item_class: ClassVar[Callable]
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        """Ensure that the subclass has the required attributes."""
+        super().__init_subclass__(**kwargs)
+        if not (hasattr(cls, "item_class") or issubclass(cls, ABC)):
+            msg = f"{cls.__name__} must have an 'item_class' attribute."
+            raise AttributeError(msg)
+
+    def __iter__(self) -> Iterator[ItemT]:
+        """Iterate over the batch."""
+        yield from self.items
+
+    @property
+    def items(self) -> list[ItemT]:
+        """Convert the batch to a list of DatasetItem objects."""
+        batch_dict = asdict(self)
+        return [
+            self.item_class(
+                **{key: value[i] if hasattr(value, "__getitem__") else None for key, value in batch_dict.items()},
+            )
+            for i in range(self.batch_size)
+        ]
+
+    def __len__(self) -> int:
+        """Get the batch size."""
+        return self.batch_size
+
+    @property
+    def batch_size(self) -> int:
+        """Get the batch size."""
+        try:
+            image = getattr(self, "image")  # noqa: B009
+            return len(image)
+        except (KeyError, AttributeError) as e:
+            msg = "Cannot determine batch size because 'image' attribute has not been set."
+            raise AttributeError(msg) from e
+
+    @classmethod
+    def collate(cls: type["BatchIterateMixin"], items: list[ItemT]) -> "BatchIterateMixin":
+        """Convert a list of DatasetItem objects to a Batch object."""
+        keys = [key for key, value in asdict(items[0]).items() if value is not None]
+        out_dict = {key: default_collate([getattr(item, key) for item in items]) for key in keys}
+        return cls(**out_dict)
diff --git a/src/anomalib/dataclasses/numpy.py b/src/anomalib/dataclasses/numpy.py
new file mode 100644
index 0000000000..a24015aea4
--- /dev/null
+++ b/src/anomalib/dataclasses/numpy.py
@@ -0,0 +1,170 @@
+"""Dataclasses for numpy data."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from .generic import BatchIterateMixin, _GenericBatch, _GenericItem, _ImageInputFields, _VideoInputFields
+
+
+@dataclass
+class NumpyItem(_GenericItem[np.ndarray, np.ndarray, np.ndarray, str]):
+    """Dataclass for numpy item."""
+
+
+@dataclass
+class NumpyBatch(_GenericBatch[np.ndarray, np.ndarray, np.ndarray, list[str]]):
+    """Dataclass for numpy batch."""
+
+
+# torch image outputs
+@dataclass
+class NumpyImageItem(
+    _ImageInputFields[str],
+    NumpyItem,
+):
+    """Dataclass for numpy image output item."""
+
+    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+        assert image.ndim == 3, f"Expected 3D image, got {image.ndim}D image."
+        if image.shape[0] == 3:
+            image = image.transpose(1, 2, 0)
+        return image
+
+    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: str) -> str:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: np.ndarray | None) -> np.ndarray | None:
+        if anomaly_map is None:
+            return None
+        assert isinstance(anomaly_map, np.ndarray), f"Anomaly map must be a numpy array, got {type(anomaly_map)}."
+        assert anomaly_map.ndim in [
+            2,
+            3,
+        ], f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
+        if anomaly_map.ndim == 3:
+            assert (
+                anomaly_map.shape[0] == 1
+            ), f"Anomaly map with 3 dimensions must have 1 channel, got {anomaly_map.shape[0]}."
+            anomaly_map = anomaly_map.squeeze(0)
+        return anomaly_map.astype(np.float32)
+
+    def _validate_pred_score(self, pred_score: np.ndarray | None) -> np.ndarray | None:
+        if pred_score is None:
+            return None
+        if pred_score.ndim == 1:
+            assert len(pred_score) == 1, f"Expected single value for pred_score, got {len(pred_score)}."
+            pred_score = pred_score[0]
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: np.ndarray) -> np.ndarray:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: np.ndarray) -> np.ndarray:
+        return pred_label
+
+    def _validate_image_path(self, image_path: str) -> str:
+        return image_path
+
+
+@dataclass
+class NumpyImageBatch(
+    BatchIterateMixin[NumpyImageItem],
+    _ImageInputFields[list[str]],
+    NumpyBatch,
+):
+    """Dataclass for numpy image output batch."""
+
+    item_class = NumpyImageItem
+
+    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+        return image
+
+    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: np.ndarray) -> np.ndarray:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: np.ndarray) -> np.ndarray:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: np.ndarray) -> np.ndarray:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: np.ndarray) -> np.ndarray:
+        return pred_label
+
+    def _validate_image_path(self, image_path: list[str]) -> list[str]:
+        return image_path
+
+
+# torch video outputs
+@dataclass
+class NumpyVideoItem(
+    _VideoInputFields[np.ndarray, np.ndarray, np.ndarray, str],
+    NumpyItem,
+):
+    """Dataclass for numpy video output item."""
+
+    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+        return image
+
+    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: str) -> str:
+        return mask_path
+
+
+@dataclass
+class NumpyVideoBatch(
+    BatchIterateMixin[NumpyVideoItem],
+    _VideoInputFields[np.ndarray, np.ndarray, np.ndarray, list[str]],
+    NumpyBatch,
+):
+    """Dataclass for numpy video output batch."""
+
+    item_class = NumpyVideoItem
+
+    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+        return image
+
+    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: np.ndarray) -> np.ndarray:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: np.ndarray) -> np.ndarray:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: np.ndarray) -> np.ndarray:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: np.ndarray) -> np.ndarray:
+        return pred_label
diff --git a/src/anomalib/dataclasses/torch.py b/src/anomalib/dataclasses/torch.py
new file mode 100644
index 0000000000..7b9b61b4aa
--- /dev/null
+++ b/src/anomalib/dataclasses/torch.py
@@ -0,0 +1,486 @@
+"""Dataclasses for torch inputs and outputs."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Callable, Sequence
+from dataclasses import asdict, dataclass, fields
+from typing import ClassVar, Generic, NamedTuple, TypeVar
+
+import numpy as np
+import torch
+from torchvision.transforms.v2.functional import to_dtype_image
+from torchvision.tv_tensors import Image, Mask, Video
+
+from .generic import (
+    BatchIterateMixin,
+    ImageT,
+    _DepthInputFields,
+    _GenericBatch,
+    _GenericItem,
+    _ImageInputFields,
+    _VideoInputFields,
+)
+from .numpy import NumpyImageBatch, NumpyImageItem, NumpyVideoBatch, NumpyVideoItem
+
+NumpyT = TypeVar("NumpyT")
+
+
+class InferenceBatch(NamedTuple):
+    """Batch for use in torch and inference models."""
+
+    pred_score: torch.Tensor | None = None
+    pred_label: torch.Tensor | None = None
+    anomaly_map: torch.Tensor | None = None
+    pred_mask: torch.Tensor | None = None
+
+
+@dataclass
+class ToNumpyMixin(
+    Generic[NumpyT],
+):
+    """Mixin for converting torch-based dataclasses to numpy."""
+
+    numpy_class: ClassVar[Callable]
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        """Ensure that the subclass has the required attributes."""
+        super().__init_subclass__(**kwargs)
+        if not hasattr(cls, "numpy_class"):
+            msg = f"{cls.__name__} must have a 'numpy_class' attribute."
+            raise AttributeError(msg)
+
+    def to_numpy(self) -> NumpyT:
+        """Convert the batch to a NumpyBatch object."""
+        batch_dict = asdict(self)
+        for key, value in batch_dict.items():
+            if isinstance(value, torch.Tensor):
+                batch_dict[key] = value.cpu().numpy()
+        return self.numpy_class(
+            **batch_dict,
+        )
+
+
+@dataclass
+class Item(Generic[ImageT], _GenericItem[torch.Tensor, ImageT, Mask, str]):
+    """Dataclass for torch item."""
+
+
+@dataclass
+class Batch(Generic[ImageT], _GenericBatch[torch.Tensor, ImageT, Mask, list[str]]):
+    """Dataclass for torch batch."""
+
+
+# torch image outputs
+@dataclass
+class ImageItem(
+    ToNumpyMixin[NumpyImageItem],
+    _ImageInputFields[str],
+    Item[Image],
+):
+    """Dataclass for torch image output item."""
+
+    numpy_class = NumpyImageItem
+
+    def _validate_image(self, image: torch.Tensor) -> Image:
+        assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
+        assert image.ndim == 3, f"Image must have shape [C, H, W], got shape {image.shape}."
+        assert image.shape[0] == 3, f"Image must have 3 channels, got {image.shape[0]}."
+        return to_dtype_image(image, torch.float32, scale=True)
+
+    def _validate_gt_label(self, gt_label: torch.Tensor | int | None) -> torch.Tensor:
+        if gt_label is None:
+            return None
+        if isinstance(gt_label, int):
+            gt_label = torch.tensor(gt_label)
+        assert isinstance(
+            gt_label,
+            torch.Tensor,
+        ), f"Ground truth label must be an integer or a torch.Tensor, got {type(gt_label)}."
+        assert gt_label.ndim == 0, f"Ground truth label must be a scalar, got shape {gt_label.shape}."
+        assert not torch.is_floating_point(gt_label), f"Ground truth label must be boolean or integer, got {gt_label}."
+        return gt_label.bool()
+
+    def _validate_gt_mask(self, gt_mask: torch.Tensor | None) -> Mask | None:
+        if gt_mask is None:
+            return None
+        assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
+        assert gt_mask.ndim in [
+            2,
+            3,
+        ], f"Ground truth mask must have shape [H, W] or [1, H, W] got shape {gt_mask.shape}."
+        if gt_mask.ndim == 3:
+            assert gt_mask.shape[0] == 1, f"Ground truth mask must have 1 channel, got {gt_mask.shape[0]}."
+            gt_mask = gt_mask.squeeze(0)
+        return Mask(gt_mask, dtype=torch.bool)
+
+    def _validate_mask_path(self, mask_path: str | None) -> str | None:
+        if mask_path is None:
+            return None
+        return str(mask_path)
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor | None) -> Mask | None:
+        if anomaly_map is None:
+            return None
+        assert isinstance(anomaly_map, torch.Tensor), f"Anomaly map must be a torch.Tensor, got {type(anomaly_map)}."
+        assert anomaly_map.ndim in [
+            2,
+            3,
+        ], f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
+        if anomaly_map.ndim == 3:
+            assert (
+                anomaly_map.shape[0] == 1
+            ), f"Anomaly map with 3 dimensions must have 1 channel, got {anomaly_map.shape[0]}."
+            anomaly_map = anomaly_map.squeeze(0)
+        return Mask(anomaly_map, dtype=torch.float32)
+
+    def _validate_pred_score(self, pred_score: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
+        if pred_score is None:
+            return torch.amax(self.anomaly_map, dim=(-2, -1)) if self.anomaly_map is not None else None
+        if not isinstance(pred_score, torch.Tensor):
+            try:
+                pred_score = torch.tensor(pred_score)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a torch.Tensor."
+                raise ValueError(msg) from e
+        pred_score = pred_score.squeeze()
+        assert pred_score.ndim == 0, f"Predicted score must be a scalar, got shape {pred_score.shape}."
+        return pred_score.to(torch.float32)
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor | None) -> Mask | None:
+        if pred_mask is None:
+            return None
+        assert isinstance(pred_mask, torch.Tensor), f"Predicted mask must be a torch.Tensor, got {type(pred_mask)}."
+        assert pred_mask.ndim in [
+            2,
+            3,
+        ], f"Predicted mask must have shape [H, W] or [1, H, W] got shape {pred_mask.shape}."
+        if pred_mask.ndim == 3:
+            assert pred_mask.shape[0] == 1, f"Predicted mask must have 1 channel, got {pred_mask.shape[0]}."
+            pred_mask = pred_mask.squeeze(0)
+        return Mask(pred_mask, dtype=torch.bool)
+
+    def _validate_pred_label(self, pred_label: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, torch.Tensor):
+            try:
+                pred_label = torch.tensor(pred_label)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a torch.Tensor."
+                raise ValueError(msg) from e
+        pred_label = pred_label.squeeze()
+        assert pred_label.ndim == 0, f"Predicted label must be a scalar, got shape {pred_label.shape}."
+        return pred_label.to(torch.bool)
+
+    def _validate_image_path(self, image_path: str | None) -> str | None:
+        if image_path is None:
+            return None
+        return str(image_path)
+
+
+@dataclass
+class ImageBatch(
+    ToNumpyMixin[NumpyImageBatch],
+    BatchIterateMixin[ImageItem],
+    _ImageInputFields[list[str]],
+    Batch[Image],
+):
+    """Dataclass for torch image output batch."""
+
+    item_class = ImageItem
+    numpy_class = NumpyImageBatch
+
+    def _validate_image(self, image: Image) -> Image:
+        assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
+        assert image.ndim in [3, 4], f"Image must have shape [C, H, W] or [N, C, H, W], got shape {image.shape}."
+        if image.ndim == 3:
+            image = image.unsqueeze(0)  # add batch dimension
+        assert image.shape[1] == 3, f"Image must have 3 channels, got {image.shape[0]}."
+        return Image(image, dtype=torch.float32)
+
+    def _validate_gt_label(self, gt_label: torch.Tensor | Sequence[int] | None) -> torch.Tensor:
+        if gt_label is None:
+            return None
+        if isinstance(gt_label, Sequence):
+            gt_label = torch.tensor(gt_label)
+        assert isinstance(
+            gt_label,
+            torch.Tensor,
+        ), f"Ground truth label must be a sequence of integers or a torch.Tensor, got {type(gt_label)}."
+        assert gt_label.ndim == 1, f"Ground truth label must be a 1-dimensional vector, got shape {gt_label.shape}."
+        assert (
+            len(gt_label) == self.batch_size
+        ), f"Ground truth label must have length {self.batch_size}, got length {len(gt_label)}."
+        assert not torch.is_floating_point(gt_label), f"Ground truth label must be boolean or integer, got {gt_label}."
+        return gt_label.bool()
+
+    def _validate_gt_mask(self, gt_mask: Mask | None) -> Mask | None:
+        if gt_mask is None:
+            return None
+        assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
+        assert gt_mask.ndim in [
+            2,
+            3,
+            4,
+        ], f"Ground truth mask must have shape [H, W] or [N, H, W] or [N, 1, H, W] got shape {gt_mask.shape}."
+        if gt_mask.ndim == 2:
+            assert (
+                self.batch_size == 1
+            ), f"Invalid shape for gt_mask. Got mask shape {gt_mask.shape} for batch size {self.batch_size}."
+            gt_mask = gt_mask.unsqueeze(0)
+        if gt_mask.ndim == 3:
+            assert (
+                gt_mask.shape[0] == self.batch_size
+            ), f"Invalid shape for gt_mask. Got mask shape {gt_mask.shape} for batch size {self.batch_size}."
+        if gt_mask.ndim == 4:
+            assert gt_mask.shape[1] == 1, f"Ground truth mask must have 1 channel, got {gt_mask.shape[1]}."
+            gt_mask = gt_mask.squeeze(1)
+        return Mask(gt_mask, dtype=torch.bool)
+
+    def _validate_mask_path(self, mask_path: Sequence[str] | Sequence[str] | None) -> list[str] | None:
+        if mask_path is None:
+            return None
+        assert isinstance(
+            mask_path,
+            Sequence,
+        ), f"Mask path must be a sequence of paths or strings, got {type(mask_path)}."
+        assert (
+            len(mask_path) == self.batch_size
+        ), f"Invalid length for mask_path. Got length {len(mask_path)} for batch size {self.batch_size}."
+        return [str(path) for path in mask_path]
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, torch.Tensor):
+            try:
+                anomaly_map = torch.tensor(anomaly_map)
+            except Exception as e:
+                msg = "Failed to convert anomaly_map to a torch.Tensor."
+                raise ValueError(msg) from e
+        assert anomaly_map.ndim in [
+            2,
+            3,
+            4,
+        ], f"Anomaly map must have shape [H, W] or [N, H, W] or [N, 1, H, W], got shape {anomaly_map.shape}."
+        if anomaly_map.ndim == 2:
+            assert (
+                self.batch_size == 1
+            ), f"Invalid shape for anomaly_map. Got mask shape {anomaly_map.shape} for batch size {self.batch_size}."
+            anomaly_map = anomaly_map.unsqueeze(0)
+        if anomaly_map.ndim == 4:
+            assert anomaly_map.shape[1] == 1, f"Anomaly map must have 1 channel, got {anomaly_map.shape[1]}."
+            anomaly_map = anomaly_map.squeeze(1)
+        return Mask(anomaly_map, dtype=torch.float32)
+
+    def _validate_pred_score(self, pred_score: torch.Tensor | None) -> torch.Tensor | None:
+        if pred_score is None and self.anomaly_map is not None:
+            return torch.amax(self.anomaly_map, dim=(-2, -1))
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor | None:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor | None:
+        return pred_label
+
+    def _validate_image_path(self, image_path: list[str]) -> list[str] | None:
+        return image_path
+
+
+# torch video outputs
+@dataclass
+class VideoItem(
+    ToNumpyMixin[NumpyVideoItem],
+    _VideoInputFields[torch.Tensor, Video, Mask, str],
+    Item[Video],
+):
+    """Dataclass for torch video output item."""
+
+    numpy_class = NumpyVideoItem
+
+    def _validate_image(self, image: Image) -> Video:
+        return image
+
+    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: str) -> str:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor | None:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: torch.Tensor | None) -> torch.Tensor | None:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor | None:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor | None:
+        return pred_label
+
+    def _validate_original_image(self, original_image: Video) -> Video:
+        return original_image
+
+    def _validate_video_path(self, video_path: str) -> str:
+        return video_path
+
+    def _validate_target_frame(self, target_frame: torch.Tensor) -> torch.Tensor:
+        return target_frame
+
+    def _validate_frames(self, frames: torch.Tensor) -> torch.Tensor:
+        return frames
+
+    def _validate_last_frame(self, last_frame: torch.Tensor) -> torch.Tensor:
+        return last_frame
+
+    def to_image(self) -> ImageItem:
+        """Convert the video item to an image item."""
+        image_keys = [field.name for field in fields(ImageItem)]
+        return ImageItem(**{key: getattr(self, key, None) for key in image_keys})
+
+
+@dataclass
+class VideoBatch(
+    ToNumpyMixin[NumpyVideoBatch],
+    BatchIterateMixin[VideoItem],
+    _VideoInputFields[torch.Tensor, Video, Mask, list[str]],
+    Batch[Video],
+):
+    """Dataclass for torch video output batch."""
+
+    item_class = VideoItem
+    numpy_class = NumpyVideoBatch
+
+    def _validate_image(self, image: Image) -> Video:
+        return image
+
+    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
+        return pred_label
+
+    def _validate_original_image(self, original_image: Video) -> Video:
+        return original_image
+
+    def _validate_video_path(self, video_path: list[str]) -> list[str]:
+        return video_path
+
+    def _validate_target_frame(self, target_frame: torch.Tensor) -> torch.Tensor:
+        return target_frame
+
+    def _validate_frames(self, frames: torch.Tensor) -> torch.Tensor:
+        return frames
+
+    def _validate_last_frame(self, last_frame: torch.Tensor) -> torch.Tensor:
+        return last_frame
+
+
+# depth
+@dataclass
+class DepthItem(
+    ToNumpyMixin[NumpyImageItem],
+    _DepthInputFields[torch.Tensor, str],
+    Item[Image],
+):
+    """Dataclass for torch depth output item."""
+
+    numpy_class = NumpyImageItem
+
+    def _validate_image(self, image: Image) -> Image:
+        return image
+
+    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: str) -> str:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
+        return pred_label
+
+    def _validate_image_path(self, image_path: str) -> str:
+        return image_path
+
+    def _validate_depth_map(self, depth_map: torch.Tensor) -> torch.Tensor:
+        return depth_map
+
+    def _validate_depth_path(self, depth_path: str) -> str:
+        return depth_path
+
+
+@dataclass
+class DepthBatch(
+    BatchIterateMixin[DepthItem],
+    _DepthInputFields[torch.Tensor, list[str]],
+    Batch[Image],
+):
+    """Dataclass for torch depth output batch."""
+
+    item_class = DepthItem
+
+    def _validate_image(self, image: Image) -> Image:
+        return image
+
+    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
+        return pred_label
+
+    def _validate_image_path(self, image_path: list[str]) -> list[str]:
+        return image_path
+
+    def _validate_depth_map(self, depth_map: torch.Tensor) -> torch.Tensor:
+        return depth_map
+
+    def _validate_depth_path(self, depth_path: list[str]) -> list[str]:
+        return depth_path
diff --git a/src/anomalib/deploy/export.py b/src/anomalib/deploy/export.py
index aae359c035..69e508396f 100644
--- a/src/anomalib/deploy/export.py
+++ b/src/anomalib/deploy/export.py
@@ -6,12 +6,6 @@
 import logging
 from enum import Enum
 
-import torch
-from torch import nn
-from torchvision.transforms.v2 import CenterCrop, Compose, Resize, Transform
-
-from anomalib.data.transforms import ExportableCenterCrop
-
 logger = logging.getLogger("anomalib")
 
 
@@ -58,56 +52,3 @@ class CompressionType(str, Enum):
     INT8 = "int8"
     INT8_PTQ = "int8_ptq"
     INT8_ACQ = "int8_acq"
-
-
-class InferenceModel(nn.Module):
-    """Inference model for export.
-
-    The InferenceModel is used to wrap the model and transform for exporting to torch and ONNX/OpenVINO.
-
-    Args:
-        model (nn.Module): Model to export.
-        transform (Transform): Input transform for the model.
-        disable_antialias (bool, optional): Disable antialiasing in the Resize transforms of the given transform. This
-            is needed for ONNX/OpenVINO export, as antialiasing is not supported in the ONNX opset.
-    """
-
-    def __init__(self, model: nn.Module, transform: Transform, disable_antialias: bool = False) -> None:
-        super().__init__()
-        self.model = model
-        self.transform = transform
-        self.convert_center_crop()
-        if disable_antialias:
-            self.disable_antialias()
-
-    def forward(self, batch: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
-        """Transform the input batch and pass it through the model."""
-        batch = self.transform(batch)
-        return self.model(batch)
-
-    def disable_antialias(self) -> None:
-        """Disable antialiasing in the Resize transforms of the given transform.
-
-        This is needed for ONNX/OpenVINO export, as antialiasing is not supported in the ONNX opset.
-        """
-        if isinstance(self.transform, Resize):
-            self.transform.antialias = False
-        if isinstance(self.transform, Compose):
-            for transform in self.transform.transforms:
-                if isinstance(transform, Resize):
-                    transform.antialias = False
-
-    def convert_center_crop(self) -> None:
-        """Convert CenterCrop to ExportableCenterCrop for ONNX export.
-
-        The original CenterCrop transform is not supported in ONNX export. This method replaces the CenterCrop to
-        ExportableCenterCrop, which is supported in ONNX export. For more details, see the implementation of
-        ExportableCenterCrop.
-        """
-        if isinstance(self.transform, CenterCrop):
-            self.transform = ExportableCenterCrop(size=self.transform.size)
-        elif isinstance(self.transform, Compose):
-            transforms = self.transform.transforms
-            for index in range(len(transforms)):
-                if isinstance(transforms[index], CenterCrop):
-                    transforms[index] = ExportableCenterCrop(size=transforms[index].size)
diff --git a/src/anomalib/deploy/inferencers/openvino_inferencer.py b/src/anomalib/deploy/inferencers/openvino_inferencer.py
index bb57a8d65a..83bd75513f 100644
--- a/src/anomalib/deploy/inferencers/openvino_inferencer.py
+++ b/src/anomalib/deploy/inferencers/openvino_inferencer.py
@@ -8,19 +8,15 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-import cv2
 import numpy as np
-from omegaconf import DictConfig
-from PIL import Image
+from openvino.runtime.utils.data_helpers.wrappers import OVDict
 
-from anomalib import TaskType
-from anomalib.data.utils.label import LabelName
-from anomalib.utils.visualization import ImageResult
-
-from .base_inferencer import Inferencer
+from anomalib.data.utils import read_image
+from anomalib.dataclasses import NumpyImageBatch
 
 logger = logging.getLogger("anomalib")
 
+
 if find_spec("openvino") is not None:
     import openvino as ov
 
@@ -30,7 +26,7 @@
     logger.warning("OpenVINO is not installed. Please install OpenVINO to use OpenVINOInferencer.")
 
 
-class OpenVINOInferencer(Inferencer):
+class OpenVINOInferencer:
     """OpenVINO implementation for the inference.
 
     Args:
@@ -97,18 +93,13 @@ class OpenVINOInferencer(Inferencer):
     def __init__(
         self,
         path: str | Path | tuple[bytes, bytes],
-        metadata: str | Path | dict | None = None,
         device: str | None = "AUTO",
-        task: str | None = None,
         config: dict | None = None,
     ) -> None:
         self.device = device
 
         self.config = config
         self.input_blob, self.output_blob, self.model = self.load_model(path)
-        self.metadata = super()._load_metadata(metadata)
-
-        self.task = TaskType(task) if task else TaskType(self.metadata["task"])
 
     def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any, "CompiledModel"]:
         """Load the OpenVINO model.
@@ -160,21 +151,31 @@ def pre_process(image: np.ndarray) -> np.ndarray:
         Returns:
             np.ndarray: pre-processed image.
         """
-        processed_image = image
+        # Normalize numpy array to range [0, 1]
+        if image.dtype != np.float32:
+            image = image.astype(np.float32)
+        if image.max() > 1.0:
+            image /= 255.0
+
+        if len(image.shape) == 3:
+            image = np.expand_dims(image, axis=0)
 
-        if len(processed_image.shape) == 3:
-            processed_image = np.expand_dims(processed_image, axis=0)
+        if image.shape[-1] == 3:
+            image = image.transpose(0, 3, 1, 2)
 
-        if processed_image.shape[-1] == 3:
-            processed_image = processed_image.transpose(0, 3, 1, 2)
+        return image
 
-        return processed_image
+    @staticmethod
+    def post_process(predictions: OVDict) -> dict:
+        """Convert OpenVINO output dictionary to NumpyBatch."""
+        names = [next(iter(name)) for name in predictions.names()]
+        values = predictions.to_tuple()
+        return dict(zip(names, values, strict=False))
 
     def predict(
         self,
         image: str | Path | np.ndarray,
-        metadata: dict[str, Any] | None = None,
-    ) -> ImageResult:
+    ) -> NumpyImageBatch:
         """Perform a prediction for a given input image.
 
         The main workflow is (i) pre-processing, (ii) forward-pass, (iii) post-process.
@@ -190,152 +191,16 @@ def predict(
         """
         # Convert file path or string to image if necessary
         if isinstance(image, str | Path):
-            image = Image.open(image)
-
-        # Convert PIL image to numpy array
-        if isinstance(image, Image.Image):
-            image = np.array(image, dtype=np.float32)
+            image = read_image(image, as_tensor=False)
         if not isinstance(image, np.ndarray):
             msg = f"Input image must be a numpy array or a path to an image. Got {type(image)}"
             raise TypeError(msg)
 
-        # Resize image to model input size if not dynamic
-        if self.input_blob.partial_shape[2].is_static and self.input_blob.partial_shape[3].is_static:
-            image = cv2.resize(image, tuple(list(self.input_blob.shape)[2:][::-1]))
+        image = self.pre_process(image)
+        predictions = self.model(image)
+        pred_dict = self.post_process(predictions)
 
-        # Normalize numpy array to range [0, 1]
-        if image.dtype != np.float32:
-            image = image.astype(np.float32)
-        if image.max() > 1.0:
-            image /= 255.0
-
-        # Check if metadata is provided, if not use the default metadata.
-        if metadata is None:
-            metadata = self.metadata if hasattr(self, "metadata") else {}
-        metadata["image_shape"] = image.shape[:2]
-
-        processed_image = self.pre_process(image)
-        predictions = self.forward(processed_image)
-        output = self.post_process(predictions, metadata=metadata)
-
-        return ImageResult(
-            image=(image * 255).astype(np.uint8),
-            pred_score=output["pred_score"],
-            pred_label=output["pred_label"],
-            anomaly_map=output["anomaly_map"],
-            pred_mask=output["pred_mask"],
-            pred_boxes=output["pred_boxes"],
-            box_labels=output["box_labels"],
+        return NumpyImageBatch(
+            image=image,
+            **pred_dict,
         )
-
-    def forward(self, image: np.ndarray) -> np.ndarray:
-        """Forward-Pass input tensor to the model.
-
-        Args:
-            image (np.ndarray): Input tensor.
-
-        Returns:
-            np.ndarray: Output predictions.
-        """
-        return self.model(image)
-
-    def post_process(self, predictions: np.ndarray, metadata: dict | DictConfig | None = None) -> dict[str, Any]:
-        """Post process the output predictions.
-
-        Args:
-            predictions (np.ndarray): Raw output predicted by the model.
-            metadata (Dict, optional): Metadata. Post-processing step sometimes requires
-                additional metadata such as image shape. This variable comprises such info.
-                Defaults to None.
-
-        Returns:
-            dict[str, Any]: Post processed prediction results.
-        """
-        if metadata is None:
-            metadata = self.metadata
-
-        predictions = predictions[self.output_blob]
-
-        # Initialize the result variables.
-        anomaly_map: np.ndarray | None = None
-        pred_label: LabelName | None = None
-        pred_mask: float | None = None
-
-        # If predictions returns a single value, this means that the task is
-        # classification, and the value is the classification prediction score.
-        if len(predictions.shape) == 1:
-            task = TaskType.CLASSIFICATION
-            pred_score = predictions
-        else:
-            task = TaskType.SEGMENTATION
-            anomaly_map = predictions.squeeze()
-            pred_score = anomaly_map.reshape(-1).max()
-
-        # Common practice in anomaly detection is to assign anomalous
-        # label to the prediction if the prediction score is greater
-        # than the image threshold.
-        if "image_threshold" in metadata:
-            pred_idx = pred_score >= metadata["image_threshold"]
-            pred_label = LabelName.ABNORMAL if pred_idx else LabelName.NORMAL
-
-        if task == TaskType.CLASSIFICATION:
-            _, pred_score = self._normalize(pred_scores=pred_score, metadata=metadata)
-        elif task in {TaskType.SEGMENTATION, TaskType.DETECTION}:
-            if "pixel_threshold" in metadata:
-                pred_mask = (anomaly_map >= metadata["pixel_threshold"]).astype(np.uint8)
-
-            anomaly_map, pred_score = self._normalize(
-                pred_scores=pred_score,
-                anomaly_maps=anomaly_map,
-                metadata=metadata,
-            )
-            if anomaly_map is None:
-                msg = "Anomaly map cannot be None."
-                raise ValueError(msg)
-
-            if "image_shape" in metadata and anomaly_map.shape != metadata["image_shape"]:
-                image_height = metadata["image_shape"][0]
-                image_width = metadata["image_shape"][1]
-                anomaly_map = cv2.resize(anomaly_map, (image_width, image_height))
-
-                if pred_mask is not None:
-                    pred_mask = cv2.resize(pred_mask, (image_width, image_height))
-        else:
-            msg = f"Unknown task type: {task}"
-            raise ValueError(msg)
-
-        if self.task == TaskType.DETECTION:
-            pred_boxes = self._get_boxes(pred_mask)
-            box_labels = np.ones(pred_boxes.shape[0])
-        else:
-            pred_boxes = None
-            box_labels = None
-
-        return {
-            "anomaly_map": anomaly_map,
-            "pred_label": pred_label,
-            "pred_score": pred_score,
-            "pred_mask": pred_mask,
-            "pred_boxes": pred_boxes,
-            "box_labels": box_labels,
-        }
-
-    @staticmethod
-    def _get_boxes(mask: np.ndarray) -> np.ndarray:
-        """Get bounding boxes from masks.
-
-        Args:
-            mask (np.ndarray): Input mask of shape (H, W)
-
-        Returns:
-            np.ndarray: array of shape (N, 4) containing the bounding box coordinates of the objects in the masks
-            in xyxy format.
-        """
-        _, comps = cv2.connectedComponents(mask)
-
-        labels = np.unique(comps)
-        boxes = []
-        for label in labels[labels != 0]:
-            y_loc, x_loc = np.where(comps == label)
-            boxes.append([np.min(x_loc), np.min(y_loc), np.max(x_loc), np.max(y_loc)])
-        return np.stack(boxes) if boxes else np.empty((0, 4))
diff --git a/src/anomalib/deploy/inferencers/torch_inferencer.py b/src/anomalib/deploy/inferencers/torch_inferencer.py
index 840063421c..c6f093a02a 100644
--- a/src/anomalib/deploy/inferencers/torch_inferencer.py
+++ b/src/anomalib/deploy/inferencers/torch_inferencer.py
@@ -3,26 +3,16 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from collections.abc import Sequence
 from pathlib import Path
-from typing import Any
 
-import cv2
-import numpy as np
 import torch
-from omegaconf import DictConfig
 from torch import nn
 
-from anomalib import TaskType
-from anomalib.data import LabelName
 from anomalib.data.utils import read_image
-from anomalib.data.utils.boxes import masks_to_boxes
-from anomalib.utils.visualization import ImageResult
+from anomalib.dataclasses import ImageBatch
 
-from .base_inferencer import Inferencer
 
-
-class TorchInferencer(Inferencer):
+class TorchInferencer:
     """PyTorch implementation for the inference.
 
     Args:
@@ -45,7 +35,7 @@ class TorchInferencer(Inferencer):
         >>> image = read_image("path/to/image.jpg")
         >>> result = inferencer.predict(image)
 
-        ``result`` will be an ``ImageResult`` object containing the prediction
+        ``result`` will be an ``PredictBatch`` object containing the prediction
         results. For example, to visualize the heatmap, we can do the following:
 
         >>> from matplotlib import pyplot as plt
@@ -66,9 +56,7 @@ def __init__(
         self.device = self._get_device(device)
 
         # Load the model weights and metadata
-        self.checkpoint = self._load_checkpoint(path)
         self.model = self.load_model(path)
-        self.metadata = self._load_metadata(path)
 
     @staticmethod
     def _get_device(device: str) -> torch.device:
@@ -108,38 +96,6 @@ def _load_checkpoint(self, path: str | Path) -> dict:
 
         return torch.load(path, map_location=self.device)
 
-    def _load_metadata(self, path: str | Path | dict | None = None) -> dict | DictConfig:
-        """Load metadata from file.
-
-        Args:
-            path (str | Path | dict): Path to the model pt file.
-
-        Returns:
-            dict: Dictionary containing the metadata.
-        """
-        metadata: dict | DictConfig
-
-        if isinstance(path, dict):
-            metadata = path
-        elif isinstance(path, str | Path):
-            checkpoint = self._load_checkpoint(path)
-
-            # Torch model should ideally contain the metadata in the checkpoint.
-            # Check if the metadata is present in the checkpoint.
-            if "metadata" not in checkpoint:
-                msg = (
-                    "``metadata`` is not found in the checkpoint. Please ensure that you save the model as Torch model."
-                )
-                raise KeyError(
-                    msg,
-                )
-            metadata = checkpoint["metadata"]
-        else:
-            msg = f"Unknown ``path`` type {type(path)}"
-            raise TypeError(msg)
-
-        return metadata
-
     def load_model(self, path: str | Path) -> nn.Module:
         """Load the PyTorch model.
 
@@ -161,162 +117,37 @@ def load_model(self, path: str | Path) -> nn.Module:
     def predict(
         self,
         image: str | Path | torch.Tensor,
-        metadata: dict[str, Any] | None = None,
-    ) -> ImageResult:
+    ) -> ImageBatch:
         """Perform a prediction for a given input image.
 
-        The main workflow is (i) pre-processing, (ii) forward-pass, (iii) post-process.
-
         Args:
             image (Union[str, np.ndarray]): Input image whose output is to be predicted.
-                It could be either a path to image or numpy array itself.
-
-            metadata: Metadata information such as shape, threshold.
+                It could be either a path to image or the tensor itself.
 
         Returns:
             ImageResult: Prediction results to be visualized.
         """
-        if metadata is None:
-            metadata = self.metadata if hasattr(self, "metadata") else {}
         if isinstance(image, str | Path):
             image = read_image(image, as_tensor=True)
 
-        metadata["image_shape"] = image.shape[-2:]
+        image = self.pre_process(image)
+        predictions = self.model(image)
 
-        processed_image = self.pre_process(image)
-        predictions = self.forward(processed_image)
-        output = self.post_process(predictions, metadata=metadata)
-
-        return ImageResult(
-            image=(image.numpy().transpose(1, 2, 0) * 255).astype(np.uint8),
-            pred_score=output["pred_score"],
-            pred_label=output["pred_label"],
-            anomaly_map=output["anomaly_map"],
-            pred_mask=output["pred_mask"],
-            pred_boxes=output["pred_boxes"],
-            box_labels=output["box_labels"],
+        return ImageBatch(
+            image=image,
+            **predictions._asdict(),
         )
 
-    def pre_process(self, image: np.ndarray) -> torch.Tensor:
+    def pre_process(self, image: torch.Tensor) -> torch.Tensor:
         """Pre process the input image.
 
         Args:
-            image (np.ndarray): Input image
+            image (torch.Tensor): Input image
 
         Returns:
             Tensor: pre-processed image.
         """
-        if len(image) == 3:
-            image = image.unsqueeze(0)
+        if image.dim() == 3:
+            image = image.unsqueeze(0)  # model expects [B, C, H, W]
 
         return image.to(self.device)
-
-    def forward(self, image: torch.Tensor) -> torch.Tensor:
-        """Forward-Pass input tensor to the model.
-
-        Args:
-            image (torch.Tensor): Input tensor.
-
-        Returns:
-            Tensor: Output predictions.
-        """
-        return self.model(image)
-
-    def post_process(
-        self,
-        predictions: torch.Tensor | list[torch.Tensor] | dict[str, torch.Tensor],
-        metadata: dict | DictConfig | None = None,
-    ) -> dict[str, Any]:
-        """Post process the output predictions.
-
-        Args:
-            predictions (Tensor | list[torch.Tensor] | dict[str, torch.Tensor]): Raw output predicted by the model.
-            metadata (dict, optional): Meta data. Post-processing step sometimes requires
-                additional meta data such as image shape. This variable comprises such info.
-                Defaults to None.
-
-        Returns:
-            dict[str, str | float | np.ndarray]: Post processed prediction results.
-        """
-        if metadata is None:
-            metadata = self.metadata
-
-        # Some models return a Tensor while others return a list or dictionary. Handle both cases.
-        # TODO(ashwinvaidya17): Wrap this post-processing stage within the model's forward pass.
-        # CVS-122674
-
-        # Case I: Predictions could be a tensor.
-        if isinstance(predictions, torch.Tensor):
-            anomaly_map = predictions.detach().cpu().numpy()
-            pred_score = anomaly_map.reshape(-1).max()
-
-        # Case II: Predictions could be a dictionary of tensors.
-        elif isinstance(predictions, dict):
-            if "anomaly_map" in predictions:
-                anomaly_map = predictions["anomaly_map"].detach().cpu().numpy()
-            else:
-                msg = "``anomaly_map`` not found in the predictions."
-                raise KeyError(msg)
-
-            if "pred_score" in predictions:
-                pred_score = predictions["pred_score"].detach().cpu().numpy()
-            else:
-                pred_score = anomaly_map.reshape(-1).max()
-
-        # Case III: Predictions could be a list of tensors.
-        elif isinstance(predictions, Sequence):
-            if isinstance(predictions[1], (torch.Tensor)):
-                pred_score, anomaly_map = predictions
-                anomaly_map = anomaly_map.detach().cpu().numpy()
-                pred_score = pred_score.detach().cpu().numpy()
-            else:
-                pred_score, anomaly_map = predictions
-                pred_score = pred_score.detach()
-        else:
-            msg = (
-                f"Unknown prediction type {type(predictions)}. "
-                "Expected torch.Tensor, list[torch.Tensor] or dict[str, torch.Tensor]."
-            )
-            raise TypeError(msg)
-
-        # Common practice in anomaly detection is to assign anomalous
-        # label to the prediction if the prediction score is greater
-        # than the image threshold.
-        pred_label: LabelName | None = None
-        if "image_threshold" in metadata:
-            pred_idx = pred_score >= metadata["image_threshold"]
-            pred_label = LabelName.ABNORMAL if pred_idx else LabelName.NORMAL
-
-        pred_mask: np.ndarray | None = None
-        if "pixel_threshold" in metadata:
-            pred_mask = (anomaly_map >= metadata["pixel_threshold"]).squeeze().astype(np.uint8)
-
-        anomaly_map = anomaly_map.squeeze()
-        anomaly_map, pred_score = self._normalize(anomaly_maps=anomaly_map, pred_scores=pred_score, metadata=metadata)
-
-        if isinstance(anomaly_map, torch.Tensor):
-            anomaly_map = anomaly_map.detach().cpu().numpy()
-
-        if "image_shape" in metadata and anomaly_map.shape != metadata["image_shape"]:
-            image_height = metadata["image_shape"][0]
-            image_width = metadata["image_shape"][1]
-            anomaly_map = cv2.resize(anomaly_map, (image_width, image_height))
-
-            if pred_mask is not None:
-                pred_mask = cv2.resize(pred_mask, (image_width, image_height))
-
-        if self.metadata["task"] == TaskType.DETECTION:
-            pred_boxes = masks_to_boxes(torch.from_numpy(pred_mask))[0][0].numpy()
-            box_labels = np.ones(pred_boxes.shape[0])
-        else:
-            pred_boxes = None
-            box_labels = None
-
-        return {
-            "anomaly_map": anomaly_map,
-            "pred_label": pred_label,
-            "pred_score": pred_score,
-            "pred_mask": pred_mask,
-            "pred_boxes": pred_boxes,
-            "box_labels": box_labels,
-        }
diff --git a/src/anomalib/deploy/utils.py b/src/anomalib/deploy/utils.py
new file mode 100644
index 0000000000..e2f23bf841
--- /dev/null
+++ b/src/anomalib/deploy/utils.py
@@ -0,0 +1,44 @@
+"""Utility functions for Anomalib deployment module."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from torchvision.transforms.v2 import CenterCrop, Compose, Resize, Transform
+
+from anomalib.data.transforms import ExportableCenterCrop
+
+
+def make_transform_exportable(transform: Transform) -> Transform:
+    """Get exportable transform.
+
+    Some transforms are not supported by ONNX/OpenVINO, so we need to replace them with exportable versions.
+    """
+    transform = disable_antialiasing(transform)
+    return convert_centercrop(transform)
+
+
+def disable_antialiasing(transform: Transform) -> Transform:
+    """Disable antialiasing in Resize transforms.
+
+    Resizing with antialiasing is not supported by ONNX, so we need to disable it.
+    """
+    if isinstance(transform, Resize):
+        transform.antialias = False
+    if isinstance(transform, Compose):
+        for tr in transform.transforms:
+            disable_antialiasing(tr)
+    return transform
+
+
+def convert_centercrop(transform: Transform) -> Transform:
+    """Convert CenterCrop to ExportableCenterCrop.
+
+    Torchvision's CenterCrop is not supported by ONNX, so we need to replace it with our own ExportableCenterCrop.
+    """
+    if isinstance(transform, CenterCrop):
+        transform = ExportableCenterCrop(size=transform.size)
+    if isinstance(transform, Compose):
+        for index in range(len(transform.transforms)):
+            tr = transform.transforms[index]
+            transform.transforms[index] = convert_centercrop(tr)
+    return transform
diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index 83b9714416..d6f22cd5d0 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -15,23 +15,16 @@
 from lightning.pytorch.utilities.types import _EVALUATE_OUTPUT, _PREDICT_OUTPUT, EVAL_DATALOADERS, TRAIN_DATALOADERS
 from torch.utils.data import DataLoader, Dataset
 from torchmetrics import Metric
-from torchvision.transforms.v2 import Transform
 
 from anomalib import LearningType, TaskType
 from anomalib.callbacks.checkpoint import ModelCheckpoint
 from anomalib.callbacks.metrics import _MetricsCallback
-from anomalib.callbacks.normalization import get_normalization_callback
-from anomalib.callbacks.normalization.base import NormalizationCallback
-from anomalib.callbacks.post_processor import _PostProcessorCallback
-from anomalib.callbacks.thresholding import _ThresholdCallback
 from anomalib.callbacks.timer import TimerCallback
 from anomalib.callbacks.visualizer import _VisualizationCallback
 from anomalib.data import AnomalibDataModule, AnomalibDataset, PredictDataset
 from anomalib.deploy import CompressionType, ExportType
 from anomalib.models import AnomalyModule
-from anomalib.utils.normalization import NormalizationMethod
 from anomalib.utils.path import create_versioned_dir
-from anomalib.utils.types import NORMALIZATION, THRESHOLD
 from anomalib.utils.visualization import ImageVisualizer
 
 logger = logging.getLogger(__name__)
@@ -123,8 +116,6 @@ class Engine:
     def __init__(
         self,
         callbacks: list[Callback] | None = None,
-        normalization: NORMALIZATION = NormalizationMethod.MIN_MAX,
-        threshold: THRESHOLD = "F1AdaptiveThreshold",
         task: TaskType | str = TaskType.SEGMENTATION,
         image_metrics: list[str] | str | dict[str, dict[str, Any]] | None = None,
         pixel_metrics: list[str] | str | dict[str, dict[str, Any]] | None = None,
@@ -146,15 +137,13 @@ def __init__(
             **kwargs,
         )
 
-        self.normalization = normalization
-        self.threshold = threshold
         self.task = TaskType(task)
-        self.image_metric_names = image_metrics if image_metrics else ["AUROC", "F1Score"]
+        self.image_metric_names = image_metrics if image_metrics else ["AUROC", "F1Max"]
 
         # pixel metrics are only used for segmentation tasks.
         self.pixel_metric_names = None
         if self.task == TaskType.SEGMENTATION:
-            self.pixel_metric_names = pixel_metrics if pixel_metrics is not None else ["AUROC", "F1Score"]
+            self.pixel_metric_names = pixel_metrics if pixel_metrics is not None else ["AUROC", "F1Max"]
 
         self._trainer: Trainer | None = None
 
@@ -188,44 +177,6 @@ def model(self) -> AnomalyModule:
             raise UnassignedError(msg)
         return self.trainer.lightning_module
 
-    @property
-    def normalization_callback(self) -> NormalizationCallback | None:
-        """The ``NormalizationCallback`` callback in the trainer.callbacks list, or ``None`` if it doesn't exist.
-
-        Returns:
-            NormalizationCallback | None: Normalization callback, if available.
-
-        Raises:
-            ValueError: If there are multiple normalization callbacks.
-        """
-        callbacks = [callback for callback in self.trainer.callbacks if isinstance(callback, NormalizationCallback)]
-        if len(callbacks) > 1:
-            msg = (
-                f"Trainer can only have one normalization callback but multiple found: {callbacks}. "
-                "Please check your configuration. Exiting to avoid unexpected behavior."
-            )
-            raise ValueError(msg)
-        return callbacks[0] if len(callbacks) > 0 else None
-
-    @property
-    def threshold_callback(self) -> _ThresholdCallback | None:
-        """The ``ThresholdCallback`` callback in the trainer.callbacks list, or ``None`` if it doesn't exist.
-
-        Returns:
-            _ThresholdCallback | None: Threshold callback, if available.
-
-        Raises:
-            ValueError: If there are multiple threshold callbacks.
-        """
-        callbacks = [callback for callback in self.trainer.callbacks if isinstance(callback, _ThresholdCallback)]
-        if len(callbacks) > 1:
-            msg = (
-                f"Trainer can only have one thresholding callback but multiple found: {callbacks}. "
-                "Please check your configuration. Exiting to avoid unexpected behavior."
-            )
-            raise ValueError(msg)
-        return callbacks[0] if len(callbacks) > 0 else None
-
     @property
     def checkpoint_callback(self) -> ModelCheckpoint | None:
         """The ``ModelCheckpoint`` callback in the trainer.callbacks list, or ``None`` if it doesn't exist.
@@ -322,7 +273,7 @@ def _setup_trainer(self, model: AnomalyModule) -> None:
             self._cache.update(model)
 
         # Setup anomalib callbacks to be used with the trainer
-        self._setup_anomalib_callbacks()
+        self._setup_anomalib_callbacks(model)
 
         # Temporarily set devices to 1 to avoid issues with multiple processes
         self._cache.args["devices"] = 1
@@ -405,7 +356,7 @@ def _setup_transform(
                 if not getattr(dataloader.dataset, "transform", None):
                     dataloader.dataset.transform = transform
 
-    def _setup_anomalib_callbacks(self) -> None:
+    def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None:
         """Set up callbacks for the trainer."""
         _callbacks: list[Callback] = []
 
@@ -420,21 +371,16 @@ def _setup_anomalib_callbacks(self) -> None:
                 ),
             )
 
-        # Add the post-processor callbacks.
-        _callbacks.append(_PostProcessorCallback())
+        # Add the post-processor callback.
+        if isinstance(model.post_processor, Callback):
+            _callbacks.append(model.post_processor)
 
-        # Add the the normalization callback.
-        normalization_callback = get_normalization_callback(self.normalization)
-        if normalization_callback is not None:
-            _callbacks.append(normalization_callback)
-
-        # Add the thresholding and metrics callbacks.
-        _callbacks.append(_ThresholdCallback(self.threshold))
+        # Add the metrics callback.
         _callbacks.append(_MetricsCallback(self.task, self.image_metric_names, self.pixel_metric_names))
 
         _callbacks.append(
             _VisualizationCallback(
-                visualizers=ImageVisualizer(task=self.task, normalize=self.normalization == NormalizationMethod.NONE),
+                visualizers=ImageVisualizer(task=self.task, normalize=False),
                 save=True,
                 root=self._cache.args["default_root_dir"] / "images",
             ),
@@ -448,8 +394,6 @@ def _setup_anomalib_callbacks(self) -> None:
     def _should_run_validation(
         self,
         model: AnomalyModule,
-        dataloaders: EVAL_DATALOADERS | None,
-        datamodule: AnomalibDataModule | None,
         ckpt_path: str | Path | None,
     ) -> bool:
         """Check if we need to run validation to collect normalization statistics and thresholds.
@@ -477,13 +421,7 @@ def _should_run_validation(
         if model.learning_type not in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}:
             return False
         # check if a checkpoint path is provided
-        if ckpt_path is not None:
-            return False
-        # check if the model needs to be validated
-        needs_normalization = self.normalization_callback is not None and not hasattr(model, "normalization_metrics")
-        needs_thresholding = self.threshold_callback is not None and not hasattr(model, "image_threshold")
-        # check if the model can be validated (i.e. validation data is available)
-        return (needs_normalization or needs_thresholding) and (dataloaders is not None or datamodule is not None)
+        return ckpt_path is None
 
     def fit(
         self,
@@ -682,7 +620,7 @@ def test(
 
         self._setup_dataset_task(dataloaders)
         self._setup_transform(model or self.model, datamodule=datamodule, ckpt_path=ckpt_path)
-        if self._should_run_validation(model or self.model, dataloaders, datamodule, ckpt_path):
+        if self._should_run_validation(model or self.model, ckpt_path):
             logger.info("Running validation before testing to collect normalization metrics and/or thresholds.")
             self.trainer.validate(model, dataloaders, None, verbose=False, datamodule=datamodule)
         return self.trainer.test(model, dataloaders, ckpt_path, verbose, datamodule)
@@ -779,15 +717,16 @@ def predict(
             msg = f"Unknown type for dataloaders {type(dataloaders)}"
             raise TypeError(msg)
         if dataset is not None:
-            dataloaders.append(DataLoader(dataset))
+            dataloaders.append(DataLoader(dataset, collate_fn=dataset.collate_fn))
         if data_path is not None:
-            dataloaders.append(DataLoader(PredictDataset(data_path)))
+            dataset = PredictDataset(data_path)
+            dataloaders.append(DataLoader(dataset, collate_fn=dataset.collate_fn))
         dataloaders = dataloaders or None
 
         self._setup_dataset_task(dataloaders, datamodule)
         self._setup_transform(model or self.model, datamodule=datamodule, dataloaders=dataloaders, ckpt_path=ckpt_path)
 
-        if self._should_run_validation(model or self.model, None, datamodule, ckpt_path):
+        if self._should_run_validation(model or self.model, ckpt_path):
             logger.info("Running validation before predicting to collect normalization metrics and/or thresholds.")
             self.trainer.validate(
                 model,
@@ -869,7 +808,6 @@ def export(
         export_type: ExportType | str,
         export_root: str | Path | None = None,
         input_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
         compression_type: CompressionType | None = None,
         datamodule: AnomalibDataModule | None = None,
         metric: Metric | str | None = None,
@@ -885,9 +823,6 @@ def export(
                 exported to trainer.default_root_dir. Defaults to None.
             input_size (tuple[int, int] | None, optional): A statis input shape for the model, which is exported to ONNX
                 and OpenVINO format. Defaults to None.
-            transform (Transform | None, optional): Input transform to include in the exported model. If not provided,
-                the engine will try to use the default transform from the model.
-                Defaults to ``None``.
             compression_type (CompressionType | None, optional): Compression type for OpenVINO exporting only.
                 Defaults to ``None``.
             datamodule (AnomalibDataModule | None, optional): Lightning datamodule.
@@ -943,21 +878,16 @@ def export(
         if export_type == ExportType.TORCH:
             exported_model_path = model.to_torch(
                 export_root=export_root,
-                transform=transform,
-                task=self.task,
             )
         elif export_type == ExportType.ONNX:
             exported_model_path = model.to_onnx(
                 export_root=export_root,
                 input_size=input_size,
-                transform=transform,
-                task=self.task,
             )
         elif export_type == ExportType.OPENVINO:
             exported_model_path = model.to_openvino(
                 export_root=export_root,
                 input_size=input_size,
-                transform=transform,
                 task=self.task,
                 compression_type=compression_type,
                 datamodule=datamodule,
diff --git a/src/anomalib/metrics/f1_max.py b/src/anomalib/metrics/f1_max.py
index 8b9b42f305..8159945c77 100644
--- a/src/anomalib/metrics/f1_max.py
+++ b/src/anomalib/metrics/f1_max.py
@@ -92,7 +92,7 @@ def compute(self) -> torch.Tensor:
 
         precision, recall, thresholds = self.precision_recall_curve.compute()
         f1_score = (2 * precision * recall) / (precision + recall + 1e-10)
-        self.threshold = thresholds[torch.argmax(f1_score)]
+        self.threshold = thresholds.item() if thresholds.ndim == 0 else thresholds[torch.argmax(f1_score)]
         return torch.max(f1_score)
 
     def reset(self) -> None:
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py
index 7751818e63..c7b6920618 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomaly_module.py
@@ -12,21 +12,23 @@
 
 import lightning.pytorch as pl
 import torch
+from lightning.pytorch import Callback
 from lightning.pytorch.trainer.states import TrainerFn
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 from torch import nn
-from torchmetrics import MetricCollection
 from torchvision.transforms.v2 import Compose, Normalize, Resize, Transform
 
 from anomalib import LearningType
-from anomalib.metrics import AnomalibMetricCollection
-from anomalib.metrics.threshold import Threshold
+from anomalib.dataclasses import Batch, InferenceBatch
+from anomalib.metrics.threshold import BaseThreshold
+from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 
 from .export_mixin import ExportMixin
 
 if TYPE_CHECKING:
     from lightning.pytorch.callbacks import Callback
 
+    from anomalib.metrics import AnomalibMetricCollection
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +39,7 @@ class AnomalyModule(ExportMixin, pl.LightningModule, ABC):
     Acts as a base class for all the Anomaly Modules in the library.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, post_processor: PostProcessor | None = None) -> None:
         super().__init__()
         logger.info("Initializing %s model.", self.__class__.__name__)
 
@@ -46,14 +48,11 @@ def __init__(self) -> None:
         self.loss: nn.Module
         self.callbacks: list[Callback]
 
-        self.image_threshold: Threshold
-        self.pixel_threshold: Threshold
-
-        self.normalization_metrics: MetricCollection
-
         self.image_metrics: AnomalibMetricCollection
         self.pixel_metrics: AnomalibMetricCollection
 
+        self.post_processor = post_processor or self.default_post_processor()
+
         self._transform: Transform | None = None
         self._input_size: tuple[int, int] | None = None
 
@@ -80,7 +79,7 @@ def _setup(self) -> None:
         initialization.
         """
 
-    def forward(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> Any:  # noqa: ANN401
+    def forward(self, batch: torch.Tensor, *args, **kwargs) -> InferenceBatch:
         """Perform the forward-pass by passing input tensor to the module.
 
         Args:
@@ -92,16 +91,13 @@ def forward(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> Any:
             Tensor: Output tensor from the model.
         """
         del args, kwargs  # These variables are not used.
-
-        return self.model(batch)
-
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
-        """To be implemented in the subclasses."""
-        raise NotImplementedError
+        batch = self.exportable_transform(batch)
+        batch = self.model(batch)
+        return self.post_processor(batch) if self.post_processor else batch
 
     def predict_step(
         self,
-        batch: dict[str, str | torch.Tensor],
+        batch: Batch,
         batch_idx: int,
         dataloader_idx: int = 0,
     ) -> STEP_OUTPUT:
@@ -122,11 +118,11 @@ def predict_step(
 
         return self.validation_step(batch, batch_idx)
 
-    def test_step(self, batch: dict[str, str | torch.Tensor], batch_idx: int, *args, **kwargs) -> STEP_OUTPUT:
+    def test_step(self, batch: Batch, batch_idx: int, *args, **kwargs) -> STEP_OUTPUT:
         """Calls validation_step for anomaly map/score calculation.
 
         Args:
-          batch (dict[str, str | torch.Tensor]): Input batch
+          batch (Batch): Input batch
           batch_idx (int): Batch index
           args: Arguments.
           kwargs: Keyword arguments.
@@ -161,62 +157,7 @@ def _save_to_state_dict(self, destination: OrderedDict, prefix: str, keep_vars:
 
         return super()._save_to_state_dict(destination, prefix, keep_vars)
 
-    def load_state_dict(self, state_dict: OrderedDict[str, Any], strict: bool = True) -> Any:  # noqa: ANN401
-        """Initialize auxiliary object."""
-        if "image_threshold_class" in state_dict:
-            self.image_threshold = self._get_instance(state_dict, "image_threshold_class")
-        if "pixel_threshold_class" in state_dict:
-            self.pixel_threshold = self._get_instance(state_dict, "pixel_threshold_class")
-
-        if "anomaly_maps_normalization_class" in state_dict:
-            self.anomaly_maps_normalization_metrics = self._get_instance(state_dict, "anomaly_maps_normalization_class")
-        if "box_scores_normalization_class" in state_dict:
-            self.box_scores_normalization_metrics = self._get_instance(state_dict, "box_scores_normalization_class")
-        if "pred_scores_normalization_class" in state_dict:
-            self.pred_scores_normalization_metrics = self._get_instance(state_dict, "pred_scores_normalization_class")
-
-        self.normalization_metrics = MetricCollection(
-            {
-                "anomaly_maps": self.anomaly_maps_normalization_metrics,
-                "box_scores": self.box_scores_normalization_metrics,
-                "pred_scores": self.pred_scores_normalization_metrics,
-            },
-        )
-        # Used to load metrics if there is any related data in state_dict
-        self._load_metrics(state_dict)
-
-        return super().load_state_dict(state_dict, strict)
-
-    def _load_metrics(self, state_dict: OrderedDict[str, torch.Tensor]) -> None:
-        """Load metrics from saved checkpoint."""
-        self._add_metrics("pixel", state_dict)
-        self._add_metrics("image", state_dict)
-
-    def _add_metrics(self, name: str, state_dict: OrderedDict[str, torch.Tensor]) -> None:
-        """Sets the pixel/image metrics.
-
-        Args:
-            name (str): is it pixel or image.
-            state_dict (OrderedDict[str, Tensor]): state dict of the model.
-        """
-        metric_keys = [key for key in state_dict if key.startswith(f"{name}_metrics")]
-        if any(metric_keys):
-            if not hasattr(self, f"{name}_metrics"):
-                setattr(self, f"{name}_metrics", AnomalibMetricCollection([], prefix=f"{name}_"))
-            metrics = getattr(self, f"{name}_metrics")
-            for key in metric_keys:
-                class_name = key.split(".")[1]
-                try:
-                    metrics_module = importlib.import_module("anomalib.metrics")
-                    metrics_cls = getattr(metrics_module, class_name)
-                except (ImportError, AttributeError) as exception:
-                    msg = f"Class {class_name} not found in module anomalib.metrics"
-                    raise ImportError(msg) from exception
-                logger.info("Loading %s metrics from state dict", class_name)
-                metrics.add_metrics(metrics_cls())
-
-    @staticmethod
-    def _get_instance(state_dict: OrderedDict[str, Any], dict_key: str) -> Threshold:
+    def _get_instance(self, state_dict: OrderedDict[str, Any], dict_key: str) -> BaseThreshold:
         """Get the threshold class from the ``state_dict``."""
         class_path = state_dict.pop(dict_key)
         module = importlib.import_module(".".join(class_path.split(".")[:-1]))
@@ -260,6 +201,17 @@ def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Tra
             ],
         )
 
+    def default_post_processor(self) -> PostProcessor:
+        """Default post processor.
+
+        Override in subclass for model-specific post-processing behaviour.
+        """
+        if self.learning_type == LearningType.ONE_CLASS:
+            return OneClassPostProcessor()
+        msg = f"No default post-processor available for model {self.__name__} with learning type {self.learning_type}. \
+              Please override the default_post_processor method in the model implementation."
+        raise NotImplementedError(msg)
+
     @property
     def input_size(self) -> tuple[int, int] | None:
         """Return the effective input size of the model.
diff --git a/src/anomalib/models/components/base/export_mixin.py b/src/anomalib/models/components/base/export_mixin.py
index e0627b462c..bd44fb2a61 100644
--- a/src/anomalib/models/components/base/export_mixin.py
+++ b/src/anomalib/models/components/base/export_mixin.py
@@ -12,13 +12,15 @@
 
 import numpy as np
 import torch
+from lightning.pytorch import LightningModule
 from torch import nn
 from torchmetrics import Metric
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
 from anomalib.data import AnomalibDataModule
-from anomalib.deploy.export import CompressionType, ExportType, InferenceModel
+from anomalib.deploy.export import CompressionType, ExportType
+from anomalib.deploy.utils import make_transform_exportable
 from anomalib.metrics import create_metric_collection
 from anomalib.utils.exceptions import try_import
 
@@ -44,8 +46,6 @@ class ExportMixin:
     def to_torch(
         self,
         export_root: Path | str,
-        transform: Transform | None = None,
-        task: TaskType | None = None,
     ) -> Path:
         """Export AnomalibModel to torch.
 
@@ -54,6 +54,8 @@ def to_torch(
             transform (Transform, optional): Input transforms used for the model. If not provided, the transform is
                 taken from the model.
                 Defaults to ``None``.
+            post_processor (nn.Module, optional): Post-processing module to apply to the model output.
+                Defaults to ``None``.
             task (TaskType | None): Task type.
                 Defaults to ``None``.
 
@@ -77,17 +79,13 @@ def to_torch(
 
             >>> model.to_torch(
             ...     export_root="path/to/export",
-            ...     transform=datamodule.test_data.transform,
             ...     task=datamodule.test_data.task,
             ... )
         """
-        transform = transform or self.transform or self.configure_transforms()
-        inference_model = InferenceModel(model=self.model, transform=transform)
         export_root = _create_export_root(export_root, ExportType.TORCH)
-        metadata = self._get_metadata(task=task)
         pt_model_path = export_root / "model.pt"
         torch.save(
-            obj={"model": inference_model, "metadata": metadata},
+            obj={"model": self},
             f=pt_model_path,
         )
         return pt_model_path
@@ -96,8 +94,6 @@ def to_onnx(
         self,
         export_root: Path | str,
         input_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        task: TaskType | None = None,
     ) -> Path:
         """Export model to onnx.
 
@@ -108,6 +104,8 @@ def to_onnx(
             transform (Transform, optional): Input transforms used for the model. If not provided, the transform is
                 taken from the model.
                 Defaults to ``None``.
+            post_processor (nn.Module, optional): Post-processing module to apply to the model output.
+                Defaults to ``None``.
             task (TaskType | None): Task type.
                 Defaults to ``None``.
 
@@ -137,23 +135,24 @@ def to_onnx(
             ...     task="segmentation",
             ... )
         """
-        transform = transform or self.transform or self.configure_transforms()
-        inference_model = InferenceModel(model=self.model, transform=transform, disable_antialias=True)
         export_root = _create_export_root(export_root, ExportType.ONNX)
         input_shape = torch.zeros((1, 3, *input_size)) if input_size else torch.zeros((1, 3, 1, 1))
+        input_shape = input_shape.to(self.device)
         dynamic_axes = (
             None if input_size else {"input": {0: "batch_size", 2: "height", 3: "weight"}, "output": {0: "batch_size"}}
         )
-        _write_metadata_to_json(self._get_metadata(task), export_root)
         onnx_path = export_root / "model.onnx"
+        # apply pass through the model to get the output names
+        assert isinstance(self, LightningModule)  # mypy
+        output_names = [name for name, value in self.eval()(input_shape)._asdict().items() if value is not None]
         torch.onnx.export(
-            inference_model,
+            self,
             input_shape.to(self.device),
             str(onnx_path),
             opset_version=14,
             dynamic_axes=dynamic_axes,
             input_names=["input"],
-            output_names=["output"],
+            output_names=output_names,
         )
 
         return onnx_path
@@ -162,7 +161,6 @@ def to_openvino(
         self,
         export_root: Path | str,
         input_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
         compression_type: CompressionType | None = None,
         datamodule: AnomalibDataModule | None = None,
         metric: Metric | str | None = None,
@@ -250,7 +248,7 @@ def to_openvino(
         import openvino as ov
 
         with TemporaryDirectory() as onnx_directory:
-            model_path = self.to_onnx(onnx_directory, input_size, transform, task)
+            model_path = self.to_onnx(onnx_directory, input_size)
             export_root = _create_export_root(export_root, ExportType.OPENVINO)
             ov_model_path = export_root / "model.xml"
             ov_args = {} if ov_args is None else ov_args
@@ -262,7 +260,6 @@ def to_openvino(
             # fp16 compression is enabled by default
             compress_to_fp16 = compression_type == CompressionType.FP16
             ov.save_model(model, ov_model_path, compress_to_fp16=compress_to_fp16)
-            _write_metadata_to_json(self._get_metadata(task), export_root)
 
         return ov_model_path
 
@@ -303,6 +300,7 @@ def _compress_ov_model(
         elif compression_type == CompressionType.INT8_PTQ:
             model = self._post_training_quantization_ov(model, datamodule)
         elif compression_type == CompressionType.INT8_ACQ:
+            assert task is not None, "Task must be provided for OpenVINO accuracy aware compression"
             model = self._accuracy_control_quantization_ov(model, datamodule, metric, task)
         else:
             msg = f"Unrecognized compression type: {compression_type}"
@@ -441,6 +439,11 @@ def _get_metadata(
 
         return metadata
 
+    @property
+    def exportable_transform(self) -> Transform:
+        """Return the exportable transform."""
+        return make_transform_exportable(self.transform)
+
 
 def _write_metadata_to_json(metadata: dict[str, Any], export_root: Path) -> None:
     """Write metadata to json file.
diff --git a/src/anomalib/models/image/cfa/lightning_model.py b/src/anomalib/models/image/cfa/lightning_model.py
index 05d38689a0..3960c4c7a1 100644
--- a/src/anomalib/models/image/cfa/lightning_model.py
+++ b/src/anomalib/models/image/cfa/lightning_model.py
@@ -15,6 +15,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import CfaLoss
@@ -71,11 +72,11 @@ def on_train_start(self) -> None:
         """Initialize the centroid for the memory bank computation."""
         self.model.initialize_centroid(data_loader=self.trainer.datamodule.train_dataloader())
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the training step for the CFA model.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Batch input.
+            batch (Batch): Batch input.
             *args: Arguments.
             **kwargs: Keyword arguments.
 
@@ -84,15 +85,15 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        distance = self.model(batch["image"])
+        distance = self.model(batch.image)
         loss = self.loss(distance)
         return {"loss": loss}
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step for the CFA model.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch.
+            batch (Batch): Input batch.
             *args: Arguments.
             **kwargs: Keyword arguments.
 
@@ -101,8 +102,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        batch["anomaly_maps"] = self.model(batch["image"])
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @staticmethod
     def backward(loss: torch.Tensor, *args, **kwargs) -> None:
diff --git a/src/anomalib/models/image/cfa/torch_model.py b/src/anomalib/models/image/cfa/torch_model.py
index 5a6c490fac..4c92eeb39b 100644
--- a/src/anomalib/models/image/cfa/torch_model.py
+++ b/src/anomalib/models/image/cfa/torch_model.py
@@ -20,6 +20,7 @@
 from torchvision.models.feature_extraction import create_feature_extractor
 from tqdm import tqdm
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import DynamicBufferMixin
 from anomalib.models.components.feature_extractors import dryrun_find_featuremap_dims
 
@@ -158,7 +159,7 @@ def initialize_centroid(self, data_loader: DataLoader) -> None:
         device = next(self.feature_extractor.parameters()).device
         with torch.no_grad():
             for i, data in enumerate(tqdm(data_loader)):
-                batch = data["image"].to(device)
+                batch = data.image.to(device)
                 features = self.feature_extractor(batch)
                 features = list(features.values())
                 target_features = self.descriptor(features)
@@ -219,14 +220,17 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
         target_features = self.descriptor(features)
         distance = self.compute_distance(target_features)
 
-        return (
-            distance
-            if self.training
-            else self.anomaly_map_generator(
-                distance=distance,
-                scale=target_features.shape[-2:],
-                image_size=input_tensor.shape[-2:],
-            )
+        if self.training:
+            return distance
+        anomaly_map = self.anomaly_map_generator(
+            distance=distance,
+            scale=target_features.shape[-2:],
+            image_size=input_tensor.shape[-2:],
+        )
+        pred_score = torch.amax(anomaly_map, dim=(-2, -1))
+        return InferenceBatch(
+            anomaly_map=anomaly_map,
+            pred_score=pred_score,
         )
 
 
diff --git a/src/anomalib/models/image/cflow/lightning_model.py b/src/anomalib/models/image/cflow/lightning_model.py
index 1b21ddc4cd..620022fd74 100644
--- a/src/anomalib/models/image/cflow/lightning_model.py
+++ b/src/anomalib/models/image/cflow/lightning_model.py
@@ -22,6 +22,7 @@
 from torch.optim import Optimizer
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .torch_model import CflowModel
@@ -100,7 +101,7 @@ def configure_optimizers(self) -> Optimizer:
             lr=self.learning_rate,
         )
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the training step of CFLOW.
 
         For each batch, decoder layers are trained with a dynamic fiber batch size.
@@ -108,7 +109,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
             per batch of input images
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch
+            batch (Batch): Input batch
             *args: Arguments.
             **kwargs: Keyword arguments.
 
@@ -120,7 +121,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
 
         opt = self.optimizers()
 
-        images: torch.Tensor = batch["image"]
+        images: torch.Tensor = batch.image
         activation = self.model.encoder(images)
         avg_loss = torch.zeros([1], dtype=torch.float64).to(images.device)
 
@@ -175,7 +176,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         self.log("train_loss", avg_loss.item(), on_epoch=True, prog_bar=True, logger=True)
         return {"loss": avg_loss}
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step of CFLOW.
 
             Similar to the training step, encoder features
@@ -183,7 +184,7 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
             map is computed.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch
+            batch (Batch): Input batch
             *args: Arguments.
             **kwargs: Keyword arguments.
 
@@ -194,8 +195,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        batch["anomaly_maps"] = self.model(batch["image"])
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/cflow/torch_model.py b/src/anomalib/models/image/cflow/torch_model.py
index 2520c9d033..57fbd37e15 100644
--- a/src/anomalib/models/image/cflow/torch_model.py
+++ b/src/anomalib/models/image/cflow/torch_model.py
@@ -9,6 +9,7 @@
 import torch
 from torch import nn
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerator
@@ -82,7 +83,7 @@ def __init__(
 
         self.anomaly_map_generator = AnomalyMapGenerator(pool_layers=self.pool_layers)
 
-    def forward(self, images: torch.Tensor) -> torch.Tensor:
+    def forward(self, images: torch.Tensor) -> InferenceBatch:
         """Forward-pass images into the network to extract encoder features and compute probability.
 
         Args:
@@ -150,4 +151,4 @@ def forward(self, images: torch.Tensor) -> torch.Tensor:
         )
         self.decoders.train()
 
-        return output.to(images.device)
+        return InferenceBatch(anomaly_map=output.to(images.device))
diff --git a/src/anomalib/models/image/csflow/lightning_model.py b/src/anomalib/models/image/csflow/lightning_model.py
index e4b4dad2ef..14fd7697de 100644
--- a/src/anomalib/models/image/csflow/lightning_model.py
+++ b/src/anomalib/models/image/csflow/lightning_model.py
@@ -13,6 +13,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import CsFlowLoss
@@ -69,11 +70,11 @@ def _setup(self) -> None:
         )
         self.model.feature_extractor.eval()
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the training step of CS-Flow.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch
+            batch (Batch): Input batch
             args: Arguments.
             kwargs: Keyword arguments.
 
@@ -82,16 +83,16 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        z_dist, jacobians = self.model(batch["image"])
+        z_dist, jacobians = self.model(batch.image)
         loss = self.loss(z_dist, jacobians)
         self.log("train_loss", loss.item(), on_epoch=True, prog_bar=True, logger=True)
         return {"loss": loss}
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step for CS Flow.
 
         Args:
-            batch (torch.Tensor): Input batch
+            batch (Batch): Input batch
             args: Arguments.
             kwargs: Keyword arguments.
 
@@ -100,10 +101,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        output = self.model(batch["image"])
-        batch["anomaly_maps"] = output["anomaly_map"]
-        batch["pred_scores"] = output["pred_score"]
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/csflow/torch_model.py b/src/anomalib/models/image/csflow/torch_model.py
index 6569c7a0dd..6f2120ec38 100644
--- a/src/anomalib/models/image/csflow/torch_model.py
+++ b/src/anomalib/models/image/csflow/torch_model.py
@@ -20,6 +20,7 @@
 from torch.nn import functional as F  # noqa: N812
 from torchvision.models.efficientnet import EfficientNet_B5_Weights
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components.feature_extractors import TorchFXFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerator, AnomalyMapMode
@@ -572,7 +573,7 @@ def __init__(
         )
         self.anomaly_map_generator = AnomalyMapGenerator(input_dims=self.input_dims, mode=AnomalyMapMode.ALL)
 
-    def forward(self, images: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    def forward(self, images: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor] | InferenceBatch:
         """Forward method of the model.
 
         Args:
@@ -585,13 +586,11 @@ def forward(self, images: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         """
         features = self.feature_extractor(images)
         if self.training:
-            output = self.graph(features)
-        else:
-            z_dist, _ = self.graph(features)  # Ignore Jacobians
-            anomaly_scores = self._compute_anomaly_scores(z_dist)
-            anomaly_maps = self.anomaly_map_generator(z_dist)
-            output = {"anomaly_map": anomaly_maps, "pred_score": anomaly_scores}
-        return output
+            return self.graph(features)
+        z_dist, _ = self.graph(features)  # Ignore Jacobians
+        anomaly_scores = self._compute_anomaly_scores(z_dist)
+        anomaly_maps = self.anomaly_map_generator(z_dist)
+        return InferenceBatch(anomaly_map=anomaly_maps, pred_score=anomaly_scores)
 
     @staticmethod
     def _compute_anomaly_scores(z_dists: torch.Tensor) -> torch.Tensor:
diff --git a/src/anomalib/models/image/dfkde/lightning_model.py b/src/anomalib/models/image/dfkde/lightning_model.py
index 1969ee42f6..f0d094696e 100644
--- a/src/anomalib/models/image/dfkde/lightning_model.py
+++ b/src/anomalib/models/image/dfkde/lightning_model.py
@@ -11,6 +11,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.models.components.classification import FeatureScalingMethod
 
@@ -64,11 +65,11 @@ def configure_optimizers() -> None:  # pylint: disable=arguments-differ
         """DFKDE doesn't require optimization, therefore returns no optimizers."""
         return
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> None:
+    def training_step(self, batch: Batch, *args, **kwargs) -> None:
         """Perform the training step of DFKDE. For each batch, features are extracted from the CNN.
 
         Args:
-            batch (batch: dict[str, str | torch.Tensor]): Batch containing image filename, image, label and mask
+            batch (batch: Batch): Batch containing image filename, image, label and mask
             args: Arguments.
             kwargs: Keyword arguments.
 
@@ -77,7 +78,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        embedding = self.model(batch["image"])
+        embedding = self.model(batch.image)
         self.embeddings.append(embedding)
 
     def fit(self) -> None:
@@ -87,13 +88,13 @@ def fit(self) -> None:
         logger.info("Fitting a KDE model to the embedding collected from the training set.")
         self.model.classifier.fit(embeddings)
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step of DFKDE.
 
         Similar to the training step, features are extracted from the CNN for each batch.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch
+            batch (Batch): Input batch
             args: Arguments.
             kwargs: Keyword arguments.
 
@@ -102,8 +103,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        batch["pred_scores"] = self.model(batch["image"])
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/dfkde/torch_model.py b/src/anomalib/models/image/dfkde/torch_model.py
index 9f19115768..e235bcff92 100644
--- a/src/anomalib/models/image/dfkde/torch_model.py
+++ b/src/anomalib/models/image/dfkde/torch_model.py
@@ -10,6 +10,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 from anomalib.models.components.classification import FeatureScalingMethod, KDEClassifier
 
@@ -68,7 +69,7 @@ def get_features(self, batch: torch.Tensor) -> torch.Tensor:
             layer_outputs[layer] = layer_outputs[layer].view(batch_size, -1)
         return torch.cat(list(layer_outputs.values())).detach()
 
-    def forward(self, batch: torch.Tensor) -> torch.Tensor:
+    def forward(self, batch: torch.Tensor) -> torch.Tensor | InferenceBatch:
         """Prediction by normality model.
 
         Args:
@@ -83,4 +84,5 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor:
             return features
 
         # 2. apply density estimation
-        return self.classifier(features)
+        scores = self.classifier(features)
+        return InferenceBatch(pred_score=scores)
diff --git a/src/anomalib/models/image/dfm/lightning_model.py b/src/anomalib/models/image/dfm/lightning_model.py
index 259ca93d99..107215437a 100644
--- a/src/anomalib/models/image/dfm/lightning_model.py
+++ b/src/anomalib/models/image/dfm/lightning_model.py
@@ -13,6 +13,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 
 from .torch_model import DFMModel
@@ -65,13 +66,13 @@ def configure_optimizers() -> None:  # pylint: disable=arguments-differ
         """DFM doesn't require optimization, therefore returns no optimizers."""
         return
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> None:
+    def training_step(self, batch: Batch, *args, **kwargs) -> None:
         """Perform the training step of DFM.
 
         For each batch, features are extracted from the CNN.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch
+            batch (Batch): Input batch
             args: Arguments.
             kwargs: Keyword arguments.
 
@@ -80,7 +81,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        embedding = self.model.get_features(batch["image"]).squeeze()
+        embedding = self.model.get_features(batch.image).squeeze()
         self.embeddings.append(embedding)
 
     def fit(self) -> None:
@@ -91,13 +92,13 @@ def fit(self) -> None:
         logger.info("Fitting a PCA and a Gaussian model to dataset.")
         self.model.fit(embeddings)
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step of DFM.
 
         Similar to the training step, features are extracted from the CNN for each batch.
 
         Args:
-          batch (dict[str, str | torch.Tensor]): Input batch
+          batch (Batch): Input batch
           args: Arguments.
           kwargs: Keyword arguments.
 
@@ -106,12 +107,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        if self.score_type == "fre":
-            batch["pred_scores"], batch["anomaly_maps"] = self.model(batch["image"])
-        elif self.score_type == "nll":
-            batch["pred_scores"], _ = self.model(batch["image"])
-
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/dfm/torch_model.py b/src/anomalib/models/image/dfm/torch_model.py
index 1552d61c90..46288457d7 100644
--- a/src/anomalib/models/image/dfm/torch_model.py
+++ b/src/anomalib/models/image/dfm/torch_model.py
@@ -9,6 +9,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import PCA, DynamicBufferMixin, TimmFeatureExtractor
 
 
@@ -163,7 +164,7 @@ def get_features(self, batch: torch.Tensor) -> torch.Tensor:
         features = features.view(batch_size, -1).detach()
         return features if self.training else (features, feature_shapes)
 
-    def forward(self, batch: torch.Tensor) -> torch.Tensor:
+    def forward(self, batch: torch.Tensor) -> torch.Tensor | InferenceBatch:
         """Compute score from input images.
 
         Args:
@@ -176,4 +177,4 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor:
         score, score_map = self.score(feature_vector.view(feature_vector.shape[:2]), feature_shapes)
         if score_map is not None:
             score_map = F.interpolate(score_map, size=batch.shape[-2:], mode="bilinear", align_corners=False)
-        return score, score_map
+        return InferenceBatch(pred_score=score, anomaly_map=score_map)
diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py
index f33bff6538..68d6f68119 100644
--- a/src/anomalib/models/image/draem/lightning_model.py
+++ b/src/anomalib/models/image/draem/lightning_model.py
@@ -15,6 +15,7 @@
 
 from anomalib import LearningType
 from anomalib.data.utils import Augmenter
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import DraemLoss
@@ -81,14 +82,14 @@ def hook(_, __, output: torch.Tensor) -> None:  # noqa: ANN001
         self.model.reconstructive_subnetwork.encoder.mp4.register_forward_hook(get_activation("input"))
         self.model.reconstructive_subnetwork.encoder.block5.register_forward_hook(get_activation("output"))
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the training step of DRAEM.
 
         Feeds the original image and the simulated anomaly
         image through the network and computes the training loss.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Batch containing image filename, image, label and mask
+            batch (Batch): Batch containing image filename, image, label and mask
             args: Arguments.
             kwargs: Keyword arguments.
 
@@ -97,7 +98,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        input_image = batch["image"]
+        input_image = batch.image
         # Apply corruption to input image
         augmented_image, anomaly_mask = self.augmenter.augment_batch(input_image)
         # Generate model prediction
@@ -114,11 +115,11 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         self.log("train_loss", loss.item(), on_epoch=True, prog_bar=True, logger=True)
         return {"loss": loss}
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step of DRAEM. The Softmax predictions of the anomalous class are used as anomaly map.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Batch of input images
+            batch (Batch): Batch of input images
             args: Arguments.
             kwargs: Keyword arguments.
 
@@ -127,9 +128,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        prediction = self.model(batch["image"])
-        batch["anomaly_maps"] = prediction
-        return batch
+        prediction = self.model(batch.image)
+        return batch.update(**prediction._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/draem/torch_model.py b/src/anomalib/models/image/draem/torch_model.py
index 9ae5d1c030..d0df3fa0cc 100644
--- a/src/anomalib/models/image/draem/torch_model.py
+++ b/src/anomalib/models/image/draem/torch_model.py
@@ -12,6 +12,7 @@
 import torch
 from torch import nn
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components.layers import SSPCAB
 
 
@@ -28,7 +29,7 @@ def __init__(self, sspcab: bool = False) -> None:
         self.reconstructive_subnetwork = ReconstructiveSubNetwork(sspcab=sspcab)
         self.discriminative_subnetwork = DiscriminativeSubNetwork(in_channels=6, out_channels=2)
 
-    def forward(self, batch: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+    def forward(self, batch: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor] | InferenceBatch:
         """Compute the reconstruction and anomaly mask from an input image.
 
         Args:
@@ -43,7 +44,8 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, tor
         prediction = self.discriminative_subnetwork(concatenated_inputs)
         if self.training:
             return reconstruction, prediction
-        return torch.softmax(prediction, dim=1)[:, 1, ...]
+        anomaly_map = torch.softmax(prediction, dim=1)[:, 1, ...]
+        return InferenceBatch(anomaly_map=anomaly_map)
 
 
 class ReconstructiveSubNetwork(nn.Module):
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index b9a1136fd3..8526699d27 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -12,11 +12,11 @@
 
 import torch
 from lightning.pytorch.utilities.types import STEP_OUTPUT, OptimizerLRScheduler
-from torch import Tensor
 
 from anomalib import LearningType
 from anomalib.data.utils import DownloadInfo, download_and_extract
 from anomalib.data.utils.augmenter import Augmenter
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 from anomalib.models.image.dsr.anomaly_generator import DsrAnomalyGenerator
 from anomalib.models.image.dsr.loss import DsrSecondStageLoss, DsrThirdStageLoss
@@ -102,14 +102,14 @@ def on_train_epoch_start(self) -> None:
         if self.current_epoch == self.second_phase:
             logger.info("Now training upsampling module.")
 
-    def training_step(self, batch: dict[str, str | Tensor]) -> STEP_OUTPUT:
+    def training_step(self, batch: Batch) -> STEP_OUTPUT:
         """Training Step of DSR.
 
         Feeds the original image and the simulated anomaly mask during first phase. During
         second phase, feeds a generated anomalous image to train the upsampling module.
 
         Args:
-            batch (dict[str, str | Tensor]): Batch containing image filename, image, label and mask
+            batch (Batch): Batch containing image filename, image, label and mask
 
         Returns:
             STEP_OUTPUT: Loss dictionary
@@ -118,7 +118,7 @@ def training_step(self, batch: dict[str, str | Tensor]) -> STEP_OUTPUT:
 
         if self.current_epoch < self.second_phase:
             # we are not yet training the upsampling module: we are only using the first optimizer
-            input_image = batch["image"]
+            input_image = batch.image
             # Create anomaly masks
             anomaly_mask = self.quantized_anomaly_generator.augment_batch(input_image)
             # Generate model prediction
@@ -142,7 +142,7 @@ def training_step(self, batch: dict[str, str | Tensor]) -> STEP_OUTPUT:
 
         else:
             # we are training the upsampling module
-            input_image = batch["image"]
+            input_image = batch.image
             # Generate anomalies
             input_image, anomaly_maps = self.perlin_generator.augment_batch(input_image)
             # Get model prediction
@@ -158,13 +158,13 @@ def training_step(self, batch: dict[str, str | Tensor]) -> STEP_OUTPUT:
         self.log("train_loss", loss.item(), on_epoch=True, prog_bar=True, logger=True)
         return {"loss": loss}
 
-    def validation_step(self, batch: dict[str, str | Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Validation step of DSR.
 
         The Softmax predictions of the anomalous class are used as anomaly map.
 
         Args:
-            batch (dict[str, str | Tensor]): Batch of input images
+            batch (Batch): Batch of input images
             *args: unused
             **kwargs: unused
 
@@ -173,10 +173,8 @@ def validation_step(self, batch: dict[str, str | Tensor], *args, **kwargs) -> ST
         """
         del args, kwargs  # These variables are not used.
 
-        model_outputs = self.model(batch["image"])
-        batch["anomaly_maps"] = model_outputs["anomaly_map"]
-        batch["pred_scores"] = model_outputs["pred_score"]
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/dsr/torch_model.py b/src/anomalib/models/image/dsr/torch_model.py
index 395c1d2b5d..b44904cb19 100644
--- a/src/anomalib/models/image/dsr/torch_model.py
+++ b/src/anomalib/models/image/dsr/torch_model.py
@@ -16,6 +16,8 @@
 import torch.nn.functional as F  # noqa: N812
 from torch import nn
 
+from anomalib.dataclasses import InferenceBatch
+
 
 class DsrModel(nn.Module):
     """DSR PyTorch model.
@@ -88,7 +90,7 @@ def forward(
         self,
         batch: torch.Tensor,
         anomaly_map_to_generate: torch.Tensor | None = None,
-    ) -> dict[str, torch.Tensor]:
+    ) -> dict[str, torch.Tensor] | InferenceBatch:
         """Compute the anomaly mask from an input image.
 
         Args:
@@ -112,8 +114,6 @@ def forward(
             If training phase 3:
                 - "anomaly_map": Reconstructed anomaly map
         """
-        outputs: dict[str, torch.Tensor]
-
         # Generate latent embeddings decoded image via general object decoder
         if anomaly_map_to_generate is None:
             # either evaluating or training phase 3
@@ -152,26 +152,25 @@ def forward(
 
             # if training phase 3, return upsampled softmax mask
             if self.training:
-                outputs = {"anomaly_map": out_mask_sm_up}
+                return {"anomaly_map": out_mask_sm_up}
             # if testing, extract image score
-            else:
-                out_mask_averaged = torch.nn.functional.avg_pool2d(
-                    out_mask_sm[:, 1:, :, :],
-                    21,
-                    stride=1,
-                    padding=21 // 2,
-                ).detach()
-                image_score = torch.amax(out_mask_averaged, dim=(2, 3)).squeeze()
+            out_mask_averaged = torch.nn.functional.avg_pool2d(
+                out_mask_sm[:, 1:, :, :],
+                21,
+                stride=1,
+                padding=21 // 2,
+            ).detach()
+            image_score = torch.amax(out_mask_averaged, dim=(2, 3)).squeeze()
 
-                # prevent crash when image_score is a single value (batch size of 1)
-                if image_score.size() == torch.Size([]):
-                    image_score = image_score.unsqueeze(0)
+            # prevent crash when image_score is a single value (batch size of 1)
+            if image_score.size() == torch.Size([]):
+                image_score = image_score.unsqueeze(0)
 
-                out_mask_cv = out_mask_sm_up[:, 1, :, :]
+            out_mask_cv = out_mask_sm_up[:, 1, :, :]
 
-                outputs = {"anomaly_map": out_mask_cv, "pred_score": image_score}
+            return InferenceBatch(anomaly_map=out_mask_cv, pred_score=image_score)
 
-        elif anomaly_map_to_generate is not None and self.training:
+        if anomaly_map_to_generate is not None and self.training:
             # we are in phase two
 
             # Generate anomaly strength factors
@@ -218,7 +217,7 @@ def forward(
             out_mask_sm = torch.softmax(out_mask, dim=1)
 
             # Outputs
-            outputs = {
+            return {
                 "recon_feat_hi": recon_feat_hi,
                 "recon_feat_lo": recon_feat_lo,
                 "embedding_bot": embd_bot,
@@ -227,11 +226,8 @@ def forward(
                 "anomaly_map": out_mask_sm,
                 "true_anomaly_map": true_anomaly_map,
             }
-        else:
-            msg = "There should not be an anomaly map to generate when not training"
-            raise RuntimeError(msg)
-
-        return outputs
+        msg = "There should not be an anomaly map to generate when not training"
+        raise RuntimeError(msg)
 
 
 class SubspaceRestrictionModule(nn.Module):
diff --git a/src/anomalib/models/image/efficient_ad/lightning_model.py b/src/anomalib/models/image/efficient_ad/lightning_model.py
index 216ab418bf..db9b1fad4c 100644
--- a/src/anomalib/models/image/efficient_ad/lightning_model.py
+++ b/src/anomalib/models/image/efficient_ad/lightning_model.py
@@ -19,6 +19,7 @@
 
 from anomalib import LearningType
 from anomalib.data.utils import DownloadInfo, download_and_extract
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .torch_model import EfficientAdModel, EfficientAdModelSize, reduce_tensor_elems
@@ -136,7 +137,7 @@ def teacher_channel_mean_std(self, dataloader: DataLoader) -> dict[str, torch.Te
         chanel_sum_sqr: torch.Tensor | None = None
 
         for batch in tqdm.tqdm(dataloader, desc="Calculate teacher channel mean & std", position=0, leave=True):
-            y = self.model.teacher(batch["image"].to(self.device))
+            y = self.model.teacher(batch.image.to(self.device))
             if not arrays_defined:
                 _, num_channels, _, _ = y.shape
                 n = torch.zeros((num_channels,), dtype=torch.int64, device=y.device)
@@ -174,11 +175,9 @@ def map_norm_quantiles(self, dataloader: DataLoader) -> dict[str, torch.Tensor]:
         maps_ae = []
         logger.info("Calculate Validation Dataset Quantiles")
         for batch in tqdm.tqdm(dataloader, desc="Calculate Validation Dataset Quantiles", position=0, leave=True):
-            for img, label in zip(batch["image"], batch["label"], strict=True):
+            for img, label in zip(batch.image, batch.gt_label, strict=True):
                 if label == 0:  # only use good images of validation set!
-                    output = self.model(img.to(self.device), normalize=False)
-                    map_st = output["map_st"]
-                    map_ae = output["map_ae"]
+                    map_st, map_ae = self.model.get_maps(img.to(self.device), normalize=False)
                     maps_st.append(map_st)
                     maps_ae.append(map_ae)
 
@@ -249,18 +248,18 @@ def on_train_start(self) -> None:
             raise ValueError(msg)
 
         sample = next(iter(self.trainer.train_dataloader))
-        image_size = sample["image"].shape[-2:]
+        image_size = sample.image.shape[-2:]
         self.prepare_pretrained_model()
         self.prepare_imagenette_data(image_size)
         if not self.model.is_set(self.model.mean_std):
             channel_mean_std = self.teacher_channel_mean_std(self.trainer.datamodule.train_dataloader())
             self.model.mean_std.update(channel_mean_std)
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> dict[str, torch.Tensor]:
+    def training_step(self, batch: Batch, *args, **kwargs) -> dict[str, torch.Tensor]:
         """Perform the training step for EfficientAd returns the student, autoencoder and combined loss.
 
         Args:
-            batch (batch: dict[str, str | torch.Tensor]): Batch containing image filename, image, label and mask
+            batch (Batch): Batch containing image filename, image, label and mask
             args: Additional arguments.
             kwargs: Additional keyword arguments.
 
@@ -276,7 +275,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
             self.imagenet_iterator = iter(self.imagenet_loader)
             batch_imagenet = next(self.imagenet_iterator)[0].to(self.device)
 
-        loss_st, loss_ae, loss_stae = self.model(batch=batch["image"], batch_imagenet=batch_imagenet)
+        loss_st, loss_ae, loss_stae = self.model(batch=batch.image, batch_imagenet=batch_imagenet)
 
         loss = loss_st + loss_ae + loss_stae
         self.log("train_st", loss_st.item(), on_epoch=True, prog_bar=True, logger=True)
@@ -290,11 +289,11 @@ def on_validation_start(self) -> None:
         map_norm_quantiles = self.map_norm_quantiles(self.trainer.datamodule.val_dataloader())
         self.model.quantiles.update(map_norm_quantiles)
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step of EfficientAd returns anomaly maps for the input image batch.
 
         Args:
-          batch (dict[str, str | torch.Tensor]): Input batch
+          batch (Batch): Input batch
           args: Additional arguments.
           kwargs: Additional keyword arguments.
 
@@ -303,9 +302,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        batch["anomaly_maps"] = self.model(batch["image"])["anomaly_map"]
-
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/efficient_ad/torch_model.py b/src/anomalib/models/image/efficient_ad/torch_model.py
index 12f320e263..57b9c87340 100644
--- a/src/anomalib/models/image/efficient_ad/torch_model.py
+++ b/src/anomalib/models/image/efficient_ad/torch_model.py
@@ -13,6 +13,8 @@
 from torch.nn import functional as F  # noqa: N812
 from torchvision import transforms
 
+from anomalib.dataclasses import InferenceBatch
+
 logger = logging.getLogger(__name__)
 
 
@@ -356,7 +358,7 @@ def forward(
         batch: torch.Tensor,
         batch_imagenet: torch.Tensor | None = None,
         normalize: bool = True,
-    ) -> torch.Tensor | dict:
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor] | InferenceBatch:
         """Perform the forward-pass of the EfficientAd models.
 
         Args:
@@ -367,7 +369,24 @@ def forward(
         Returns:
             Tensor: Predictions
         """
-        image_size = batch.shape[-2:]
+        student_output, distance_st = self.compute_student_teacher_distance(batch)
+        if self.training:
+            return self.compute_losses(batch, batch_imagenet, distance_st)
+        map_st, map_stae = self.compute_maps(batch, student_output, distance_st, normalize)
+        map_combined = 0.5 * map_st + 0.5 * map_stae
+        return InferenceBatch(anomaly_map=map_combined)
+
+    def compute_student_teacher_distance(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        """Compute the student-teacher distance vectors.
+
+        Args:
+            batch (torch.Tensor): Input images.
+            batch_imagenet (torch.Tensor): ImageNet batch. Defaults to None.
+            normalize (bool): Normalize anomaly maps or not
+
+        Returns:
+            Tensor: Predictions
+        """
         with torch.no_grad():
             teacher_output = self.teacher(batch)
             if self.is_set(self.mean_std):
@@ -375,34 +394,50 @@ def forward(
 
         student_output = self.student(batch)
         distance_st = torch.pow(teacher_output - student_output[:, : self.teacher_out_channels, :, :], 2)
+        return student_output, distance_st
 
-        if self.training:
-            # Student loss
-            distance_st = reduce_tensor_elems(distance_st)
-            d_hard = torch.quantile(distance_st, 0.999)
-            loss_hard = torch.mean(distance_st[distance_st >= d_hard])
-            student_output_penalty = self.student(batch_imagenet)[:, : self.teacher_out_channels, :, :]
-            loss_penalty = torch.mean(student_output_penalty**2)
-            loss_st = loss_hard + loss_penalty
-
-            # Autoencoder and Student AE Loss
-            aug_img = self.choose_random_aug_image(batch)
-            ae_output_aug = self.ae(aug_img, image_size)
+    def compute_losses(
+        self,
+        batch: torch.Tensor,
+        batch_imagenet: torch.Tensor,
+        distance_st: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Compute the student-teacher loss and the autoencoder loss."""
+        # Student loss
+        distance_st = reduce_tensor_elems(distance_st)
+        d_hard = torch.quantile(distance_st, 0.999)
+        loss_hard = torch.mean(distance_st[distance_st >= d_hard])
+        student_output_penalty = self.student(batch_imagenet)[:, : self.teacher_out_channels, :, :]
+        loss_penalty = torch.mean(student_output_penalty**2)
+        loss_st = loss_hard + loss_penalty
+
+        # Autoencoder and Student AE Loss
+        aug_img = self.choose_random_aug_image(batch)
+        ae_output_aug = self.ae(aug_img, batch.shape[-2:])
 
-            with torch.no_grad():
-                teacher_output_aug = self.teacher(aug_img)
-                if self.is_set(self.mean_std):
-                    teacher_output_aug = (teacher_output_aug - self.mean_std["mean"]) / self.mean_std["std"]
+        with torch.no_grad():
+            teacher_output_aug = self.teacher(aug_img)
+            if self.is_set(self.mean_std):
+                teacher_output_aug = (teacher_output_aug - self.mean_std["mean"]) / self.mean_std["std"]
 
-            student_output_ae_aug = self.student(aug_img)[:, self.teacher_out_channels :, :, :]
+        student_output_ae_aug = self.student(aug_img)[:, self.teacher_out_channels :, :, :]
 
-            distance_ae = torch.pow(teacher_output_aug - ae_output_aug, 2)
-            distance_stae = torch.pow(ae_output_aug - student_output_ae_aug, 2)
+        distance_ae = torch.pow(teacher_output_aug - ae_output_aug, 2)
+        distance_stae = torch.pow(ae_output_aug - student_output_ae_aug, 2)
 
-            loss_ae = torch.mean(distance_ae)
-            loss_stae = torch.mean(distance_stae)
-            return (loss_st, loss_ae, loss_stae)
+        loss_ae = torch.mean(distance_ae)
+        loss_stae = torch.mean(distance_stae)
+        return (loss_st, loss_ae, loss_stae)
 
+    def compute_maps(
+        self,
+        batch: torch.Tensor,
+        student_output: torch.Tensor,
+        distance_st: torch.Tensor,
+        normalize: bool = True,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Compute the anomaly maps."""
+        image_size = batch.shape[-2:]
         # Eval mode.
         with torch.no_grad():
             ae_output = self.ae(batch, image_size)
@@ -423,6 +458,9 @@ def forward(
         if self.is_set(self.quantiles) and normalize:
             map_st = 0.1 * (map_st - self.quantiles["qa_st"]) / (self.quantiles["qb_st"] - self.quantiles["qa_st"])
             map_stae = 0.1 * (map_stae - self.quantiles["qa_ae"]) / (self.quantiles["qb_ae"] - self.quantiles["qa_ae"])
+        return map_st, map_stae
 
-        map_combined = 0.5 * map_st + 0.5 * map_stae
-        return {"anomaly_map": map_combined, "map_st": map_st, "map_ae": map_stae}
+    def get_maps(self, batch: torch.Tensor, normalize: bool = False) -> tuple[torch.Tensor, torch.Tensor]:
+        """Standalone function to compute anomaly maps."""
+        student_output, distance_st = self.compute_student_teacher_distance(batch)
+        return self.compute_maps(batch, student_output, distance_st, normalize)
diff --git a/src/anomalib/models/image/fastflow/lightning_model.py b/src/anomalib/models/image/fastflow/lightning_model.py
index e6f2df0780..587f117f5b 100644
--- a/src/anomalib/models/image/fastflow/lightning_model.py
+++ b/src/anomalib/models/image/fastflow/lightning_model.py
@@ -13,6 +13,7 @@
 from torch import optim
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import FastflowLoss
@@ -68,7 +69,7 @@ def _setup(self) -> None:
             hidden_ratio=self.hidden_ratio,
         )
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the training step input and return the loss.
 
         Args:
@@ -81,12 +82,12 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        hidden_variables, jacobians = self.model(batch["image"])
+        hidden_variables, jacobians = self.model(batch.image)
         loss = self.loss(hidden_variables, jacobians)
         self.log("train_loss", loss.item(), on_epoch=True, prog_bar=True, logger=True)
         return {"loss": loss}
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step and return the anomaly map.
 
         Args:
@@ -99,9 +100,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        anomaly_maps = self.model(batch["image"])
-        batch["anomaly_maps"] = anomaly_maps
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/fastflow/torch_model.py b/src/anomalib/models/image/fastflow/torch_model.py
index 379416a8f3..3c84b69fa2 100644
--- a/src/anomalib/models/image/fastflow/torch_model.py
+++ b/src/anomalib/models/image/fastflow/torch_model.py
@@ -18,6 +18,7 @@
 from timm.models.vision_transformer import VisionTransformer
 from torch import nn
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components.flow import AllInOneBlock
 
 from .anomaly_map import AnomalyMapGenerator
@@ -170,7 +171,7 @@ def __init__(
             )
         self.anomaly_map_generator = AnomalyMapGenerator(input_size=input_size)
 
-    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | list[torch.Tensor] | tuple[list[torch.Tensor]]:
+    def forward(self, input_tensor: torch.Tensor) -> tuple[list[torch.Tensor], list[torch.Tensor]] | InferenceBatch:
         """Forward-Pass the input to the FastFlow Model.
 
         Args:
@@ -181,8 +182,6 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | list[torch.Tenso
                 (hidden_variables, log-of-the-jacobian-determinants).
                 During the validation/test, return the anomaly map.
         """
-        return_val: torch.Tensor | list[torch.Tensor] | tuple[list[torch.Tensor]]
-
         self.feature_extractor.eval()
         if isinstance(self.feature_extractor, VisionTransformer):
             features = self._get_vit_features(input_tensor)
@@ -201,12 +200,11 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | list[torch.Tenso
             hidden_variables.append(hidden_variable)
             log_jacobians.append(log_jacobian)
 
-        return_val = (hidden_variables, log_jacobians)
-
-        if not self.training:
-            return_val = self.anomaly_map_generator(hidden_variables)
+        if self.training:
+            return hidden_variables, log_jacobians
 
-        return return_val
+        anomaly_map = self.anomaly_map_generator(hidden_variables)
+        return InferenceBatch(anomaly_map=anomaly_map)
 
     def _get_cnn_features(self, input_tensor: torch.Tensor) -> list[torch.Tensor]:
         """Get CNN-based features.
diff --git a/src/anomalib/models/image/fre/lightning_model.py b/src/anomalib/models/image/fre/lightning_model.py
index 355844f0f7..7abcd8d0a8 100755
--- a/src/anomalib/models/image/fre/lightning_model.py
+++ b/src/anomalib/models/image/fre/lightning_model.py
@@ -14,6 +14,7 @@
 from torch import optim
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .torch_model import FREModel
@@ -69,13 +70,13 @@ def configure_optimizers(self) -> torch.optim.Optimizer:
         """
         return optim.Adam(params=self.model.fre_model.parameters(), lr=1e-3)
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the training step of FRE.
 
         For each batch, features are extracted from the CNN.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch
+            batch (Batch): Input batch
             args: Arguments.
             kwargs: Keyword arguments.
 
@@ -83,18 +84,18 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
           Deep CNN features.
         """
         del args, kwargs  # These variables are not used.
-        features_in, features_out, _ = self.model.get_features(batch["image"])
+        features_in, features_out, _ = self.model.get_features(batch.image)
         loss = self.loss_fn(features_in, features_out)
         self.log("train_loss", loss.item(), on_epoch=True, prog_bar=True, logger=True)
         return {"loss": loss}
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step of FRE.
 
         Similar to the training step, features are extracted from the CNN for each batch.
 
         Args:
-          batch (dict[str, str | torch.Tensor]): Input batch
+          batch (Batch): Input batch
           args: Arguments.
           kwargs: Keyword arguments.
 
@@ -103,8 +104,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        batch["pred_scores"], batch["anomaly_maps"] = self.model(batch["image"])
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/fre/torch_model.py b/src/anomalib/models/image/fre/torch_model.py
index 534521dd01..fdb13fb9e2 100755
--- a/src/anomalib/models/image/fre/torch_model.py
+++ b/src/anomalib/models/image/fre/torch_model.py
@@ -7,6 +7,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 
 
@@ -96,7 +97,7 @@ def get_features(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor,
         features_out = self.fre_model(features_in)
         return features_in, features_out, feature_shapes
 
-    def forward(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    def forward(self, batch: torch.Tensor) -> InferenceBatch:
         """Compute score from input images.
 
         Args:
@@ -111,4 +112,4 @@ def forward(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         score = torch.sum(anomaly_map, (1, 2))  # NxHxW --> N
         anomaly_map = torch.unsqueeze(anomaly_map, 1)
         anomaly_map = F.interpolate(anomaly_map, size=batch.shape[-2:], mode="bilinear", align_corners=False)
-        return score, anomaly_map
+        return InferenceBatch(pred_score=score, anomaly_map=anomaly_map)
diff --git a/src/anomalib/models/image/ganomaly/lightning_model.py b/src/anomalib/models/image/ganomaly/lightning_model.py
index 7860cde3ae..495dbe294c 100644
--- a/src/anomalib/models/image/ganomaly/lightning_model.py
+++ b/src/anomalib/models/image/ganomaly/lightning_model.py
@@ -14,6 +14,7 @@
 from torch import optim
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import DiscriminatorLoss, GeneratorLoss
@@ -128,7 +129,7 @@ def configure_optimizers(self) -> list[optim.Optimizer]:
 
     def training_step(
         self,
-        batch: dict[str, str | torch.Tensor],
+        batch: Batch,
         batch_idx: int,
     ) -> STEP_OUTPUT:
         """Perform the training step.
@@ -145,7 +146,7 @@ def training_step(
         d_opt, g_opt = self.optimizers()
 
         # forward pass
-        padded, fake, latent_i, latent_o = self.model(batch["image"])
+        padded, fake, latent_i, latent_o = self.model(batch.image)
         pred_real, _ = self.model.discriminator(padded)
 
         # generator update
@@ -177,11 +178,11 @@ def on_validation_start(self) -> None:
         self._reset_min_max()
         return super().on_validation_start()
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> Batch:
         """Update min and max scores from the current step.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Predicted difference between z and z_hat.
+            batch (Batch): Predicted difference between z and z_hat.
             args: Additional arguments.
             kwargs: Additional keyword arguments.
 
@@ -190,20 +191,20 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # Unused arguments.
 
-        batch["pred_scores"] = self.model(batch["image"])
-        self.max_scores = max(self.max_scores, torch.max(batch["pred_scores"]))
-        self.min_scores = min(self.min_scores, torch.min(batch["pred_scores"]))
-        return batch
+        predictions = self.model(batch.image)
+        self.max_scores = max(self.max_scores, torch.max(predictions.pred_score))
+        self.min_scores = min(self.min_scores, torch.min(predictions.pred_score))
+        return batch.update(**predictions._asdict())
 
     def on_validation_batch_end(
         self,
-        outputs: STEP_OUTPUT,
+        outputs: Batch,
         batch: Any,  # noqa: ANN401
         batch_idx: int,
         dataloader_idx: int = 0,
     ) -> None:
         """Normalize outputs based on min/max values."""
-        outputs["pred_scores"] = self._normalize(outputs["pred_scores"])
+        outputs.pred_score = self._normalize(outputs.pred_score)
         super().on_validation_batch_end(outputs, batch, batch_idx, dataloader_idx=dataloader_idx)
 
     def on_test_start(self) -> None:
@@ -211,24 +212,24 @@ def on_test_start(self) -> None:
         self._reset_min_max()
         return super().on_test_start()
 
-    def test_step(self, batch: dict[str, str | torch.Tensor], batch_idx: int, *args, **kwargs) -> STEP_OUTPUT:
+    def test_step(self, batch: Batch, batch_idx: int, *args, **kwargs) -> Batch:
         """Update min and max scores from the current step."""
         del args, kwargs  # Unused arguments.
 
         super().test_step(batch, batch_idx)
-        self.max_scores = max(self.max_scores, torch.max(batch["pred_scores"]))
-        self.min_scores = min(self.min_scores, torch.min(batch["pred_scores"]))
+        self.max_scores = max(self.max_scores, torch.max(batch.pred_score))
+        self.min_scores = min(self.min_scores, torch.min(batch.pred_score))
         return batch
 
     def on_test_batch_end(
         self,
-        outputs: STEP_OUTPUT,
+        outputs: Batch,
         batch: Any,  # noqa: ANN401
         batch_idx: int,
         dataloader_idx: int = 0,
     ) -> None:
         """Normalize outputs based on min/max values."""
-        outputs["pred_scores"] = self._normalize(outputs["pred_scores"])
+        outputs.pred_score = self._normalize(outputs.pred_score)
         super().on_test_batch_end(outputs, batch, batch_idx, dataloader_idx=dataloader_idx)
 
     def _normalize(self, scores: torch.Tensor) -> torch.Tensor:
diff --git a/src/anomalib/models/image/ganomaly/torch_model.py b/src/anomalib/models/image/ganomaly/torch_model.py
index 4c29602897..3703349997 100644
--- a/src/anomalib/models/image/ganomaly/torch_model.py
+++ b/src/anomalib/models/image/ganomaly/torch_model.py
@@ -15,6 +15,7 @@
 from torch import nn
 
 from anomalib.data.utils.image import pad_nextpow2
+from anomalib.dataclasses import InferenceBatch
 
 
 class Encoder(nn.Module):
@@ -352,7 +353,7 @@ def weights_init(module: nn.Module) -> None:
     def forward(
         self,
         batch: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor] | torch.Tensor:
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor] | InferenceBatch:
         """Get scores for batch.
 
         Args:
@@ -365,4 +366,5 @@ def forward(
         fake, latent_i, latent_o = self.generator(padded_batch)
         if self.training:
             return padded_batch, fake, latent_i, latent_o
-        return torch.mean(torch.pow((latent_i - latent_o), 2), dim=1).view(-1)  # convert nx1x1 to n
+        scores = torch.mean(torch.pow((latent_i - latent_o), 2), dim=1).view(-1)  # convert nx1x1 to n
+        return InferenceBatch(pred_score=scores)
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index c232403852..819eb73cca 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -13,7 +13,9 @@
 from torchvision.transforms.v2 import Compose, Normalize, Resize, Transform
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.post_processing.one_class import OneClassPostProcessor, PostProcessor
 
 from .torch_model import PadimModel
 
@@ -61,7 +63,7 @@ def configure_optimizers() -> None:
         """PADIM doesn't require optimization, therefore returns no optimizers."""
         return
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> None:
+    def training_step(self, batch: Batch, *args, **kwargs) -> None:
         """Perform the training step of PADIM. For each batch, hierarchical features are extracted from the CNN.
 
         Args:
@@ -74,7 +76,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        embedding = self.model(batch["image"])
+        embedding = self.model(batch.image)
         self.embeddings.append(embedding.cpu())
 
     def fit(self) -> None:
@@ -85,7 +87,7 @@ def fit(self) -> None:
         logger.info("Fitting a Gaussian to the embedding collected from the training set.")
         self.stats = self.model.gaussian.fit(embeddings)
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform a validation step of PADIM.
 
         Similar to the training step, hierarchical features are extracted from the CNN for each batch.
@@ -101,8 +103,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        batch["anomaly_maps"] = self.model(batch["image"])
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, int | float]:
@@ -132,3 +134,7 @@ def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform
                 Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
             ],
         )
+
+    def default_post_processor(self) -> PostProcessor:
+        """Return the default post-processor for PADIM."""
+        return OneClassPostProcessor()
diff --git a/src/anomalib/models/image/padim/torch_model.py b/src/anomalib/models/image/padim/torch_model.py
index f45dde1f79..14dc379eee 100644
--- a/src/anomalib/models/image/padim/torch_model.py
+++ b/src/anomalib/models/image/padim/torch_model.py
@@ -10,6 +10,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import MultiVariateGaussian, TimmFeatureExtractor
 from anomalib.models.components.feature_extractors import dryrun_find_featuremap_dims
 
@@ -138,15 +139,14 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
             embeddings = self.tiler.untile(embeddings)
 
         if self.training:
-            output = embeddings
-        else:
-            output = self.anomaly_map_generator(
-                embedding=embeddings,
-                mean=self.gaussian.mean,
-                inv_covariance=self.gaussian.inv_covariance,
-                image_size=output_size,
-            )
-        return output
+            return embeddings
+        anomaly_map = self.anomaly_map_generator(
+            embedding=embeddings,
+            mean=self.gaussian.mean,
+            inv_covariance=self.gaussian.inv_covariance,
+            image_size=output_size,
+        )
+        return InferenceBatch(anomaly_map=anomaly_map)
 
     def generate_embedding(self, features: dict[str, torch.Tensor]) -> torch.Tensor:
         """Generate embedding from hierarchical feature map.
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index 3f471a159c..15126838bf 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -15,7 +15,9 @@
 from torchvision.transforms.v2 import CenterCrop, Compose, Normalize, Resize, Transform
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.post_processing.one_class import OneClassPostProcessor
 
 from .torch_model import PatchcoreModel
 
@@ -66,7 +68,7 @@ def configure_optimizers() -> None:
         """
         return
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> None:
+    def training_step(self, batch: Batch, *args, **kwargs) -> None:
         """Generate feature embedding of the batch.
 
         Args:
@@ -79,7 +81,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        embedding = self.model(batch["image"])
+        embedding = self.model(batch.image)
         self.embeddings.append(embedding)
 
     def fit(self) -> None:
@@ -90,7 +92,7 @@ def fit(self) -> None:
         logger.info("Applying core-set subsampling to get the embedding.")
         self.model.subsample_embedding(embeddings, self.coreset_sampling_ratio)
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Get batch of anomaly maps from input image batch.
 
         Args:
@@ -105,13 +107,9 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         del args, kwargs
 
         # Get anomaly maps and predicted scores from the model.
-        output = self.model(batch["image"])
+        predictions = self.model(batch.image)
 
-        # Add anomaly maps and predicted scores to the batch.
-        batch["anomaly_maps"] = output["anomaly_map"]
-        batch["pred_scores"] = output["pred_score"]
-
-        return batch
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
@@ -141,3 +139,11 @@ def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform
                 Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
             ],
         )
+
+    def default_post_processor(self) -> OneClassPostProcessor:
+        """Return the default post-processor for the model.
+
+        Returns:
+            OneClassPostProcessor: Post-processor for one-class models.
+        """
+        return OneClassPostProcessor()
diff --git a/src/anomalib/models/image/patchcore/torch_model.py b/src/anomalib/models/image/patchcore/torch_model.py
index a2ceb32b91..bde5607aae 100644
--- a/src/anomalib/models/image/patchcore/torch_model.py
+++ b/src/anomalib/models/image/patchcore/torch_model.py
@@ -10,6 +10,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import DynamicBufferMixin, KCenterGreedy, TimmFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerator
@@ -56,7 +57,7 @@ def __init__(
         self.register_buffer("memory_bank", torch.Tensor())
         self.memory_bank: torch.Tensor
 
-    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | dict[str, torch.Tensor]:
+    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
         """Return Embedding during training, or a tuple of anomaly map and anomaly score during testing.
 
         Steps performed:
@@ -87,23 +88,20 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | dict[str, torch.
         embedding = self.reshape_embedding(embedding)
 
         if self.training:
-            output = embedding
-        else:
-            # apply nearest neighbor search
-            patch_scores, locations = self.nearest_neighbors(embedding=embedding, n_neighbors=1)
-            # reshape to batch dimension
-            patch_scores = patch_scores.reshape((batch_size, -1))
-            locations = locations.reshape((batch_size, -1))
-            # compute anomaly score
-            pred_score = self.compute_anomaly_score(patch_scores, locations, embedding)
-            # reshape to w, h
-            patch_scores = patch_scores.reshape((batch_size, 1, width, height))
-            # get anomaly map
-            anomaly_map = self.anomaly_map_generator(patch_scores, output_size)
-
-            output = {"anomaly_map": anomaly_map, "pred_score": pred_score}
-
-        return output
+            return embedding
+        # apply nearest neighbor search
+        patch_scores, locations = self.nearest_neighbors(embedding=embedding, n_neighbors=1)
+        # reshape to batch dimension
+        patch_scores = patch_scores.reshape((batch_size, -1))
+        locations = locations.reshape((batch_size, -1))
+        # compute anomaly score
+        pred_score = self.compute_anomaly_score(patch_scores, locations, embedding)
+        # reshape to w, h
+        patch_scores = patch_scores.reshape((batch_size, 1, width, height))
+        # get anomaly map
+        anomaly_map = self.anomaly_map_generator(patch_scores, output_size)
+
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
     def generate_embedding(self, features: dict[str, torch.Tensor]) -> torch.Tensor:
         """Generate embedding from hierarchical feature map.
diff --git a/src/anomalib/models/image/reverse_distillation/lightning_model.py b/src/anomalib/models/image/reverse_distillation/lightning_model.py
index 5684e52f1e..b68cfb8287 100644
--- a/src/anomalib/models/image/reverse_distillation/lightning_model.py
+++ b/src/anomalib/models/image/reverse_distillation/lightning_model.py
@@ -9,11 +9,11 @@
 from collections.abc import Sequence
 from typing import Any
 
-import torch
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 from torch import optim
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .anomaly_map import AnomalyMapGenerationMode
@@ -77,7 +77,7 @@ def configure_optimizers(self) -> optim.Adam:
             betas=(0.5, 0.99),
         )
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform a training step of Reverse Distillation Model.
 
         Features are extracted from three layers of the Encoder model. These are passed to the bottleneck layer
@@ -85,7 +85,7 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         encoder and decoder features.
 
         Args:
-          batch (batch: dict[str, str | torch.Tensor]): Input batch
+          batch (batch: Batch): Input batch
           args: Additional arguments.
           kwargs: Additional keyword arguments.
 
@@ -94,18 +94,18 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        loss = self.loss(*self.model(batch["image"]))
+        loss = self.loss(*self.model(batch.image))
         self.log("train_loss", loss.item(), on_epoch=True, prog_bar=True, logger=True)
         return {"loss": loss}
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform a validation step of Reverse Distillation Model.
 
         Similar to the training step, encoder/decoder features are extracted from the CNN for each batch, and
         anomaly map is computed.
 
         Args:
-          batch (dict[str, str | torch.Tensor]): Input batch
+          batch (Batch): Input batch
           args: Additional arguments.
           kwargs: Additional keyword arguments.
 
@@ -115,8 +115,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        batch["anomaly_maps"] = self.model(batch["image"])
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/reverse_distillation/torch_model.py b/src/anomalib/models/image/reverse_distillation/torch_model.py
index df43b43c3d..66e0d4415a 100644
--- a/src/anomalib/models/image/reverse_distillation/torch_model.py
+++ b/src/anomalib/models/image/reverse_distillation/torch_model.py
@@ -9,6 +9,7 @@
 import torch
 from torch import nn
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerationMode, AnomalyMapGenerator
@@ -51,7 +52,7 @@ def __init__(
 
         self.anomaly_map_generator = AnomalyMapGenerator(image_size=input_size, mode=anomaly_map_mode)
 
-    def forward(self, images: torch.Tensor) -> torch.Tensor | list[torch.Tensor] | tuple[list[torch.Tensor]]:
+    def forward(self, images: torch.Tensor) -> tuple[list[torch.Tensor], list[torch.Tensor]] | InferenceBatch:
         """Forward-pass images to the network.
 
         During the training mode the model extracts features from encoder and decoder networks.
@@ -61,7 +62,7 @@ def forward(self, images: torch.Tensor) -> torch.Tensor | list[torch.Tensor] | t
             images (torch.Tensor): Batch of images
 
         Returns:
-            torch.Tensor | list[torch.Tensor] | tuple[list[torch.Tensor]]: Encoder and decoder features
+            torch.Tensor | tuple[list[torch.Tensor]] | InferenceBatch: Encoder and decoder features
                 in training mode, else anomaly maps.
         """
         self.encoder.eval()
@@ -79,8 +80,7 @@ def forward(self, images: torch.Tensor) -> torch.Tensor | list[torch.Tensor] | t
                 decoder_features[i] = self.tiler.untile(features)
 
         if self.training:
-            output = encoder_features, decoder_features
-        else:
-            output = self.anomaly_map_generator(encoder_features, decoder_features)
+            return encoder_features, decoder_features
+        anomaly_map = self.anomaly_map_generator(encoder_features, decoder_features)
 
-        return output
+        return InferenceBatch(anomaly_map=anomaly_map)
diff --git a/src/anomalib/models/image/stfpm/lightning_model.py b/src/anomalib/models/image/stfpm/lightning_model.py
index 59cc5df98d..21b8c49952 100644
--- a/src/anomalib/models/image/stfpm/lightning_model.py
+++ b/src/anomalib/models/image/stfpm/lightning_model.py
@@ -14,6 +14,7 @@
 from torch import optim
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import STFPMLoss
@@ -45,13 +46,13 @@ def __init__(
         )
         self.loss = STFPMLoss()
 
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform a training step of STFPM.
 
         For each batch, teacher and student and teacher features are extracted from the CNN.
 
         Args:
-          batch (dict[str, str | torch.Tensor]): Input batch.
+          batch (Batch): Input batch.
           args: Additional arguments.
           kwargs: Additional keyword arguments.
 
@@ -60,19 +61,19 @@ def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -
         """
         del args, kwargs  # These variables are not used.
 
-        teacher_features, student_features = self.model.forward(batch["image"])
+        teacher_features, student_features = self.model.forward(batch.image)
         loss = self.loss(teacher_features, student_features)
         self.log("train_loss", loss.item(), on_epoch=True, prog_bar=True, logger=True)
         return {"loss": loss}
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform a validation Step of STFPM.
 
         Similar to the training step, student/teacher features are extracted from the CNN for each batch, and
         anomaly map is computed.
 
         Args:
-          batch (dict[str, str | torch.Tensor]): Input batch
+          batch (Batch): Input batch
           args: Additional arguments
           kwargs: Additional keyword arguments
 
@@ -82,8 +83,8 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # These variables are not used.
 
-        batch["anomaly_maps"] = self.model(batch["image"])
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/models/image/stfpm/torch_model.py b/src/anomalib/models/image/stfpm/torch_model.py
index 5b80a6ec7a..b501921705 100644
--- a/src/anomalib/models/image/stfpm/torch_model.py
+++ b/src/anomalib/models/image/stfpm/torch_model.py
@@ -9,6 +9,7 @@
 import torch
 from torch import nn
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerator
@@ -49,7 +50,10 @@ def __init__(
 
         self.anomaly_map_generator = AnomalyMapGenerator()
 
-    def forward(self, images: torch.Tensor) -> torch.Tensor | dict[str, torch.Tensor] | tuple[dict[str, torch.Tensor]]:
+    def forward(
+        self,
+        images: torch.Tensor,
+    ) -> tuple[dict[str, torch.Tensor], dict[str, torch.Tensor]] | InferenceBatch:
         """Forward-pass images into the network.
 
         During the training mode the model extracts the features from the teacher and student networks.
@@ -74,12 +78,11 @@ def forward(self, images: torch.Tensor) -> torch.Tensor | dict[str, torch.Tensor
                 student_features[layer] = self.tiler.untile(data)
 
         if self.training:
-            output = teacher_features, student_features
-        else:
-            output = self.anomaly_map_generator(
-                teacher_features=teacher_features,
-                student_features=student_features,
-                image_size=output_size,
-            )
-
-        return output
+            return teacher_features, student_features
+        anomaly_map = self.anomaly_map_generator(
+            teacher_features=teacher_features,
+            student_features=student_features,
+            image_size=output_size,
+        )
+
+        return InferenceBatch(anomaly_map=anomaly_map)
diff --git a/src/anomalib/models/image/uflow/lightning_model.py b/src/anomalib/models/image/uflow/lightning_model.py
index 06ed9b9eeb..d28188181a 100644
--- a/src/anomalib/models/image/uflow/lightning_model.py
+++ b/src/anomalib/models/image/uflow/lightning_model.py
@@ -12,11 +12,11 @@
 import torch
 from lightning.pytorch.core.optimizer import LightningOptimizer
 from lightning.pytorch.utilities.types import STEP_OUTPUT
-from torch import Tensor
 from torch.optim.lr_scheduler import LRScheduler
 from torchvision.transforms.v2 import Compose, Normalize, Resize, Transform
 
 from anomalib import LearningType
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import UFlowLoss
@@ -73,18 +73,17 @@ def _setup(self) -> None:
             permute_soft=self.permute_soft,
         )
 
-    def training_step(self, batch: dict[str, str | Tensor], *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
         """Training step."""
-        z, ljd = self.model(batch["image"])
+        z, ljd = self.model(batch.image)
         loss = self.loss(z, ljd)
         self.log_dict({"loss": loss}, on_step=True, on_epoch=False, prog_bar=False, logger=True)
         return {"loss": loss}
 
-    def validation_step(self, batch: dict[str, str | Tensor], *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
         """Validation step."""
-        anomaly_maps = self.model(batch["image"])
-        batch["anomaly_maps"] = anomaly_maps
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     def configure_optimizers(self) -> tuple[list[LightningOptimizer], list[LRScheduler]]:
         """Return optimizer and scheduler."""
diff --git a/src/anomalib/models/image/uflow/torch_model.py b/src/anomalib/models/image/uflow/torch_model.py
index dfbad59bec..659b21c755 100644
--- a/src/anomalib/models/image/uflow/torch_model.py
+++ b/src/anomalib/models/image/uflow/torch_model.py
@@ -8,6 +8,7 @@
 from FrEIA import modules as fm
 from torch import nn
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components.flow import AllInOneBlock
 
 from .anomaly_map import AnomalyMapGenerator
@@ -171,14 +172,15 @@ def build_flow_stage(self, in_node: ff.Node, flow_steps: int, condition_node: ff
             in_node = nodes[-1]
         return nodes
 
-    def forward(self, image: torch.Tensor) -> torch.Tensor:
+    def forward(self, image: torch.Tensor) -> torch.Tensor | InferenceBatch:
         """Return anomaly map."""
         features = self.feature_extractor(image)
         z, ljd = self.encode(features)
 
         if self.training:
             return z, ljd
-        return self.anomaly_map_generator(z)
+        anomaly_map = self.anomaly_map_generator(z)
+        return InferenceBatch(anomaly_map=anomaly_map)
 
     def encode(self, features: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         """Return"""
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index 6a405969fd..e422f42566 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -17,7 +17,9 @@
 
 from anomalib import LearningType
 from anomalib.data.predict import PredictDataset
+from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import OneClassPostProcessor
 
 from .torch_model import WinClipModel
 
@@ -111,7 +113,7 @@ def collect_reference_images(self, dataloader: DataLoader) -> torch.Tensor:
         """
         ref_images = torch.Tensor()
         for batch in dataloader:
-            images = batch["image"][: self.k_shot - ref_images.shape[0]]
+            images = batch.image[: self.k_shot - ref_images.shape[0]]
             ref_images = torch.cat((ref_images, images))
             if self.k_shot == ref_images.shape[0]:
                 break
@@ -122,11 +124,11 @@ def configure_optimizers() -> None:
         """WinCLIP doesn't require optimization, therefore returns no optimizers."""
         return
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> dict:
+    def validation_step(self, batch: Batch, *args, **kwargs) -> dict:
         """Validation Step of WinCLIP."""
         del args, kwargs  # These variables are not used.
-        batch["pred_scores"], batch["anomaly_maps"] = self.model(batch["image"])
-        return batch
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, int | float]:
@@ -142,13 +144,13 @@ def learning_type(self) -> LearningType:
         """
         return LearningType.FEW_SHOT if self.k_shot else LearningType.ZERO_SHOT
 
-    def state_dict(self) -> OrderedDict[str, Any]:
+    def state_dict(self, **kwargs) -> OrderedDict[str, Any]:
         """Return the state dict of the model.
 
         Before returning the state dict, we remove the parameters of the frozen backbone to reduce the size of the
         checkpoint.
         """
-        state_dict = super().state_dict()
+        state_dict = super().state_dict(**kwargs)
         for pattern in self.EXCLUDE_FROM_STATE_DICT:
             remove_keys = [key for key in state_dict if key.startswith(pattern)]
             for key in remove_keys:
@@ -179,3 +181,7 @@ def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform
                 Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711)),
             ],
         )
+
+    def default_post_processor(self) -> OneClassPostProcessor:
+        """Return the default post-processor for WinCLIP."""
+        return OneClassPostProcessor()
diff --git a/src/anomalib/models/image/winclip/torch_model.py b/src/anomalib/models/image/winclip/torch_model.py
index 5c69853db6..210b3446b0 100644
--- a/src/anomalib/models/image/winclip/torch_model.py
+++ b/src/anomalib/models/image/winclip/torch_model.py
@@ -13,6 +13,7 @@
 from torch.nn.modules.linear import Identity
 from torchvision.transforms import Compose, ToPILImage
 
+from anomalib.dataclasses import InferenceBatch
 from anomalib.models.components import BufferListMixin, DynamicBufferMixin
 
 from .prompting import create_prompt_ensemble
@@ -223,7 +224,7 @@ def _get_window_embeddings(self, feature_map: torch.Tensor, masks: torch.Tensor)
         return pooled.reshape((n_masks, batch_size, -1)).permute(1, 0, 2)
 
     @torch.no_grad
-    def forward(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    def forward(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor] | InferenceBatch:
         """Forward-pass through the model to obtain image and pixel scores.
 
         Args:
@@ -250,7 +251,7 @@ def forward(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
             size=batch.shape[-2:],
             mode="bilinear",
         )
-        return image_scores, pixel_scores.squeeze(1)
+        return InferenceBatch(pred_score=image_scores, anomaly_map=pixel_scores.squeeze(1))
 
     def _compute_zero_shot_scores(
         self,
diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py
index 40f6d50b8b..41127ccd48 100644
--- a/src/anomalib/models/video/ai_vad/lightning_model.py
+++ b/src/anomalib/models/video/ai_vad/lightning_model.py
@@ -7,14 +7,16 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+from dataclasses import replace
 from typing import Any
 
-import torch
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 from torchvision.transforms.v2 import Transform
 
 from anomalib import LearningType
+from anomalib.dataclasses import VideoBatch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.post_processing.one_class import OneClassPostProcessor, PostProcessor
 
 from .torch_model import AiVadModel
 
@@ -102,17 +104,18 @@ def configure_optimizers() -> None:
         """AI-VAD training does not involve fine-tuning of NN weights, no optimizers needed."""
         return
 
-    def training_step(self, batch: dict[str, str | torch.Tensor]) -> None:
+    def training_step(self, batch: VideoBatch) -> None:
         """Training Step of AI-VAD.
 
         Extract features from the batch of clips and update the density estimators.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Batch containing image filename, image, label and mask
+            batch (Batch): Batch containing image filename, image, label and mask
         """
-        features_per_batch = self.model(batch["image"])
+        features_per_batch = self.model(batch.image)
 
-        for features, video_path in zip(features_per_batch, batch["video_path"], strict=True):
+        assert isinstance(batch.video_path, list)
+        for features, video_path in zip(features_per_batch, batch.video_path, strict=True):
             self.model.density_estimator.update(features, video_path)
             self.total_detections += len(next(iter(features.values())))
 
@@ -123,13 +126,13 @@ def fit(self) -> None:
             raise ValueError(msg)
         self.model.density_estimator.fit()
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
+    def validation_step(self, batch: VideoBatch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step of AI-VAD.
 
         Extract boxes and box scores..
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch
+            batch (Batch): Input batch
             *args: Arguments.
             **kwargs: Keyword arguments.
 
@@ -138,12 +141,14 @@ def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs)
         """
         del args, kwargs  # Unused arguments.
 
-        boxes, anomaly_scores, image_scores = self.model(batch["image"])
-        batch["pred_boxes"] = [box.int() for box in boxes]
-        batch["box_scores"] = [score.to(self.device) for score in anomaly_scores]
-        batch["pred_scores"] = torch.Tensor(image_scores).to(self.device)
+        predictions = self.model(batch.image)
 
-        return batch
+        return replace(
+            batch,
+            pred_score=predictions.pred_score,
+            anomaly_map=predictions.anomaly_map,
+            pred_mask=predictions.pred_mask,
+        )
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
@@ -164,3 +169,7 @@ def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform
         """AI-VAD does not need a transform, as the region- and feature-extractors apply their own transforms."""
         del image_size
         return None
+
+    def default_post_processor(self) -> PostProcessor:
+        """Return the default post-processor for AI-VAD."""
+        return OneClassPostProcessor()
diff --git a/src/anomalib/models/video/ai_vad/torch_model.py b/src/anomalib/models/video/ai_vad/torch_model.py
index d8867f9da4..cc1305af90 100644
--- a/src/anomalib/models/video/ai_vad/torch_model.py
+++ b/src/anomalib/models/video/ai_vad/torch_model.py
@@ -9,6 +9,8 @@
 import torch
 from torch import nn
 
+from anomalib.dataclasses import InferenceBatch
+
 from .density import CombinedDensityEstimator
 from .features import FeatureExtractor
 from .flow import FlowExtractor
@@ -105,7 +107,7 @@ def __init__(
             n_neighbors_deep=n_neighbors_deep,
         )
 
-    def forward(self, batch: torch.Tensor) -> tuple[list[torch.Tensor], list[torch.Tensor], list[torch.Tensor]]:
+    def forward(self, batch: torch.Tensor) -> InferenceBatch:
         """Forward pass through AI-VAD model.
 
         Args:
@@ -143,5 +145,14 @@ def forward(self, batch: torch.Tensor) -> tuple[list[torch.Tensor], list[torch.T
             box_scores.append(box)
             image_scores.append(image)
 
-        box_locations = [batch_item["boxes"] for batch_item in regions]
-        return box_locations, box_scores, image_scores
+        anomaly_map = torch.stack(
+            [
+                torch.amax(region["masks"] * scores.view(-1, 1, 1, 1), dim=0)
+                for region, scores in zip(regions, box_scores, strict=False)
+            ],
+        )
+
+        return InferenceBatch(
+            pred_score=torch.stack(image_scores),
+            anomaly_map=anomaly_map,
+        )
diff --git a/src/anomalib/post_processing/__init__.py b/src/anomalib/post_processing/__init__.py
new file mode 100644
index 0000000000..25e3ab2adf
--- /dev/null
+++ b/src/anomalib/post_processing/__init__.py
@@ -0,0 +1,9 @@
+"""Anomalib post-processing module."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .base import PostProcessor
+from .one_class import OneClassPostProcessor
+
+__all__ = ["OneClassPostProcessor", "PostProcessor"]
diff --git a/src/anomalib/post_processing/base.py b/src/anomalib/post_processing/base.py
new file mode 100644
index 0000000000..027925f30d
--- /dev/null
+++ b/src/anomalib/post_processing/base.py
@@ -0,0 +1,22 @@
+"""Base class for post-processor."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+
+from lightning.pytorch import Callback
+from torch import nn
+
+from anomalib.dataclasses import InferenceBatch
+
+
+class PostProcessor(nn.Module, Callback, ABC):
+    """Base class for post-processor.
+
+    The post-processor is a callback that is used to post-process the predictions of the model.
+    """
+
+    @abstractmethod
+    def forward(self, batch: InferenceBatch) -> InferenceBatch:
+        """Functional forward method for post-processing."""
diff --git a/src/anomalib/post_processing/one_class.py b/src/anomalib/post_processing/one_class.py
new file mode 100644
index 0000000000..27d78c0853
--- /dev/null
+++ b/src/anomalib/post_processing/one_class.py
@@ -0,0 +1,196 @@
+"""Post-processing module for anomaly detection models."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import torch
+from lightning import LightningModule, Trainer
+
+from anomalib.dataclasses import Batch, InferenceBatch
+from anomalib.metrics import F1AdaptiveThreshold, MinMax
+
+from .base import PostProcessor
+
+
+class OneClassPostProcessor(PostProcessor):
+    """Default post-processor for one-class anomaly detection."""
+
+    def __init__(
+        self,
+        image_sensitivity: float | None = None,
+        pixel_sensitivity: float | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+
+        self._image_threshold = F1AdaptiveThreshold()
+        self._pixel_threshold = F1AdaptiveThreshold()
+        self._image_normalization_stats = MinMax()
+        self._pixel_normalization_stats = MinMax()
+
+        self.image_sensitivity = image_sensitivity
+        self.pixel_sensitivity = pixel_sensitivity
+
+    def on_validation_batch_end(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+        outputs: Batch,
+        *args,
+        **kwargs,
+    ) -> None:
+        """Update the normalization and thresholding metrics using the batch output."""
+        del trainer, pl_module, args, kwargs  # Unused arguments.
+        if outputs.pred_score is not None:
+            self._image_threshold.update(outputs.pred_score, outputs.gt_label)
+        if outputs.anomaly_map is not None:
+            self._pixel_threshold.update(outputs.anomaly_map, outputs.gt_mask)
+        if outputs.pred_score is not None:
+            self._image_normalization_stats.update(outputs.pred_score)
+        if outputs.anomaly_map is not None:
+            self._pixel_normalization_stats.update(outputs.anomaly_map)
+
+    def on_validation_epoch_end(self, trainer: Trainer, pl_module: LightningModule) -> None:
+        """Compute the final threshold and normalization values."""
+        del trainer, pl_module
+        if self._image_threshold.update_called:
+            self._image_threshold.compute()
+        if self._pixel_threshold.update_called:
+            self._pixel_threshold.compute()
+        if self._image_normalization_stats.update_called:
+            self._image_normalization_stats.compute()
+        if self._pixel_normalization_stats.update_called:
+            self._pixel_normalization_stats.compute()
+
+    def on_test_batch_end(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+        outputs: Batch,
+        *args,
+        **kwargs,
+    ) -> None:
+        """Apply the post-processing steps to the current batch of predictions."""
+        del trainer, pl_module, args, kwargs
+        self.post_process_batch(outputs)
+
+    def on_predict_batch_end(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+        outputs: Batch,
+        *args,
+        **kwargs,
+    ) -> None:
+        """Normalize the predicted scores and anomaly maps."""
+        del trainer, pl_module, args, kwargs
+        self.post_process_batch(outputs)
+
+    def forward(self, predictions: InferenceBatch) -> InferenceBatch:
+        """Funcional forward method for post-processing."""
+        if predictions.pred_score is None and predictions.anomaly_map is None:
+            msg = "At least one of pred_score or anomaly_map must be provided."
+            raise ValueError(msg)
+        pred_score = predictions.pred_score or torch.amax(predictions.anomaly_map, dim=(-2, -1))
+        pred_score = self._normalize(pred_score, self.image_min, self.image_max, self.raw_image_threshold)
+        anomaly_map = self._normalize(predictions.anomaly_map, self.pixel_min, self.pixel_max, self.raw_pixel_threshold)
+        pred_label = self._threshold(pred_score, self.normalized_image_threshold)
+        pred_mask = self._threshold(anomaly_map, self.normalized_pixel_threshold)
+        return InferenceBatch(
+            pred_label=pred_label,
+            pred_score=pred_score,
+            pred_mask=pred_mask,
+            anomaly_map=anomaly_map,
+        )
+
+    def post_process_batch(self, batch: Batch) -> None:
+        """Normalize the predicted scores and anomaly maps."""
+        # apply normalization
+        self.normalize_batch(batch)
+        # apply threshold
+        self.threshold_batch(batch)
+
+    def threshold_batch(self, batch: Batch) -> None:
+        """Apply thresholding to the batch predictions."""
+        batch.pred_label = (
+            batch.pred_label
+            if batch.pred_label is not None
+            else self._threshold(batch.pred_score, self.normalized_image_threshold)
+        )
+        batch.pred_mask = (
+            batch.pred_mask
+            if batch.pred_mask is not None
+            else self._threshold(batch.anomaly_map, self.normalized_pixel_threshold)
+        )
+
+    def normalize_batch(self, batch: Batch) -> None:
+        """Normalize the predicted scores and anomaly maps."""
+        # normalize pixel-level predictions
+        batch.anomaly_map = self._normalize(batch.anomaly_map, self.pixel_min, self.pixel_max, self.raw_pixel_threshold)
+        # normalize image-level predictions
+        batch.pred_score = self._normalize(batch.pred_score, self.image_min, self.image_max, self.raw_image_threshold)
+
+    @staticmethod
+    def _threshold(preds: torch.Tensor | None, threshold: float) -> torch.Tensor | None:
+        """Apply thresholding to a single tensor."""
+        if preds is None:
+            return None
+        return preds > threshold
+
+    @staticmethod
+    def _normalize(
+        preds: torch.Tensor | None,
+        norm_min: float,
+        norm_max: float,
+        threshold: float,
+    ) -> torch.Tensor | None:
+        """Normalize a tensor using the min, max, and threshold values."""
+        if preds is None:
+            return None
+        preds = ((preds - threshold) / (norm_max - norm_min)) + 0.5
+        preds = torch.minimum(preds, torch.tensor(1))
+        return torch.maximum(preds, torch.tensor(0))
+
+    @property
+    def raw_image_threshold(self) -> float:
+        """Get the image-level threshold."""
+        return self._image_threshold.value
+
+    @property
+    def raw_pixel_threshold(self) -> float:
+        """Get the pixel-level threshold."""
+        return self._pixel_threshold.value
+
+    @property
+    def normalized_image_threshold(self) -> float:
+        """Get the image-level threshold."""
+        if self.image_sensitivity is not None:
+            return 1 - self.image_sensitivity
+        return 0.5
+
+    @property
+    def normalized_pixel_threshold(self) -> float:
+        """Get the pixel-level threshold."""
+        if self.pixel_sensitivity is not None:
+            return 1 - self.pixel_sensitivity
+        return 0.5
+
+    @property
+    def image_min(self) -> float:
+        """Get the minimum value for normalization."""
+        return self._image_normalization_stats.min
+
+    @property
+    def image_max(self) -> float:
+        """Get the maximum value for normalization."""
+        return self._image_normalization_stats.max
+
+    @property
+    def pixel_min(self) -> float:
+        """Get the minimum value for normalization."""
+        return self._pixel_normalization_stats.min
+
+    @property
+    def pixel_max(self) -> float:
+        """Get the maximum value for normalization."""
+        return self._pixel_normalization_stats.max
diff --git a/src/anomalib/utils/post_processing.py b/src/anomalib/utils/post_processing.py
index 27c5f95073..ff6a7d33eb 100644
--- a/src/anomalib/utils/post_processing.py
+++ b/src/anomalib/utils/post_processing.py
@@ -117,6 +117,8 @@ def superimpose_anomaly_map(
         np.ndarray: Image with anomaly map superimposed on top of it.
     """
     anomaly_map = anomaly_map_to_color_map(anomaly_map.squeeze(), normalize=normalize)
+    height, width = anomaly_map.shape[:2]
+    image = cv2.resize(image, (width, height))
     return cv2.addWeighted(anomaly_map, alpha, image, (1 - alpha), gamma)
 
 
diff --git a/src/anomalib/utils/visualization/image.py b/src/anomalib/utils/visualization/image.py
index d2e1cb0d6e..f66f95a4b3 100644
--- a/src/anomalib/utils/visualization/image.py
+++ b/src/anomalib/utils/visualization/image.py
@@ -2,8 +2,8 @@
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
-
 from collections.abc import Iterator
+from dataclasses import InitVar, asdict, dataclass, fields
 from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -16,7 +16,12 @@
 
 from anomalib import TaskType
 from anomalib.data.utils import read_image
-from anomalib.utils.post_processing import add_anomalous_label, add_normal_label, draw_boxes, superimpose_anomaly_map
+from anomalib.dataclasses import ImageItem, NumpyImageItem, VideoItem
+from anomalib.utils.post_processing import (
+    add_anomalous_label,
+    add_normal_label,
+    superimpose_anomaly_map,
+)
 
 from .base import BaseVisualizer, GeneratorResult, VisualizationStep
 
@@ -31,71 +36,68 @@ class VisualizationMode(str, Enum):
     SIMPLE = "simple"
 
 
+@dataclass
 class ImageResult:
     """Collection of data needed to visualize the predictions for an image."""
 
-    def __init__(
-        self,
-        image: np.ndarray,
-        pred_score: float,
-        pred_label: str,
-        anomaly_map: np.ndarray | None = None,
-        gt_mask: np.ndarray | None = None,
-        pred_mask: np.ndarray | None = None,
-        gt_boxes: np.ndarray | None = None,
-        pred_boxes: np.ndarray | None = None,
-        box_labels: np.ndarray | None = None,
-        normalize: bool = False,
-    ) -> None:
-        self.anomaly_map = anomaly_map
-        self.box_labels = box_labels
-        self.gt_boxes = gt_boxes
-        self.gt_mask = gt_mask
-        self.image = image
-        self.pred_score = pred_score
-        self.pred_label = pred_label
-        self.pred_boxes = pred_boxes
-        self.heat_map: np.ndarray | None = None
-        self.segmentations: np.ndarray | None = None
-        self.normal_boxes: np.ndarray | None = None
-        self.anomalous_boxes: np.ndarray | None = None
-
-        if anomaly_map is not None:
+    image: np.ndarray
+    pred_score: float
+    pred_label: str
+    anomaly_map: np.ndarray | None = None
+    gt_mask: np.ndarray | None = None
+    pred_mask: np.ndarray | None = None
+    normalize: InitVar[bool] = False
+
+    def __post_init__(self, normalize: bool) -> None:
+        """Format and compute additional fields."""
+        if self.image.dtype != np.uint8:
+            self.image = (self.image * 255).astype(np.uint8)
+        if self.anomaly_map is not None:
+            height, width = self.anomaly_map.squeeze().shape[:2]
+            self.image = cv2.resize(self.image.squeeze(), (width, height))
+
+        if self.anomaly_map is not None:
             self.heat_map = superimpose_anomaly_map(self.anomaly_map, self.image, normalize=normalize)
+        else:
+            self.heat_map = None
 
         if self.gt_mask is not None and self.gt_mask.max() <= 1.0:
+            if self.gt_mask.dtype == bool:
+                self.gt_mask = self.gt_mask.astype(np.uint8)
             self.gt_mask *= 255
 
-        self.pred_mask = pred_mask
-        if self.pred_mask is not None and self.pred_mask.max() <= 1.0:
-            self.pred_mask *= 255
-            self.segmentations = mark_boundaries(self.image, self.pred_mask, color=(1, 0, 0), mode="thick")
-            if self.segmentations.max() <= 1.0:
-                self.segmentations = (self.segmentations * 255).astype(np.uint8)
-
-        if self.pred_boxes is not None:
-            if self.box_labels is None:
-                msg = "Box labels must be provided when box locations are provided."
-                raise ValueError(msg)
-
-            self.normal_boxes = self.pred_boxes[~self.box_labels.astype(bool)]
-            self.anomalous_boxes = self.pred_boxes[self.box_labels.astype(bool)]
+        if self.pred_mask is not None:
+            self.pred_mask = self.pred_mask.astype(np.uint8).squeeze()
+            if self.pred_mask.max() <= 1.0:
+                self.pred_mask *= 255
+                self.segmentations = mark_boundaries(self.image, self.pred_mask, color=(1, 0, 0), mode="thick")
+                if self.segmentations.max() <= 1.0:
+                    self.segmentations = (self.segmentations * 255).astype(np.uint8)
 
     def __repr__(self) -> str:
         """Return a string representation of the object."""
         repr_str = (
             f"ImageResult(image={self.image}, pred_score={self.pred_score}, pred_label={self.pred_label}, "
             f"anomaly_map={self.anomaly_map}, gt_mask={self.gt_mask}, "
-            f"gt_boxes={self.gt_boxes}, pred_boxes={self.pred_boxes}, box_labels={self.box_labels}"
         )
         repr_str += f", pred_mask={self.pred_mask}" if self.pred_mask is not None else ""
         repr_str += f", heat_map={self.heat_map}" if self.heat_map is not None else ""
         repr_str += f", segmentations={self.segmentations}" if self.segmentations is not None else ""
-        repr_str += f", normal_boxes={self.normal_boxes}" if self.normal_boxes is not None else ""
-        repr_str += f", anomalous_boxes={self.anomalous_boxes}" if self.anomalous_boxes is not None else ""
         repr_str += ")"
         return repr_str
 
+    @classmethod
+    def from_dataset_item(cls: type["ImageResult"], item: ImageItem | NumpyImageItem) -> "ImageResult":
+        """Create an ImageResult object from a DatasetItem object.
+
+        This is a temporary solution until we refactor the visualizer to take a DatasetItem object directly as input.
+        """
+        if isinstance(item, ImageItem):
+            item = item.to_numpy()
+        item_dict = asdict(item)
+        field_names = {field.name for field in fields(cls)} & set(item_dict.keys())
+        return cls(**{key: item_dict[key] for key in field_names})
+
 
 class ImageVisualizer(BaseVisualizer):
     """Image/video generator.
@@ -136,40 +138,26 @@ def _visualize_batch(self, batch: dict) -> Iterator[GeneratorResult]:
         Returns:
             Generator that yields a display-ready visualization for each image.
         """
-        batch_size = batch["image"].shape[0]
-        for i in range(batch_size):
-            if "image_path" in batch:
-                height, width = batch["image"].shape[-2:]
-                image = (read_image(path=batch["image_path"][i]) * 255).astype(np.uint8)
-                image = cv2.resize(image, dsize=(width, height), interpolation=cv2.INTER_AREA)
-            elif "video_path" in batch:
-                height, width = batch["image"].shape[-2:]
-                image = batch["original_image"][i].squeeze().cpu().numpy()
-                image = cv2.resize(image, dsize=(width, height), interpolation=cv2.INTER_AREA)
+        for item in batch:
+            if hasattr(item, "image_path") and item.image_path is not None:
+                image = read_image(path=item.image_path, as_tensor=True)
+                # set filename
+                file_name = Path(item.image_path)
+            elif hasattr(item, "video_path") and item.video_path is not None:
+                image = item.original_image
+                # set filename
+                zero_fill = int(np.log10(item.last_frame.cpu())) + 1
+                suffix = f"{str(item.frames.int().item()).zfill(zero_fill)}.png"
+                file_name = Path(item.video_path) / suffix
             else:
-                msg = "Batch must have either 'image_path' or 'video_path' defined."
-                raise KeyError(msg)
-
-            file_name = None
-            if "image_path" in batch:
-                file_name = Path(batch["image_path"][i])
-            elif "video_path" in batch:
-                zero_fill = int(np.log10(batch["last_frame"][i])) + 1
-                suffix = f"{str(batch['frames'][i].int().item()).zfill(zero_fill)}.png"
-                file_name = Path(batch["video_path"][i]) / suffix
-
-            image_result = ImageResult(
-                image=image,
-                pred_score=batch["pred_scores"][i].cpu().numpy().item() if "pred_scores" in batch else None,
-                pred_label=batch["pred_labels"][i].cpu().numpy().item() if "pred_labels" in batch else None,
-                anomaly_map=batch["anomaly_maps"][i].cpu().numpy() if "anomaly_maps" in batch else None,
-                pred_mask=batch["pred_masks"][i].squeeze().int().cpu().numpy() if "pred_masks" in batch else None,
-                gt_mask=batch["mask"][i].squeeze().int().cpu().numpy() if "mask" in batch else None,
-                gt_boxes=batch["boxes"][i].cpu().numpy() if "boxes" in batch else None,
-                pred_boxes=batch["pred_boxes"][i].cpu().numpy() if "pred_boxes" in batch else None,
-                box_labels=batch["box_labels"][i].cpu().numpy() if "box_labels" in batch else None,
-                normalize=self.normalize,
-            )
+                msg = "Item must have image path or video path defined."
+                raise TypeError(msg)
+
+            item.image = image
+            if isinstance(item, VideoItem):
+                image_result = ImageResult.from_dataset_item(item.to_image())
+            else:
+                image_result = ImageResult.from_dataset_item(item)
             yield GeneratorResult(image=self.visualize_image(image_result), file_name=file_name)
 
     def visualize_image(self, image_result: ImageResult) -> np.ndarray:
@@ -202,20 +190,6 @@ def _visualize_full(self, image_result: ImageResult) -> np.ndarray:
             An image showing the full set of visualizations for the input image.
         """
         image_grid = _ImageGrid()
-        if self.task == TaskType.DETECTION:
-            if image_result.pred_boxes is None:
-                msg = "Image result predicted boxes are None."
-                raise ValueError(msg)
-
-            image_grid.add_image(image_result.image, "Image")
-            if image_result.gt_boxes is not None:
-                gt_image = draw_boxes(np.copy(image_result.image), image_result.gt_boxes, color=(255, 0, 0))
-                image_grid.add_image(image=gt_image, color_map="gray", title="Ground Truth")
-            else:
-                image_grid.add_image(image_result.image, "Image")
-            pred_image = draw_boxes(np.copy(image_result.image), image_result.normal_boxes, color=(0, 255, 0))
-            pred_image = draw_boxes(pred_image, image_result.anomalous_boxes, color=(255, 0, 0))
-            image_grid.add_image(pred_image, "Predictions")
         if self.task == TaskType.SEGMENTATION:
             if image_result.pred_mask is None:
                 msg = "Image result predicted mask is None."
@@ -250,16 +224,6 @@ def _visualize_simple(self, image_result: ImageResult) -> np.ndarray:
         Returns:
             An image showing the simple visualization for the input image.
         """
-        if self.task == TaskType.DETECTION:
-            # return image with bounding boxes augmented
-            image_with_boxes = draw_boxes(
-                image=np.copy(image_result.image),
-                boxes=image_result.anomalous_boxes,
-                color=(0, 0, 255),
-            )
-            if image_result.gt_boxes is not None:
-                image_with_boxes = draw_boxes(image=image_with_boxes, boxes=image_result.gt_boxes, color=(255, 0, 0))
-            return image_with_boxes
         if self.task == TaskType.SEGMENTATION:
             visualization = mark_boundaries(
                 image_result.heat_map,
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index e743cd52f2..0d2acd56b2 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -19,7 +19,7 @@
 
 def models() -> set[str]:
     """Return all available models."""
-    return get_available_models()
+    return [model for model in get_available_models() if model != "rkde"]
 
 
 def export_types() -> list[ExportType]:
@@ -177,12 +177,8 @@ def _get_objects(
                 and engine
         """
         # select task type
-        if model_name in {"rkde", "ai_vad"}:
-            task_type = TaskType.DETECTION
-        elif model_name in {"ganomaly", "dfkde"}:
-            task_type = TaskType.CLASSIFICATION
-        else:
-            task_type = TaskType.SEGMENTATION
+
+        task_type = TaskType.CLASSIFICATION if model_name in ("ganomaly", "dfkde") else TaskType.SEGMENTATION
 
         # set extra model args
         # TODO(ashwinvaidya17): Fix these Edge cases
@@ -214,7 +210,7 @@ def _get_objects(
             default_root_dir=project_path,
             max_epochs=1,
             devices=1,
-            pixel_metrics=["F1Score", "AUROC"],
+            pixel_metrics=["F1Max", "AUROC"],
             task=task_type,
             # TODO(ashwinvaidya17): Fix these Edge cases
             # https://github.com/openvinotoolkit/anomalib/issues/1478
diff --git a/tests/integration/tools/test_gradio_entrypoint.py b/tests/integration/tools/test_gradio_entrypoint.py
index 25b0d7de5f..eb25878554 100644
--- a/tests/integration/tools/test_gradio_entrypoint.py
+++ b/tests/integration/tools/test_gradio_entrypoint.py
@@ -47,7 +47,6 @@ def test_torch_inference(
         # export torch model
         model.to_torch(
             export_root=_ckpt_path.parent.parent.parent,
-            task=TaskType.SEGMENTATION,
         )
 
         arguments = parser().parse_args(
@@ -56,7 +55,7 @@ def test_torch_inference(
                 str(_ckpt_path.parent.parent) + "/torch/model.pt",
             ],
         )
-        assert isinstance(inferencer(arguments.weights, arguments.metadata), TorchInferencer)
+        assert isinstance(inferencer(arguments.weights), TorchInferencer)
 
     @staticmethod
     def test_openvino_inference(
@@ -79,18 +78,6 @@ def test_openvino_inference(
             [
                 "--weights",
                 str(_ckpt_path.parent.parent) + "/openvino/model.bin",
-                "--metadata",
-                str(_ckpt_path.parent.parent) + "/openvino/metadata.json",
-            ],
-        )
-        assert isinstance(inferencer(arguments.weights, arguments.metadata), OpenVINOInferencer)
-
-        # test error is raised when metadata is not provided to openvino model
-        arguments = parser().parse_args(
-            [
-                "--weights",
-                str(_ckpt_path) + "/openvino/model.bin",
             ],
         )
-        with pytest.raises(ValueError):  # noqa: PT011
-            inferencer(arguments.weights, arguments.metadata)
+        assert isinstance(inferencer(arguments.weights), OpenVINOInferencer)
diff --git a/tests/integration/tools/test_openvino_entrypoint.py b/tests/integration/tools/test_openvino_entrypoint.py
index 5883a49957..159c3a1a08 100644
--- a/tests/integration/tools/test_openvino_entrypoint.py
+++ b/tests/integration/tools/test_openvino_entrypoint.py
@@ -52,8 +52,6 @@ def test_openvino_inference(
             [
                 "--weights",
                 str(_ckpt_path.parent.parent) + "/openvino/model.bin",
-                "--metadata",
-                str(_ckpt_path.parent.parent) + "/openvino/metadata.json",
                 "--input",
                 get_dummy_inference_image,
                 "--output",
diff --git a/tests/integration/tools/test_torch_entrypoint.py b/tests/integration/tools/test_torch_entrypoint.py
index 7d81093cec..6f72203f7d 100644
--- a/tests/integration/tools/test_torch_entrypoint.py
+++ b/tests/integration/tools/test_torch_entrypoint.py
@@ -10,7 +10,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.models import Padim
 
 sys.path.append("tools/inference")
@@ -43,7 +42,6 @@ def test_torch_inference(
         model = Padim.load_from_checkpoint(_ckpt_path)
         model.to_torch(
             export_root=_ckpt_path.parent.parent.parent,
-            task=TaskType.SEGMENTATION,
         )
         arguments = get_parser().parse_args(
             [
diff --git a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py b/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
index e8c52f13f5..74aec3293b 100644
--- a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
+++ b/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
@@ -3,21 +3,28 @@
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from collections import OrderedDict
-from itertools import chain
 from pathlib import Path
 
 import lightning.pytorch as pl
 import pytest
-import torch
 from omegaconf import DictConfig, OmegaConf
 from torchvision.transforms.v2 import Resize
 
 from anomalib import LearningType
 from anomalib.callbacks.metrics import _MetricsCallback
+from anomalib.dataclasses import InferenceBatch
 from anomalib.metrics import AnomalibMetricCollection
 from anomalib.metrics.threshold import F1AdaptiveThreshold
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
+
+
+class DummyPostProcessor(PostProcessor):
+    """Dummy post-processor for testing."""
+
+    def forward(self, batch: InferenceBatch) -> InferenceBatch:
+        """Dummy forward method."""
+        return batch
 
 
 class _DummyAnomalyModule(AnomalyModule):
@@ -58,6 +65,9 @@ def trainer_arguments(self) -> dict:
     def configure_transforms(self) -> None:
         return Resize((256, 256))
 
+    def default_post_processor(self) -> PostProcessor:
+        return super().default_post_processor()
+
 
 @pytest.fixture()
 def config_from_yaml(request: "pytest.FixtureRequest") -> DictConfig:
@@ -94,61 +104,3 @@ def test_metric_collection_configuration_callback(config_from_yaml: str, tmpdir:
         dummy_anomaly_module.pixel_metrics,
         AnomalibMetricCollection,
     ), f"{dummy_anomaly_module.pixel_metrics}"
-
-
-@pytest.mark.parametrize(
-    ("ori_config_from_yaml", "saved_config_from_yaml"),
-    [("data/config-good-02.yaml", "data/config-good-02-serialized.yaml")],
-)
-def test_metric_collection_configuration_deserialzation_callback(
-    ori_config_from_yaml: str,
-    saved_config_from_yaml: str,
-    tmpdir: str,
-) -> None:
-    """Test if metrics are properly instantiated during deserialzation."""
-    ori_config_from_yaml_res = OmegaConf.load(Path(__file__).parent / ori_config_from_yaml)
-    saved_config_from_yaml_res = OmegaConf.load(Path(__file__).parent / saved_config_from_yaml)
-    callback = _MetricsCallback(
-        task="segmentation",
-        image_metrics=ori_config_from_yaml_res.metrics.image,
-        pixel_metrics=ori_config_from_yaml_res.metrics.pixel,
-    )
-
-    dummy_anomaly_module = _DummyAnomalyModule()
-    trainer = pl.Trainer(
-        callbacks=[callback],
-        enable_checkpointing=False,
-        default_root_dir=tmpdir,
-    )
-
-    saved_image_state_dict = OrderedDict(
-        {
-            "image_metrics." + k: torch.tensor(1.0)
-            for k, v in saved_config_from_yaml_res.metrics.image.items()
-            if v["class_path"].startswith("anomalib.metrics")
-        },
-    )
-    saved_pixel_state_dict = OrderedDict(
-        {
-            "pixel_metrics." + k: torch.tensor(1.0)
-            for k, v in saved_config_from_yaml_res.metrics.pixel.items()
-            if v["class_path"].startswith("anomalib.metrics")
-        },
-    )
-
-    final_state_dict = OrderedDict(chain(saved_image_state_dict.items(), saved_pixel_state_dict.items()))
-
-    dummy_anomaly_module._load_metrics(final_state_dict)  # noqa: SLF001
-    callback.setup(trainer, dummy_anomaly_module)
-
-    assert isinstance(
-        dummy_anomaly_module.image_metrics,
-        AnomalibMetricCollection,
-    ), f"{dummy_anomaly_module.image_metrics}"
-    assert isinstance(
-        dummy_anomaly_module.pixel_metrics,
-        AnomalibMetricCollection,
-    ), f"{dummy_anomaly_module.pixel_metrics}"
-
-    for metric_name in ("AUROC", "F1Score"):
-        assert metric_name in dummy_anomaly_module.pixel_metrics
diff --git a/tests/unit/data/base/depth.py b/tests/unit/data/base/depth.py
index 3e1a6bde9f..e4b201cb3d 100644
--- a/tests/unit/data/base/depth.py
+++ b/tests/unit/data/base/depth.py
@@ -3,6 +3,8 @@
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+from dataclasses import fields
+
 import pytest
 
 from anomalib.data import AnomalibDataModule
@@ -22,22 +24,20 @@ def test_get_item_returns_correct_keys_and_shapes(subset: str, datamodule: Anoma
         batch = next(iter(dataloader))
 
         # Check that the batch has the correct keys.
-        expected_keys = {"image_path", "depth_path", "label", "image", "depth_image"}
-
-        if dataloader.dataset.task in {"detection", "segmentation"}:
-            expected_keys |= {"mask_path", "mask"}
+        expected_fields = {"image_path", "depth_path", "gt_label", "image", "depth_map"}
 
-            if dataloader.dataset.task == "detection":
-                expected_keys |= {"boxes"}
+        if dataloader.dataset.task == "segmentation":
+            expected_fields |= {"mask_path", "gt_mask"}
 
-        assert batch.keys() == expected_keys
+        batch_fields = {field.name for field in fields(batch) if getattr(batch, field.name) is not None}
+        assert batch_fields == expected_fields
 
         # Check that the batch has the correct shape.
-        assert len(batch["image_path"]) == 4
-        assert len(batch["depth_path"]) == 4
-        assert batch["image"].shape == (4, 3, 256, 256)
-        assert batch["depth_image"].shape == (4, 3, 256, 256)
-        assert batch["label"].shape == (4,)
-
-        if dataloader.dataset.task in {"detection", "segmentation"}:
-            assert batch["mask"].shape == (4, 256, 256)
+        assert len(batch.image_path) == 4
+        assert len(batch.depth_path) == 4
+        assert batch.image.shape == (4, 3, 256, 256)
+        assert batch.depth_map.shape == (4, 3, 256, 256)
+        assert batch.gt_label.shape == (4,)
+
+        if dataloader.dataset.task == "segmentation":
+            assert batch.gt_mask.shape == (4, 256, 256)
diff --git a/tests/unit/data/base/image.py b/tests/unit/data/base/image.py
index d5b1a59f8c..6e00e3de42 100644
--- a/tests/unit/data/base/image.py
+++ b/tests/unit/data/base/image.py
@@ -25,11 +25,11 @@ def test_get_item_returns_correct_keys_and_shapes(subset: str, datamodule: Anoma
         batch = next(iter(dataloader))
 
         # Check that the batch has the correct shape.
-        assert batch["image"].shape == (4, 3, 256, 256)
-        assert batch["label"].shape == (4,)
+        assert batch.image.shape == (4, 3, 256, 256)
+        assert batch.gt_label.shape == (4,)
 
-        if dataloader.dataset.task in {"detection", "segmentation"}:
-            assert batch["mask"].shape == (4, 256, 256)
+        if dataloader.dataset.task in ("detection", "segmentation"):
+            assert batch.gt_mask.shape == (4, 256, 256)
 
     @staticmethod
     def test_non_overlapping_splits(datamodule: AnomalibDataModule) -> None:
diff --git a/tests/unit/data/base/video.py b/tests/unit/data/base/video.py
index ef14fc50db..1f544c6e7c 100644
--- a/tests/unit/data/base/video.py
+++ b/tests/unit/data/base/video.py
@@ -3,6 +3,8 @@
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+from dataclasses import fields
+
 import pytest
 import torch
 
@@ -23,30 +25,26 @@ def test_get_item_returns_correct_keys_and_shapes(datamodule: AnomalibDataModule
         batch = next(iter(dataloader))
 
         # Check that the batch has the correct keys.
-        expected_train_keys = {"image", "video_path", "frames", "last_frame", "original_image"}
-        expected_eval_keys = expected_train_keys | {"label", "mask"}
+        expected_train_fields = {"image", "video_path", "frames", "last_frame", "original_image"}
+        expected_eval_fields = expected_train_fields | {"gt_label", "gt_mask"}
 
-        if subset == "train":
-            expected_keys = expected_train_keys
-        else:
-            expected_keys = (
-                expected_eval_keys | {"boxes"} if dataloader.dataset.task == "detection" else expected_eval_keys
-            )
+        expected_fields = expected_train_fields if subset == "train" else expected_eval_fields
 
-        assert batch.keys() == expected_keys
+        batch_fields = {field.name for field in fields(batch) if getattr(batch, field.name) is not None}
+        assert batch_fields == expected_fields
 
         # Check that the batch has the correct shape.
-        assert batch["image"].shape == (4, 2, 3, 256, 256)
-        assert len(batch["video_path"]) == 4
-        assert len(batch["frames"]) == 4
-        assert len(batch["last_frame"]) == 4
+        assert batch.image.shape == (4, 2, 3, 256, 256)
+        assert len(batch.video_path) == 4
+        assert len(batch.frames) == 4
+        assert len(batch.last_frame) == 4
         # We don't know the shape of the original image, so we only check that it is a list of 4 images.
-        assert batch["original_image"].shape[0] == 4
+        assert batch.original_image.shape[0] == 4
 
-        if subset in {"val", "test"}:
-            assert len(batch["label"]) == 4
-            assert batch["mask"].shape == (4, 256, 256)
-            assert batch["mask"].shape == (4, 256, 256)
+        if subset in ("val", "test"):
+            assert len(batch.gt_label) == 4
+            assert batch.gt_mask.shape == (4, 256, 256)
+            assert batch.gt_mask.shape == (4, 256, 256)
 
     @staticmethod
     @pytest.mark.parametrize("subset", ["train", "val", "test"])
@@ -57,7 +55,7 @@ def test_item_dtype(subset: str, datamodule: AnomalibDataModule) -> None:
 
         # Get the first batch.
         batch = next(iter(dataloader))
-        clip = batch["image"]
+        clip = batch.image
         assert clip.dtype == torch.float32
         assert clip.min() >= 0
         assert clip.max() <= 1
@@ -71,5 +69,5 @@ def test_single_frame_squeezed(datamodule: AnomalibDataModule) -> None:
 
         # Get the first batch.
         batch = next(iter(dataloader))
-        clip = batch["image"]
+        clip = batch.image
         assert clip.shape == (4, 3, 256, 256)
diff --git a/tests/unit/data/conftest.py b/tests/unit/data/conftest.py
index f23fd8c1e1..2d9c548bcc 100644
--- a/tests/unit/data/conftest.py
+++ b/tests/unit/data/conftest.py
@@ -8,7 +8,7 @@
 from anomalib import TaskType
 
 
-@pytest.fixture(params=[TaskType.CLASSIFICATION, TaskType.DETECTION, TaskType.SEGMENTATION])
+@pytest.fixture(params=[TaskType.CLASSIFICATION, TaskType.SEGMENTATION])
 def task_type(request: type[pytest.FixtureRequest]) -> str:
     """Create and return a task type."""
     return request.param
diff --git a/tests/unit/data/test_inference.py b/tests/unit/data/test_inference.py
index 0ac049db18..9c1ab941fb 100644
--- a/tests/unit/data/test_inference.py
+++ b/tests/unit/data/test_inference.py
@@ -9,6 +9,7 @@
 from torchvision.transforms import v2
 
 from anomalib.data import PredictDataset
+from anomalib.dataclasses import ImageItem
 
 
 @pytest.fixture(scope="module")
@@ -31,11 +32,11 @@ def test_inference_dataset(predict_dataset_path: Path) -> None:
 
         # Check the first sample.
         sample = dataset[0]
-        assert isinstance(sample, dict)
-        assert "image" in sample
-        assert "image_path" in sample
-        assert sample["image"].shape == (3, 256, 256)
-        assert Path(sample["image_path"]).suffix == ".png"
+        assert isinstance(sample, ImageItem)
+        assert getattr(sample, "image", None) is not None
+        assert getattr(sample, "image_path", None) is not None
+        assert sample.image.shape == (3, 256, 256)
+        assert Path(sample.image_path).suffix == ".png"
 
     @staticmethod
     def test_transforms_applied(predict_dataset_path: Path) -> None:
@@ -48,4 +49,4 @@ def test_transforms_applied(predict_dataset_path: Path) -> None:
         sample = dataset[0]
 
         # Check that the image is resized to 512x512.
-        assert sample["image"].shape == (3, 512, 512)
+        assert sample.image.shape == (3, 512, 512)
diff --git a/tests/unit/deploy/test_inferencer.py b/tests/unit/deploy/test_inferencer.py
index 99fd02bae3..9565cd58bc 100644
--- a/tests/unit/deploy/test_inferencer.py
+++ b/tests/unit/deploy/test_inferencer.py
@@ -52,7 +52,6 @@ def __call__(self) -> Iterable[np.ndarray] | Iterable[torch.Tensor]:
     "task",
     [
         TaskType.CLASSIFICATION,
-        TaskType.DETECTION,
         TaskType.SEGMENTATION,
     ],
 )
@@ -91,7 +90,6 @@ def test_torch_inference(task: TaskType, ckpt_path: Callable[[str], Path]) -> No
     "task",
     [
         TaskType.CLASSIFICATION,
-        TaskType.DETECTION,
         TaskType.SEGMENTATION,
     ],
 )
@@ -118,7 +116,6 @@ def test_openvino_inference(task: TaskType, ckpt_path: Callable[[str], Path]) ->
     # Test OpenVINO inferencer
     openvino_inferencer = OpenVINOInferencer(
         exported_xml_file_path,
-        exported_xml_file_path.parent / "metadata.json",
     )
     openvino_dataloader = _MockImageLoader([256, 256], total_count=1, as_numpy=True)
     for image in openvino_dataloader():
diff --git a/tests/unit/engine/test_engine.py b/tests/unit/engine/test_engine.py
index 412268cfd5..1c2e157a05 100644
--- a/tests/unit/engine/test_engine.py
+++ b/tests/unit/engine/test_engine.py
@@ -62,25 +62,12 @@ def fxt_full_config_path(tmp_path: Path) -> Path:
             plugins: null
             sync_batchnorm: false
             reload_dataloaders_every_n_epochs: 0
-        normalization:
-            normalization_method: MIN_MAX
         task: SEGMENTATION
         metrics:
             image:
             - F1Score
             - AUROC
             pixel: null
-            threshold:
-                class_path: anomalib.metrics.F1AdaptiveThreshold
-                init_args:
-                    default_value: 0.5
-                    thresholds: null
-                    ignore_index: null
-                    validate_args: true
-                    compute_on_cpu: false
-                    dist_sync_on_step: false
-                    sync_on_compute: true
-                    compute_with_cache: true
         logging:
             log_graph: false
         default_root_dir: results
diff --git a/tests/unit/engine/test_setup_transform.py b/tests/unit/engine/test_setup_transform.py
index f1a7ce9ee7..bae883d742 100644
--- a/tests/unit/engine/test_setup_transform.py
+++ b/tests/unit/engine/test_setup_transform.py
@@ -14,8 +14,10 @@
 
 from anomalib import LearningType, TaskType
 from anomalib.data import AnomalibDataModule, AnomalibDataset
+from anomalib.dataclasses import InferenceBatch
 from anomalib.engine import Engine
 from anomalib.models import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 
 class DummyDataset(AnomalibDataset):
@@ -34,6 +36,14 @@ def __len__(self) -> int:
         return 1
 
 
+class DummyPostProcessor(PostProcessor):
+    """Dummy post-processor for testing the setup_transform method."""
+
+    def forward(self, batch: InferenceBatch) -> InferenceBatch:
+        """Return the batch unmodified."""
+        return batch
+
+
 class DummyModel(AnomalyModule):
     """Dummy model for testing the setup_transform method."""
 
@@ -58,6 +68,10 @@ def learning_type() -> LearningType:
         """Return the learning type."""
         return LearningType.ZERO_SHOT
 
+    def default_post_processor(self) -> PostProcessor:
+        """Return a dummy post-processor."""
+        return DummyPostProcessor()
+
 
 class DummyDataModule(AnomalibDataModule):
     """Dummy datamodule for testing the setup_transform method."""
diff --git a/tests/unit/metrics/test_adaptive_threshold.py b/tests/unit/metrics/test_adaptive_threshold.py
index 1eadab4e4d..1ee530d4ab 100644
--- a/tests/unit/metrics/test_adaptive_threshold.py
+++ b/tests/unit/metrics/test_adaptive_threshold.py
@@ -6,11 +6,7 @@
 import pytest
 import torch
 
-from anomalib.data import MVTec
-from anomalib.engine import Engine
 from anomalib.metrics import F1AdaptiveThreshold
-from anomalib.models import Padim
-from anomalib.utils.normalization import NormalizationMethod
 
 
 @pytest.mark.parametrize(
@@ -27,33 +23,3 @@ def test_adaptive_threshold(labels: torch.Tensor, preds: torch.Tensor, target_th
     threshold_value = adaptive_threshold.compute()
 
     assert threshold_value == target_threshold
-
-
-def test_manual_threshold() -> None:
-    """Test manual threshold.
-
-    Test if the manual threshold gets used in the F1 score computation when
-    adaptive thresholding is disabled and no normalization is used.
-    """
-    image_threshold = 0.12345  # random.random()  # nosec: B311
-    pixel_threshold = 0.189761  # random.random()  # nosec: B311
-    threshold = [
-        {"class_path": "ManualThreshold", "init_args": {"default_value": image_threshold}},
-        {"class_path": "ManualThreshold", "init_args": {"default_value": pixel_threshold}},
-    ]
-
-    model = Padim()
-    datamodule = MVTec()
-
-    engine = Engine(
-        normalization=NormalizationMethod.NONE,
-        threshold=threshold,
-        image_metrics="F1Score",
-        pixel_metrics="F1Score",
-        fast_dev_run=True,
-        accelerator="gpu",
-        devices=1,
-    )
-    engine.fit(model=model, datamodule=datamodule)
-    assert engine.trainer.lightning_module.image_metrics.F1Score.threshold == image_threshold
-    assert engine.trainer.lightning_module.pixel_metrics.F1Score.threshold == pixel_threshold
diff --git a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
index d03dde1fd4..317e1c6a60 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
@@ -10,12 +10,22 @@
 from torch import nn
 
 from anomalib import LearningType
+from anomalib.dataclasses import ImageBatch, InferenceBatch
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 
 class _DummyModel(nn.Module): ...
 
 
+class DummyPostProcessor(PostProcessor):
+    """Dummy post-processor for testing."""
+
+    def forward(self, batch: InferenceBatch) -> InferenceBatch:
+        """Dummy forward method."""
+        return batch
+
+
 class DummyModule(AnomalyModule):
     """A dummy model which calls visualizer callback on fake images and masks.
 
@@ -30,23 +40,23 @@ def __init__(self, dataset_path: Path) -> None:
         self.mode = "full"
         self.dataset_path = dataset_path
 
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> dict:
+    def validation_step(self, batch: ImageBatch, *args, **kwargs) -> ImageBatch:
         """Only used to avoid NotImplementedError."""
         del batch
         return self.test_step(*args, **kwargs)
 
-    def test_step(self, *_, **__) -> dict:
+    def test_step(self, *_, **__) -> ImageBatch:
         """Only used to trigger on_test_epoch_end."""
         self.log(name="loss", value=0.0, prog_bar=True)
-        return {
-            "image_path": [Path(self.dataset_path / "mvtec" / "dummy" / "train" / "good" / "000.png")],
-            "image": torch.rand((1, 3, 100, 100)).to(self.device),
-            "mask": torch.zeros((1, 100, 100)).to(self.device),
-            "anomaly_maps": torch.ones((1, 100, 100)).to(self.device),
-            "label": torch.Tensor([0]).to(self.device),
-            "pred_labels": torch.Tensor([0]).to(self.device),
-            "pred_masks": torch.zeros((1, 100, 100)).to(self.device),
-        }
+        return ImageBatch(
+            image_path=[Path(self.dataset_path / "mvtec" / "dummy" / "train" / "good" / "000.png")],
+            image=torch.rand((1, 3, 100, 100)).to(self.device),
+            gt_mask=torch.zeros((1, 100, 100)).to(self.device),
+            anomaly_map=torch.ones((1, 100, 100)).to(self.device),
+            gt_label=torch.Tensor([0]).int().to(self.device),
+            pred_label=torch.Tensor([0]).int().to(self.device),
+            pred_mask=torch.zeros((1, 100, 100)).to(self.device),
+        )
 
     def configure_optimizers(self) -> None:
         """Optimization is not required."""
@@ -60,3 +70,7 @@ def trainer_arguments(self) -> dict[str, Any]:
     def learning_type(self) -> LearningType:
         """Returns the learning type."""
         return LearningType.ZERO_SHOT
+
+    def default_post_processor(self) -> PostProcessor:
+        """Returns a dummy post-processor."""
+        return DummyPostProcessor()
diff --git a/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py b/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
index 2ae53e90fc..a8d397c2f5 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
@@ -16,7 +16,7 @@
 from .dummy_lightning_model import DummyModule
 
 
-@pytest.mark.parametrize("task", [TaskType.CLASSIFICATION, TaskType.SEGMENTATION, TaskType.DETECTION])
+@pytest.mark.parametrize("task", [TaskType.CLASSIFICATION, TaskType.SEGMENTATION])
 def test_add_images(task: TaskType, dataset_path: Path) -> None:
     """Tests if tensorboard logs are generated."""
     with tempfile.TemporaryDirectory() as dir_loc:
diff --git a/tests/unit/utils/test_visualizer.py b/tests/unit/utils/test_visualizer.py
index 4df882a7f1..e5fb1b97f9 100644
--- a/tests/unit/utils/test_visualizer.py
+++ b/tests/unit/utils/test_visualizer.py
@@ -13,6 +13,7 @@
 
 from anomalib import TaskType
 from anomalib.data import MVTec, PredictDataset
+from anomalib.dataclasses import ImageBatch
 from anomalib.engine import Engine
 from anomalib.models import get_model
 from anomalib.utils.visualization.image import _ImageGrid
@@ -39,7 +40,7 @@ class TestVisualizer:
     """Test visualization callback for test and predict with different task types."""
 
     @staticmethod
-    @pytest.mark.parametrize("task", [TaskType.CLASSIFICATION, TaskType.SEGMENTATION, TaskType.DETECTION])
+    @pytest.mark.parametrize("task", [TaskType.CLASSIFICATION, TaskType.SEGMENTATION])
     def test_model_visualizer_mode(
         ckpt_path: Callable[[str], Path],
         project_path: Path,
@@ -59,5 +60,5 @@ def test_model_visualizer_mode(
         engine.test(model=model, datamodule=datamodule, ckpt_path=str(_ckpt_path))
 
         dataset = PredictDataset(path=dataset_path / "mvtec" / "dummy" / "test")
-        datamodule = DataLoader(dataset)
+        datamodule = DataLoader(dataset, collate_fn=ImageBatch.collate)
         engine.predict(model=model, dataloaders=datamodule, ckpt_path=str(_ckpt_path))
diff --git a/tools/inference/gradio_inference.py b/tools/inference/gradio_inference.py
index 89cf5f14ec..f7278a36fd 100644
--- a/tools/inference/gradio_inference.py
+++ b/tools/inference/gradio_inference.py
@@ -29,13 +29,12 @@ def get_parser() -> ArgumentParser:
     """
     parser = ArgumentParser()
     parser.add_argument("--weights", type=Path, required=True, help="Path to model weights")
-    parser.add_argument("--metadata", type=Path, required=False, help="Path to a JSON file containing the metadata.")
     parser.add_argument("--share", type=bool, required=False, default=False, help="Share Gradio `share_url`")
 
     return parser
 
 
-def get_inferencer(weight_path: Path, metadata: Path | None = None) -> Inferencer:
+def get_inferencer(weight_path: Path) -> Inferencer:
     """Parse args and open inferencer.
 
     Args:
@@ -57,13 +56,10 @@ def get_inferencer(weight_path: Path, metadata: Path | None = None) -> Inference
         torch_inferencer = module.TorchInferencer
         inferencer = torch_inferencer(path=weight_path)
 
-    elif extension in {".onnx", ".bin", ".xml"}:
-        if metadata is None:
-            msg = "When using OpenVINO Inferencer, the following arguments are required: --metadata"
-            raise ValueError(msg)
-
+    elif extension in (".onnx", ".bin", ".xml"):
         openvino_inferencer = module.OpenVINOInferencer
-        inferencer = openvino_inferencer(path=weight_path, metadata=metadata)
+        inferencer = openvino_inferencer(path=weight_path)
+
     else:
         msg = (
             "Model extension is not supported. "
@@ -95,7 +91,7 @@ def infer(image: np.ndarray, inferencer: Inferencer) -> tuple[np.ndarray, np.nda
 
 if __name__ == "__main__":
     args = get_parser().parse_args()
-    gradio_inferencer = get_inferencer(args.weights, args.metadata)
+    gradio_inferencer = get_inferencer(args.weights)
 
     interface = gradio.Interface(
         fn=lambda image: infer(image, gradio_inferencer),
diff --git a/tools/inference/lightning_inference.py b/tools/inference/lightning_inference.py
index 4f5103dd74..400b46ae00 100644
--- a/tools/inference/lightning_inference.py
+++ b/tools/inference/lightning_inference.py
@@ -53,7 +53,7 @@ def infer(args: Namespace) -> None:
 
     # create the dataset
     dataset = PredictDataset(**args.data)
-    dataloader = DataLoader(dataset)
+    dataloader = DataLoader(dataset, collate_fn=dataset.collate_fn)
 
     engine.predict(model=model, dataloaders=[dataloader], ckpt_path=args.ckpt_path)
 
diff --git a/tools/inference/openvino_inference.py b/tools/inference/openvino_inference.py
index c5b61f53ff..dcb8fafd23 100644
--- a/tools/inference/openvino_inference.py
+++ b/tools/inference/openvino_inference.py
@@ -14,7 +14,7 @@
 from anomalib.data.utils import generate_output_image_filename, get_image_filenames, read_image
 from anomalib.data.utils.image import save_image, show_image
 from anomalib.deploy import OpenVINOInferencer
-from anomalib.utils.visualization import ImageVisualizer
+from anomalib.utils.visualization import ImageResult, ImageVisualizer
 
 logger = logging.getLogger(__name__)
 
@@ -27,7 +27,6 @@ def get_parser() -> ArgumentParser:
     """
     parser = ArgumentParser()
     parser.add_argument("--weights", type=Path, required=True, help="Path to model weights")
-    parser.add_argument("--metadata", type=Path, required=True, help="Path to a JSON file containing the metadata.")
     parser.add_argument("--input", type=Path, required=True, help="Path to an image to infer.")
     parser.add_argument("--output", type=Path, required=False, help="Path to save the output image.")
     parser.add_argument(
@@ -73,14 +72,17 @@ def infer(args: Namespace) -> None:
         args (Namespace): The arguments from the command line.
     """
     # Get the inferencer.
-    inferencer = OpenVINOInferencer(path=args.weights, metadata=args.metadata, device=args.device)
+    inferencer = OpenVINOInferencer(path=args.weights, device=args.device)
     visualizer = ImageVisualizer(mode=args.visualization_mode, task=args.task)
 
     filenames = get_image_filenames(path=args.input)
     for filename in filenames:
         image = read_image(filename)
         predictions = inferencer.predict(image=image)
-        output = visualizer.visualize_image(predictions)
+
+        # this is temporary until we update the visualizer to take the dataclass directly.
+        image_result = ImageResult.from_dataset_item(predictions.items[0])
+        output = visualizer.visualize_image(image_result)
 
         if args.output is None and args.show is False:
             msg = "Neither output path is provided nor show flag is set. Inferencer will run but return nothing."
diff --git a/tools/inference/torch_inference.py b/tools/inference/torch_inference.py
index 76cebc4864..7764a0d9bb 100644
--- a/tools/inference/torch_inference.py
+++ b/tools/inference/torch_inference.py
@@ -15,8 +15,8 @@
 
 from anomalib.data.utils import generate_output_image_filename, get_image_filenames, read_image
 from anomalib.data.utils.image import save_image, show_image
-from anomalib.deploy import TorchInferencer
-from anomalib.utils.visualization import ImageVisualizer
+from anomalib.deploy.inferencers.torch_inferencer import TorchInferencer
+from anomalib.utils.visualization import ImageResult, ImageVisualizer
 
 logger = logging.getLogger(__name__)
 
@@ -83,7 +83,9 @@ def infer(args: Namespace) -> None:
     for filename in filenames:
         image = read_image(filename, as_tensor=True)
         predictions = inferencer.predict(image=image)
-        output = visualizer.visualize_image(predictions)
+
+        image_result = ImageResult.from_dataset_item(predictions.items[0])
+        output = visualizer.visualize_image(image_result)
 
         if args.output is None and args.show is False:
             msg = "Neither output path is provided nor show flag is set. Inferencer will run but return nothing."

From 2e6e18a710cbfed19092ec873d79f368dbc307fa Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Mon, 2 Sep 2024 13:47:57 +0100
Subject: [PATCH 02/45] Merge main and resolve conflicts (#2287)

* Reduce rich methods (#2283)

remove rich

Signed-off-by: Ashwin Vaidya 

* Refactor BaseThreshold to Threshold (#2278)

* Refactor BaseThreshold to Threshold

* Add relative import and add tests

Signed-off-by: Samet Akcay 

* Revert threshold.py to base.py

Signed-off-by: Samet Akcay 

* Revert threshold imports

Signed-off-by: Samet Akcay 

* Update tests/unit/metrics/threshold/test_threshold.py

Co-authored-by: Ashwin Vaidya 

---------

Signed-off-by: Samet Akcay 
Co-authored-by: Ashwin Vaidya 

* Enable Ruff Rules: PLW1514 and PLR6201 (#2284)

* pre-commit autoupdate

Signed-off-by: Samet Akcay 

* Enable preview feautures, and disable some of the updated features

* Add missing copyrights

Signed-off-by: Samet Akcay 

* Ignore copyrights in notebooks

* "PLW1514", # Add explicit encoding argument

Signed-off-by: Samet Akcay 

* "PLR6201", # Convert to set

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Ashwin Vaidya 
Signed-off-by: Samet Akcay 
Co-authored-by: Ashwin Vaidya 
Co-authored-by: Ashwin Vaidya 
---
 src/anomalib/deploy/inferencers/openvino_inferencer.py | 5 +----
 src/anomalib/models/components/base/anomaly_module.py  | 4 ++--
 tests/integration/model/test_models.py                 | 2 +-
 tests/unit/data/base/image.py                          | 2 +-
 tests/unit/data/base/video.py                          | 2 +-
 tools/inference/gradio_inference.py                    | 2 +-
 6 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/src/anomalib/deploy/inferencers/openvino_inferencer.py b/src/anomalib/deploy/inferencers/openvino_inferencer.py
index 83bd75513f..201ea78707 100644
--- a/src/anomalib/deploy/inferencers/openvino_inferencer.py
+++ b/src/anomalib/deploy/inferencers/openvino_inferencer.py
@@ -200,7 +200,4 @@ def predict(
         predictions = self.model(image)
         pred_dict = self.post_process(predictions)
 
-        return NumpyImageBatch(
-            image=image,
-            **pred_dict,
-        )
+        return NumpyImageBatch(image=image, **pred_dict)
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py
index c7b6920618..d970f8840c 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomaly_module.py
@@ -20,7 +20,7 @@
 
 from anomalib import LearningType
 from anomalib.dataclasses import Batch, InferenceBatch
-from anomalib.metrics.threshold import BaseThreshold
+from anomalib.metrics.threshold import Threshold
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 
 from .export_mixin import ExportMixin
@@ -157,7 +157,7 @@ def _save_to_state_dict(self, destination: OrderedDict, prefix: str, keep_vars:
 
         return super()._save_to_state_dict(destination, prefix, keep_vars)
 
-    def _get_instance(self, state_dict: OrderedDict[str, Any], dict_key: str) -> BaseThreshold:
+    def _get_instance(self, state_dict: OrderedDict[str, Any], dict_key: str) -> Threshold:
         """Get the threshold class from the ``state_dict``."""
         class_path = state_dict.pop(dict_key)
         module = importlib.import_module(".".join(class_path.split(".")[:-1]))
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index 0d2acd56b2..fc360b0463 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -178,7 +178,7 @@ def _get_objects(
         """
         # select task type
 
-        task_type = TaskType.CLASSIFICATION if model_name in ("ganomaly", "dfkde") else TaskType.SEGMENTATION
+        task_type = TaskType.CLASSIFICATION if model_name in {"ganomaly", "dfkde"} else TaskType.SEGMENTATION
 
         # set extra model args
         # TODO(ashwinvaidya17): Fix these Edge cases
diff --git a/tests/unit/data/base/image.py b/tests/unit/data/base/image.py
index 6e00e3de42..682c611fb3 100644
--- a/tests/unit/data/base/image.py
+++ b/tests/unit/data/base/image.py
@@ -28,7 +28,7 @@ def test_get_item_returns_correct_keys_and_shapes(subset: str, datamodule: Anoma
         assert batch.image.shape == (4, 3, 256, 256)
         assert batch.gt_label.shape == (4,)
 
-        if dataloader.dataset.task in ("detection", "segmentation"):
+        if dataloader.dataset.task in {"detection", "segmentation"}:
             assert batch.gt_mask.shape == (4, 256, 256)
 
     @staticmethod
diff --git a/tests/unit/data/base/video.py b/tests/unit/data/base/video.py
index 1f544c6e7c..83e7b6267e 100644
--- a/tests/unit/data/base/video.py
+++ b/tests/unit/data/base/video.py
@@ -41,7 +41,7 @@ def test_get_item_returns_correct_keys_and_shapes(datamodule: AnomalibDataModule
         # We don't know the shape of the original image, so we only check that it is a list of 4 images.
         assert batch.original_image.shape[0] == 4
 
-        if subset in ("val", "test"):
+        if subset in {"val", "test"}:
             assert len(batch.gt_label) == 4
             assert batch.gt_mask.shape == (4, 256, 256)
             assert batch.gt_mask.shape == (4, 256, 256)
diff --git a/tools/inference/gradio_inference.py b/tools/inference/gradio_inference.py
index f7278a36fd..8650cdcb8d 100644
--- a/tools/inference/gradio_inference.py
+++ b/tools/inference/gradio_inference.py
@@ -56,7 +56,7 @@ def get_inferencer(weight_path: Path) -> Inferencer:
         torch_inferencer = module.TorchInferencer
         inferencer = torch_inferencer(path=weight_path)
 
-    elif extension in (".onnx", ".bin", ".xml"):
+    elif extension in {".onnx", ".bin", ".xml"}:
         openvino_inferencer = module.OpenVINOInferencer
         inferencer = openvino_inferencer(path=weight_path)
 

From ec5a8777ab408d4bf22256829591e34dcd81ce19 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Mon, 2 Sep 2024 16:46:07 +0100
Subject: [PATCH 03/45] Rename Item to DatasetItem (#2289)

---
 src/anomalib/data/base/dataset.py    |  4 ++--
 src/anomalib/dataclasses/__init__.py |  4 ++--
 src/anomalib/dataclasses/numpy.py    |  4 ++--
 src/anomalib/dataclasses/torch.py    | 30 ++++++++++++++--------------
 4 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/anomalib/data/base/dataset.py b/src/anomalib/data/base/dataset.py
index b629555960..d7878f7506 100644
--- a/src/anomalib/data/base/dataset.py
+++ b/src/anomalib/data/base/dataset.py
@@ -18,7 +18,7 @@
 
 from anomalib import TaskType
 from anomalib.data.utils import LabelName, read_image, read_mask
-from anomalib.dataclasses import ImageBatch, ImageItem, Item
+from anomalib.dataclasses import DatasetItem, ImageBatch, ImageItem
 
 _EXPECTED_COLUMNS_CLASSIFICATION = ["image_path", "split"]
 _EXPECTED_COLUMNS_SEGMENTATION = [*_EXPECTED_COLUMNS_CLASSIFICATION, "mask_path"]
@@ -153,7 +153,7 @@ def has_anomalous(self) -> bool:
         """Check if the dataset contains any anomalous samples."""
         return LabelName.ABNORMAL in list(self.samples.label_index)
 
-    def __getitem__(self, index: int) -> Item:
+    def __getitem__(self, index: int) -> DatasetItem:
         """Get dataset item for the index ``index``.
 
         Args:
diff --git a/src/anomalib/dataclasses/__init__.py b/src/anomalib/dataclasses/__init__.py
index 4af6acdc35..2054dea22c 100644
--- a/src/anomalib/dataclasses/__init__.py
+++ b/src/anomalib/dataclasses/__init__.py
@@ -11,18 +11,18 @@
 )
 from .torch import (
     Batch,
+    DatasetItem,
     DepthBatch,
     DepthItem,
     ImageBatch,
     ImageItem,
     InferenceBatch,
-    Item,
     VideoBatch,
     VideoItem,
 )
 
 __all__ = [
-    "Item",
+    "DatasetItem",
     "Batch",
     "InferenceBatch",
     "ImageItem",
diff --git a/src/anomalib/dataclasses/numpy.py b/src/anomalib/dataclasses/numpy.py
index a24015aea4..eb265d92d9 100644
--- a/src/anomalib/dataclasses/numpy.py
+++ b/src/anomalib/dataclasses/numpy.py
@@ -47,10 +47,10 @@ def _validate_anomaly_map(self, anomaly_map: np.ndarray | None) -> np.ndarray |
         if anomaly_map is None:
             return None
         assert isinstance(anomaly_map, np.ndarray), f"Anomaly map must be a numpy array, got {type(anomaly_map)}."
-        assert anomaly_map.ndim in [
+        assert anomaly_map.ndim in {
             2,
             3,
-        ], f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
+        }, f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
         if anomaly_map.ndim == 3:
             assert (
                 anomaly_map.shape[0] == 1
diff --git a/src/anomalib/dataclasses/torch.py b/src/anomalib/dataclasses/torch.py
index 7b9b61b4aa..dab9cac066 100644
--- a/src/anomalib/dataclasses/torch.py
+++ b/src/anomalib/dataclasses/torch.py
@@ -62,7 +62,7 @@ def to_numpy(self) -> NumpyT:
 
 
 @dataclass
-class Item(Generic[ImageT], _GenericItem[torch.Tensor, ImageT, Mask, str]):
+class DatasetItem(Generic[ImageT], _GenericItem[torch.Tensor, ImageT, Mask, str]):
     """Dataclass for torch item."""
 
 
@@ -76,7 +76,7 @@ class Batch(Generic[ImageT], _GenericBatch[torch.Tensor, ImageT, Mask, list[str]
 class ImageItem(
     ToNumpyMixin[NumpyImageItem],
     _ImageInputFields[str],
-    Item[Image],
+    DatasetItem[Image],
 ):
     """Dataclass for torch image output item."""
 
@@ -105,10 +105,10 @@ def _validate_gt_mask(self, gt_mask: torch.Tensor | None) -> Mask | None:
         if gt_mask is None:
             return None
         assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
-        assert gt_mask.ndim in [
+        assert gt_mask.ndim in {
             2,
             3,
-        ], f"Ground truth mask must have shape [H, W] or [1, H, W] got shape {gt_mask.shape}."
+        }, f"Ground truth mask must have shape [H, W] or [1, H, W] got shape {gt_mask.shape}."
         if gt_mask.ndim == 3:
             assert gt_mask.shape[0] == 1, f"Ground truth mask must have 1 channel, got {gt_mask.shape[0]}."
             gt_mask = gt_mask.squeeze(0)
@@ -123,10 +123,10 @@ def _validate_anomaly_map(self, anomaly_map: torch.Tensor | None) -> Mask | None
         if anomaly_map is None:
             return None
         assert isinstance(anomaly_map, torch.Tensor), f"Anomaly map must be a torch.Tensor, got {type(anomaly_map)}."
-        assert anomaly_map.ndim in [
+        assert anomaly_map.ndim in {
             2,
             3,
-        ], f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
+        }, f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
         if anomaly_map.ndim == 3:
             assert (
                 anomaly_map.shape[0] == 1
@@ -151,10 +151,10 @@ def _validate_pred_mask(self, pred_mask: torch.Tensor | None) -> Mask | None:
         if pred_mask is None:
             return None
         assert isinstance(pred_mask, torch.Tensor), f"Predicted mask must be a torch.Tensor, got {type(pred_mask)}."
-        assert pred_mask.ndim in [
+        assert pred_mask.ndim in {
             2,
             3,
-        ], f"Predicted mask must have shape [H, W] or [1, H, W] got shape {pred_mask.shape}."
+        }, f"Predicted mask must have shape [H, W] or [1, H, W] got shape {pred_mask.shape}."
         if pred_mask.ndim == 3:
             assert pred_mask.shape[0] == 1, f"Predicted mask must have 1 channel, got {pred_mask.shape[0]}."
             pred_mask = pred_mask.squeeze(0)
@@ -193,7 +193,7 @@ class ImageBatch(
 
     def _validate_image(self, image: Image) -> Image:
         assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
-        assert image.ndim in [3, 4], f"Image must have shape [C, H, W] or [N, C, H, W], got shape {image.shape}."
+        assert image.ndim in {3, 4}, f"Image must have shape [C, H, W] or [N, C, H, W], got shape {image.shape}."
         if image.ndim == 3:
             image = image.unsqueeze(0)  # add batch dimension
         assert image.shape[1] == 3, f"Image must have 3 channels, got {image.shape[0]}."
@@ -219,11 +219,11 @@ def _validate_gt_mask(self, gt_mask: Mask | None) -> Mask | None:
         if gt_mask is None:
             return None
         assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
-        assert gt_mask.ndim in [
+        assert gt_mask.ndim in {
             2,
             3,
             4,
-        ], f"Ground truth mask must have shape [H, W] or [N, H, W] or [N, 1, H, W] got shape {gt_mask.shape}."
+        }, f"Ground truth mask must have shape [H, W] or [N, H, W] or [N, 1, H, W] got shape {gt_mask.shape}."
         if gt_mask.ndim == 2:
             assert (
                 self.batch_size == 1
@@ -259,11 +259,11 @@ def _validate_anomaly_map(self, anomaly_map: torch.Tensor | np.ndarray | None) -
             except Exception as e:
                 msg = "Failed to convert anomaly_map to a torch.Tensor."
                 raise ValueError(msg) from e
-        assert anomaly_map.ndim in [
+        assert anomaly_map.ndim in {
             2,
             3,
             4,
-        ], f"Anomaly map must have shape [H, W] or [N, H, W] or [N, 1, H, W], got shape {anomaly_map.shape}."
+        }, f"Anomaly map must have shape [H, W] or [N, H, W] or [N, 1, H, W], got shape {anomaly_map.shape}."
         if anomaly_map.ndim == 2:
             assert (
                 self.batch_size == 1
@@ -294,7 +294,7 @@ def _validate_image_path(self, image_path: list[str]) -> list[str] | None:
 class VideoItem(
     ToNumpyMixin[NumpyVideoItem],
     _VideoInputFields[torch.Tensor, Video, Mask, str],
-    Item[Video],
+    DatasetItem[Video],
 ):
     """Dataclass for torch video output item."""
 
@@ -402,7 +402,7 @@ def _validate_last_frame(self, last_frame: torch.Tensor) -> torch.Tensor:
 class DepthItem(
     ToNumpyMixin[NumpyImageItem],
     _DepthInputFields[torch.Tensor, str],
-    Item[Image],
+    DatasetItem[Image],
 ):
     """Dataclass for torch depth output item."""
 

From 1500db643da1c3cc3bc647e9b2724887e6adf32e Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Fri, 6 Sep 2024 09:18:52 +0100
Subject: [PATCH 04/45] =?UTF-8?q?=F0=9F=93=9A=20Add=20docstrings=20to=20da?=
 =?UTF-8?q?taclasses=20(#2292)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Reduce rich methods (#2283)

remove rich

Signed-off-by: Ashwin Vaidya 

* Refactor BaseThreshold to Threshold (#2278)

* Refactor BaseThreshold to Threshold

* Add relative import and add tests

Signed-off-by: Samet Akcay 

* Revert threshold.py to base.py

Signed-off-by: Samet Akcay 

* Revert threshold imports

Signed-off-by: Samet Akcay 

* Update tests/unit/metrics/threshold/test_threshold.py

Co-authored-by: Ashwin Vaidya 

---------

Signed-off-by: Samet Akcay 
Co-authored-by: Ashwin Vaidya 

* Enable Ruff Rules: PLW1514 and PLR6201 (#2284)

* pre-commit autoupdate

Signed-off-by: Samet Akcay 

* Enable preview feautures, and disable some of the updated features

* Add missing copyrights

Signed-off-by: Samet Akcay 

* Ignore copyrights in notebooks

* "PLW1514", # Add explicit encoding argument

Signed-off-by: Samet Akcay 

* "PLR6201", # Convert to set

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 

* Update docstring - FieldDescriptor

* Add docstring to generic.py

Signed-off-by: Samet Akcay 

* Add docstring to numpy.py

Signed-off-by: Samet Akcay 

* Add docstring to torch.py

Signed-off-by: Samet Akcay 

* Update src/anomalib/dataclasses/torch.py

Co-authored-by: Dick Ameln 

* Update src/anomalib/dataclasses/torch.py

Co-authored-by: Dick Ameln 

* Update src/anomalib/dataclasses/generic.py

Co-authored-by: Dick Ameln 

* Update src/anomalib/dataclasses/torch.py

Co-authored-by: Dick Ameln 

* Update src/anomalib/dataclasses/torch.py

Co-authored-by: Dick Ameln 

* Update src/anomalib/dataclasses/torch.py

Co-authored-by: Dick Ameln 

* Update src/anomalib/dataclasses/torch.py

Co-authored-by: Dick Ameln 

* Update src/anomalib/dataclasses/torch.py

Co-authored-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 
Signed-off-by: Samet Akcay 
Co-authored-by: Ashwin Vaidya 
Co-authored-by: Ashwin Vaidya 
Co-authored-by: Dick Ameln 
---
 src/anomalib/dataclasses/__init__.py |  33 ++-
 src/anomalib/dataclasses/generic.py  | 382 +++++++++++++++++++++++++--
 src/anomalib/dataclasses/numpy.py    | 122 ++++++---
 src/anomalib/dataclasses/torch.py    | 229 +++++++++++++++-
 4 files changed, 691 insertions(+), 75 deletions(-)

diff --git a/src/anomalib/dataclasses/__init__.py b/src/anomalib/dataclasses/__init__.py
index 2054dea22c..e6d3112a92 100644
--- a/src/anomalib/dataclasses/__init__.py
+++ b/src/anomalib/dataclasses/__init__.py
@@ -1,4 +1,35 @@
-"""Anomalib dataclasses."""
+"""Anomalib dataclasses.
+
+This module provides a collection of dataclasses used throughout the Anomalib library
+for representing and managing various types of data related to anomaly detection tasks.
+
+The dataclasses are organized into two main categories:
+1. Numpy-based dataclasses for handling numpy array data.
+2. Torch-based dataclasses for handling PyTorch tensor data.
+
+Key components:
+
+Numpy Dataclasses:
+    ``NumpyImageItem``: Represents a single image item as numpy arrays.
+    ``NumpyImageBatch``: Represents a batch of image data as numpy arrays.
+    ``NumpyVideoItem``: Represents a single video item as numpy arrays.
+    ``NumpyVideoBatch``: Represents a batch of video data as numpy arrays.
+
+Torch Dataclasses:
+    ``Batch``: Base class for torch-based batch data.
+    ``DatasetItem``: Base class for torch-based dataset items.
+    ``DepthItem``: Represents a single depth data item.
+    ``DepthBatch``: Represents a batch of depth data.
+    ``ImageItem``: Represents a single image item as torch tensors.
+    ``ImageBatch``: Represents a batch of image data as torch tensors.
+    ``VideoItem``: Represents a single video item as torch tensors.
+    ``VideoBatch``: Represents a batch of video data as torch tensors.
+    ``InferenceBatch``: Specialized batch class for inference results.
+
+These dataclasses provide a structured way to handle various types of data
+in anomaly detection tasks, ensuring type consistency and easy data manipulation
+across different components of the Anomalib library.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/dataclasses/generic.py b/src/anomalib/dataclasses/generic.py
index cf5258dc01..7d6ea72777 100644
--- a/src/anomalib/dataclasses/generic.py
+++ b/src/anomalib/dataclasses/generic.py
@@ -1,4 +1,10 @@
-"""Generic dataclasses that can be implemented for different data types."""
+"""Generic dataclasses that can be implemented for different data types.
+
+This module provides a set of generic dataclasses and mixins that can be used
+to define and validate various types of data fields used in Anomalib.
+The dataclasses are designed to be flexible and extensible, allowing for easy
+customization and validation of input and output data.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -24,13 +30,19 @@
 Value = TypeVar("Value")
 
 
-class FieldDescriptor(
-    Generic[Value],
-):
+class FieldDescriptor(Generic[Value]):
     """Descriptor for Anomalib's dataclass fields.
 
-    Using a descriptor ensures that the values of dataclass fields can be validated before being set.
-    This allows validation of the input data not only when it is first set, but also when it is updated.
+    Using a descriptor ensures that the values of dataclass fields can be
+    validated before being set. This allows validation of the input data not
+    only when it is first set, but also when it is updated.
+
+    Attributes:
+        validator_name (str | None): The name of the validator method to be
+            called when setting the value.
+            Defaults to ``None``.
+        default (Value | None): The default value for the field.
+            Defaults to ``None``.
     """
 
     def __init__(self, validator_name: str | None = None, default: Value | None = None) -> None:
@@ -56,7 +68,7 @@ def __get__(self, instance: Instance | None, owner: type[Instance]) -> Value | N
             raise AttributeError(msg)
         return instance.__dict__[self.name]
 
-    def __set__(self, instance: Instance, value: Value) -> None:
+    def __set__(self, instance: object, value: Value) -> None:
         """Set the value of the descriptor.
 
         First calls the validator method if available, then sets the value of the attribute.
@@ -82,7 +94,39 @@ def is_optional(self, owner: type[Instance]) -> bool:
 
 @dataclass
 class _InputFields(Generic[T, ImageT, MaskT, PathT], ABC):
-    """Generic dataclass that defines the standard input fields."""
+    """Generic dataclass that defines the standard input fields for Anomalib.
+
+    This abstract base class provides a structure for input data used in Anomalib,
+    a library for anomaly detection in images and videos. It defines common fields
+    used across various anomaly detection tasks and data types in Anomalib.
+
+    Subclasses must implement the abstract validation methods to define the
+    specific validation logic for each field based on the requirements of different
+    Anomalib models and data processing pipelines.
+
+    Examples:
+        Assuming a concrete implementation `DummyInput`:
+
+        >>> class DummyInput(_InputFields[int, Image, Mask, str]):
+        ...     # Implement actual validation
+
+        >>> # Create an input instance
+        >>> input_item = DummyInput(
+        ...     image=torch.rand(3, 224, 224),
+        ...     gt_label=1,
+        ...     gt_mask=torch.rand(224, 224) > 0.5,
+        ...     mask_path="path/to/mask.png"
+        ... )
+
+        >>> # Access fields
+        >>> image = input_item.image
+        >>> label = input_item.gt_label
+
+    Note:
+        This is an abstract base class and is not intended to be instantiated
+        directly. Concrete subclasses should implement all required validation
+        methods.
+    """
 
     image: FieldDescriptor[ImageT] = FieldDescriptor(validator_name="_validate_image")
     gt_label: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_gt_label")
@@ -111,11 +155,40 @@ def _validate_gt_label(self, gt_label: T) -> T | None:
 
 
 @dataclass
-class _ImageInputFields(
-    Generic[PathT],
-    ABC,
-):
-    """Generic dataclass that defines the image input fields."""
+class _ImageInputFields(Generic[PathT], ABC):
+    """Generic dataclass for image-specific input fields in Anomalib.
+
+    This class extends standard input fields with an ``image_path`` attribute for
+    image-based anomaly detection tasks. It allows Anomalib to work efficiently
+    with disk-stored image datasets, facilitating custom data loading strategies.
+
+    The ``image_path`` field uses a ``FieldDescriptor`` with a validation method.
+    Subclasses must implement ``_validate_image_path`` to ensure path validity
+    according to specific Anomalib model or dataset requirements.
+
+    This class is designed to complement ``_InputFields`` for comprehensive
+    image-based anomaly detection input in Anomalib.
+
+    Examples:
+        Assuming a concrete implementation ``DummyImageInput``:
+        >>> class DummyImageInput(_ImageInputFields):
+        ...     def _validate_image_path(self, image_path):
+        ...         return image_path  # Implement actual validation
+        ...     # Implement other required methods
+
+        >>> # Create an image input instance
+        >>> image_input = DummyImageInput(
+        ...     image_path="path/to/image.jpg"
+        ... )
+
+        >>> # Access image-specific field
+        >>> path = image_input.image_path
+
+    Note:
+        This is an abstract base class and is not intended to be instantiated
+        directly. Concrete subclasses should implement all required validation
+        methods.
+    """
 
     image_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_image_path")
 
@@ -126,11 +199,49 @@ def _validate_image_path(self, image_path: PathT) -> PathT | None:
 
 
 @dataclass
-class _VideoInputFields(
-    Generic[T, ImageT, MaskT, PathT],
-    ABC,
-):
-    """Generic dataclass that defines the video input fields."""
+class _VideoInputFields(Generic[T, ImageT, MaskT, PathT], ABC):
+    """Generic dataclass that defines the video input fields for Anomalib.
+
+    This class extends standard input fields with attributes specific to video-based
+    anomaly detection tasks. It includes fields for original images, video paths,
+    target frames, frame sequences, and last frames.
+
+    Each field uses a ``FieldDescriptor`` with a corresponding validation method.
+    Subclasses must implement these abstract validation methods to ensure data
+    consistency with Anomalib's video processing requirements.
+
+    This class is designed to work alongside other input field classes to provide
+    comprehensive support for video-based anomaly detection in Anomalib.
+
+    Examples:
+        Assuming a concrete implementation ``DummyVideoInput``:
+
+        >>> class DummyVideoInput(_VideoInputFields):
+        ...     def _validate_original_image(self, original_image):
+        ...         return original_image  # Implement actual validation
+        ...     # Implement other required methods
+
+        >>> # Create a video input instance
+        >>> video_input = DummyVideoInput(
+        ...     original_image=torch.rand(3, 224, 224),
+        ...     video_path="path/to/video.mp4",
+        ...     target_frame=10,
+        ...     frames=torch.rand(3, 224, 224),
+        ...     last_frame=torch.rand(3, 224, 224)
+        ... )
+
+        >>> # Access video-specific fields
+        >>> original_image = video_input.original_image
+        >>> path = video_input.video_path
+        >>> target_frame = video_input.target_frame
+        >>> frames = video_input.frames
+        >>> last_frame = video_input.last_frame
+
+    Note:
+        This is an abstract base class and is not intended to be instantiated
+        directly. Concrete subclasses should implement all required validation
+        methods.
+    """
 
     original_image: FieldDescriptor[ImageT | None] = FieldDescriptor(validator_name="_validate_original_image")
     video_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_video_path")
@@ -165,12 +276,45 @@ def _validate_last_frame(self, last_frame: T) -> T | None:
 
 
 @dataclass
-class _DepthInputFields(
-    Generic[T, PathT],
-    _ImageInputFields[PathT],
-    ABC,
-):
-    """Generic dataclass that defines the depth input fields."""
+class _DepthInputFields(Generic[T, PathT], _ImageInputFields[PathT], ABC):
+    """Generic dataclass that defines the depth input fields for Anomalib.
+
+    This class extends the standard input fields with a ``depth_map`` and
+    ``depth_path`` attribute for depth-based anomaly detection tasks. It allows
+    Anomalib to work efficiently with depth-based anomaly detection tasks,
+    facilitating custom data loading strategies.
+
+    The ``depth_map`` and ``depth_path`` fields use a ``FieldDescriptor`` with
+    corresponding validation methods. Subclasses must implement these abstract
+    validation methods to ensure data consistency with Anomalib's depth processing
+    requirements.
+
+    Examples:
+        Assuming a concrete implementation ``DummyDepthInput``:
+
+        >>> class DummyDepthInput(_DepthInputFields):
+        ...     def _validate_depth_map(self, depth_map):
+        ...         return depth_map  # Implement actual validation
+        ...     def _validate_depth_path(self, depth_path):
+        ...         return depth_path  # Implement actual validation
+        ...     # Implement other required methods
+
+        >>> # Create a depth input instance
+        >>> depth_input = DummyDepthInput(
+        ...     image_path="path/to/image.jpg",
+        ...     depth_map=torch.rand(224, 224),
+        ...     depth_path="path/to/depth.png"
+        ... )
+
+        >>> # Access depth-specific fields
+        >>> depth_map = depth_input.depth_map
+        >>> depth_path = depth_input.depth_path
+
+    Note:
+        This is an abstract base class and is not intended to be instantiated
+        directly. Concrete subclasses should implement all required validation
+        methods.
+    """
 
     depth_map: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_depth_map")
     depth_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_depth_path")
@@ -188,7 +332,47 @@ def _validate_depth_path(self, depth_path: PathT) -> PathT | None:
 
 @dataclass
 class _OutputFields(Generic[T, MaskT], ABC):
-    """Generic dataclass that defines the standard output fields."""
+    """Generic dataclass that defines the standard output fields for Anomalib.
+
+    This class defines the standard output fields used in Anomalib, including
+    anomaly maps, predicted scores, predicted masks, and predicted labels.
+
+    Each field uses a ``FieldDescriptor`` with a corresponding validation method.
+    Subclasses must implement these abstract validation methods to ensure data
+    consistency with Anomalib's anomaly detection tasks.
+
+    Examples:
+        Assuming a concrete implementation ``DummyOutput``:
+
+        >>> class DummyOutput(_OutputFields):
+        ...     def _validate_anomaly_map(self, anomaly_map):
+        ...         return anomaly_map  # Implement actual validation
+        ...     def _validate_pred_score(self, pred_score):
+        ...         return pred_score  # Implement actual validation
+        ...     def _validate_pred_mask(self, pred_mask):
+        ...         return pred_mask  # Implement actual validation
+        ...     def _validate_pred_label(self, pred_label):
+        ...         return pred_label  # Implement actual validation
+
+        >>> # Create an output instance with predictions
+        >>> output = DummyOutput(
+        ...     anomaly_map=torch.rand(224, 224),
+        ...     pred_score=0.7,
+        ...     pred_mask=torch.rand(224, 224) > 0.5,
+        ...     pred_label=1
+        ... )
+
+        >>> # Access individual fields
+        >>> anomaly_map = output.anomaly_map
+        >>> score = output.pred_score
+        >>> mask = output.pred_mask
+        >>> label = output.pred_label
+
+    Note:
+        This is an abstract base class and is not intended to be instantiated
+        directly. Concrete subclasses should implement all required validation
+        methods.
+    """
 
     anomaly_map: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="_validate_anomaly_map")
     pred_score: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_pred_score")
@@ -218,7 +402,34 @@ def _validate_pred_label(self, pred_label: T) -> T | None:
 
 @dataclass
 class UpdateMixin:
-    """Mixin class for dataclasses that allows for in-place replacement of attributes."""
+    """Mixin class for dataclasses that allows for in-place replacement of attributes.
+
+    This mixin class provides a method for updating dataclass instances in place or
+    by creating a new instance. It ensures that the updated instance is reinitialized
+    by calling the ``__post_init__`` method if it exists.
+
+    Examples:
+        Assuming a dataclass `DummyItem` that uses UpdateMixin:
+
+        >>> item = DummyItem(image=torch.rand(3, 224, 224), label=0)
+
+        >>> # In-place update
+        >>> item.update(label=1, pred_score=0.9)
+        >>> print(item.label, item.pred_score)
+        1 0.9
+
+        >>> # Create a new instance with updates
+        >>> new_item = item.update(in_place=False, image=torch.rand(3, 224, 224))
+        >>> print(id(item) != id(new_item))
+        True
+
+        >>> # Update with multiple fields
+        >>> item.update(label=2, pred_score=0.8, anomaly_map=torch.rand(224, 224))
+
+    The `update` method can be used to modify single or multiple fields, either
+    in-place or by creating a new instance. This flexibility is particularly useful
+    in data processing pipelines and when working with model predictions in Anomalib.
+    """
 
     def update(self, in_place: bool = True, **changes) -> Any:  # noqa: ANN401
         """Replace fields in place and call __post_init__ to reinitialize the instance.
@@ -247,7 +458,46 @@ class _GenericItem(
     _OutputFields[T, MaskT],
     _InputFields[T, ImageT, MaskT, PathT],
 ):
-    """Generic dataclass for a dataset item."""
+    """Generic dataclass for a single item in Anomalib datasets.
+
+    This class combines input and output fields for anomaly detection tasks,
+    providing a comprehensive representation of a single data item. It inherits
+    from ``_InputFields`` for standard input data and ``_OutputFields`` for
+    prediction results.
+
+    The class also includes the ``UpdateMixin``, allowing for easy updates of
+    field values. This is particularly useful during data processing pipelines
+    and when working with model predictions.
+
+    By using generic types, this class can accommodate various data types used
+    in different Anomalib models and datasets, ensuring flexibility and
+    reusability across the library.
+
+    Examples:
+        Assuming a concrete implementation ``DummyItem``:
+
+        >>> class DummyItem(_GenericItem):
+        ...     def _validate_image(self, image):
+        ...         return image  # Implement actual validation
+        ...     # Implement other required methods
+
+        >>> # Create a generic item instance
+        >>> item = DummyItem(
+        ...     image=torch.rand(3, 224, 224),
+        ...     gt_label=0,
+        ...     pred_score=0.3,
+        ...     anomaly_map=torch.rand(224, 224)
+        ... )
+
+        >>> # Access and update fields
+        >>> image = item.image
+        >>> item.update(pred_score=0.8, pred_label=1)
+
+    Note:
+        This is an abstract base class and is not intended to be instantiated
+        directly. Concrete subclasses should implement all required validation
+        methods.
+    """
 
 
 @dataclass
@@ -257,7 +507,47 @@ class _GenericBatch(
     _OutputFields[T, MaskT],
     _InputFields[T, ImageT, MaskT, PathT],
 ):
-    """Generic dataclass for a batch."""
+    """Generic dataclass for a batch of items in Anomalib datasets.
+
+    This class represents a batch of data items, combining both input and output
+    fields for anomaly detection tasks. It inherits from ``_InputFields`` for
+    input data and ``_OutputFields`` for prediction results, allowing it to
+    handle both training data and model outputs.
+
+    The class includes the ``UpdateMixin``, enabling easy updates of field values
+    across the entire batch. This is particularly useful for in-place modifications
+    during data processing or when updating predictions.
+
+    Examples:
+        Assuming a concrete implementation ``DummyBatch``:
+
+        >>> class DummyBatch(_GenericBatch):
+        ...     def _validate_image(self, image):
+        ...         return image  # Implement actual validation
+        ...     # Implement other required methods
+
+        >>> # Create a batch with input data
+        >>> batch = DummyBatch(
+        ...     image=torch.rand(32, 3, 224, 224),
+        ...     gt_label=torch.randint(0, 2, (32,))
+        ... )
+
+        >>> # Update the entire batch with new predictions
+        >>> batch.update(
+        ...     pred_score=torch.rand(32),
+        ...     anomaly_map=torch.rand(32, 224, 224)
+        ... )
+
+        >>> # Access individual fields
+        >>> images = batch.image
+        >>> labels = batch.gt_label
+        >>> predictions = batch.pred_score
+
+    Note:
+        This is an abstract base class and is not intended to be instantiated
+        directly. Concrete subclasses should implement all required validation
+        methods.
+    """
 
 
 ItemT = TypeVar("ItemT", bound="_GenericItem")
@@ -265,7 +555,41 @@ class _GenericBatch(
 
 @dataclass
 class BatchIterateMixin(Generic[ItemT]):
-    """Generic dataclass for a batch."""
+    """Mixin class for iterating over batches of items in Anomalib datasets.
+
+    This class provides functionality to iterate over individual items within a
+    batch, convert batches to lists of items, and determine batch sizes. It's
+    designed to work with Anomalib's batch processing pipelines.
+
+    The mixin requires subclasses to define an ``item_class`` attribute, which
+    specifies the class used for individual items in the batch. This ensures
+    type consistency when iterating or converting batches.
+
+    Key features include:
+    - Iteration over batch items
+    - Conversion of batches to lists of individual items
+    - Batch size determination
+    - A class method for collating individual items into a batch
+
+    Examples:
+        Assuming a subclass `DummyBatch` with `DummyItem` as its item_class:
+
+        >>> batch = DummyBatch(images=[...], labels=[...])
+        >>> for item in batch:
+        ...     process_item(item)  # Iterate over items
+
+        >>> item_list = batch.items  # Convert batch to list of items
+        >>> type(item_list[0])
+        
+
+        >>> batch_size = len(batch)  # Get batch size
+
+        >>> items = [DummyItem(...) for _ in range(5)]
+        >>> new_batch = DummyBatch.collate(items)  # Collate items into a batch
+
+    This mixin enhances batch handling capabilities in Anomalib, facilitating
+    efficient data processing and model interactions.
+    """
 
     item_class: ClassVar[Callable]
 
diff --git a/src/anomalib/dataclasses/numpy.py b/src/anomalib/dataclasses/numpy.py
index eb265d92d9..6e1ea1a21a 100644
--- a/src/anomalib/dataclasses/numpy.py
+++ b/src/anomalib/dataclasses/numpy.py
@@ -1,4 +1,18 @@
-"""Dataclasses for numpy data."""
+"""Numpy-based dataclasses for Anomalib.
+
+This module provides numpy-based implementations of the generic dataclasses
+used in Anomalib. These classes are designed to work with numpy arrays for
+efficient data handling and processing in anomaly detection tasks.
+
+The module includes the following main classes:
+
+- NumpyItem: Represents a single item in Anomalib datasets using numpy arrays.
+- NumpyBatch: Represents a batch of items in Anomalib datasets using numpy arrays.
+- NumpyImageItem: Represents a single image item with additional image-specific fields.
+- NumpyImageBatch: Represents a batch of image items with batch operations.
+- NumpyVideoItem: Represents a single video item with video-specific fields.
+- NumpyVideoBatch: Represents a batch of video items with video-specific operations.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,21 +26,49 @@
 
 @dataclass
 class NumpyItem(_GenericItem[np.ndarray, np.ndarray, np.ndarray, str]):
-    """Dataclass for numpy item."""
+    """Dataclass for a single item in Anomalib datasets using numpy arrays.
+
+    This class extends _GenericItem for numpy-based data representation. It includes
+    both input data (e.g., images, labels) and output data (e.g., predictions,
+    anomaly maps) as numpy arrays. It is suitable for numpy-based processing
+    pipelines in Anomalib.
+    """
 
 
 @dataclass
 class NumpyBatch(_GenericBatch[np.ndarray, np.ndarray, np.ndarray, list[str]]):
-    """Dataclass for numpy batch."""
+    """Dataclass for a batch of items in Anomalib datasets using numpy arrays.
+
+    This class extends _GenericBatch for batches of numpy-based data. It represents
+    multiple data points for batch processing in anomaly detection tasks. It includes
+    an additional dimension for batch size in all tensor-like fields.
+    """
 
 
-# torch image outputs
 @dataclass
-class NumpyImageItem(
-    _ImageInputFields[str],
-    NumpyItem,
-):
-    """Dataclass for numpy image output item."""
+class NumpyImageItem(_ImageInputFields[str], NumpyItem):
+    """Dataclass for a single image item in Anomalib datasets using numpy arrays.
+
+    This class combines _ImageInputFields and NumpyItem for image-based anomaly detection.
+    It includes image-specific fields and validation methods to ensure proper formatting
+    for Anomalib's image-based models.
+
+    Examples:
+        >>> item = NumpyImageItem(
+        ...     image=np.random.rand(224, 224, 3),
+        ...     gt_label=np.array(1),
+        ...     gt_mask=np.random.rand(224, 224) > 0.5,
+        ...     anomaly_map=np.random.rand(224, 224),
+        ...     pred_score=np.array(0.7),
+        ...     pred_label=np.array(1),
+        ...     image_path="path/to/image.jpg"
+        ... )
+
+        >>> # Access fields
+        >>> image = item.image
+        >>> label = item.gt_label
+        >>> path = item.image_path
+    """
 
     def _validate_image(self, image: np.ndarray) -> np.ndarray:
         assert image.ndim == 3, f"Expected 3D image, got {image.ndim}D image."
@@ -77,12 +119,33 @@ def _validate_image_path(self, image_path: str) -> str:
 
 
 @dataclass
-class NumpyImageBatch(
-    BatchIterateMixin[NumpyImageItem],
-    _ImageInputFields[list[str]],
-    NumpyBatch,
-):
-    """Dataclass for numpy image output batch."""
+class NumpyImageBatch(BatchIterateMixin[NumpyImageItem], _ImageInputFields[list[str]], NumpyBatch):
+    """Dataclass for a batch of image items in Anomalib datasets using numpy arrays.
+
+    This class combines BatchIterateMixin, _ImageInputFields, and NumpyBatch for batches
+    of image data. It supports batch operations and iteration over individual NumpyImageItems.
+    It ensures proper formatting for Anomalib's image-based models.
+
+    Examples:
+        >>> batch = NumpyImageBatch(
+        ...     image=np.random.rand(32, 224, 224, 3),
+        ...     gt_label=np.random.randint(0, 2, (32,)),
+        ...     gt_mask=np.random.rand(32, 224, 224) > 0.5,
+        ...     anomaly_map=np.random.rand(32, 224, 224),
+        ...     pred_score=np.random.rand(32),
+        ...     pred_label=np.random.randint(0, 2, (32,)),
+        ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)]
+        ... )
+
+        >>> # Access batch fields
+        >>> images = batch.image
+        >>> labels = batch.gt_label
+        >>> paths = batch.image_path
+
+        >>> # Iterate over items in the batch
+        >>> for item in batch:
+        ...     process_item(item)
+    """
 
     item_class = NumpyImageItem
 
@@ -114,13 +177,14 @@ def _validate_image_path(self, image_path: list[str]) -> list[str]:
         return image_path
 
 
-# torch video outputs
 @dataclass
-class NumpyVideoItem(
-    _VideoInputFields[np.ndarray, np.ndarray, np.ndarray, str],
-    NumpyItem,
-):
-    """Dataclass for numpy video output item."""
+class NumpyVideoItem(_VideoInputFields[np.ndarray, np.ndarray, np.ndarray, str], NumpyItem):
+    """Dataclass for a single video item in Anomalib datasets using numpy arrays.
+
+    This class combines _VideoInputFields and NumpyItem for video-based anomaly detection.
+    It includes video-specific fields and validation methods to ensure proper formatting
+    for Anomalib's video-based models.
+    """
 
     def _validate_image(self, image: np.ndarray) -> np.ndarray:
         return image
@@ -141,7 +205,12 @@ class NumpyVideoBatch(
     _VideoInputFields[np.ndarray, np.ndarray, np.ndarray, list[str]],
     NumpyBatch,
 ):
-    """Dataclass for numpy video output batch."""
+    """Dataclass for a batch of video items in Anomalib datasets using numpy arrays.
+
+    This class combines BatchIterateMixin, _VideoInputFields, and NumpyBatch for batches
+    of video data. It supports batch operations and iteration over individual NumpyVideoItems.
+    It ensures proper formatting for Anomalib's video-based models.
+    """
 
     item_class = NumpyVideoItem
 
@@ -159,12 +228,3 @@ def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
 
     def _validate_anomaly_map(self, anomaly_map: np.ndarray) -> np.ndarray:
         return anomaly_map
-
-    def _validate_pred_score(self, pred_score: np.ndarray) -> np.ndarray:
-        return pred_score
-
-    def _validate_pred_mask(self, pred_mask: np.ndarray) -> np.ndarray:
-        return pred_mask
-
-    def _validate_pred_label(self, pred_label: np.ndarray) -> np.ndarray:
-        return pred_label
diff --git a/src/anomalib/dataclasses/torch.py b/src/anomalib/dataclasses/torch.py
index dab9cac066..7bc4e93c0c 100644
--- a/src/anomalib/dataclasses/torch.py
+++ b/src/anomalib/dataclasses/torch.py
@@ -1,4 +1,18 @@
-"""Dataclasses for torch inputs and outputs."""
+"""Torch-based dataclasses for Anomalib.
+
+This module provides PyTorch-based implementations of the generic dataclasses
+used in Anomalib. These classes are designed to work with PyTorch tensors for
+efficient data handling and processing in anomaly detection tasks.
+
+These classes extend the generic dataclasses defined in the Anomalib framework,
+providing concrete implementations that use PyTorch tensors for tensor-like data.
+They include methods for data validation and support operations specific to
+image, video, and depth data in the context of anomaly detection.
+
+Note:
+    When using these classes, ensure that the input data is in the correct
+    format (PyTorch tensors with appropriate shapes) to avoid validation errors.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -36,10 +50,26 @@ class InferenceBatch(NamedTuple):
 
 
 @dataclass
-class ToNumpyMixin(
-    Generic[NumpyT],
-):
-    """Mixin for converting torch-based dataclasses to numpy."""
+class ToNumpyMixin(Generic[NumpyT]):
+    """Mixin for converting torch-based dataclasses to numpy.
+
+    This mixin provides functionality to convert PyTorch tensor data to numpy arrays.
+    It requires the subclass to define a 'numpy_class' attribute specifying the
+    corresponding numpy-based class.
+
+    Examples:
+        >>> from anomalib.dataclasses.numpy import NumpyImageItem
+        >>> @dataclass
+        ... class TorchImageItem(ToNumpyMixin[NumpyImageItem]):
+        ...     numpy_class = NumpyImageItem
+        ...     image: torch.Tensor
+        ...     gt_label: torch.Tensor
+
+        >>> torch_item = TorchImageItem(image=torch.rand(3, 224, 224), gt_label=torch.tensor(1))
+        >>> numpy_item = torch_item.to_numpy()
+        >>> isinstance(numpy_item, NumpyImageItem)
+        True
+    """
 
     numpy_class: ClassVar[Callable]
 
@@ -63,22 +93,83 @@ def to_numpy(self) -> NumpyT:
 
 @dataclass
 class DatasetItem(Generic[ImageT], _GenericItem[torch.Tensor, ImageT, Mask, str]):
-    """Dataclass for torch item."""
+    """Base dataclass for individual items in Anomalib datasets using PyTorch tensors.
+
+    This class extends the generic _GenericItem class to provide a PyTorch-specific
+    implementation for single data items in Anomalib datasets. It is designed to
+    handle various types of data (e.g., images, labels, masks) represented as
+    PyTorch tensors.
+
+    The class uses generic types to allow flexibility in the image representation,
+    which can vary depending on the specific use case (e.g., standard images, video clips).
+
+    Attributes:
+        Inherited from _GenericItem, with PyTorch tensor and Mask types.
+
+    Note:
+        This class is typically subclassed to create more specific item types
+        (e.g., ImageItem, VideoItem) with additional fields and methods.
+    """
 
 
 @dataclass
 class Batch(Generic[ImageT], _GenericBatch[torch.Tensor, ImageT, Mask, list[str]]):
-    """Dataclass for torch batch."""
+    """Base dataclass for batches of items in Anomalib datasets using PyTorch tensors.
+
+    This class extends the generic _GenericBatch class to provide a PyTorch-specific
+    implementation for batches of data in Anomalib datasets. It is designed to
+    handle collections of data items (e.g., multiple images, labels, masks)
+    represented as PyTorch tensors.
+
+    The class uses generic types to allow flexibility in the image representation,
+    which can vary depending on the specific use case (e.g., standard images, video clips).
+
+    Attributes:
+        Inherited from _GenericBatch, with PyTorch tensor and Mask types.
+
+    Note:
+        This class is typically subclassed to create more specific batch types
+        (e.g., ImageBatch, VideoBatch) with additional fields and methods.
+    """
 
 
-# torch image outputs
 @dataclass
 class ImageItem(
     ToNumpyMixin[NumpyImageItem],
     _ImageInputFields[str],
     DatasetItem[Image],
 ):
-    """Dataclass for torch image output item."""
+    """Dataclass for individual image items in Anomalib datasets using PyTorch tensors.
+
+    This class combines the functionality of ToNumpyMixin, _ImageInputFields, and
+    DatasetItem to represent single image data points in Anomalib. It includes
+    image-specific fields and provides methods for data validation and conversion
+    to numpy format.
+
+    The class is designed to work with PyTorch tensors and includes fields for
+    the image data, ground truth labels and masks, anomaly maps, and related metadata.
+
+    Attributes:
+        Inherited from _ImageInputFields and DatasetItem.
+
+    Methods:
+        Inherited from ToNumpyMixin, including to_numpy() for conversion to numpy format.
+
+    Examples:
+        >>> item = ImageItem(
+        ...     image=torch.rand(3, 224, 224),
+        ...     gt_label=torch.tensor(1),
+        ...     gt_mask=torch.rand(224, 224) > 0.5,
+        ...     image_path="path/to/image.jpg"
+        ... )
+
+        >>> print(item.image.shape)
+        torch.Size([3, 224, 224])
+
+        >>> numpy_item = item.to_numpy()
+        >>> print(type(numpy_item))
+        
+    """
 
     numpy_class = NumpyImageItem
 
@@ -186,7 +277,35 @@ class ImageBatch(
     _ImageInputFields[list[str]],
     Batch[Image],
 ):
-    """Dataclass for torch image output batch."""
+    """Dataclass for batches of image items in Anomalib datasets using PyTorch tensors.
+
+    This class combines the functionality of ``ToNumpyMixin``, ``BatchIterateMixin``,
+    ``_ImageInputFields``, and ``Batch`` to represent collections of image data points in Anomalib.
+    It includes image-specific fields and provides methods for batch operations,
+    iteration over individual items, and conversion to numpy format.
+
+    The class is designed to work with PyTorch tensors and includes fields for
+    batches of image data, ground truth labels and masks, anomaly maps, and related metadata.
+
+    Examples:
+        >>> batch = ImageBatch(
+        ...     image=torch.rand(32, 3, 224, 224),
+        ...     gt_label=torch.randint(0, 2, (32,)),
+        ...     gt_mask=torch.rand(32, 224, 224) > 0.5,
+        ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)]
+        ... )
+
+        >>> print(batch.image.shape)
+        torch.Size([32, 3, 224, 224])
+
+        >>> for item in batch:
+        ...     print(item.image.shape)
+        torch.Size([3, 224, 224])
+
+        >>> numpy_batch = batch.to_numpy()
+        >>> print(type(numpy_batch))
+        
+    """
 
     item_class = ImageItem
     numpy_class = NumpyImageBatch
@@ -296,7 +415,27 @@ class VideoItem(
     _VideoInputFields[torch.Tensor, Video, Mask, str],
     DatasetItem[Video],
 ):
-    """Dataclass for torch video output item."""
+    """Dataclass for individual video items in Anomalib datasets using PyTorch tensors.
+
+    This class represents a single video item in Anomalib datasets using PyTorch tensors.
+    It combines the functionality of ToNumpyMixin, _VideoInputFields, and DatasetItem
+    to handle video data, including frames, labels, masks, and metadata.
+
+    Examples:
+        >>> item = VideoItem(
+        ...     image=torch.rand(10, 3, 224, 224),  # 10 frames
+        ...     gt_label=torch.tensor(1),
+        ...     gt_mask=torch.rand(10, 224, 224) > 0.5,
+        ...     video_path="path/to/video.mp4"
+        ... )
+
+        >>> print(item.image.shape)
+        torch.Size([10, 3, 224, 224])
+
+        >>> numpy_item = item.to_numpy()
+        >>> print(type(numpy_item))
+        
+    """
 
     numpy_class = NumpyVideoItem
 
@@ -352,7 +491,31 @@ class VideoBatch(
     _VideoInputFields[torch.Tensor, Video, Mask, list[str]],
     Batch[Video],
 ):
-    """Dataclass for torch video output batch."""
+    """Dataclass for batches of video items in Anomalib datasets using PyTorch tensors.
+
+    This class represents a batch of video items in Anomalib datasets using PyTorch tensors.
+    It combines the functionality of ToNumpyMixin, BatchIterateMixin, _VideoInputFields,
+    and Batch to handle batches of video data, including frames, labels, masks, and metadata.
+
+    Examples:
+        >>> batch = VideoBatch(
+        ...     image=torch.rand(32, 10, 3, 224, 224),  # 32 videos, 10 frames each
+        ...     gt_label=torch.randint(0, 2, (32,)),
+        ...     gt_mask=torch.rand(32, 10, 224, 224) > 0.5,
+        ...     video_path=["path/to/video_{}.mp4".format(i) for i in range(32)]
+        ... )
+
+        >>> print(batch.image.shape)
+        torch.Size([32, 10, 3, 224, 224])
+
+        >>> for item in batch:
+        ...     print(item.image.shape)
+        torch.Size([10, 3, 224, 224])
+
+        >>> numpy_batch = batch.to_numpy()
+        >>> print(type(numpy_batch))
+        
+    """
 
     item_class = VideoItem
     numpy_class = NumpyVideoBatch
@@ -404,7 +567,24 @@ class DepthItem(
     _DepthInputFields[torch.Tensor, str],
     DatasetItem[Image],
 ):
-    """Dataclass for torch depth output item."""
+    """Dataclass for individual depth items in Anomalib datasets using PyTorch tensors.
+
+    This class represents a single depth item in Anomalib datasets using PyTorch tensors.
+    It combines the functionality of ToNumpyMixin, _DepthInputFields, and DatasetItem
+    to handle depth data, including depth maps, labels, and metadata.
+
+    Examples:
+        >>> item = DepthItem(
+        ...     image=torch.rand(3, 224, 224),
+        ...     gt_label=torch.tensor(1),
+        ...     depth_map=torch.rand(224, 224),
+        ...     image_path="path/to/image.jpg",
+        ...     depth_path="path/to/depth.png"
+        ... )
+
+        >>> print(item.image.shape, item.depth_map.shape)
+        torch.Size([3, 224, 224]) torch.Size([224, 224])
+    """
 
     numpy_class = NumpyImageItem
 
@@ -448,7 +628,28 @@ class DepthBatch(
     _DepthInputFields[torch.Tensor, list[str]],
     Batch[Image],
 ):
-    """Dataclass for torch depth output batch."""
+    """Dataclass for batches of depth items in Anomalib datasets using PyTorch tensors.
+
+    This class represents a batch of depth items in Anomalib datasets using PyTorch tensors.
+    It combines the functionality of BatchIterateMixin, _DepthInputFields, and Batch
+    to handle batches of depth data, including depth maps, labels, and metadata.
+
+    Examples:
+        >>> batch = DepthBatch(
+        ...     image=torch.rand(32, 3, 224, 224),
+        ...     gt_label=torch.randint(0, 2, (32,)),
+        ...     depth_map=torch.rand(32, 224, 224),
+        ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)],
+        ...     depth_path=["path/to/depth_{}.png".format(i) for i in range(32)]
+        ... )
+
+        >>> print(batch.image.shape, batch.depth_map.shape)
+        torch.Size([32, 3, 224, 224]) torch.Size([32, 224, 224])
+
+        >>> for item in batch:
+        ...     print(item.image.shape, item.depth_map.shape)
+        torch.Size([3, 224, 224]) torch.Size([224, 224])
+    """
 
     item_class = DepthItem
 

From 627be88e175961d6f86f4590747cd3730b239f21 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 11 Sep 2024 12:35:09 +0100
Subject: [PATCH 05/45] Refactor and restructure anomalib.data (#2302)

* Move datamodules to datamodule sub-package

* Move datamodules to datamodule sub-package

* Split datamodules and datasets

* Restructure dataclasses to data

* Fix relative imports

* Use absolute imports

* Add datasets dir

* Add relative imports for torch datasets

* Update src/anomalib/data/datamodules/base/__init__.py

Co-authored-by: Ashwin Vaidya 

---------

Co-authored-by: Ashwin Vaidya 
---
 .gitignore                                    |   3 +-
 notebooks/100_datamodules/101_btech.ipynb     |   2 +-
 notebooks/100_datamodules/102_mvtec.ipynb     |   2 +-
 notebooks/100_datamodules/103_folder.ipynb    |   2 +-
 src/anomalib/callbacks/metrics.py             |   2 +-
 src/anomalib/data/__init__.py                 |  60 +-
 src/anomalib/data/base/__init__.py            |  17 -
 .../{ => data}/dataclasses/__init__.py        |  10 +-
 .../{ => data}/dataclasses/generic.py         |   0
 .../data/dataclasses/numpy/__init__.py        |  24 +
 src/anomalib/data/dataclasses/numpy/base.py   |  36 +
 src/anomalib/data/dataclasses/numpy/depth.py  |   4 +
 .../dataclasses/numpy/image.py}               |  93 +--
 src/anomalib/data/dataclasses/numpy/video.py  |  64 ++
 .../data/dataclasses/torch/__init__.py        |  40 +
 src/anomalib/data/dataclasses/torch/base.py   | 116 +++
 src/anomalib/data/dataclasses/torch/depth.py  | 144 ++++
 src/anomalib/data/dataclasses/torch/image.py  | 296 ++++++++
 src/anomalib/data/dataclasses/torch/video.py  | 170 +++++
 src/anomalib/data/datamodules/__init__.py     |  21 +
 .../data/datamodules/base/__init__.py         |   9 +
 .../base/image.py}                            |   2 +-
 src/anomalib/data/datamodules/base/video.py   |  39 +
 .../data/{ => datamodules}/depth/__init__.py  |   2 +-
 .../data/datamodules/depth/folder_3d.py       | 165 +++++
 .../data/datamodules/depth/mvtec_3d.py        | 143 ++++
 .../data/{ => datamodules}/image/__init__.py  |   5 +-
 .../data/{ => datamodules}/image/btech.py     | 147 +---
 src/anomalib/data/datamodules/image/folder.py | 218 ++++++
 .../data/datamodules/image/kolektor.py        | 175 +++++
 .../data/{ => datamodules}/image/mvtec.py     | 195 +----
 .../data/{ => datamodules}/image/visa.py      | 107 +--
 .../data/{ => datamodules}/video/__init__.py  |   2 +-
 .../data/{ => datamodules}/video/avenue.py    | 199 +----
 .../data/datamodules/video/shanghaitech.py    | 174 +++++
 .../data/datamodules/video/ucsd_ped.py        | 127 ++++
 src/anomalib/data/datasets/__init__.py        |  29 +
 src/anomalib/data/datasets/base/__init__.py   |  10 +
 .../data/{ => datasets}/base/depth.py         |   5 +-
 .../dataset.py => datasets/base/image.py}     |   2 +-
 .../data/{ => datasets}/base/video.py         |  42 +-
 src/anomalib/data/datasets/depth/__init__.py  |   9 +
 .../data/{ => datasets}/depth/folder_3d.py    | 345 +++------
 .../data/{ => datasets}/depth/mvtec_3d.py     | 181 +----
 src/anomalib/data/datasets/image/__init__.py  |  18 +
 src/anomalib/data/datasets/image/btech.py     | 158 ++++
 .../data/{ => datasets}/image/folder.py       | 405 +++--------
 .../data/{ => datasets}/image/kolektor.py     | 235 ++----
 src/anomalib/data/datasets/image/mvtec.py     | 215 ++++++
 src/anomalib/data/datasets/image/visa.py      | 119 +++
 src/anomalib/data/datasets/video/__init__.py  |  10 +
 src/anomalib/data/datasets/video/avenue.py    | 209 ++++++
 .../data/{ => datasets}/video/shanghaitech.py | 316 +++-----
 .../data/{ => datasets}/video/ucsd_ped.py     | 276 ++-----
 src/anomalib/data/predict.py                  |   2 +-
 src/anomalib/data/utils/split.py              |   2 +-
 src/anomalib/data/utils/synthetic.py          |   2 +-
 src/anomalib/data/utils/video.py              |   2 +-
 src/anomalib/dataclasses/torch.py             | 687 ------------------
 .../deploy/inferencers/openvino_inferencer.py |   2 +-
 .../deploy/inferencers/torch_inferencer.py    |   2 +-
 .../models/components/base/anomaly_module.py  |   2 +-
 .../models/image/cfa/lightning_model.py       |   2 +-
 src/anomalib/models/image/cfa/torch_model.py  |   2 +-
 .../models/image/cflow/lightning_model.py     |   2 +-
 .../models/image/cflow/torch_model.py         |   2 +-
 .../models/image/csflow/lightning_model.py    |   2 +-
 .../models/image/csflow/torch_model.py        |   2 +-
 .../models/image/dfkde/lightning_model.py     |   2 +-
 .../models/image/dfkde/torch_model.py         |   2 +-
 .../models/image/dfm/lightning_model.py       |   2 +-
 src/anomalib/models/image/dfm/torch_model.py  |   2 +-
 .../models/image/draem/lightning_model.py     |   2 +-
 .../models/image/draem/torch_model.py         |   2 +-
 .../models/image/dsr/lightning_model.py       |   2 +-
 src/anomalib/models/image/dsr/torch_model.py  |   2 +-
 .../image/efficient_ad/lightning_model.py     |   2 +-
 .../models/image/efficient_ad/torch_model.py  |   2 +-
 .../models/image/fastflow/lightning_model.py  |   2 +-
 .../models/image/fastflow/torch_model.py      |   2 +-
 .../models/image/fre/lightning_model.py       |   2 +-
 src/anomalib/models/image/fre/torch_model.py  |   2 +-
 .../models/image/ganomaly/lightning_model.py  |   2 +-
 .../models/image/ganomaly/torch_model.py      |   2 +-
 .../models/image/padim/lightning_model.py     |   2 +-
 .../models/image/padim/torch_model.py         |   2 +-
 .../models/image/patchcore/lightning_model.py |   2 +-
 .../models/image/patchcore/torch_model.py     |   2 +-
 .../reverse_distillation/lightning_model.py   |   2 +-
 .../image/reverse_distillation/torch_model.py |   2 +-
 .../models/image/stfpm/lightning_model.py     |   2 +-
 .../models/image/stfpm/torch_model.py         |   2 +-
 .../models/image/uflow/lightning_model.py     |   2 +-
 .../models/image/uflow/torch_model.py         |   2 +-
 .../models/image/winclip/lightning_model.py   |   2 +-
 .../models/image/winclip/torch_model.py       |   2 +-
 .../models/video/ai_vad/lightning_model.py    |   2 +-
 .../models/video/ai_vad/torch_model.py        |   2 +-
 src/anomalib/post_processing/base.py          |   2 +-
 src/anomalib/post_processing/one_class.py     |   2 +-
 src/anomalib/utils/visualization/image.py     |   2 +-
 .../test_metrics_configuration_callback.py    |   2 +-
 tests/unit/data/test_inference.py             |   3 +-
 tests/unit/data/utils/test_synthetic.py       |   2 +-
 tests/unit/engine/test_setup_transform.py     |   3 +-
 .../dummy_lightning_model.py                  |   2 +-
 tests/unit/utils/test_visualizer.py           |   3 +-
 107 files changed, 3326 insertions(+), 2867 deletions(-)
 delete mode 100644 src/anomalib/data/base/__init__.py
 rename src/anomalib/{ => data}/dataclasses/__init__.py (98%)
 rename src/anomalib/{ => data}/dataclasses/generic.py (100%)
 create mode 100644 src/anomalib/data/dataclasses/numpy/__init__.py
 create mode 100644 src/anomalib/data/dataclasses/numpy/base.py
 create mode 100644 src/anomalib/data/dataclasses/numpy/depth.py
 rename src/anomalib/{dataclasses/numpy.py => data/dataclasses/numpy/image.py} (58%)
 create mode 100644 src/anomalib/data/dataclasses/numpy/video.py
 create mode 100644 src/anomalib/data/dataclasses/torch/__init__.py
 create mode 100644 src/anomalib/data/dataclasses/torch/base.py
 create mode 100644 src/anomalib/data/dataclasses/torch/depth.py
 create mode 100644 src/anomalib/data/dataclasses/torch/image.py
 create mode 100644 src/anomalib/data/dataclasses/torch/video.py
 create mode 100644 src/anomalib/data/datamodules/__init__.py
 create mode 100644 src/anomalib/data/datamodules/base/__init__.py
 rename src/anomalib/data/{base/datamodule.py => datamodules/base/image.py} (99%)
 create mode 100644 src/anomalib/data/datamodules/base/video.py
 rename src/anomalib/data/{ => datamodules}/depth/__init__.py (90%)
 create mode 100644 src/anomalib/data/datamodules/depth/folder_3d.py
 create mode 100644 src/anomalib/data/datamodules/depth/mvtec_3d.py
 rename src/anomalib/data/{ => datamodules}/image/__init__.py (84%)
 rename src/anomalib/data/{ => datamodules}/image/btech.py (61%)
 create mode 100644 src/anomalib/data/datamodules/image/folder.py
 create mode 100644 src/anomalib/data/datamodules/image/kolektor.py
 rename src/anomalib/data/{ => datamodules}/image/mvtec.py (52%)
 rename src/anomalib/data/{ => datamodules}/image/visa.py (76%)
 rename src/anomalib/data/{ => datamodules}/video/__init__.py (92%)
 rename src/anomalib/data/{ => datamodules}/video/avenue.py (60%)
 create mode 100644 src/anomalib/data/datamodules/video/shanghaitech.py
 create mode 100644 src/anomalib/data/datamodules/video/ucsd_ped.py
 create mode 100644 src/anomalib/data/datasets/__init__.py
 create mode 100644 src/anomalib/data/datasets/base/__init__.py
 rename src/anomalib/data/{ => datasets}/base/depth.py (96%)
 rename src/anomalib/data/{base/dataset.py => datasets/base/image.py} (99%)
 rename src/anomalib/data/{ => datasets}/base/video.py (81%)
 create mode 100644 src/anomalib/data/datasets/depth/__init__.py
 rename src/anomalib/data/{ => datasets}/depth/folder_3d.py (62%)
 rename src/anomalib/data/{ => datasets}/depth/mvtec_3d.py (62%)
 create mode 100644 src/anomalib/data/datasets/image/__init__.py
 create mode 100644 src/anomalib/data/datasets/image/btech.py
 rename src/anomalib/data/{ => datasets}/image/folder.py (56%)
 rename src/anomalib/data/{ => datasets}/image/kolektor.py (57%)
 create mode 100644 src/anomalib/data/datasets/image/mvtec.py
 create mode 100644 src/anomalib/data/datasets/image/visa.py
 create mode 100644 src/anomalib/data/datasets/video/__init__.py
 create mode 100644 src/anomalib/data/datasets/video/avenue.py
 rename src/anomalib/data/{ => datasets}/video/shanghaitech.py (53%)
 rename src/anomalib/data/{ => datasets}/video/ucsd_ped.py (55%)
 delete mode 100644 src/anomalib/dataclasses/torch.py

diff --git a/.gitignore b/.gitignore
index e37d76063c..8362f12559 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,9 +1,8 @@
 # Project related
 datasets
+!src/anomalib/data/datasets
 pre_trained
-!anomalib/datasets
 results
-!anomalib/core/results
 
 # Test-related files and directories
 tmp*
diff --git a/notebooks/100_datamodules/101_btech.ipynb b/notebooks/100_datamodules/101_btech.ipynb
index a10fc1e35d..ef188665e6 100644
--- a/notebooks/100_datamodules/101_btech.ipynb
+++ b/notebooks/100_datamodules/101_btech.ipynb
@@ -71,7 +71,7 @@
     "from torchvision.transforms.v2 import Resize\n",
     "from torchvision.transforms.v2.functional import to_pil_image\n",
     "\n",
-    "from anomalib.data.image.btech import BTech, BTechDataset\n",
+    "from anomalib.data import BTech, BTechDataset\n",
     "from anomalib import TaskType"
    ]
   },
diff --git a/notebooks/100_datamodules/102_mvtec.ipynb b/notebooks/100_datamodules/102_mvtec.ipynb
index 3a04717178..4c274939d6 100644
--- a/notebooks/100_datamodules/102_mvtec.ipynb
+++ b/notebooks/100_datamodules/102_mvtec.ipynb
@@ -33,7 +33,7 @@
     "from torchvision.transforms.v2 import Resize\n",
     "from torchvision.transforms.v2.functional import to_pil_image\n",
     "\n",
-    "from anomalib.data.image.mvtec import MVTec, MVTecDataset\n",
+    "from anomalib.data import MVTec, MVTecDataset\n",
     "from anomalib import TaskType"
    ]
   },
diff --git a/notebooks/100_datamodules/103_folder.ipynb b/notebooks/100_datamodules/103_folder.ipynb
index 6a5ab89d4c..2f642e145a 100644
--- a/notebooks/100_datamodules/103_folder.ipynb
+++ b/notebooks/100_datamodules/103_folder.ipynb
@@ -73,7 +73,7 @@
     "from torchvision.transforms.v2 import Resize\n",
     "from torchvision.transforms.v2.functional import to_pil_image\n",
     "\n",
-    "from anomalib.data.image.folder import Folder, FolderDataset\n",
+    "from anomalib.data import Folder, FolderDataset\n",
     "from anomalib import TaskType"
    ]
   },
diff --git a/src/anomalib/callbacks/metrics.py b/src/anomalib/callbacks/metrics.py
index 0dd7cd882e..3546310294 100644
--- a/src/anomalib/callbacks/metrics.py
+++ b/src/anomalib/callbacks/metrics.py
@@ -13,7 +13,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import TaskType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.metrics import AnomalibMetricCollection, create_metric_collection
 from anomalib.models import AnomalyModule
 
diff --git a/src/anomalib/data/__init__.py b/src/anomalib/data/__init__.py
index e7eaf11156..e5ee6bae4c 100644
--- a/src/anomalib/data/__init__.py
+++ b/src/anomalib/data/__init__.py
@@ -12,12 +12,36 @@
 
 from anomalib.utils.config import to_tuple
 
-from .base import AnomalibDataModule, AnomalibDataset
-from .depth import DepthDataFormat, Folder3D, MVTec3D
-from .image import BTech, Folder, ImageDataFormat, Kolektor, MVTec, Visa
+# Dataclasses
+from .dataclasses import (
+    Batch,
+    DatasetItem,
+    DepthBatch,
+    DepthItem,
+    ImageBatch,
+    ImageItem,
+    InferenceBatch,
+    NumpyImageBatch,
+    NumpyImageItem,
+    NumpyVideoBatch,
+    NumpyVideoItem,
+    VideoBatch,
+    VideoItem,
+)
+
+# Datamodules
+from .datamodules.base import AnomalibDataModule
+from .datamodules.depth import DepthDataFormat, Folder3D, MVTec3D
+from .datamodules.image import BTech, Folder, ImageDataFormat, Kolektor, MVTec, Visa
+from .datamodules.video import Avenue, ShanghaiTech, UCSDped, VideoDataFormat
+
+# Datasets
+from .datasets import AnomalibDataset
+from .datasets.depth import Folder3DDataset, MVTec3DDataset
+from .datasets.image import BTechDataset, FolderDataset, KolektorDataset, MVTecDataset, VisaDataset
+from .datasets.video import AvenueDataset, ShanghaiTechDataset, UCSDpedDataset
 from .predict import PredictDataset
 from .utils import LabelName
-from .video import Avenue, ShanghaiTech, UCSDped, VideoDataFormat
 
 logger = logging.getLogger(__name__)
 
@@ -63,7 +87,34 @@ def get_datamodule(config: DictConfig | ListConfig | dict) -> AnomalibDataModule
 
 
 __all__ = [
+    # Anomalib dataclasses
+    "DatasetItem",
+    "Batch",
+    "InferenceBatch",
+    "ImageItem",
+    "ImageBatch",
+    "VideoItem",
+    "VideoBatch",
+    "DepthItem",
+    "DepthBatch",
+    "NumpyImageItem",
+    "NumpyImageBatch",
+    "NumpyVideoItem",
+    "NumpyVideoBatch",
+    # Anomalib datasets
     "AnomalibDataset",
+    "Folder3DDataset",
+    "MVTec3DDataset",
+    "BTechDataset",
+    "FolderDataset",
+    "KolektorDataset",
+    "MVTecDataset",
+    "VisaDataset",
+    "AvenueDataset",
+    "ShanghaiTechDataset",
+    "UCSDpedDataset",
+    "PredictDataset",
+    # Anomalib datamodules
     "AnomalibDataModule",
     "DepthDataFormat",
     "ImageDataFormat",
@@ -72,7 +123,6 @@ def get_datamodule(config: DictConfig | ListConfig | dict) -> AnomalibDataModule
     "BTech",
     "Folder",
     "Folder3D",
-    "PredictDataset",
     "Kolektor",
     "MVTec",
     "MVTec3D",
diff --git a/src/anomalib/data/base/__init__.py b/src/anomalib/data/base/__init__.py
deleted file mode 100644
index 4a5c50e772..0000000000
--- a/src/anomalib/data/base/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-"""Base classes for custom dataset and datamodules."""
-
-# Copyright (C) 2022 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from .datamodule import AnomalibDataModule
-from .dataset import AnomalibDataset
-from .depth import AnomalibDepthDataset
-from .video import AnomalibVideoDataModule, AnomalibVideoDataset
-
-__all__ = [
-    "AnomalibDataset",
-    "AnomalibDataModule",
-    "AnomalibVideoDataset",
-    "AnomalibVideoDataModule",
-    "AnomalibDepthDataset",
-]
diff --git a/src/anomalib/dataclasses/__init__.py b/src/anomalib/data/dataclasses/__init__.py
similarity index 98%
rename from src/anomalib/dataclasses/__init__.py
rename to src/anomalib/data/dataclasses/__init__.py
index e6d3112a92..a7f8516ae5 100644
--- a/src/anomalib/dataclasses/__init__.py
+++ b/src/anomalib/data/dataclasses/__init__.py
@@ -53,6 +53,12 @@
 )
 
 __all__ = [
+    # Numpy
+    "NumpyImageItem",
+    "NumpyImageBatch",
+    "NumpyVideoItem",
+    "NumpyVideoBatch",
+    # Torch
     "DatasetItem",
     "Batch",
     "InferenceBatch",
@@ -60,10 +66,6 @@
     "ImageBatch",
     "VideoItem",
     "VideoBatch",
-    "NumpyImageItem",
-    "NumpyImageBatch",
-    "NumpyVideoItem",
-    "NumpyVideoBatch",
     "DepthItem",
     "DepthBatch",
 ]
diff --git a/src/anomalib/dataclasses/generic.py b/src/anomalib/data/dataclasses/generic.py
similarity index 100%
rename from src/anomalib/dataclasses/generic.py
rename to src/anomalib/data/dataclasses/generic.py
diff --git a/src/anomalib/data/dataclasses/numpy/__init__.py b/src/anomalib/data/dataclasses/numpy/__init__.py
new file mode 100644
index 0000000000..717e3d6c6e
--- /dev/null
+++ b/src/anomalib/data/dataclasses/numpy/__init__.py
@@ -0,0 +1,24 @@
+"""Numpy-based dataclasses for Anomalib.
+
+This module provides numpy-based implementations of the generic dataclasses
+used in Anomalib. These classes are designed to work with numpy arrays for
+efficient data handling and processing in anomaly detection tasks.
+
+The module includes the following main classes:
+
+- NumpyItem: Represents a single item in Anomalib datasets using numpy arrays.
+- NumpyBatch: Represents a batch of items in Anomalib datasets using numpy arrays.
+- NumpyImageItem: Represents a single image item with additional image-specific fields.
+- NumpyImageBatch: Represents a batch of image items with batch operations.
+- NumpyVideoItem: Represents a single video item with video-specific fields.
+- NumpyVideoBatch: Represents a batch of video items with video-specific operations.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .base import NumpyBatch, NumpyItem
+from .image import NumpyImageBatch, NumpyImageItem
+from .video import NumpyVideoBatch, NumpyVideoItem
+
+__all__ = ["NumpyBatch", "NumpyItem", "NumpyImageBatch", "NumpyImageItem", "NumpyVideoBatch", "NumpyVideoItem"]
diff --git a/src/anomalib/data/dataclasses/numpy/base.py b/src/anomalib/data/dataclasses/numpy/base.py
new file mode 100644
index 0000000000..a27496f697
--- /dev/null
+++ b/src/anomalib/data/dataclasses/numpy/base.py
@@ -0,0 +1,36 @@
+"""Numpy-based dataclasses for Anomalib.
+
+This module provides numpy-based implementations of the generic dataclasses
+used in Anomalib. These classes are designed to work with numpy arrays for
+efficient data handling and processing in anomaly detection tasks.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from anomalib.data.dataclasses.generic import _GenericBatch, _GenericItem
+
+
+@dataclass
+class NumpyItem(_GenericItem[np.ndarray, np.ndarray, np.ndarray, str]):
+    """Dataclass for a single item in Anomalib datasets using numpy arrays.
+
+    This class extends _GenericItem for numpy-based data representation. It includes
+    both input data (e.g., images, labels) and output data (e.g., predictions,
+    anomaly maps) as numpy arrays. It is suitable for numpy-based processing
+    pipelines in Anomalib.
+    """
+
+
+@dataclass
+class NumpyBatch(_GenericBatch[np.ndarray, np.ndarray, np.ndarray, list[str]]):
+    """Dataclass for a batch of items in Anomalib datasets using numpy arrays.
+
+    This class extends _GenericBatch for batches of numpy-based data. It represents
+    multiple data points for batch processing in anomaly detection tasks. It includes
+    an additional dimension for batch size in all tensor-like fields.
+    """
diff --git a/src/anomalib/data/dataclasses/numpy/depth.py b/src/anomalib/data/dataclasses/numpy/depth.py
new file mode 100644
index 0000000000..8275b9c90f
--- /dev/null
+++ b/src/anomalib/data/dataclasses/numpy/depth.py
@@ -0,0 +1,4 @@
+"""Numpy-based depth dataclasses for Anomalib."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/dataclasses/numpy.py b/src/anomalib/data/dataclasses/numpy/image.py
similarity index 58%
rename from src/anomalib/dataclasses/numpy.py
rename to src/anomalib/data/dataclasses/numpy/image.py
index 6e1ea1a21a..80db77b465 100644
--- a/src/anomalib/dataclasses/numpy.py
+++ b/src/anomalib/data/dataclasses/numpy/image.py
@@ -1,18 +1,4 @@
-"""Numpy-based dataclasses for Anomalib.
-
-This module provides numpy-based implementations of the generic dataclasses
-used in Anomalib. These classes are designed to work with numpy arrays for
-efficient data handling and processing in anomaly detection tasks.
-
-The module includes the following main classes:
-
-- NumpyItem: Represents a single item in Anomalib datasets using numpy arrays.
-- NumpyBatch: Represents a batch of items in Anomalib datasets using numpy arrays.
-- NumpyImageItem: Represents a single image item with additional image-specific fields.
-- NumpyImageBatch: Represents a batch of image items with batch operations.
-- NumpyVideoItem: Represents a single video item with video-specific fields.
-- NumpyVideoBatch: Represents a batch of video items with video-specific operations.
-"""
+"""Numpy-based image dataclasses for Anomalib."""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -21,28 +7,8 @@
 
 import numpy as np
 
-from .generic import BatchIterateMixin, _GenericBatch, _GenericItem, _ImageInputFields, _VideoInputFields
-
-
-@dataclass
-class NumpyItem(_GenericItem[np.ndarray, np.ndarray, np.ndarray, str]):
-    """Dataclass for a single item in Anomalib datasets using numpy arrays.
-
-    This class extends _GenericItem for numpy-based data representation. It includes
-    both input data (e.g., images, labels) and output data (e.g., predictions,
-    anomaly maps) as numpy arrays. It is suitable for numpy-based processing
-    pipelines in Anomalib.
-    """
-
-
-@dataclass
-class NumpyBatch(_GenericBatch[np.ndarray, np.ndarray, np.ndarray, list[str]]):
-    """Dataclass for a batch of items in Anomalib datasets using numpy arrays.
-
-    This class extends _GenericBatch for batches of numpy-based data. It represents
-    multiple data points for batch processing in anomaly detection tasks. It includes
-    an additional dimension for batch size in all tensor-like fields.
-    """
+from anomalib.data.dataclasses.generic import BatchIterateMixin, _ImageInputFields
+from anomalib.data.dataclasses.numpy.base import NumpyBatch, NumpyItem
 
 
 @dataclass
@@ -175,56 +141,3 @@ def _validate_pred_label(self, pred_label: np.ndarray) -> np.ndarray:
 
     def _validate_image_path(self, image_path: list[str]) -> list[str]:
         return image_path
-
-
-@dataclass
-class NumpyVideoItem(_VideoInputFields[np.ndarray, np.ndarray, np.ndarray, str], NumpyItem):
-    """Dataclass for a single video item in Anomalib datasets using numpy arrays.
-
-    This class combines _VideoInputFields and NumpyItem for video-based anomaly detection.
-    It includes video-specific fields and validation methods to ensure proper formatting
-    for Anomalib's video-based models.
-    """
-
-    def _validate_image(self, image: np.ndarray) -> np.ndarray:
-        return image
-
-    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
-        return gt_label
-
-    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
-        return gt_mask
-
-    def _validate_mask_path(self, mask_path: str) -> str:
-        return mask_path
-
-
-@dataclass
-class NumpyVideoBatch(
-    BatchIterateMixin[NumpyVideoItem],
-    _VideoInputFields[np.ndarray, np.ndarray, np.ndarray, list[str]],
-    NumpyBatch,
-):
-    """Dataclass for a batch of video items in Anomalib datasets using numpy arrays.
-
-    This class combines BatchIterateMixin, _VideoInputFields, and NumpyBatch for batches
-    of video data. It supports batch operations and iteration over individual NumpyVideoItems.
-    It ensures proper formatting for Anomalib's video-based models.
-    """
-
-    item_class = NumpyVideoItem
-
-    def _validate_image(self, image: np.ndarray) -> np.ndarray:
-        return image
-
-    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
-        return gt_label
-
-    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
-        return gt_mask
-
-    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
-        return mask_path
-
-    def _validate_anomaly_map(self, anomaly_map: np.ndarray) -> np.ndarray:
-        return anomaly_map
diff --git a/src/anomalib/data/dataclasses/numpy/video.py b/src/anomalib/data/dataclasses/numpy/video.py
new file mode 100644
index 0000000000..8998d4c557
--- /dev/null
+++ b/src/anomalib/data/dataclasses/numpy/video.py
@@ -0,0 +1,64 @@
+"""Numpy-based video dataclasses for Anomalib."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from anomalib.data.dataclasses.generic import BatchIterateMixin, _VideoInputFields
+from anomalib.data.dataclasses.numpy.base import NumpyBatch, NumpyItem
+
+
+@dataclass
+class NumpyVideoItem(_VideoInputFields[np.ndarray, np.ndarray, np.ndarray, str], NumpyItem):
+    """Dataclass for a single video item in Anomalib datasets using numpy arrays.
+
+    This class combines _VideoInputFields and NumpyItem for video-based anomaly detection.
+    It includes video-specific fields and validation methods to ensure proper formatting
+    for Anomalib's video-based models.
+    """
+
+    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+        return image
+
+    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: str) -> str:
+        return mask_path
+
+
+@dataclass
+class NumpyVideoBatch(
+    BatchIterateMixin[NumpyVideoItem],
+    _VideoInputFields[np.ndarray, np.ndarray, np.ndarray, list[str]],
+    NumpyBatch,
+):
+    """Dataclass for a batch of video items in Anomalib datasets using numpy arrays.
+
+    This class combines BatchIterateMixin, _VideoInputFields, and NumpyBatch for batches
+    of video data. It supports batch operations and iteration over individual NumpyVideoItems.
+    It ensures proper formatting for Anomalib's video-based models.
+    """
+
+    item_class = NumpyVideoItem
+
+    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+        return image
+
+    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: np.ndarray) -> np.ndarray:
+        return anomaly_map
diff --git a/src/anomalib/data/dataclasses/torch/__init__.py b/src/anomalib/data/dataclasses/torch/__init__.py
new file mode 100644
index 0000000000..d26858f0a3
--- /dev/null
+++ b/src/anomalib/data/dataclasses/torch/__init__.py
@@ -0,0 +1,40 @@
+"""Torch-based dataclasses for Anomalib.
+
+This module provides PyTorch-based implementations of the generic dataclasses
+used in Anomalib. These classes are designed to work with PyTorch tensors for
+efficient data handling and processing in anomaly detection tasks.
+
+These classes extend the generic dataclasses defined in the Anomalib framework,
+providing concrete implementations that use PyTorch tensors for tensor-like data.
+They include methods for data validation and support operations specific to
+image, video, and depth data in the context of anomaly detection.
+
+Note:
+    When using these classes, ensure that the input data is in the correct
+    format (PyTorch tensors with appropriate shapes) to avoid validation errors.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .base import Batch, DatasetItem, InferenceBatch, ToNumpyMixin
+from .depth import DepthBatch, DepthItem
+from .image import ImageBatch, ImageItem
+from .video import VideoBatch, VideoItem
+
+__all__ = [
+    # Base
+    "Batch",
+    "DatasetItem",
+    "InferenceBatch",
+    "ToNumpyMixin",
+    # Depth
+    "DepthItem",
+    "DepthBatch",
+    # Image
+    "ImageItem",
+    "ImageBatch",
+    # Video
+    "VideoItem",
+    "VideoBatch",
+]
diff --git a/src/anomalib/data/dataclasses/torch/base.py b/src/anomalib/data/dataclasses/torch/base.py
new file mode 100644
index 0000000000..77b0cc5022
--- /dev/null
+++ b/src/anomalib/data/dataclasses/torch/base.py
@@ -0,0 +1,116 @@
+"""Torch-based dataclasses for Anomalib.
+
+This module provides PyTorch-based implementations of the generic dataclasses
+used in Anomalib. These classes are designed to work with PyTorch tensors for
+efficient data handling and processing in anomaly detection tasks.
+
+These classes extend the generic dataclasses defined in the Anomalib framework,
+providing concrete implementations that use PyTorch tensors for tensor-like data.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Callable
+from dataclasses import asdict, dataclass
+from typing import ClassVar, Generic, NamedTuple, TypeVar
+
+import torch
+from torchvision.tv_tensors import Mask
+
+from anomalib.data.dataclasses.generic import ImageT, _GenericBatch, _GenericItem
+
+NumpyT = TypeVar("NumpyT")
+
+
+class InferenceBatch(NamedTuple):
+    """Batch for use in torch and inference models."""
+
+    pred_score: torch.Tensor | None = None
+    pred_label: torch.Tensor | None = None
+    anomaly_map: torch.Tensor | None = None
+    pred_mask: torch.Tensor | None = None
+
+
+@dataclass
+class ToNumpyMixin(Generic[NumpyT]):
+    """Mixin for converting torch-based dataclasses to numpy.
+
+    This mixin provides functionality to convert PyTorch tensor data to numpy arrays.
+    It requires the subclass to define a 'numpy_class' attribute specifying the
+    corresponding numpy-based class.
+
+    Examples:
+        >>> from anomalib.dataclasses.numpy import NumpyImageItem
+        >>> @dataclass
+        ... class TorchImageItem(ToNumpyMixin[NumpyImageItem]):
+        ...     numpy_class = NumpyImageItem
+        ...     image: torch.Tensor
+        ...     gt_label: torch.Tensor
+
+        >>> torch_item = TorchImageItem(image=torch.rand(3, 224, 224), gt_label=torch.tensor(1))
+        >>> numpy_item = torch_item.to_numpy()
+        >>> isinstance(numpy_item, NumpyImageItem)
+        True
+    """
+
+    numpy_class: ClassVar[Callable]
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        """Ensure that the subclass has the required attributes."""
+        super().__init_subclass__(**kwargs)
+        if not hasattr(cls, "numpy_class"):
+            msg = f"{cls.__name__} must have a 'numpy_class' attribute."
+            raise AttributeError(msg)
+
+    def to_numpy(self) -> NumpyT:
+        """Convert the batch to a NumpyBatch object."""
+        batch_dict = asdict(self)
+        for key, value in batch_dict.items():
+            if isinstance(value, torch.Tensor):
+                batch_dict[key] = value.cpu().numpy()
+        return self.numpy_class(
+            **batch_dict,
+        )
+
+
+@dataclass
+class DatasetItem(Generic[ImageT], _GenericItem[torch.Tensor, ImageT, Mask, str]):
+    """Base dataclass for individual items in Anomalib datasets using PyTorch tensors.
+
+    This class extends the generic _GenericItem class to provide a PyTorch-specific
+    implementation for single data items in Anomalib datasets. It is designed to
+    handle various types of data (e.g., images, labels, masks) represented as
+    PyTorch tensors.
+
+    The class uses generic types to allow flexibility in the image representation,
+    which can vary depending on the specific use case (e.g., standard images, video clips).
+
+    Attributes:
+        Inherited from _GenericItem, with PyTorch tensor and Mask types.
+
+    Note:
+        This class is typically subclassed to create more specific item types
+        (e.g., ImageItem, VideoItem) with additional fields and methods.
+    """
+
+
+@dataclass
+class Batch(Generic[ImageT], _GenericBatch[torch.Tensor, ImageT, Mask, list[str]]):
+    """Base dataclass for batches of items in Anomalib datasets using PyTorch tensors.
+
+    This class extends the generic _GenericBatch class to provide a PyTorch-specific
+    implementation for batches of data in Anomalib datasets. It is designed to
+    handle collections of data items (e.g., multiple images, labels, masks)
+    represented as PyTorch tensors.
+
+    The class uses generic types to allow flexibility in the image representation,
+    which can vary depending on the specific use case (e.g., standard images, video clips).
+
+    Attributes:
+        Inherited from _GenericBatch, with PyTorch tensor and Mask types.
+
+    Note:
+        This class is typically subclassed to create more specific batch types
+        (e.g., ImageBatch, VideoBatch) with additional fields and methods.
+    """
diff --git a/src/anomalib/data/dataclasses/torch/depth.py b/src/anomalib/data/dataclasses/torch/depth.py
new file mode 100644
index 0000000000..1d5e230b52
--- /dev/null
+++ b/src/anomalib/data/dataclasses/torch/depth.py
@@ -0,0 +1,144 @@
+"""Torch-based dataclasses for depth data in Anomalib.
+
+This module provides PyTorch-based implementations of the generic dataclasses
+used in Anomalib for depth data. These classes are designed to work with PyTorch
+tensors for efficient data handling and processing in anomaly detection tasks.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass
+
+import torch
+from torchvision.tv_tensors import Image, Mask
+
+from anomalib.data.dataclasses.generic import BatchIterateMixin, _DepthInputFields
+from anomalib.data.dataclasses.numpy.image import NumpyImageItem
+from anomalib.data.dataclasses.torch.base import Batch, DatasetItem, ToNumpyMixin
+
+
+@dataclass
+class DepthItem(
+    ToNumpyMixin[NumpyImageItem],
+    _DepthInputFields[torch.Tensor, str],
+    DatasetItem[Image],
+):
+    """Dataclass for individual depth items in Anomalib datasets using PyTorch tensors.
+
+    This class represents a single depth item in Anomalib datasets using PyTorch tensors.
+    It combines the functionality of ToNumpyMixin, _DepthInputFields, and DatasetItem
+    to handle depth data, including depth maps, labels, and metadata.
+
+    Examples:
+        >>> item = DepthItem(
+        ...     image=torch.rand(3, 224, 224),
+        ...     gt_label=torch.tensor(1),
+        ...     depth_map=torch.rand(224, 224),
+        ...     image_path="path/to/image.jpg",
+        ...     depth_path="path/to/depth.png"
+        ... )
+
+        >>> print(item.image.shape, item.depth_map.shape)
+        torch.Size([3, 224, 224]) torch.Size([224, 224])
+    """
+
+    numpy_class = NumpyImageItem
+
+    def _validate_image(self, image: Image) -> Image:
+        return image
+
+    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: str) -> str:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
+        return pred_label
+
+    def _validate_image_path(self, image_path: str) -> str:
+        return image_path
+
+    def _validate_depth_map(self, depth_map: torch.Tensor) -> torch.Tensor:
+        return depth_map
+
+    def _validate_depth_path(self, depth_path: str) -> str:
+        return depth_path
+
+
+@dataclass
+class DepthBatch(
+    BatchIterateMixin[DepthItem],
+    _DepthInputFields[torch.Tensor, list[str]],
+    Batch[Image],
+):
+    """Dataclass for batches of depth items in Anomalib datasets using PyTorch tensors.
+
+    This class represents a batch of depth items in Anomalib datasets using PyTorch tensors.
+    It combines the functionality of BatchIterateMixin, _DepthInputFields, and Batch
+    to handle batches of depth data, including depth maps, labels, and metadata.
+
+    Examples:
+        >>> batch = DepthBatch(
+        ...     image=torch.rand(32, 3, 224, 224),
+        ...     gt_label=torch.randint(0, 2, (32,)),
+        ...     depth_map=torch.rand(32, 224, 224),
+        ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)],
+        ...     depth_path=["path/to/depth_{}.png".format(i) for i in range(32)]
+        ... )
+
+        >>> print(batch.image.shape, batch.depth_map.shape)
+        torch.Size([32, 3, 224, 224]) torch.Size([32, 224, 224])
+
+        >>> for item in batch:
+        ...     print(item.image.shape, item.depth_map.shape)
+        torch.Size([3, 224, 224]) torch.Size([224, 224])
+    """
+
+    item_class = DepthItem
+
+    def _validate_image(self, image: Image) -> Image:
+        return image
+
+    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
+        return pred_label
+
+    def _validate_image_path(self, image_path: list[str]) -> list[str]:
+        return image_path
+
+    def _validate_depth_map(self, depth_map: torch.Tensor) -> torch.Tensor:
+        return depth_map
+
+    def _validate_depth_path(self, depth_path: list[str]) -> list[str]:
+        return depth_path
diff --git a/src/anomalib/data/dataclasses/torch/image.py b/src/anomalib/data/dataclasses/torch/image.py
new file mode 100644
index 0000000000..13d6dc52ed
--- /dev/null
+++ b/src/anomalib/data/dataclasses/torch/image.py
@@ -0,0 +1,296 @@
+"""Torch-based dataclasses for image data in Anomalib.
+
+This module provides PyTorch-based implementations of the generic dataclasses
+used in Anomalib for image data. These classes are designed to work with PyTorch
+tensors for efficient data handling and processing in anomaly detection tasks.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+import numpy as np
+import torch
+from torchvision.transforms.v2.functional import to_dtype_image
+from torchvision.tv_tensors import Image, Mask
+
+from anomalib.data.dataclasses.generic import BatchIterateMixin, _ImageInputFields
+from anomalib.data.dataclasses.numpy.image import NumpyImageBatch, NumpyImageItem
+from anomalib.data.dataclasses.torch.base import Batch, DatasetItem, ToNumpyMixin
+
+
+@dataclass
+class ImageItem(
+    ToNumpyMixin[NumpyImageItem],
+    _ImageInputFields[str],
+    DatasetItem[Image],
+):
+    """Dataclass for individual image items in Anomalib datasets using PyTorch tensors.
+
+    This class combines the functionality of ToNumpyMixin, _ImageInputFields, and
+    DatasetItem to represent single image data points in Anomalib. It includes
+    image-specific fields and provides methods for data validation and conversion
+    to numpy format.
+
+    The class is designed to work with PyTorch tensors and includes fields for
+    the image data, ground truth labels and masks, anomaly maps, and related metadata.
+
+    Attributes:
+        Inherited from _ImageInputFields and DatasetItem.
+
+    Methods:
+        Inherited from ToNumpyMixin, including to_numpy() for conversion to numpy format.
+
+    Examples:
+        >>> item = ImageItem(
+        ...     image=torch.rand(3, 224, 224),
+        ...     gt_label=torch.tensor(1),
+        ...     gt_mask=torch.rand(224, 224) > 0.5,
+        ...     image_path="path/to/image.jpg"
+        ... )
+
+        >>> print(item.image.shape)
+        torch.Size([3, 224, 224])
+
+        >>> numpy_item = item.to_numpy()
+        >>> print(type(numpy_item))
+        
+    """
+
+    numpy_class = NumpyImageItem
+
+    def _validate_image(self, image: torch.Tensor) -> Image:
+        assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
+        assert image.ndim == 3, f"Image must have shape [C, H, W], got shape {image.shape}."
+        assert image.shape[0] == 3, f"Image must have 3 channels, got {image.shape[0]}."
+        return to_dtype_image(image, torch.float32, scale=True)
+
+    def _validate_gt_label(self, gt_label: torch.Tensor | int | None) -> torch.Tensor:
+        if gt_label is None:
+            return None
+        if isinstance(gt_label, int):
+            gt_label = torch.tensor(gt_label)
+        assert isinstance(
+            gt_label,
+            torch.Tensor,
+        ), f"Ground truth label must be an integer or a torch.Tensor, got {type(gt_label)}."
+        assert gt_label.ndim == 0, f"Ground truth label must be a scalar, got shape {gt_label.shape}."
+        assert not torch.is_floating_point(gt_label), f"Ground truth label must be boolean or integer, got {gt_label}."
+        return gt_label.bool()
+
+    def _validate_gt_mask(self, gt_mask: torch.Tensor | None) -> Mask | None:
+        if gt_mask is None:
+            return None
+        assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
+        assert gt_mask.ndim in {
+            2,
+            3,
+        }, f"Ground truth mask must have shape [H, W] or [1, H, W] got shape {gt_mask.shape}."
+        if gt_mask.ndim == 3:
+            assert gt_mask.shape[0] == 1, f"Ground truth mask must have 1 channel, got {gt_mask.shape[0]}."
+            gt_mask = gt_mask.squeeze(0)
+        return Mask(gt_mask, dtype=torch.bool)
+
+    def _validate_mask_path(self, mask_path: str | None) -> str | None:
+        if mask_path is None:
+            return None
+        return str(mask_path)
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor | None) -> Mask | None:
+        if anomaly_map is None:
+            return None
+        assert isinstance(anomaly_map, torch.Tensor), f"Anomaly map must be a torch.Tensor, got {type(anomaly_map)}."
+        assert anomaly_map.ndim in {
+            2,
+            3,
+        }, f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
+        if anomaly_map.ndim == 3:
+            assert (
+                anomaly_map.shape[0] == 1
+            ), f"Anomaly map with 3 dimensions must have 1 channel, got {anomaly_map.shape[0]}."
+            anomaly_map = anomaly_map.squeeze(0)
+        return Mask(anomaly_map, dtype=torch.float32)
+
+    def _validate_pred_score(self, pred_score: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
+        if pred_score is None:
+            return torch.amax(self.anomaly_map, dim=(-2, -1)) if self.anomaly_map is not None else None
+        if not isinstance(pred_score, torch.Tensor):
+            try:
+                pred_score = torch.tensor(pred_score)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a torch.Tensor."
+                raise ValueError(msg) from e
+        pred_score = pred_score.squeeze()
+        assert pred_score.ndim == 0, f"Predicted score must be a scalar, got shape {pred_score.shape}."
+        return pred_score.to(torch.float32)
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor | None) -> Mask | None:
+        if pred_mask is None:
+            return None
+        assert isinstance(pred_mask, torch.Tensor), f"Predicted mask must be a torch.Tensor, got {type(pred_mask)}."
+        assert pred_mask.ndim in {
+            2,
+            3,
+        }, f"Predicted mask must have shape [H, W] or [1, H, W] got shape {pred_mask.shape}."
+        if pred_mask.ndim == 3:
+            assert pred_mask.shape[0] == 1, f"Predicted mask must have 1 channel, got {pred_mask.shape[0]}."
+            pred_mask = pred_mask.squeeze(0)
+        return Mask(pred_mask, dtype=torch.bool)
+
+    def _validate_pred_label(self, pred_label: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, torch.Tensor):
+            try:
+                pred_label = torch.tensor(pred_label)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a torch.Tensor."
+                raise ValueError(msg) from e
+        pred_label = pred_label.squeeze()
+        assert pred_label.ndim == 0, f"Predicted label must be a scalar, got shape {pred_label.shape}."
+        return pred_label.to(torch.bool)
+
+    def _validate_image_path(self, image_path: str | None) -> str | None:
+        if image_path is None:
+            return None
+        return str(image_path)
+
+
+@dataclass
+class ImageBatch(
+    ToNumpyMixin[NumpyImageBatch],
+    BatchIterateMixin[ImageItem],
+    _ImageInputFields[list[str]],
+    Batch[Image],
+):
+    """Dataclass for batches of image items in Anomalib datasets using PyTorch tensors.
+
+    This class combines the functionality of ``ToNumpyMixin``, ``BatchIterateMixin``,
+    ``_ImageInputFields``, and ``Batch`` to represent collections of image data points in Anomalib.
+    It includes image-specific fields and provides methods for batch operations,
+    iteration over individual items, and conversion to numpy format.
+
+    The class is designed to work with PyTorch tensors and includes fields for
+    batches of image data, ground truth labels and masks, anomaly maps, and related metadata.
+
+    Examples:
+        >>> batch = ImageBatch(
+        ...     image=torch.rand(32, 3, 224, 224),
+        ...     gt_label=torch.randint(0, 2, (32,)),
+        ...     gt_mask=torch.rand(32, 224, 224) > 0.5,
+        ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)]
+        ... )
+
+        >>> print(batch.image.shape)
+        torch.Size([32, 3, 224, 224])
+
+        >>> for item in batch:
+        ...     print(item.image.shape)
+        torch.Size([3, 224, 224])
+
+        >>> numpy_batch = batch.to_numpy()
+        >>> print(type(numpy_batch))
+        
+    """
+
+    item_class = ImageItem
+    numpy_class = NumpyImageBatch
+
+    def _validate_image(self, image: Image) -> Image:
+        assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
+        assert image.ndim in {3, 4}, f"Image must have shape [C, H, W] or [N, C, H, W], got shape {image.shape}."
+        if image.ndim == 3:
+            image = image.unsqueeze(0)  # add batch dimension
+        assert image.shape[1] == 3, f"Image must have 3 channels, got {image.shape[0]}."
+        return Image(image, dtype=torch.float32)
+
+    def _validate_gt_label(self, gt_label: torch.Tensor | Sequence[int] | None) -> torch.Tensor:
+        if gt_label is None:
+            return None
+        if isinstance(gt_label, Sequence):
+            gt_label = torch.tensor(gt_label)
+        assert isinstance(
+            gt_label,
+            torch.Tensor,
+        ), f"Ground truth label must be a sequence of integers or a torch.Tensor, got {type(gt_label)}."
+        assert gt_label.ndim == 1, f"Ground truth label must be a 1-dimensional vector, got shape {gt_label.shape}."
+        assert (
+            len(gt_label) == self.batch_size
+        ), f"Ground truth label must have length {self.batch_size}, got length {len(gt_label)}."
+        assert not torch.is_floating_point(gt_label), f"Ground truth label must be boolean or integer, got {gt_label}."
+        return gt_label.bool()
+
+    def _validate_gt_mask(self, gt_mask: Mask | None) -> Mask | None:
+        if gt_mask is None:
+            return None
+        assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
+        assert gt_mask.ndim in {
+            2,
+            3,
+            4,
+        }, f"Ground truth mask must have shape [H, W] or [N, H, W] or [N, 1, H, W] got shape {gt_mask.shape}."
+        if gt_mask.ndim == 2:
+            assert (
+                self.batch_size == 1
+            ), f"Invalid shape for gt_mask. Got mask shape {gt_mask.shape} for batch size {self.batch_size}."
+            gt_mask = gt_mask.unsqueeze(0)
+        if gt_mask.ndim == 3:
+            assert (
+                gt_mask.shape[0] == self.batch_size
+            ), f"Invalid shape for gt_mask. Got mask shape {gt_mask.shape} for batch size {self.batch_size}."
+        if gt_mask.ndim == 4:
+            assert gt_mask.shape[1] == 1, f"Ground truth mask must have 1 channel, got {gt_mask.shape[1]}."
+            gt_mask = gt_mask.squeeze(1)
+        return Mask(gt_mask, dtype=torch.bool)
+
+    def _validate_mask_path(self, mask_path: Sequence[str] | Sequence[str] | None) -> list[str] | None:
+        if mask_path is None:
+            return None
+        assert isinstance(
+            mask_path,
+            Sequence,
+        ), f"Mask path must be a sequence of paths or strings, got {type(mask_path)}."
+        assert (
+            len(mask_path) == self.batch_size
+        ), f"Invalid length for mask_path. Got length {len(mask_path)} for batch size {self.batch_size}."
+        return [str(path) for path in mask_path]
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, torch.Tensor):
+            try:
+                anomaly_map = torch.tensor(anomaly_map)
+            except Exception as e:
+                msg = "Failed to convert anomaly_map to a torch.Tensor."
+                raise ValueError(msg) from e
+        assert anomaly_map.ndim in {
+            2,
+            3,
+            4,
+        }, f"Anomaly map must have shape [H, W] or [N, H, W] or [N, 1, H, W], got shape {anomaly_map.shape}."
+        if anomaly_map.ndim == 2:
+            assert (
+                self.batch_size == 1
+            ), f"Invalid shape for anomaly_map. Got mask shape {anomaly_map.shape} for batch size {self.batch_size}."
+            anomaly_map = anomaly_map.unsqueeze(0)
+        if anomaly_map.ndim == 4:
+            assert anomaly_map.shape[1] == 1, f"Anomaly map must have 1 channel, got {anomaly_map.shape[1]}."
+            anomaly_map = anomaly_map.squeeze(1)
+        return Mask(anomaly_map, dtype=torch.float32)
+
+    def _validate_pred_score(self, pred_score: torch.Tensor | None) -> torch.Tensor | None:
+        if pred_score is None and self.anomaly_map is not None:
+            return torch.amax(self.anomaly_map, dim=(-2, -1))
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor | None:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor | None:
+        return pred_label
+
+    def _validate_image_path(self, image_path: list[str]) -> list[str] | None:
+        return image_path
diff --git a/src/anomalib/data/dataclasses/torch/video.py b/src/anomalib/data/dataclasses/torch/video.py
new file mode 100644
index 0000000000..12a32dd471
--- /dev/null
+++ b/src/anomalib/data/dataclasses/torch/video.py
@@ -0,0 +1,170 @@
+"""Torch-based dataclasses for video data in Anomalib.
+
+This module provides PyTorch-based implementations of the generic dataclasses
+used in Anomalib for video data. These classes are designed to work with PyTorch
+tensors for efficient data handling and processing in anomaly detection tasks.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass, fields
+
+import torch
+from torchvision.tv_tensors import Image, Mask, Video
+
+from anomalib.data.dataclasses.generic import BatchIterateMixin, _VideoInputFields
+from anomalib.data.dataclasses.numpy.video import NumpyVideoBatch, NumpyVideoItem
+from anomalib.data.dataclasses.torch.base import Batch, DatasetItem, ToNumpyMixin
+from anomalib.data.dataclasses.torch.image import ImageItem
+
+
+@dataclass
+class VideoItem(
+    ToNumpyMixin[NumpyVideoItem],
+    _VideoInputFields[torch.Tensor, Video, Mask, str],
+    DatasetItem[Video],
+):
+    """Dataclass for individual video items in Anomalib datasets using PyTorch tensors.
+
+    This class represents a single video item in Anomalib datasets using PyTorch tensors.
+    It combines the functionality of ToNumpyMixin, _VideoInputFields, and DatasetItem
+    to handle video data, including frames, labels, masks, and metadata.
+
+    Examples:
+        >>> item = VideoItem(
+        ...     image=torch.rand(10, 3, 224, 224),  # 10 frames
+        ...     gt_label=torch.tensor(1),
+        ...     gt_mask=torch.rand(10, 224, 224) > 0.5,
+        ...     video_path="path/to/video.mp4"
+        ... )
+
+        >>> print(item.image.shape)
+        torch.Size([10, 3, 224, 224])
+
+        >>> numpy_item = item.to_numpy()
+        >>> print(type(numpy_item))
+        
+    """
+
+    numpy_class = NumpyVideoItem
+
+    def _validate_image(self, image: Image) -> Video:
+        return image
+
+    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: str) -> str:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor | None:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: torch.Tensor | None) -> torch.Tensor | None:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor | None:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor | None:
+        return pred_label
+
+    def _validate_original_image(self, original_image: Video) -> Video:
+        return original_image
+
+    def _validate_video_path(self, video_path: str) -> str:
+        return video_path
+
+    def _validate_target_frame(self, target_frame: torch.Tensor) -> torch.Tensor:
+        return target_frame
+
+    def _validate_frames(self, frames: torch.Tensor) -> torch.Tensor:
+        return frames
+
+    def _validate_last_frame(self, last_frame: torch.Tensor) -> torch.Tensor:
+        return last_frame
+
+    def to_image(self) -> ImageItem:
+        """Convert the video item to an image item."""
+        image_keys = [field.name for field in fields(ImageItem)]
+        return ImageItem(**{key: getattr(self, key, None) for key in image_keys})
+
+
+@dataclass
+class VideoBatch(
+    ToNumpyMixin[NumpyVideoBatch],
+    BatchIterateMixin[VideoItem],
+    _VideoInputFields[torch.Tensor, Video, Mask, list[str]],
+    Batch[Video],
+):
+    """Dataclass for batches of video items in Anomalib datasets using PyTorch tensors.
+
+    This class represents a batch of video items in Anomalib datasets using PyTorch tensors.
+    It combines the functionality of ToNumpyMixin, BatchIterateMixin, _VideoInputFields,
+    and Batch to handle batches of video data, including frames, labels, masks, and metadata.
+
+    Examples:
+        >>> batch = VideoBatch(
+        ...     image=torch.rand(32, 10, 3, 224, 224),  # 32 videos, 10 frames each
+        ...     gt_label=torch.randint(0, 2, (32,)),
+        ...     gt_mask=torch.rand(32, 10, 224, 224) > 0.5,
+        ...     video_path=["path/to/video_{}.mp4".format(i) for i in range(32)]
+        ... )
+
+        >>> print(batch.image.shape)
+        torch.Size([32, 10, 3, 224, 224])
+
+        >>> for item in batch:
+        ...     print(item.image.shape)
+        torch.Size([10, 3, 224, 224])
+
+        >>> numpy_batch = batch.to_numpy()
+        >>> print(type(numpy_batch))
+        
+    """
+
+    item_class = VideoItem
+    numpy_class = NumpyVideoBatch
+
+    def _validate_image(self, image: Image) -> Video:
+        return image
+
+    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+        return gt_label
+
+    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+        return gt_mask
+
+    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+        return mask_path
+
+    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
+        return anomaly_map
+
+    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
+        return pred_score
+
+    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
+        return pred_mask
+
+    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
+        return pred_label
+
+    def _validate_original_image(self, original_image: Video) -> Video:
+        return original_image
+
+    def _validate_video_path(self, video_path: list[str]) -> list[str]:
+        return video_path
+
+    def _validate_target_frame(self, target_frame: torch.Tensor) -> torch.Tensor:
+        return target_frame
+
+    def _validate_frames(self, frames: torch.Tensor) -> torch.Tensor:
+        return frames
+
+    def _validate_last_frame(self, last_frame: torch.Tensor) -> torch.Tensor:
+        return last_frame
diff --git a/src/anomalib/data/datamodules/__init__.py b/src/anomalib/data/datamodules/__init__.py
new file mode 100644
index 0000000000..c81666db5e
--- /dev/null
+++ b/src/anomalib/data/datamodules/__init__.py
@@ -0,0 +1,21 @@
+"""Anomalib Data Modules."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .depth import Folder3D, MVTec3D
+from .image import BTech, Folder, Kolektor, MVTec, Visa
+from .video import Avenue, ShanghaiTech, UCSDped
+
+__all__ = [
+    "Folder3D",
+    "MVTec3D",
+    "BTech",
+    "Folder",
+    "Kolektor",
+    "MVTec",
+    "Visa",
+    "Avenue",
+    "ShanghaiTech",
+    "UCSDped",
+]
diff --git a/src/anomalib/data/datamodules/base/__init__.py b/src/anomalib/data/datamodules/base/__init__.py
new file mode 100644
index 0000000000..b03babf685
--- /dev/null
+++ b/src/anomalib/data/datamodules/base/__init__.py
@@ -0,0 +1,9 @@
+"""Base Anomalib Data Modules."""
+
+# Copyright (C) 2022-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .image import AnomalibDataModule
+from .video import AnomalibVideoDataModule
+
+__all__ = ["AnomalibDataModule", "AnomalibVideoDataModule"]
diff --git a/src/anomalib/data/base/datamodule.py b/src/anomalib/data/datamodules/base/image.py
similarity index 99%
rename from src/anomalib/data/base/datamodule.py
rename to src/anomalib/data/datamodules/base/image.py
index d631433823..28fd9499eb 100644
--- a/src/anomalib/data/base/datamodule.py
+++ b/src/anomalib/data/datamodules/base/image.py
@@ -20,7 +20,7 @@
 if TYPE_CHECKING:
     from pandas import DataFrame
 
-    from anomalib.data.base.dataset import AnomalibDataset
+    from anomalib.data.datasets.base.image import AnomalibDataset
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/anomalib/data/datamodules/base/video.py b/src/anomalib/data/datamodules/base/video.py
new file mode 100644
index 0000000000..3bc7af6772
--- /dev/null
+++ b/src/anomalib/data/datamodules/base/video.py
@@ -0,0 +1,39 @@
+"""Base Video Data Module."""
+
+# Copyright (C) 2023-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from anomalib.data.utils import ValSplitMode
+
+from .image import AnomalibDataModule
+
+
+class AnomalibVideoDataModule(AnomalibDataModule):
+    """Base class for video data modules."""
+
+    def _create_test_split(self) -> None:
+        """Video datamodules do not support dynamic assignment of the test split."""
+
+    def _setup(self, _stage: str | None = None) -> None:
+        """Set up the datasets and perform dynamic subset splitting.
+
+        This method may be overridden in subclass for custom splitting behaviour.
+
+        Video datamodules are not compatible with synthetic anomaly generation.
+        """
+        if self.train_data is None:
+            msg = "self.train_data cannot be None."
+            raise ValueError(msg)
+
+        if self.test_data is None:
+            msg = "self.test_data cannot be None."
+            raise ValueError(msg)
+
+        self.train_data.setup()
+        self.test_data.setup()
+
+        if self.val_split_mode == ValSplitMode.SYNTHETIC:
+            msg = f"Val split mode {self.test_split_mode} not supported for video datasets."
+            raise ValueError(msg)
+
+        self._create_val_split()
diff --git a/src/anomalib/data/depth/__init__.py b/src/anomalib/data/datamodules/depth/__init__.py
similarity index 90%
rename from src/anomalib/data/depth/__init__.py
rename to src/anomalib/data/datamodules/depth/__init__.py
index 8720f5285d..b7f24ab8d1 100644
--- a/src/anomalib/data/depth/__init__.py
+++ b/src/anomalib/data/datamodules/depth/__init__.py
@@ -1,4 +1,4 @@
-"""Anomalib Depth Datasets."""
+"""Anomalib Depth Data Modules."""
 
 # Copyright (C) 2023 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/datamodules/depth/folder_3d.py b/src/anomalib/data/datamodules/depth/folder_3d.py
new file mode 100644
index 0000000000..cebea42d02
--- /dev/null
+++ b/src/anomalib/data/datamodules/depth/folder_3d.py
@@ -0,0 +1,165 @@
+"""Custom Folder Datamodule.
+
+This script creates a custom datamodule from a folder.
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datamodules.base.image import AnomalibDataModule
+from anomalib.data.datasets.depth.folder_3d import Folder3DDataset
+from anomalib.data.utils import Split, TestSplitMode, ValSplitMode
+
+
+class Folder3D(AnomalibDataModule):
+    """Folder DataModule.
+
+    Args:
+        name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
+        normal_dir (str | Path): Name of the directory containing normal images.
+        root (str | Path | None): Path to the root folder containing normal and abnormal dirs.
+            Defaults to ``None``.
+        abnormal_dir (str | Path | None): Name of the directory containing abnormal images.
+            Defaults to ``abnormal``.
+        normal_test_dir (str | Path | None, optional): Path to the directory containing normal images for the test
+            dataset.
+            Defaults to ``None``.
+        mask_dir (str | Path | None, optional): Path to the directory containing the mask annotations.
+            Defaults to ``None``.
+        normal_depth_dir (str | Path | None, optional): Path to the directory containing
+            normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir`
+        abnormal_depth_dir (str | Path | None, optional): Path to the directory containing
+            abnormal depth images for the test dataset.
+        normal_test_depth_dir (str | Path | None, optional): Path to the directory containing
+            normal depth images for the test dataset. Normal test images will be a split of `normal_dir`
+            if `None`. Defaults to None.
+        normal_split_ratio (float, optional): Ratio to split normal training images and add to the
+            test set in case test set doesn't contain any normal images.
+            Defaults to 0.2.
+        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the
+            directory. Defaults to None.
+        train_batch_size (int, optional): Training batch size.
+            Defaults to ``32``.
+        eval_batch_size (int, optional): Test batch size.
+            Defaults to ``32``.
+        num_workers (int, optional): Number of workers.
+            Defaults to ``8``.
+        task (TaskType, optional): Task type. Could be ``classification``, ``detection`` or ``segmentation``.
+            Defaults to ``TaskType.SEGMENTATION``.
+        image_size (tuple[int, int], optional): Size to which input images should be resized.
+            Defaults to ``None``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
+            Defaults to ``None``.
+        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
+            Defaults to ``None``.
+        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+            Defaults to ``TestSplitMode.FROM_DIR``.
+        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+            Defaults to ``0.2``.
+        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+            Defaults to ``ValSplitMode.FROM_TEST``.
+        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+            Defaults to ``0.5``.
+        seed (int | None, optional): Seed used during random subset splitting.
+            Defaults to ``None``.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        normal_dir: str | Path,
+        root: str | Path,
+        abnormal_dir: str | Path | None = None,
+        normal_test_dir: str | Path | None = None,
+        mask_dir: str | Path | None = None,
+        normal_depth_dir: str | Path | None = None,
+        abnormal_depth_dir: str | Path | None = None,
+        normal_test_depth_dir: str | Path | None = None,
+        extensions: tuple[str] | None = None,
+        train_batch_size: int = 32,
+        eval_batch_size: int = 32,
+        num_workers: int = 8,
+        task: TaskType | str = TaskType.SEGMENTATION,
+        image_size: tuple[int, int] | None = None,
+        transform: Transform | None = None,
+        train_transform: Transform | None = None,
+        eval_transform: Transform | None = None,
+        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
+        test_split_ratio: float = 0.2,
+        val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
+        val_split_ratio: float = 0.5,
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            train_batch_size=train_batch_size,
+            eval_batch_size=eval_batch_size,
+            num_workers=num_workers,
+            image_size=image_size,
+            transform=transform,
+            train_transform=train_transform,
+            eval_transform=eval_transform,
+            test_split_mode=test_split_mode,
+            test_split_ratio=test_split_ratio,
+            val_split_mode=val_split_mode,
+            val_split_ratio=val_split_ratio,
+            seed=seed,
+        )
+        self._name = name
+        self.task = TaskType(task)
+        self.root = Path(root)
+        self.normal_dir = normal_dir
+        self.abnormal_dir = abnormal_dir
+        self.normal_test_dir = normal_test_dir
+        self.mask_dir = mask_dir
+        self.normal_depth_dir = normal_depth_dir
+        self.abnormal_depth_dir = abnormal_depth_dir
+        self.normal_test_depth_dir = normal_test_depth_dir
+        self.extensions = extensions
+
+    def _setup(self, _stage: str | None = None) -> None:
+        self.train_data = Folder3DDataset(
+            name=self.name,
+            task=self.task,
+            transform=self.train_transform,
+            split=Split.TRAIN,
+            root=self.root,
+            normal_dir=self.normal_dir,
+            abnormal_dir=self.abnormal_dir,
+            normal_test_dir=self.normal_test_dir,
+            mask_dir=self.mask_dir,
+            normal_depth_dir=self.normal_depth_dir,
+            abnormal_depth_dir=self.abnormal_depth_dir,
+            normal_test_depth_dir=self.normal_test_depth_dir,
+            extensions=self.extensions,
+        )
+
+        self.test_data = Folder3DDataset(
+            name=self.name,
+            task=self.task,
+            transform=self.eval_transform,
+            split=Split.TEST,
+            root=self.root,
+            normal_dir=self.normal_dir,
+            abnormal_dir=self.abnormal_dir,
+            normal_test_dir=self.normal_test_dir,
+            normal_depth_dir=self.normal_depth_dir,
+            abnormal_depth_dir=self.abnormal_depth_dir,
+            normal_test_depth_dir=self.normal_test_depth_dir,
+            mask_dir=self.mask_dir,
+            extensions=self.extensions,
+        )
+
+    @property
+    def name(self) -> str:
+        """Name of the datamodule.
+
+        Folder3D datamodule overrides the name property to provide a custom name.
+        """
+        return self._name
diff --git a/src/anomalib/data/datamodules/depth/mvtec_3d.py b/src/anomalib/data/datamodules/depth/mvtec_3d.py
new file mode 100644
index 0000000000..1e5b90e917
--- /dev/null
+++ b/src/anomalib/data/datamodules/depth/mvtec_3d.py
@@ -0,0 +1,143 @@
+"""MVTec 3D-AD Datamodule (CC BY-NC-SA 4.0).
+
+Description:
+    This script contains PyTorch Dataset, Dataloader and PyTorch Lightning DataModule for the MVTec 3D-AD dataset.
+    If the dataset is not on the file system, the script downloads and extracts the dataset and create PyTorch data
+    objects.
+
+License:
+    MVTec 3D-AD dataset is released under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+        License (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
+
+Reference:
+    - Paul Bergmann, Xin Jin, David Sattlegger, Carsten Steger: The MVTec 3D-AD Dataset for Unsupervised 3D Anomaly
+        Detection and Localization in: Proceedings of the 17th International Joint Conference on Computer Vision,
+        Imaging and Computer Graphics Theory and Applications - Volume 5: VISAPP, 202-213, 2022, DOI: 10.5220/
+        0010865000003124.
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from pathlib import Path
+
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datamodules.base.image import AnomalibDataModule
+from anomalib.data.datasets.depth.mvtec_3d import MVTec3DDataset
+from anomalib.data.utils import (
+    DownloadInfo,
+    Split,
+    TestSplitMode,
+    ValSplitMode,
+    download_and_extract,
+)
+
+logger = logging.getLogger(__name__)
+
+
+DOWNLOAD_INFO = DownloadInfo(
+    name="mvtec_3d",
+    url="https://www.mydrive.ch/shares/45920/dd1eb345346df066c63b5c95676b961b/download/428824485-1643285832"
+    "/mvtec_3d_anomaly_detection.tar.xz",
+    hashsum="d8bb2800fbf3ac88e798da6ae10dc819",
+)
+
+
+class MVTec3D(AnomalibDataModule):
+    """MVTec Datamodule.
+
+    Args:
+        root (Path | str): Path to the root of the dataset
+            Defaults to ``"./datasets/MVTec3D"``.
+        category (str): Category of the MVTec dataset (e.g. "bottle" or "cable").
+            Defaults to ``bagel``.
+        train_batch_size (int, optional): Training batch size.
+            Defaults to ``32``.
+        eval_batch_size (int, optional): Test batch size.
+            Defaults to ``32``.
+        num_workers (int, optional): Number of workers.
+            Defaults to ``8``.
+        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
+            Defaults to ``TaskType.SEGMENTATION``.
+        image_size (tuple[int, int], optional): Size to which input images should be resized.
+            Defaults to ``None``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
+            Defaults to ``None``.
+        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
+            Defaults to ``None``.
+        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+            Defaults to ``TestSplitMode.FROM_DIR``.
+        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+            Defaults to ``0.2``.
+        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+            Defaults to ``ValSplitMode.SAME_AS_TEST``.
+        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+            Defaults to ``0.5``.
+        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+            Defaults to ``None``.
+    """
+
+    def __init__(
+        self,
+        root: Path | str = "./datasets/MVTec3D",
+        category: str = "bagel",
+        train_batch_size: int = 32,
+        eval_batch_size: int = 32,
+        num_workers: int = 8,
+        task: TaskType | str = TaskType.SEGMENTATION,
+        image_size: tuple[int, int] | None = None,
+        transform: Transform | None = None,
+        train_transform: Transform | None = None,
+        eval_transform: Transform | None = None,
+        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
+        test_split_ratio: float = 0.2,
+        val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
+        val_split_ratio: float = 0.5,
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            train_batch_size=train_batch_size,
+            eval_batch_size=eval_batch_size,
+            num_workers=num_workers,
+            image_size=image_size,
+            transform=transform,
+            train_transform=train_transform,
+            eval_transform=eval_transform,
+            test_split_mode=test_split_mode,
+            test_split_ratio=test_split_ratio,
+            val_split_mode=val_split_mode,
+            val_split_ratio=val_split_ratio,
+            seed=seed,
+        )
+
+        self.task = TaskType(task)
+        self.root = Path(root)
+        self.category = category
+
+    def _setup(self, _stage: str | None = None) -> None:
+        self.train_data = MVTec3DDataset(
+            task=self.task,
+            transform=self.train_transform,
+            split=Split.TRAIN,
+            root=self.root,
+            category=self.category,
+        )
+        self.test_data = MVTec3DDataset(
+            task=self.task,
+            transform=self.eval_transform,
+            split=Split.TEST,
+            root=self.root,
+            category=self.category,
+        )
+
+    def prepare_data(self) -> None:
+        """Download the dataset if not available."""
+        if (self.root / self.category).is_dir():
+            logger.info("Found the dataset.")
+        else:
+            download_and_extract(self.root, DOWNLOAD_INFO)
diff --git a/src/anomalib/data/image/__init__.py b/src/anomalib/data/datamodules/image/__init__.py
similarity index 84%
rename from src/anomalib/data/image/__init__.py
rename to src/anomalib/data/datamodules/image/__init__.py
index 0bea0f07ad..ca57cf6868 100644
--- a/src/anomalib/data/image/__init__.py
+++ b/src/anomalib/data/datamodules/image/__init__.py
@@ -1,7 +1,4 @@
-"""Anomalib Image Datasets.
-
-This module contains the supported image datasets for Anomalib.
-"""
+"""Anomalib Image Data Modules."""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/image/btech.py b/src/anomalib/data/datamodules/image/btech.py
similarity index 61%
rename from src/anomalib/data/image/btech.py
rename to src/anomalib/data/datamodules/image/btech.py
index 9cceacf947..5abda6156e 100644
--- a/src/anomalib/data/image/btech.py
+++ b/src/anomalib/data/datamodules/image/btech.py
@@ -1,4 +1,4 @@
-"""BTech Dataset.
+"""BTech Data Module.
 
 This script contains PyTorch Lightning DataModule for the BTech dataset.
 
@@ -14,21 +14,18 @@
 from pathlib import Path
 
 import cv2
-import pandas as pd
-from pandas.core.frame import DataFrame
 from torchvision.transforms.v2 import Transform
 from tqdm import tqdm
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibDataModule, AnomalibDataset
+from anomalib.data.datamodules.base.image import AnomalibDataModule
+from anomalib.data.datasets.image.btech import BTechDataset
 from anomalib.data.utils import (
     DownloadInfo,
-    LabelName,
     Split,
     TestSplitMode,
     ValSplitMode,
     download_and_extract,
-    validate_path,
 )
 
 logger = logging.getLogger(__name__)
@@ -39,144 +36,6 @@
     hashsum="461c9387e515bfed41ecaae07c50cf6b10def647b36c9e31d239ab2736b10d2a",
 )
 
-CATEGORIES = ("01", "02", "03")
-
-
-def make_btech_dataset(path: Path, split: str | Split | None = None) -> DataFrame:
-    """Create BTech samples by parsing the BTech data file structure.
-
-    The files are expected to follow the structure:
-
-        .. code-block:: bash
-
-            path/to/dataset/split/category/image_filename.png
-            path/to/dataset/ground_truth/category/mask_filename.png
-
-    Args:
-        path (Path): Path to dataset
-        split (str | Split | None, optional): Dataset split (ie., either train or test).
-            Defaults to ``None``.
-
-    Example:
-        The following example shows how to get training samples from BTech 01 category:
-
-        .. code-block:: python
-
-            >>> root = Path('./BTech')
-            >>> category = '01'
-            >>> path = root / category
-            >>> path
-            PosixPath('BTech/01')
-
-            >>> samples = make_btech_dataset(path, split='train')
-            >>> samples.head()
-            path     split label image_path                  mask_path                     label_index
-            0  BTech/01 train 01    BTech/01/train/ok/105.bmp BTech/01/ground_truth/ok/105.png      0
-            1  BTech/01 train 01    BTech/01/train/ok/017.bmp BTech/01/ground_truth/ok/017.png      0
-            ...
-
-    Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
-    """
-    path = validate_path(path)
-
-    samples_list = [
-        (str(path),) + filename.parts[-3:] for filename in path.glob("**/*") if filename.suffix in {".bmp", ".png"}
-    ]
-    if not samples_list:
-        msg = f"Found 0 images in {path}"
-        raise RuntimeError(msg)
-
-    samples = pd.DataFrame(samples_list, columns=["path", "split", "label", "image_path"])
-    samples = samples[samples.split != "ground_truth"]
-
-    # Create mask_path column
-    # (safely handles cases where non-mask image_paths end with either .png or .bmp)
-    samples["mask_path"] = (
-        samples.path
-        + "/ground_truth/"
-        + samples.label
-        + "/"
-        + samples.image_path.str.rstrip("png").str.rstrip(".").str.rstrip("bmp").str.rstrip(".")
-        + ".png"
-    )
-
-    # Modify image_path column by converting to absolute path
-    samples["image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.image_path
-
-    # Good images don't have mask
-    samples.loc[(samples.split == "test") & (samples.label == "ok"), "mask_path"] = ""
-
-    # Create label index for normal (0) and anomalous (1) images.
-    samples.loc[(samples.label == "ok"), "label_index"] = LabelName.NORMAL
-    samples.loc[(samples.label != "ok"), "label_index"] = LabelName.ABNORMAL
-    samples.label_index = samples.label_index.astype(int)
-
-    # Get the data frame for the split.
-    if split:
-        samples = samples[samples.split == split]
-        samples = samples.reset_index(drop=True)
-
-    return samples
-
-
-class BTechDataset(AnomalibDataset):
-    """Btech Dataset class.
-
-    Args:
-        root: Path to the BTech dataset
-        category: Name of the BTech category.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split: 'train', 'val' or 'test'
-        task: ``classification``, ``detection`` or ``segmentation``
-        create_validation_set: Create a validation subset in addition to the train and test subsets
-
-    Examples:
-        >>> from anomalib.data.image.btech import BTechDataset
-        >>> from anomalib.data.utils.transforms import get_transforms
-        >>> transform = get_transforms(image_size=256)
-        >>> dataset = BTechDataset(
-        ...     task="classification",
-        ...     transform=transform,
-        ...     root='./datasets/BTech',
-        ...     category='01',
-        ... )
-        >>> dataset[0].keys()
-        >>> dataset.setup()
-        dict_keys(['image'])
-
-        >>> dataset.split = "test"
-        >>> dataset[0].keys()
-        dict_keys(['image', 'image_path', 'label'])
-
-        >>> dataset.task = "segmentation"
-        >>> dataset.split = "train"
-        >>> dataset[0].keys()
-        dict_keys(['image'])
-
-        >>> dataset.split = "test"
-        >>> dataset[0].keys()
-        dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
-
-        >>> dataset[0]["image"].shape, dataset[0]["mask"].shape
-        (torch.Size([3, 256, 256]), torch.Size([256, 256]))
-    """
-
-    def __init__(
-        self,
-        root: str | Path,
-        category: str,
-        transform: Transform | None = None,
-        split: str | Split | None = None,
-        task: TaskType | str = TaskType.SEGMENTATION,
-    ) -> None:
-        super().__init__(task, transform)
-
-        self.root_category = Path(root) / category
-        self.split = split
-        self.samples = make_btech_dataset(path=self.root_category, split=self.split)
-
 
 class BTech(AnomalibDataModule):
     """BTech Lightning Data Module.
diff --git a/src/anomalib/data/datamodules/image/folder.py b/src/anomalib/data/datamodules/image/folder.py
new file mode 100644
index 0000000000..7941ba2f7b
--- /dev/null
+++ b/src/anomalib/data/datamodules/image/folder.py
@@ -0,0 +1,218 @@
+"""Custom Folder Data Module.
+
+This script creates a custom Lightning DataModule from a folder.
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+from pathlib import Path
+
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datamodules.base.image import AnomalibDataModule
+from anomalib.data.datasets.image.folder import FolderDataset
+from anomalib.data.utils import Split, TestSplitMode, ValSplitMode
+
+
+class Folder(AnomalibDataModule):
+    """Folder DataModule.
+
+    Args:
+        name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
+        normal_dir (str | Path | Sequence): Name of the directory containing normal images.
+        root (str | Path | None): Path to the root folder containing normal and abnormal dirs.
+            Defaults to ``None``.
+        abnormal_dir (str | Path | None | Sequence): Name of the directory containing abnormal images.
+            Defaults to ``None``.
+        normal_test_dir (str | Path | Sequence | None, optional): Path to the directory containing
+            normal images for the test dataset.
+            Defaults to ``None``.
+        mask_dir (str | Path | Sequence | None, optional): Path to the directory containing
+            the mask annotations.
+            Defaults to ``None``.
+        normal_split_ratio (float, optional): Ratio to split normal training images and add to the
+            test set in case test set doesn't contain any normal images.
+            Defaults to 0.2.
+        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the
+            directory.
+            Defaults to ``None``.
+        train_batch_size (int, optional): Training batch size.
+            Defaults to ``32``.
+        eval_batch_size (int, optional): Validation, test and predict batch size.
+            Defaults to ``32``.
+        num_workers (int, optional): Number of workers.
+            Defaults to ``8``.
+        task (TaskType, optional): Task type. Could be ``classification``, ``detection`` or ``segmentation``.
+            Defaults to ``segmentation``.
+        image_size (tuple[int, int], optional): Size to which input images should be resized.
+            Defaults to ``None``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
+            Defaults to ``None``.
+        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
+            Defaults to ``None``.
+        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+            Defaults to ``TestSplitMode.FROM_DIR``.
+        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+            Defaults to ``0.2``.
+        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+            Defaults to ``ValSplitMode.FROM_TEST``.
+        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+            Defaults to ``0.5``.
+        seed (int | None, optional): Seed used during random subset splitting.
+            Defaults to ``None``.
+
+    Examples:
+        The following code demonstrates how to use the ``Folder`` datamodule. Assume that the dataset is structured
+        as follows:
+
+        .. code-block:: bash
+
+            $ tree sample_dataset
+            sample_dataset
+            ├── colour
+            │   ├── 00.jpg
+            │   ├── ...
+            │   └── x.jpg
+            ├── crack
+            │   ├── 00.jpg
+            │   ├── ...
+            │   └── y.jpg
+            ├── good
+            │   ├── ...
+            │   └── z.jpg
+            ├── LICENSE
+            └── mask
+                ├── colour
+                │   ├── ...
+                │   └── x.jpg
+                └── crack
+                    ├── ...
+                    └── y.jpg
+
+        .. code-block:: python
+
+            folder_datamodule = Folder(
+                root=dataset_root,
+                normal_dir="good",
+                abnormal_dir="crack",
+                task=TaskType.SEGMENTATION,
+                mask_dir=dataset_root / "mask" / "crack",
+                image_size=256,
+                normalization=InputNormalizationMethod.NONE,
+            )
+            folder_datamodule.setup()
+
+        To access the training images,
+
+        .. code-block:: python
+
+            >> i, data = next(enumerate(folder_datamodule.train_dataloader()))
+            >> print(data.keys(), data["image"].shape)
+
+        To access the test images,
+
+        .. code-block:: python
+
+            >> i, data = next(enumerate(folder_datamodule.test_dataloader()))
+            >> print(data.keys(), data["image"].shape)
+    """
+
+    def __init__(
+        self,
+        name: str,
+        normal_dir: str | Path | Sequence[str | Path],
+        root: str | Path | None = None,
+        abnormal_dir: str | Path | Sequence[str | Path] | None = None,
+        normal_test_dir: str | Path | Sequence[str | Path] | None = None,
+        mask_dir: str | Path | Sequence[str | Path] | None = None,
+        normal_split_ratio: float = 0.2,
+        extensions: tuple[str] | None = None,
+        train_batch_size: int = 32,
+        eval_batch_size: int = 32,
+        num_workers: int = 8,
+        task: TaskType | str = TaskType.SEGMENTATION,
+        image_size: tuple[int, int] | None = None,
+        transform: Transform | None = None,
+        train_transform: Transform | None = None,
+        eval_transform: Transform | None = None,
+        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
+        test_split_ratio: float = 0.2,
+        val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
+        val_split_ratio: float = 0.5,
+        seed: int | None = None,
+    ) -> None:
+        self._name = name
+        self.root = root
+        self.normal_dir = normal_dir
+        self.abnormal_dir = abnormal_dir
+        self.normal_test_dir = normal_test_dir
+        self.mask_dir = mask_dir
+        self.task = TaskType(task)
+        self.extensions = extensions
+        test_split_mode = TestSplitMode(test_split_mode)
+        val_split_mode = ValSplitMode(val_split_mode)
+        super().__init__(
+            train_batch_size=train_batch_size,
+            eval_batch_size=eval_batch_size,
+            num_workers=num_workers,
+            test_split_mode=test_split_mode,
+            test_split_ratio=test_split_ratio,
+            val_split_mode=val_split_mode,
+            val_split_ratio=val_split_ratio,
+            image_size=image_size,
+            transform=transform,
+            train_transform=train_transform,
+            eval_transform=eval_transform,
+            seed=seed,
+        )
+
+        if task == TaskType.SEGMENTATION and test_split_mode == TestSplitMode.FROM_DIR and mask_dir is None:
+            msg = (
+                f"Segmentation task requires mask directory if test_split_mode is {test_split_mode}. "
+                "You could set test_split_mode to {TestSplitMode.NONE} or provide a mask directory."
+            )
+            raise ValueError(
+                msg,
+            )
+
+        self.normal_split_ratio = normal_split_ratio
+
+    def _setup(self, _stage: str | None = None) -> None:
+        self.train_data = FolderDataset(
+            name=self.name,
+            task=self.task,
+            transform=self.train_transform,
+            split=Split.TRAIN,
+            root=self.root,
+            normal_dir=self.normal_dir,
+            abnormal_dir=self.abnormal_dir,
+            normal_test_dir=self.normal_test_dir,
+            mask_dir=self.mask_dir,
+            extensions=self.extensions,
+        )
+
+        self.test_data = FolderDataset(
+            name=self.name,
+            task=self.task,
+            transform=self.eval_transform,
+            split=Split.TEST,
+            root=self.root,
+            normal_dir=self.normal_dir,
+            abnormal_dir=self.abnormal_dir,
+            normal_test_dir=self.normal_test_dir,
+            mask_dir=self.mask_dir,
+            extensions=self.extensions,
+        )
+
+    @property
+    def name(self) -> str:
+        """Name of the datamodule.
+
+        Folder datamodule overrides the name property to provide a custom name.
+        """
+        return self._name
diff --git a/src/anomalib/data/datamodules/image/kolektor.py b/src/anomalib/data/datamodules/image/kolektor.py
new file mode 100644
index 0000000000..2f8dc3b92b
--- /dev/null
+++ b/src/anomalib/data/datamodules/image/kolektor.py
@@ -0,0 +1,175 @@
+"""Kolektor Surface-Defect Data Module.
+
+Description:
+    This script provides a PyTorch DataModule for the Kolektor
+    Surface-Defect dataset. The dataset can be accessed at `Kolektor Surface-Defect Dataset `_.
+
+License:
+    The Kolektor Surface-Defect dataset is released under the Creative Commons Attribution-NonCommercial-ShareAlike
+    4.0 International License (CC BY-NC-SA 4.0). For more details, visit
+    `Creative Commons License `_.
+
+Reference:
+    Tabernik, Domen, Samo Šela, Jure Skvarč, and Danijel Skočaj. "Segmentation-based deep-learning approach
+    for surface-defect detection." Journal of Intelligent Manufacturing 31, no. 3 (2020): 759-776.
+"""
+
+# Copyright (C) 2023-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from pathlib import Path
+
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datamodules.base.image import AnomalibDataModule
+from anomalib.data.datasets.image.kolektor import KolektorDataset
+from anomalib.data.utils import (
+    DownloadInfo,
+    Split,
+    TestSplitMode,
+    ValSplitMode,
+    download_and_extract,
+)
+
+logger = logging.getLogger(__name__)
+
+DOWNLOAD_INFO = DownloadInfo(
+    name="kolektor",
+    url="https://go.vicos.si/kolektorsdd",
+    hashsum="65dc621693418585de9c4467d1340ea7958a6181816f0dc2883a1e8b61f9d4dc",
+    filename="KolektorSDD.zip",
+)
+
+
+class Kolektor(AnomalibDataModule):
+    """Kolektor Datamodule.
+
+    Args:
+        root (Path | str): Path to the root of the dataset
+        train_batch_size (int, optional): Training batch size.
+            Defaults to ``32``.
+        eval_batch_size (int, optional): Test batch size.
+            Defaults to ``32``.
+        num_workers (int, optional): Number of workers.
+            Defaults to ``8``.
+        task TaskType): Task type, 'classification', 'detection' or 'segmentation'
+            Defaults to ``TaskType.SEGMENTATION``.
+        image_size (tuple[int, int], optional): Size to which input images should be resized.
+            Defaults to ``None``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
+            Defaults to ``None``.
+        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
+            Defaults to ``None``.
+        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+            Defaults to ``TestSplitMode.FROM_DIR``
+        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+            Defaults to ``0.2``
+        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+            Defaults to ``ValSplitMode.SAME_AS_TEST``
+        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+            Defaults to ``0.5``
+        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+            Defaults to ``None``.
+    """
+
+    def __init__(
+        self,
+        root: Path | str = "./datasets/kolektor",
+        train_batch_size: int = 32,
+        eval_batch_size: int = 32,
+        num_workers: int = 8,
+        task: TaskType | str = TaskType.SEGMENTATION,
+        image_size: tuple[int, int] | None = None,
+        transform: Transform | None = None,
+        train_transform: Transform | None = None,
+        eval_transform: Transform | None = None,
+        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
+        test_split_ratio: float = 0.2,
+        val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
+        val_split_ratio: float = 0.5,
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            train_batch_size=train_batch_size,
+            eval_batch_size=eval_batch_size,
+            num_workers=num_workers,
+            image_size=image_size,
+            transform=transform,
+            train_transform=train_transform,
+            eval_transform=eval_transform,
+            test_split_mode=test_split_mode,
+            test_split_ratio=test_split_ratio,
+            val_split_mode=val_split_mode,
+            val_split_ratio=val_split_ratio,
+            seed=seed,
+        )
+
+        self.task = TaskType(task)
+        self.root = Path(root)
+
+    def _setup(self, _stage: str | None = None) -> None:
+        self.train_data = KolektorDataset(
+            task=self.task,
+            transform=self.train_transform,
+            split=Split.TRAIN,
+            root=self.root,
+        )
+        self.test_data = KolektorDataset(
+            task=self.task,
+            transform=self.eval_transform,
+            split=Split.TEST,
+            root=self.root,
+        )
+
+    def prepare_data(self) -> None:
+        """Download the dataset if not available.
+
+        This method checks if the specified dataset is available in the file system.
+        If not, it downloads and extracts the dataset into the appropriate directory.
+
+        Example:
+            Assume the dataset is not available on the file system.
+            Here's how the directory structure looks before and after calling the
+            `prepare_data` method:
+
+            Before:
+
+            .. code-block:: bash
+
+                $ tree datasets
+                datasets
+                ├── dataset1
+                └── dataset2
+
+            Calling the method:
+
+            .. code-block:: python
+
+                >> datamodule = Kolektor(root="./datasets/kolektor")
+                >> datamodule.prepare_data()
+
+            After:
+
+            .. code-block:: bash
+
+                $ tree datasets
+                datasets
+                ├── dataset1
+                ├── dataset2
+                └── kolektor
+                    ├── kolektorsdd
+                    ├── kos01
+                    ├── ...
+                    └── kos50
+                        ├── Part0.jpg
+                        ├── Part0_label.bmp
+                        └── ...
+        """
+        if (self.root).is_dir():
+            logger.info("Found the dataset.")
+        else:
+            download_and_extract(self.root, DOWNLOAD_INFO)
diff --git a/src/anomalib/data/image/mvtec.py b/src/anomalib/data/datamodules/image/mvtec.py
similarity index 52%
rename from src/anomalib/data/image/mvtec.py
rename to src/anomalib/data/datamodules/image/mvtec.py
index c2cdc69755..508a582380 100644
--- a/src/anomalib/data/image/mvtec.py
+++ b/src/anomalib/data/datamodules/image/mvtec.py
@@ -1,9 +1,9 @@
-"""MVTec AD Dataset (CC BY-NC-SA 4.0).
+"""MVTec AD Data Module.
 
 Description:
-    This script contains PyTorch Dataset, Dataloader and PyTorch Lightning
-    DataModule for the MVTec AD dataset. If the dataset is not on the file system,
-    the script downloads and extracts the dataset and create PyTorch data objects.
+    This script contains PyTorch Lightning DataModule for the MVTec AD dataset.
+    If the dataset is not on the file system, the script downloads and extracts
+    the dataset and create PyTorch data objects.
 
 License:
     MVTec AD dataset is released under the Creative Commons
@@ -26,30 +26,24 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
-from collections.abc import Sequence
 from pathlib import Path
 
-from pandas import DataFrame
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibDataModule, AnomalibDataset
-from anomalib.data.errors import MisMatchError
+from anomalib.data.datamodules.base.image import AnomalibDataModule
+from anomalib.data.datasets.image.mvtec import MVTecDataset
 from anomalib.data.utils import (
     DownloadInfo,
-    LabelName,
     Split,
     TestSplitMode,
     ValSplitMode,
     download_and_extract,
-    validate_path,
 )
 
 logger = logging.getLogger(__name__)
 
 
-IMG_EXTENSIONS = (".png", ".PNG")
-
 DOWNLOAD_INFO = DownloadInfo(
     name="mvtec",
     url="https://www.mydrive.ch/shares/38536/3830184030e49fe74747669442f0f282/download/420938113-1629952094"
@@ -57,183 +51,6 @@
     hashsum="cf4313b13603bec67abb49ca959488f7eedce2a9f7795ec54446c649ac98cd3d",
 )
 
-CATEGORIES = (
-    "bottle",
-    "cable",
-    "capsule",
-    "carpet",
-    "grid",
-    "hazelnut",
-    "leather",
-    "metal_nut",
-    "pill",
-    "screw",
-    "tile",
-    "toothbrush",
-    "transistor",
-    "wood",
-    "zipper",
-)
-
-
-def make_mvtec_dataset(
-    root: str | Path,
-    split: str | Split | None = None,
-    extensions: Sequence[str] | None = None,
-) -> DataFrame:
-    """Create MVTec AD samples by parsing the MVTec AD data file structure.
-
-    The files are expected to follow the structure:
-        path/to/dataset/split/category/image_filename.png
-        path/to/dataset/ground_truth/category/mask_filename.png
-
-    This function creates a dataframe to store the parsed information based on the following format:
-
-    +---+---------------+-------+---------+---------------+---------------------------------------+-------------+
-    |   | path          | split | label   | image_path    | mask_path                             | label_index |
-    +===+===============+=======+=========+===============+=======================================+=============+
-    | 0 | datasets/name | test  | defect  | filename.png  | ground_truth/defect/filename_mask.png | 1           |
-    +---+---------------+-------+---------+---------------+---------------------------------------+-------------+
-
-    Args:
-        root (Path): Path to dataset
-        split (str | Split | None, optional): Dataset split (ie., either train or test).
-            Defaults to ``None``.
-        extensions (Sequence[str] | None, optional): List of file extensions to be included in the dataset.
-            Defaults to ``None``.
-
-    Examples:
-        The following example shows how to get training samples from MVTec AD bottle category:
-
-        >>> root = Path('./MVTec')
-        >>> category = 'bottle'
-        >>> path = root / category
-        >>> path
-        PosixPath('MVTec/bottle')
-
-        >>> samples = make_mvtec_dataset(path, split='train', split_ratio=0.1, seed=0)
-        >>> samples.head()
-           path         split label image_path                           mask_path                   label_index
-        0  MVTec/bottle train good MVTec/bottle/train/good/105.png MVTec/bottle/ground_truth/good/105_mask.png 0
-        1  MVTec/bottle train good MVTec/bottle/train/good/017.png MVTec/bottle/ground_truth/good/017_mask.png 0
-        2  MVTec/bottle train good MVTec/bottle/train/good/137.png MVTec/bottle/ground_truth/good/137_mask.png 0
-        3  MVTec/bottle train good MVTec/bottle/train/good/152.png MVTec/bottle/ground_truth/good/152_mask.png 0
-        4  MVTec/bottle train good MVTec/bottle/train/good/109.png MVTec/bottle/ground_truth/good/109_mask.png 0
-
-    Returns:
-        DataFrame: an output dataframe containing the samples of the dataset.
-    """
-    if extensions is None:
-        extensions = IMG_EXTENSIONS
-
-    root = validate_path(root)
-    samples_list = [(str(root),) + f.parts[-3:] for f in root.glob(r"**/*") if f.suffix in extensions]
-    if not samples_list:
-        msg = f"Found 0 images in {root}"
-        raise RuntimeError(msg)
-
-    samples = DataFrame(samples_list, columns=["path", "split", "label", "image_path"])
-
-    # Modify image_path column by converting to absolute path
-    samples["image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.image_path
-
-    # Create label index for normal (0) and anomalous (1) images.
-    samples.loc[(samples.label == "good"), "label_index"] = LabelName.NORMAL
-    samples.loc[(samples.label != "good"), "label_index"] = LabelName.ABNORMAL
-    samples.label_index = samples.label_index.astype(int)
-
-    # separate masks from samples
-    mask_samples = samples.loc[samples.split == "ground_truth"].sort_values(by="image_path", ignore_index=True)
-    samples = samples[samples.split != "ground_truth"].sort_values(by="image_path", ignore_index=True)
-
-    # assign mask paths to anomalous test images
-    samples["mask_path"] = ""
-    samples.loc[
-        (samples.split == "test") & (samples.label_index == LabelName.ABNORMAL),
-        "mask_path",
-    ] = mask_samples.image_path.to_numpy()
-
-    # assert that the right mask files are associated with the right test images
-    abnormal_samples = samples.loc[samples.label_index == LabelName.ABNORMAL]
-    if (
-        len(abnormal_samples)
-        and not abnormal_samples.apply(lambda x: Path(x.image_path).stem in Path(x.mask_path).stem, axis=1).all()
-    ):
-        msg = """Mismatch between anomalous images and ground truth masks. Make sure t
-        he mask files in 'ground_truth' folder follow the same naming convention as the
-        anomalous images in the dataset (e.g. image: '000.png', mask: '000.png' or '000_mask.png')."""
-        raise MisMatchError(msg)
-
-    if split:
-        samples = samples[samples.split == split].reset_index(drop=True)
-
-    return samples
-
-
-class MVTecDataset(AnomalibDataset):
-    """MVTec dataset class.
-
-    Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
-        root (Path | str): Path to the root of the dataset.
-            Defaults to ``./datasets/MVTec``.
-        category (str): Sub-category of the dataset, e.g. 'bottle'
-            Defaults to ``bottle``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
-            Defaults to ``None``.
-
-    Examples:
-        .. code-block:: python
-
-            from anomalib.data.image.mvtec import MVTecDataset
-            from anomalib.data.utils.transforms import get_transforms
-
-            transform = get_transforms(image_size=256)
-            dataset = MVTecDataset(
-                task="classification",
-                transform=transform,
-                root='./datasets/MVTec',
-                category='zipper',
-            )
-            dataset.setup()
-            print(dataset[0].keys())
-            # Output: dict_keys(['image_path', 'label', 'image'])
-
-        When the task is segmentation, the dataset will also contain the mask:
-
-        .. code-block:: python
-
-            dataset.task = "segmentation"
-            dataset.setup()
-            print(dataset[0].keys())
-            # Output: dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask'])
-
-        The image is a torch tensor of shape (C, H, W) and the mask is a torch tensor of shape (H, W).
-
-        .. code-block:: python
-
-            print(dataset[0]["image"].shape, dataset[0]["mask"].shape)
-            # Output: (torch.Size([3, 256, 256]), torch.Size([256, 256]))
-
-    """
-
-    def __init__(
-        self,
-        task: TaskType,
-        root: Path | str = "./datasets/MVTec",
-        category: str = "bottle",
-        transform: Transform | None = None,
-        split: str | Split | None = None,
-    ) -> None:
-        super().__init__(task=task, transform=transform)
-
-        self.root_category = Path(root) / Path(category)
-        self.category = category
-        self.split = split
-        self.samples = make_mvtec_dataset(self.root_category, split=self.split, extensions=IMG_EXTENSIONS)
-
 
 class MVTec(AnomalibDataModule):
     """MVTec Datamodule.
diff --git a/src/anomalib/data/image/visa.py b/src/anomalib/data/datamodules/image/visa.py
similarity index 76%
rename from src/anomalib/data/image/visa.py
rename to src/anomalib/data/datamodules/image/visa.py
index a788803370..30bf945c73 100644
--- a/src/anomalib/data/image/visa.py
+++ b/src/anomalib/data/datamodules/image/visa.py
@@ -1,14 +1,15 @@
-"""Visual Anomaly (VisA) Dataset (CC BY-NC-SA 4.0).
+"""Visual Anomaly (VisA) Data Module.
 
 Description:
-    This script contains PyTorch Dataset, Dataloader and PyTorch
-        Lightning DataModule for the Visual Anomal (VisA) dataset.
-    If the dataset is not on the file system, the script downloads and
-        extracts the dataset and create PyTorch data objects.
+    This script contains PyTorch Lightning DataModule for the Visual Anomal
+    (VisA) dataset. If the dataset is not on the file system, the script
+    downloads and extracts the dataset and create PyTorch data objects.
+
 License:
     The VisA dataset is released under the Creative Commons
     Attribution-NonCommercial-ShareAlike 4.0 International License
     (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
+
 Reference:
     - Zou, Y., Jeong, J., Pemula, L., Zhang, D., & Dabeer, O. (2022). SPot-the-Difference
       Self-supervised Pre-training for Anomaly Detection and Segmentation. In European
@@ -30,7 +31,8 @@
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibDataModule, AnomalibDataset
+from anomalib.data.datamodules.base.image import AnomalibDataModule
+from anomalib.data.datasets.image.visa import VisaDataset
 from anomalib.data.utils import (
     DownloadInfo,
     Split,
@@ -39,107 +41,14 @@
     download_and_extract,
 )
 
-from .mvtec import make_mvtec_dataset
-
 logger = logging.getLogger(__name__)
 
-EXTENSIONS = (".png", ".jpg", ".JPG")
-
 DOWNLOAD_INFO = DownloadInfo(
     name="VisA",
     url="https://amazon-visual-anomaly.s3.us-west-2.amazonaws.com/VisA_20220922.tar",
     hashsum="2eb8690c803ab37de0324772964100169ec8ba1fa3f7e94291c9ca673f40f362",
 )
 
-CATEGORIES = (
-    "candle",
-    "capsules",
-    "cashew",
-    "chewinggum",
-    "fryum",
-    "macaroni1",
-    "macaroni2",
-    "pcb1",
-    "pcb2",
-    "pcb3",
-    "pcb4",
-    "pipe_fryum",
-)
-
-
-class VisaDataset(AnomalibDataset):
-    """VisA dataset class.
-
-    Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``
-        root (str | Path): Path to the root of the dataset
-        category (str): Sub-category of the dataset, e.g. 'candle'
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
-            Defaults to ``None``.
-
-    Examples:
-        To create a Visa dataset for classification:
-
-        .. code-block:: python
-
-            from anomalib.data.image.visa import VisaDataset
-            from anomalib.data.utils.transforms import get_transforms
-
-            transform = get_transforms(image_size=256)
-            dataset = VisaDataset(
-                task="classification",
-                transform=transform,
-                split="train",
-                root="./datasets/visa/visa_pytorch/",
-                category="candle",
-            )
-            dataset.setup()
-            dataset[0].keys()
-
-            # Output
-            dict_keys(['image_path', 'label', 'image'])
-
-        If you want to use the dataset for segmentation, you can use the same
-        code as above, with the task set to ``segmentation``. The dataset will
-        then have a ``mask`` key in the output dictionary.
-
-        .. code-block:: python
-
-            from anomalib.data.image.visa import VisaDataset
-            from anomalib.data.utils.transforms import get_transforms
-
-            transform = get_transforms(image_size=256)
-            dataset = VisaDataset(
-                task="segmentation",
-                transform=transform,
-                split="train",
-                root="./datasets/visa/visa_pytorch/",
-                category="candle",
-            )
-            dataset.setup()
-            dataset[0].keys()
-
-            # Output
-            dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask'])
-
-    """
-
-    def __init__(
-        self,
-        task: TaskType,
-        root: str | Path,
-        category: str,
-        transform: Transform | None = None,
-        split: str | Split | None = None,
-    ) -> None:
-        super().__init__(task=task, transform=transform)
-
-        self.root_category = Path(root) / category
-        self.split = split
-        self.samples = make_mvtec_dataset(self.root_category, split=self.split, extensions=EXTENSIONS)
-
 
 class Visa(AnomalibDataModule):
     """VisA Datamodule.
diff --git a/src/anomalib/data/video/__init__.py b/src/anomalib/data/datamodules/video/__init__.py
similarity index 92%
rename from src/anomalib/data/video/__init__.py
rename to src/anomalib/data/datamodules/video/__init__.py
index 3578f2379d..f9b3763525 100644
--- a/src/anomalib/data/video/__init__.py
+++ b/src/anomalib/data/datamodules/video/__init__.py
@@ -1,4 +1,4 @@
-"""Anomalib Video Datasets."""
+"""Anomalib Video Data Modules."""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/video/avenue.py b/src/anomalib/data/datamodules/video/avenue.py
similarity index 60%
rename from src/anomalib/data/video/avenue.py
rename to src/anomalib/data/datamodules/video/avenue.py
index 831caa4021..8914475081 100644
--- a/src/anomalib/data/video/avenue.py
+++ b/src/anomalib/data/datamodules/video/avenue.py
@@ -1,7 +1,7 @@
-"""CUHK Avenue Dataset.
+"""CUHK Avenue Data Module.
 
 Description:
-    This module provides a PyTorch Dataset and PyTorch Lightning DataModule for the CUHK Avenue dataset.
+    This module provides a PyTorch Lightning DataModule for the CUHK Avenue dataset.
     If the dataset is not already present on the file system, the DataModule class will download and
     extract the dataset, converting the .mat mask files to .png format.
 
@@ -14,36 +14,25 @@
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-__all__ = ["Avenue", "AvenueDataset", "make_avenue_dataset"]
-
 import logging
 import math
 from pathlib import Path
 from shutil import move
-from typing import TYPE_CHECKING
 
 import cv2
-import numpy as np
 import scipy.io
-import torch
-from pandas import DataFrame
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibVideoDataModule, AnomalibVideoDataset
-from anomalib.data.base.video import VideoTargetFrame
+from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
+from anomalib.data.datasets.base.video import VideoTargetFrame
+from anomalib.data.datasets.video.avenue import AvenueDataset
 from anomalib.data.utils import (
     DownloadInfo,
     Split,
     ValSplitMode,
     download_and_extract,
-    read_mask,
-    validate_path,
 )
-from anomalib.data.utils.video import ClipsIndexer
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
 
 logger = logging.getLogger(__name__)
 
@@ -59,184 +48,6 @@
 )
 
 
-def make_avenue_dataset(root: Path, gt_dir: Path, split: Split | str | None = None) -> DataFrame:
-    """Create CUHK Avenue dataset by parsing the file structure.
-
-    The files are expected to follow the structure:
-        - path/to/dataset/[training_videos|testing_videos]/video_filename.avi
-        - path/to/ground_truth/mask_filename.mat
-
-    Args:
-        root (Path): Path to dataset
-        gt_dir (Path): Path to the ground truth
-        split (Split | str | None = None, optional): Dataset split (ie., either train or test).
-            Defaults to ``None``.
-
-    Example:
-        The following example shows how to get testing samples from Avenue dataset:
-
-        >>> root = Path('./avenue')
-        >>> gt_dir = Path('./avenue/masks')
-        >>> samples = make_avenue_dataset(path, gt_dir, split='test')
-        >>> samples.head()
-           root     folder         image_path                      mask_path                   split
-        0  ./avenue testing_videos ./avenue/training_videos/01.avi ./avenue/masks/01_label.mat test
-        1  ./avenue testing_videos ./avenue/training_videos/02.avi ./avenue/masks/01_label.mat test
-        ...
-
-    Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
-    """
-    root = validate_path(root)
-
-    samples_list = [(str(root),) + filename.parts[-2:] for filename in root.glob("**/*.avi")]
-    samples = DataFrame(samples_list, columns=["root", "folder", "image_path"])
-
-    samples.loc[samples.folder == "testing_videos", "mask_path"] = (
-        samples.image_path.str.split(".").str[0].str.lstrip("0") + "_label.mat"
-    )
-    samples.loc[samples.folder == "testing_videos", "mask_path"] = (
-        str(gt_dir) + "/testing_label_mask/" + samples.mask_path
-    )
-    samples.loc[samples.folder == "training_videos", "mask_path"] = ""
-
-    samples["image_path"] = samples.root + "/" + samples.folder + "/" + samples.image_path
-
-    samples.loc[samples.folder == "training_videos", "split"] = "train"
-    samples.loc[samples.folder == "testing_videos", "split"] = "test"
-
-    if split:
-        samples = samples[samples.split == split]
-        samples = samples.reset_index(drop=True)
-
-    return samples
-
-
-class AvenueClipsIndexer(ClipsIndexer):
-    """Clips class for Avenue dataset."""
-
-    def get_mask(self, idx: int) -> np.ndarray | None:
-        """Retrieve the masks from the file system."""
-        video_idx, frames_idx = self.get_clip_location(idx)
-        matfile = self.mask_paths[video_idx]
-        if matfile == "":  # no gt masks available for this clip
-            return None
-        frames = self.clips[video_idx][frames_idx]
-
-        # read masks from .png files if available, othwerise from mat files.
-        mask_folder = Path(matfile).with_suffix("")
-        if mask_folder.exists():
-            mask_frames = sorted(mask_folder.glob("*"))
-            mask_paths = [mask_frames[idx] for idx in frames.int()]
-            masks = torch.stack([read_mask(mask_path, as_tensor=True) for mask_path in mask_paths])
-        else:
-            mat = scipy.io.loadmat(matfile)
-            masks = np.vstack([np.stack(m) for m in mat["volLabel"]])
-            masks = np.take(masks, frames, 0)
-        return masks
-
-
-class AvenueDataset(AnomalibVideoDataset):
-    """Avenue Dataset class.
-
-    Args:
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
-        split (Split): Split of the dataset, usually Split.TRAIN or Split.TEST
-        root (Path | str): Path to the root of the dataset
-            Defaults to ``./datasets/avenue``.
-        gt_dir (Path | str): Path to the ground truth files
-            Defaults to ``./datasets/avenue/ground_truth_demo``.
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
-            Defaults to ``2``.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-            Defaults to ``1``.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
-            Defaults to ``VideoTargetFrame.LAST``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-
-    Examples:
-        To create an Avenue dataset to train a classification model:
-
-        .. code-block:: python
-
-            transform = A.Compose([A.Resize(256, 256), A.pytorch.ToTensorV2()])
-            dataset = AvenueDataset(
-                task="classification",
-                transform=transform,
-                split="train",
-                root="./datasets/avenue/",
-            )
-
-            dataset.setup()
-            dataset[0].keys()
-
-            # Output: dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image'])
-
-        If you would like to test a segmentation model, you can use the following code:
-
-        .. code-block:: python
-
-            dataset = AvenueDataset(
-                task="segmentation",
-                transform=transform,
-                split="test",
-                root="./datasets/avenue/",
-            )
-
-            dataset.setup()
-            dataset[0].keys()
-
-            # Output: dict_keys(['image', 'mask', 'video_path', 'frames', 'last_frame', 'original_image', 'label'])
-
-        Avenue video dataset can also be used as an image dataset if you set the clip length to 1. This means that each
-        video frame will be treated as a separate sample. This is useful for training a classification model on the
-        Avenue dataset. The following code shows how to create an image dataset for classification:
-
-        .. code-block:: python
-
-            dataset = AvenueDataset(
-                task="classification",
-                transform=transform,
-                split="test",
-                root="./datasets/avenue/",
-                clip_length_in_frames=1,
-            )
-
-            dataset.setup()
-            dataset[0].keys()
-            # Output: dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image', 'label'])
-
-            dataset[0]["image"].shape
-            # Output: torch.Size([3, 256, 256])
-    """
-
-    def __init__(
-        self,
-        task: TaskType,
-        split: Split,
-        root: Path | str = "./datasets/avenue",
-        gt_dir: Path | str = "./datasets/avenue/ground_truth_demo",
-        clip_length_in_frames: int = 2,
-        frames_between_clips: int = 1,
-        transform: Transform | None = None,
-        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
-    ) -> None:
-        super().__init__(
-            task=task,
-            clip_length_in_frames=clip_length_in_frames,
-            frames_between_clips=frames_between_clips,
-            target_frame=target_frame,
-            transform=transform,
-        )
-
-        self.root = root if isinstance(root, Path) else Path(root)
-        self.gt_dir = gt_dir if isinstance(gt_dir, Path) else Path(gt_dir)
-        self.split = split
-        self.indexer_cls: Callable = AvenueClipsIndexer
-        self.samples = make_avenue_dataset(self.root, self.gt_dir, self.split)
-
-
 class Avenue(AnomalibVideoDataModule):
     """Avenue DataModule class.
 
diff --git a/src/anomalib/data/datamodules/video/shanghaitech.py b/src/anomalib/data/datamodules/video/shanghaitech.py
new file mode 100644
index 0000000000..b474f09547
--- /dev/null
+++ b/src/anomalib/data/datamodules/video/shanghaitech.py
@@ -0,0 +1,174 @@
+"""ShanghaiTech Campus Data Module.
+
+Description:
+    This module contains PyTorch Lightning DataModule for the ShanghaiTech Campus dataset.
+    If the dataset is not on the file system, the DataModule class downloads and
+    extracts the dataset and converts video files to a format that is readable by pyav.
+
+License:
+    ShanghaiTech Campus Dataset is released under the BSD 2-Clause License.
+
+Reference:
+    - W. Liu and W. Luo, D. Lian and S. Gao. "Future Frame Prediction for Anomaly Detection -- A New Baseline."
+      IEEE Conference on Computer Vision and Pattern Recognition (CVPR). 2018.
+"""
+
+# Copyright (C) 2023-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from pathlib import Path
+from shutil import move
+
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
+from anomalib.data.datasets.base.video import VideoTargetFrame
+from anomalib.data.datasets.video.shanghaitech import ShanghaiTechDataset
+from anomalib.data.utils import (
+    DownloadInfo,
+    Split,
+    ValSplitMode,
+    download_and_extract,
+)
+from anomalib.data.utils.video import convert_video
+
+logger = logging.getLogger(__name__)
+
+DATASET_DOWNLOAD_INFO = DownloadInfo(
+    name="ShanghaiTech Dataset",
+    url="http://101.32.75.151:8181/dataset/shanghaitech.tar.gz",
+    hashsum="c13a827043b259ccf8493c9d9130486872992153a9d714fe229e523cd4c94116",
+)
+
+
+class ShanghaiTech(AnomalibVideoDataModule):
+    """ShanghaiTech DataModule class.
+
+    Args:
+        root (Path | str): Path to the root of the dataset
+        scene (int): Index of the dataset scene (category) in range [1, 13]
+        clip_length_in_frames (int, optional): Number of video frames in each clip.
+        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
+        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
+        task TaskType): Task type, 'classification', 'detection' or 'segmentation'
+        image_size (tuple[int, int], optional): Size to which input images should be resized.
+            Defaults to ``None``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
+            Defaults to ``None``.
+        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
+            Defaults to ``None``.
+        train_batch_size (int, optional): Training batch size. Defaults to 32.
+        eval_batch_size (int, optional): Test batch size. Defaults to 32.
+        num_workers (int, optional): Number of workers. Defaults to 8.
+        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+    """
+
+    def __init__(
+        self,
+        root: Path | str = "./datasets/shanghaitech",
+        scene: int = 1,
+        clip_length_in_frames: int = 2,
+        frames_between_clips: int = 1,
+        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
+        task: TaskType | str = TaskType.SEGMENTATION,
+        image_size: tuple[int, int] | None = None,
+        transform: Transform | None = None,
+        train_transform: Transform | None = None,
+        eval_transform: Transform | None = None,
+        train_batch_size: int = 32,
+        eval_batch_size: int = 32,
+        num_workers: int = 8,
+        val_split_mode: ValSplitMode = ValSplitMode.SAME_AS_TEST,
+        val_split_ratio: float = 0.5,
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            train_batch_size=train_batch_size,
+            eval_batch_size=eval_batch_size,
+            num_workers=num_workers,
+            image_size=image_size,
+            transform=transform,
+            train_transform=train_transform,
+            eval_transform=eval_transform,
+            val_split_mode=val_split_mode,
+            val_split_ratio=val_split_ratio,
+            seed=seed,
+        )
+
+        self.task = TaskType(task)
+        self.root = Path(root)
+        self.scene = scene
+
+        self.clip_length_in_frames = clip_length_in_frames
+        self.frames_between_clips = frames_between_clips
+        self.target_frame = target_frame
+
+    def _setup(self, _stage: str | None = None) -> None:
+        self.train_data = ShanghaiTechDataset(
+            task=self.task,
+            transform=self.train_transform,
+            clip_length_in_frames=self.clip_length_in_frames,
+            frames_between_clips=self.frames_between_clips,
+            target_frame=self.target_frame,
+            root=self.root,
+            scene=self.scene,
+            split=Split.TRAIN,
+        )
+
+        self.test_data = ShanghaiTechDataset(
+            task=self.task,
+            transform=self.eval_transform,
+            clip_length_in_frames=self.clip_length_in_frames,
+            frames_between_clips=self.frames_between_clips,
+            target_frame=self.target_frame,
+            root=self.root,
+            scene=self.scene,
+            split=Split.TEST,
+        )
+
+    def prepare_data(self) -> None:
+        """Download the dataset and convert video files."""
+        training_root = self.root / "training"
+        if training_root.is_dir():
+            logger.info("Found the dataset.")
+        else:
+            download_and_extract(self.root, DATASET_DOWNLOAD_INFO)
+
+            # move contents to root
+            extracted_folder = self.root / "shanghaitech"
+            for filename in extracted_folder.glob("*"):
+                move(str(filename), str(self.root / filename.name))
+            extracted_folder.rmdir()
+
+        # convert images if not done already
+        vid_dir = training_root / "videos"
+        converted_vid_dir = training_root / "converted_videos"
+        vid_count = len(list(vid_dir.glob("*")))
+        converted_vid_count = len(list(converted_vid_dir.glob("*")))
+        if vid_count != converted_vid_count:
+            self._convert_training_videos(vid_dir, converted_vid_dir)
+
+    @staticmethod
+    def _convert_training_videos(video_folder: Path, target_folder: Path) -> None:
+        """Re-code the training videos to ensure correct reading of frames by torchvision.
+
+        The encoding of the raw video files in the ShanghaiTech dataset causes some problems when
+        reading the frames using pyav. To prevent this, we read the frames from the video files using opencv,
+        and write them to a new video file that can be parsed correctly with pyav.
+
+        Args:
+            video_folder (Path): Path to the folder of training videos.
+            target_folder (Path): File system location where the converted videos will be stored.
+        """
+        training_videos = sorted(video_folder.glob("*"))
+        for video_idx, video_path in enumerate(training_videos):
+            logger.info("Converting training video %s (%i/%i)...", video_path.name, video_idx + 1, len(training_videos))
+            file_name = video_path.name
+            target_path = target_folder / file_name
+            convert_video(video_path, target_path, codec="XVID")
diff --git a/src/anomalib/data/datamodules/video/ucsd_ped.py b/src/anomalib/data/datamodules/video/ucsd_ped.py
new file mode 100644
index 0000000000..2dd480ef37
--- /dev/null
+++ b/src/anomalib/data/datamodules/video/ucsd_ped.py
@@ -0,0 +1,127 @@
+"""UCSD Pedestrian Data Module."""
+
+# Copyright (C) 2023-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from pathlib import Path
+from shutil import move
+
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
+from anomalib.data.datasets.base.video import VideoTargetFrame
+from anomalib.data.datasets.video.ucsd_ped import UCSDpedDataset
+from anomalib.data.utils import DownloadInfo, Split, ValSplitMode, download_and_extract
+
+logger = logging.getLogger(__name__)
+
+DOWNLOAD_INFO = DownloadInfo(
+    name="UCSD Pedestrian",
+    url="http://www.svcl.ucsd.edu/projects/anomaly/UCSD_Anomaly_Dataset.tar.gz",
+    hashsum="2329af326951f5097fdd114c50e853957d3e569493a49d22fc082a9fd791915b",
+)
+
+
+class UCSDped(AnomalibVideoDataModule):
+    """UCSDped DataModule class.
+
+    Args:
+        root (Path | str): Path to the root of the dataset
+        category (str): Sub-category of the dataset, e.g. "UCSDped1" or "UCSDped2"
+        clip_length_in_frames (int, optional): Number of video frames in each clip.
+        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
+        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
+        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
+        image_size (tuple[int, int], optional): Size to which input images should be resized.
+            Defaults to ``None``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
+            Defaults to ``None``.
+        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
+            Defaults to ``None``.
+        train_batch_size (int, optional): Training batch size. Defaults to 32.
+        eval_batch_size (int, optional): Test batch size. Defaults to 32.
+        num_workers (int, optional): Number of workers. Defaults to 8.
+        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+    """
+
+    def __init__(
+        self,
+        root: Path | str = "./datasets/ucsd",
+        category: str = "UCSDped2",
+        clip_length_in_frames: int = 2,
+        frames_between_clips: int = 10,
+        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
+        task: TaskType | str = TaskType.SEGMENTATION,
+        image_size: tuple[int, int] | None = None,
+        transform: Transform | None = None,
+        train_transform: Transform | None = None,
+        eval_transform: Transform | None = None,
+        train_batch_size: int = 8,
+        eval_batch_size: int = 8,
+        num_workers: int = 8,
+        val_split_mode: ValSplitMode = ValSplitMode.SAME_AS_TEST,
+        val_split_ratio: float = 0.5,
+        seed: int | None = None,
+    ) -> None:
+        super().__init__(
+            train_batch_size=train_batch_size,
+            eval_batch_size=eval_batch_size,
+            num_workers=num_workers,
+            image_size=image_size,
+            transform=transform,
+            train_transform=train_transform,
+            eval_transform=eval_transform,
+            val_split_mode=val_split_mode,
+            val_split_ratio=val_split_ratio,
+            seed=seed,
+        )
+
+        self.task = TaskType(task)
+        self.root = Path(root)
+        self.category = category
+
+        self.clip_length_in_frames = clip_length_in_frames
+        self.frames_between_clips = frames_between_clips
+        self.target_frame = VideoTargetFrame(target_frame)
+
+    def _setup(self, _stage: str | None = None) -> None:
+        self.train_data = UCSDpedDataset(
+            task=self.task,
+            transform=self.train_transform,
+            clip_length_in_frames=self.clip_length_in_frames,
+            frames_between_clips=self.frames_between_clips,
+            target_frame=self.target_frame,
+            root=self.root,
+            category=self.category,
+            split=Split.TRAIN,
+        )
+
+        self.test_data = UCSDpedDataset(
+            task=self.task,
+            transform=self.eval_transform,
+            clip_length_in_frames=self.clip_length_in_frames,
+            frames_between_clips=self.frames_between_clips,
+            target_frame=self.target_frame,
+            root=self.root,
+            category=self.category,
+            split=Split.TEST,
+        )
+
+    def prepare_data(self) -> None:
+        """Download the dataset if not available."""
+        if (self.root / self.category).is_dir():
+            logger.info("Found the dataset.")
+        else:
+            download_and_extract(self.root, DOWNLOAD_INFO)
+
+            # move contents to root
+            extracted_folder = self.root / "UCSD_Anomaly_Dataset.v1p2"
+            for filename in extracted_folder.glob("*"):
+                move(str(filename), str(self.root / filename.name))
+            extracted_folder.rmdir()
diff --git a/src/anomalib/data/datasets/__init__.py b/src/anomalib/data/datasets/__init__.py
new file mode 100644
index 0000000000..3208bda54a
--- /dev/null
+++ b/src/anomalib/data/datasets/__init__.py
@@ -0,0 +1,29 @@
+"""Torch Dataset Implementations of Anomalib Datasets."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .base import AnomalibDataset, AnomalibDepthDataset, AnomalibVideoDataset
+from .depth import Folder3DDataset, MVTec3DDataset
+from .image import BTechDataset, FolderDataset, KolektorDataset, MVTecDataset, VisaDataset
+from .video import AvenueDataset, ShanghaiTechDataset, UCSDpedDataset
+
+__all__ = [
+    # Base
+    "AnomalibDataset",
+    "AnomalibDepthDataset",
+    "AnomalibVideoDataset",
+    # Depth
+    "Folder3DDataset",
+    "MVTec3DDataset",
+    # Image
+    "BTechDataset",
+    "FolderDataset",
+    "KolektorDataset",
+    "MVTecDataset",
+    "VisaDataset",
+    # Video
+    "AvenueDataset",
+    "ShanghaiTechDataset",
+    "UCSDpedDataset",
+]
diff --git a/src/anomalib/data/datasets/base/__init__.py b/src/anomalib/data/datasets/base/__init__.py
new file mode 100644
index 0000000000..b39af32f4c
--- /dev/null
+++ b/src/anomalib/data/datasets/base/__init__.py
@@ -0,0 +1,10 @@
+"""Base Classes for Torch Datasets."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .depth import AnomalibDepthDataset
+from .image import AnomalibDataset
+from .video import AnomalibVideoDataset
+
+__all__ = ["AnomalibDataset", "AnomalibVideoDataset", "AnomalibDepthDataset"]
diff --git a/src/anomalib/data/base/depth.py b/src/anomalib/data/datasets/base/depth.py
similarity index 96%
rename from src/anomalib/data/base/depth.py
rename to src/anomalib/data/datasets/base/depth.py
index 8f97eb202a..56460b3a6a 100644
--- a/src/anomalib/data/base/depth.py
+++ b/src/anomalib/data/datasets/base/depth.py
@@ -13,9 +13,10 @@
 from torchvision.tv_tensors import Mask
 
 from anomalib import TaskType
-from anomalib.data.base.dataset import AnomalibDataset
+from anomalib.data.dataclasses import DepthBatch, DepthItem
 from anomalib.data.utils import LabelName, read_depth_image
-from anomalib.dataclasses import DepthBatch, DepthItem
+
+from .image import AnomalibDataset
 
 
 class AnomalibDepthDataset(AnomalibDataset, ABC):
diff --git a/src/anomalib/data/base/dataset.py b/src/anomalib/data/datasets/base/image.py
similarity index 99%
rename from src/anomalib/data/base/dataset.py
rename to src/anomalib/data/datasets/base/image.py
index d7878f7506..5aaabc8fe4 100644
--- a/src/anomalib/data/base/dataset.py
+++ b/src/anomalib/data/datasets/base/image.py
@@ -17,8 +17,8 @@
 from torchvision.tv_tensors import Mask
 
 from anomalib import TaskType
+from anomalib.data.dataclasses import DatasetItem, ImageBatch, ImageItem
 from anomalib.data.utils import LabelName, read_image, read_mask
-from anomalib.dataclasses import DatasetItem, ImageBatch, ImageItem
 
 _EXPECTED_COLUMNS_CLASSIFICATION = ["image_path", "split"]
 _EXPECTED_COLUMNS_SEGMENTATION = [*_EXPECTED_COLUMNS_CLASSIFICATION, "mask_path"]
diff --git a/src/anomalib/data/base/video.py b/src/anomalib/data/datasets/base/video.py
similarity index 81%
rename from src/anomalib/data/base/video.py
rename to src/anomalib/data/datasets/base/video.py
index 3bad81efdd..3ba8f2fd83 100644
--- a/src/anomalib/data/base/video.py
+++ b/src/anomalib/data/datasets/base/video.py
@@ -1,6 +1,6 @@
-"""Base Video Dataset."""
+"""Base Torch Video Dataset."""
 
-# Copyright (C) 2023-2024 Intel Corporation
+# Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from abc import ABC
@@ -14,11 +14,10 @@
 from torchvision.tv_tensors import Mask
 
 from anomalib import TaskType
-from anomalib.data.base.datamodule import AnomalibDataModule
-from anomalib.data.base.dataset import AnomalibDataset
-from anomalib.data.utils import ValSplitMode
+from anomalib.data.dataclasses import VideoBatch, VideoItem
 from anomalib.data.utils.video import ClipsIndexer
-from anomalib.dataclasses import VideoBatch, VideoItem
+
+from .image import AnomalibDataset
 
 
 class VideoTargetFrame(str, Enum):
@@ -175,34 +174,3 @@ def __getitem__(self, index: int) -> VideoItem:
     def collate_fn(self) -> Callable:
         """Return the collate function for video batches."""
         return VideoBatch.collate
-
-
-class AnomalibVideoDataModule(AnomalibDataModule):
-    """Base class for video data modules."""
-
-    def _create_test_split(self) -> None:
-        """Video datamodules do not support dynamic assignment of the test split."""
-
-    def _setup(self, _stage: str | None = None) -> None:
-        """Set up the datasets and perform dynamic subset splitting.
-
-        This method may be overridden in subclass for custom splitting behaviour.
-
-        Video datamodules are not compatible with synthetic anomaly generation.
-        """
-        if self.train_data is None:
-            msg = "self.train_data cannot be None."
-            raise ValueError(msg)
-
-        if self.test_data is None:
-            msg = "self.test_data cannot be None."
-            raise ValueError(msg)
-
-        self.train_data.setup()
-        self.test_data.setup()
-
-        if self.val_split_mode == ValSplitMode.SYNTHETIC:
-            msg = f"Val split mode {self.test_split_mode} not supported for video datasets."
-            raise ValueError(msg)
-
-        self._create_val_split()
diff --git a/src/anomalib/data/datasets/depth/__init__.py b/src/anomalib/data/datasets/depth/__init__.py
new file mode 100644
index 0000000000..7d7c5361ee
--- /dev/null
+++ b/src/anomalib/data/datasets/depth/__init__.py
@@ -0,0 +1,9 @@
+"""Torch Dataset Implementations of Anomalib Depth Datasets."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .folder_3d import Folder3DDataset
+from .mvtec_3d import MVTec3DDataset
+
+__all__ = ["Folder3DDataset", "MVTec3DDataset"]
diff --git a/src/anomalib/data/depth/folder_3d.py b/src/anomalib/data/datasets/depth/folder_3d.py
similarity index 62%
rename from src/anomalib/data/depth/folder_3d.py
rename to src/anomalib/data/datasets/depth/folder_3d.py
index 41a12fbf40..9ec78487b3 100644
--- a/src/anomalib/data/depth/folder_3d.py
+++ b/src/anomalib/data/datasets/depth/folder_3d.py
@@ -3,7 +3,7 @@
 This script creates a custom dataset from a folder.
 """
 
-# Copyright (C) 2022 Intel Corporation
+# Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from pathlib import Path
@@ -12,18 +12,104 @@
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibDataModule, AnomalibDepthDataset
+from anomalib.data.datasets.base.depth import AnomalibDepthDataset
 from anomalib.data.errors import MisMatchError
-from anomalib.data.utils import (
-    DirType,
-    LabelName,
-    Split,
-    TestSplitMode,
-    ValSplitMode,
-)
+from anomalib.data.utils import DirType, LabelName, Split
 from anomalib.data.utils.path import _prepare_files_labels, validate_and_resolve_path
 
 
+class Folder3DDataset(AnomalibDepthDataset):
+    """Folder dataset.
+
+    Args:
+        name (str): Name of the dataset.
+        task (TaskType): Task type. (``classification``, ``detection`` or ``segmentation``).
+        transform (Transform): Transforms that should be applied to the input images.
+        normal_dir (str | Path): Path to the directory containing normal images.
+        root (str | Path | None): Root folder of the dataset.
+            Defaults to ``None``.
+        abnormal_dir (str | Path | None, optional): Path to the directory containing abnormal images.
+            Defaults to ``None``.
+        normal_test_dir (str | Path | None, optional): Path to the directory containing
+            normal images for the test dataset.
+            Defaults to ``None``.
+        mask_dir (str | Path | None, optional): Path to the directory containing
+            the mask annotations.
+            Defaults to ``None``.
+        normal_depth_dir (str | Path | None, optional): Path to the directory containing
+            normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir`
+            Defaults to ``None``.
+        abnormal_depth_dir (str | Path | None, optional): Path to the directory containing abnormal depth images for
+            the test dataset.
+            Defaults to ``None``.
+        normal_test_depth_dir (str | Path | None, optional): Path to the directory containing
+            normal depth images for the test dataset. Normal test images will be a split of `normal_dir` if `None`.
+            Defaults to ``None``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        split (str | Split | None): Fixed subset split that follows from folder structure on file system.
+            Choose from [Split.FULL, Split.TRAIN, Split.TEST]
+            Defaults to ``None``.
+        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
+            Defaults to ``None``.
+
+    Raises:
+        ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is
+            provided, `task` should be set to `segmentation`.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        task: TaskType,
+        normal_dir: str | Path,
+        root: str | Path | None = None,
+        abnormal_dir: str | Path | None = None,
+        normal_test_dir: str | Path | None = None,
+        mask_dir: str | Path | None = None,
+        normal_depth_dir: str | Path | None = None,
+        abnormal_depth_dir: str | Path | None = None,
+        normal_test_depth_dir: str | Path | None = None,
+        transform: Transform | None = None,
+        split: str | Split | None = None,
+        extensions: tuple[str, ...] | None = None,
+    ) -> None:
+        super().__init__(task, transform)
+
+        self._name = name
+        self.split = split
+        self.root = root
+        self.normal_dir = normal_dir
+        self.abnormal_dir = abnormal_dir
+        self.normal_test_dir = normal_test_dir
+        self.mask_dir = mask_dir
+        self.normal_depth_dir = normal_depth_dir
+        self.abnormal_depth_dir = abnormal_depth_dir
+        self.normal_test_depth_dir = normal_test_depth_dir
+        self.extensions = extensions
+
+        self.samples = make_folder3d_dataset(
+            root=self.root,
+            normal_dir=self.normal_dir,
+            abnormal_dir=self.abnormal_dir,
+            normal_test_dir=self.normal_test_dir,
+            mask_dir=self.mask_dir,
+            normal_depth_dir=self.normal_depth_dir,
+            abnormal_depth_dir=self.abnormal_depth_dir,
+            normal_test_depth_dir=self.normal_test_depth_dir,
+            split=self.split,
+            extensions=self.extensions,
+        )
+
+    @property
+    def name(self) -> str:
+        """Name of the dataset.
+
+        Folder3D dataset overrides the name property to provide a custom name.
+        """
+        return self._name
+
+
 def make_folder3d_dataset(  # noqa: C901
     normal_dir: str | Path,
     root: str | Path | None = None,
@@ -189,244 +275,3 @@ def make_folder3d_dataset(  # noqa: C901
         samples = samples.reset_index(drop=True)
 
     return samples
-
-
-class Folder3DDataset(AnomalibDepthDataset):
-    """Folder dataset.
-
-    Args:
-        name (str): Name of the dataset.
-        task (TaskType): Task type. (``classification``, ``detection`` or ``segmentation``).
-        transform (Transform): Transforms that should be applied to the input images.
-        normal_dir (str | Path): Path to the directory containing normal images.
-        root (str | Path | None): Root folder of the dataset.
-            Defaults to ``None``.
-        abnormal_dir (str | Path | None, optional): Path to the directory containing abnormal images.
-            Defaults to ``None``.
-        normal_test_dir (str | Path | None, optional): Path to the directory containing
-            normal images for the test dataset.
-            Defaults to ``None``.
-        mask_dir (str | Path | None, optional): Path to the directory containing
-            the mask annotations.
-            Defaults to ``None``.
-        normal_depth_dir (str | Path | None, optional): Path to the directory containing
-            normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir`
-            Defaults to ``None``.
-        abnormal_depth_dir (str | Path | None, optional): Path to the directory containing abnormal depth images for
-            the test dataset.
-            Defaults to ``None``.
-        normal_test_depth_dir (str | Path | None, optional): Path to the directory containing
-            normal depth images for the test dataset. Normal test images will be a split of `normal_dir` if `None`.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Fixed subset split that follows from folder structure on file system.
-            Choose from [Split.FULL, Split.TRAIN, Split.TEST]
-            Defaults to ``None``.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
-            Defaults to ``None``.
-
-    Raises:
-        ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is
-            provided, `task` should be set to `segmentation`.
-    """
-
-    def __init__(
-        self,
-        name: str,
-        task: TaskType,
-        normal_dir: str | Path,
-        root: str | Path | None = None,
-        abnormal_dir: str | Path | None = None,
-        normal_test_dir: str | Path | None = None,
-        mask_dir: str | Path | None = None,
-        normal_depth_dir: str | Path | None = None,
-        abnormal_depth_dir: str | Path | None = None,
-        normal_test_depth_dir: str | Path | None = None,
-        transform: Transform | None = None,
-        split: str | Split | None = None,
-        extensions: tuple[str, ...] | None = None,
-    ) -> None:
-        super().__init__(task, transform)
-
-        self._name = name
-        self.split = split
-        self.root = root
-        self.normal_dir = normal_dir
-        self.abnormal_dir = abnormal_dir
-        self.normal_test_dir = normal_test_dir
-        self.mask_dir = mask_dir
-        self.normal_depth_dir = normal_depth_dir
-        self.abnormal_depth_dir = abnormal_depth_dir
-        self.normal_test_depth_dir = normal_test_depth_dir
-        self.extensions = extensions
-
-        self.samples = make_folder3d_dataset(
-            root=self.root,
-            normal_dir=self.normal_dir,
-            abnormal_dir=self.abnormal_dir,
-            normal_test_dir=self.normal_test_dir,
-            mask_dir=self.mask_dir,
-            normal_depth_dir=self.normal_depth_dir,
-            abnormal_depth_dir=self.abnormal_depth_dir,
-            normal_test_depth_dir=self.normal_test_depth_dir,
-            split=self.split,
-            extensions=self.extensions,
-        )
-
-    @property
-    def name(self) -> str:
-        """Name of the dataset.
-
-        Folder3D dataset overrides the name property to provide a custom name.
-        """
-        return self._name
-
-
-class Folder3D(AnomalibDataModule):
-    """Folder DataModule.
-
-    Args:
-        name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
-        normal_dir (str | Path): Name of the directory containing normal images.
-        root (str | Path | None): Path to the root folder containing normal and abnormal dirs.
-            Defaults to ``None``.
-        abnormal_dir (str | Path | None): Name of the directory containing abnormal images.
-            Defaults to ``abnormal``.
-        normal_test_dir (str | Path | None, optional): Path to the directory containing normal images for the test
-            dataset.
-            Defaults to ``None``.
-        mask_dir (str | Path | None, optional): Path to the directory containing the mask annotations.
-            Defaults to ``None``.
-        normal_depth_dir (str | Path | None, optional): Path to the directory containing
-            normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir`
-        abnormal_depth_dir (str | Path | None, optional): Path to the directory containing
-            abnormal depth images for the test dataset.
-        normal_test_depth_dir (str | Path | None, optional): Path to the directory containing
-            normal depth images for the test dataset. Normal test images will be a split of `normal_dir`
-            if `None`. Defaults to None.
-        normal_split_ratio (float, optional): Ratio to split normal training images and add to the
-            test set in case test set doesn't contain any normal images.
-            Defaults to 0.2.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the
-            directory. Defaults to None.
-        train_batch_size (int, optional): Training batch size.
-            Defaults to ``32``.
-        eval_batch_size (int, optional): Test batch size.
-            Defaults to ``32``.
-        num_workers (int, optional): Number of workers.
-            Defaults to ``8``.
-        task (TaskType, optional): Task type. Could be ``classification``, ``detection`` or ``segmentation``.
-            Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
-            Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
-            Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-            Defaults to ``ValSplitMode.FROM_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-            Defaults to ``0.5``.
-        seed (int | None, optional): Seed used during random subset splitting.
-            Defaults to ``None``.
-    """
-
-    def __init__(
-        self,
-        name: str,
-        normal_dir: str | Path,
-        root: str | Path,
-        abnormal_dir: str | Path | None = None,
-        normal_test_dir: str | Path | None = None,
-        mask_dir: str | Path | None = None,
-        normal_depth_dir: str | Path | None = None,
-        abnormal_depth_dir: str | Path | None = None,
-        normal_test_depth_dir: str | Path | None = None,
-        extensions: tuple[str] | None = None,
-        train_batch_size: int = 32,
-        eval_batch_size: int = 32,
-        num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
-        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
-        test_split_ratio: float = 0.2,
-        val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
-        val_split_ratio: float = 0.5,
-        seed: int | None = None,
-    ) -> None:
-        super().__init__(
-            train_batch_size=train_batch_size,
-            eval_batch_size=eval_batch_size,
-            num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
-            test_split_mode=test_split_mode,
-            test_split_ratio=test_split_ratio,
-            val_split_mode=val_split_mode,
-            val_split_ratio=val_split_ratio,
-            seed=seed,
-        )
-        self._name = name
-        self.task = TaskType(task)
-        self.root = Path(root)
-        self.normal_dir = normal_dir
-        self.abnormal_dir = abnormal_dir
-        self.normal_test_dir = normal_test_dir
-        self.mask_dir = mask_dir
-        self.normal_depth_dir = normal_depth_dir
-        self.abnormal_depth_dir = abnormal_depth_dir
-        self.normal_test_depth_dir = normal_test_depth_dir
-        self.extensions = extensions
-
-    def _setup(self, _stage: str | None = None) -> None:
-        self.train_data = Folder3DDataset(
-            name=self.name,
-            task=self.task,
-            transform=self.train_transform,
-            split=Split.TRAIN,
-            root=self.root,
-            normal_dir=self.normal_dir,
-            abnormal_dir=self.abnormal_dir,
-            normal_test_dir=self.normal_test_dir,
-            mask_dir=self.mask_dir,
-            normal_depth_dir=self.normal_depth_dir,
-            abnormal_depth_dir=self.abnormal_depth_dir,
-            normal_test_depth_dir=self.normal_test_depth_dir,
-            extensions=self.extensions,
-        )
-
-        self.test_data = Folder3DDataset(
-            name=self.name,
-            task=self.task,
-            transform=self.eval_transform,
-            split=Split.TEST,
-            root=self.root,
-            normal_dir=self.normal_dir,
-            abnormal_dir=self.abnormal_dir,
-            normal_test_dir=self.normal_test_dir,
-            normal_depth_dir=self.normal_depth_dir,
-            abnormal_depth_dir=self.abnormal_depth_dir,
-            normal_test_depth_dir=self.normal_test_depth_dir,
-            mask_dir=self.mask_dir,
-            extensions=self.extensions,
-        )
-
-    @property
-    def name(self) -> str:
-        """Name of the datamodule.
-
-        Folder3D datamodule overrides the name property to provide a custom name.
-        """
-        return self._name
diff --git a/src/anomalib/data/depth/mvtec_3d.py b/src/anomalib/data/datasets/depth/mvtec_3d.py
similarity index 62%
rename from src/anomalib/data/depth/mvtec_3d.py
rename to src/anomalib/data/datasets/depth/mvtec_3d.py
index f07cef730e..de6d326a4a 100644
--- a/src/anomalib/data/depth/mvtec_3d.py
+++ b/src/anomalib/data/datasets/depth/mvtec_3d.py
@@ -1,4 +1,4 @@
-"""MVTec 3D-AD Dataset (CC BY-NC-SA 4.0).
+"""MVTec 3D-AD Datamodule (CC BY-NC-SA 4.0).
 
 Description:
     This script contains PyTorch Dataset, Dataloader and PyTorch Lightning DataModule for the MVTec 3D-AD dataset.
@@ -16,10 +16,9 @@
         0010865000003124.
 """
 
-# Copyright (C) 2022 Intel Corporation
+# Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import logging
 from collections.abc import Sequence
 from pathlib import Path
 
@@ -27,31 +26,42 @@
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibDataModule, AnomalibDepthDataset
+from anomalib.data.datasets.base.depth import AnomalibDepthDataset
 from anomalib.data.errors import MisMatchError
-from anomalib.data.utils import (
-    DownloadInfo,
-    LabelName,
-    Split,
-    TestSplitMode,
-    ValSplitMode,
-    download_and_extract,
-    validate_path,
-)
+from anomalib.data.utils import LabelName, Split, validate_path
 
-logger = logging.getLogger(__name__)
+IMG_EXTENSIONS = [".png", ".PNG", ".tiff"]
+CATEGORIES = ("bagel", "cable_gland", "carrot", "cookie", "dowel", "foam", "peach", "potato", "rope", "tire")
 
 
-IMG_EXTENSIONS = [".png", ".PNG", ".tiff"]
+class MVTec3DDataset(AnomalibDepthDataset):
+    """MVTec 3D dataset class.
 
-DOWNLOAD_INFO = DownloadInfo(
-    name="mvtec_3d",
-    url="https://www.mydrive.ch/shares/45920/dd1eb345346df066c63b5c95676b961b/download/428824485-1643285832"
-    "/mvtec_3d_anomaly_detection.tar.xz",
-    hashsum="d8bb2800fbf3ac88e798da6ae10dc819",
-)
+    Args:
+        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``
+        root (Path | str): Path to the root of the dataset
+            Defaults to ``"./datasets/MVTec3D"``.
+        category (str): Sub-category of the dataset, e.g. 'bagel'
+            Defaults to ``"bagel"``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+            Defaults to ``None``.
+    """
 
-CATEGORIES = ("bagel", "cable_gland", "carrot", "cookie", "dowel", "foam", "peach", "potato", "rope", "tire")
+    def __init__(
+        self,
+        task: TaskType,
+        root: Path | str = "./datasets/MVTec3D",
+        category: str = "bagel",
+        transform: Transform | None = None,
+        split: str | Split | None = None,
+    ) -> None:
+        super().__init__(task=task, transform=transform)
+
+        self.root_category = Path(root) / Path(category)
+        self.split = split
+        self.samples = make_mvtec_3d_dataset(self.root_category, split=self.split, extensions=IMG_EXTENSIONS)
 
 
 def make_mvtec_3d_dataset(
@@ -172,130 +182,3 @@ def make_mvtec_3d_dataset(
         samples = samples[samples.split == split].reset_index(drop=True)
 
     return samples
-
-
-class MVTec3DDataset(AnomalibDepthDataset):
-    """MVTec 3D dataset class.
-
-    Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``
-        root (Path | str): Path to the root of the dataset
-            Defaults to ``"./datasets/MVTec3D"``.
-        category (str): Sub-category of the dataset, e.g. 'bagel'
-            Defaults to ``"bagel"``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
-            Defaults to ``None``.
-    """
-
-    def __init__(
-        self,
-        task: TaskType,
-        root: Path | str = "./datasets/MVTec3D",
-        category: str = "bagel",
-        transform: Transform | None = None,
-        split: str | Split | None = None,
-    ) -> None:
-        super().__init__(task=task, transform=transform)
-
-        self.root_category = Path(root) / Path(category)
-        self.split = split
-        self.samples = make_mvtec_3d_dataset(self.root_category, split=self.split, extensions=IMG_EXTENSIONS)
-
-
-class MVTec3D(AnomalibDataModule):
-    """MVTec Datamodule.
-
-    Args:
-        root (Path | str): Path to the root of the dataset
-            Defaults to ``"./datasets/MVTec3D"``.
-        category (str): Category of the MVTec dataset (e.g. "bottle" or "cable").
-            Defaults to ``bagel``.
-        train_batch_size (int, optional): Training batch size.
-            Defaults to ``32``.
-        eval_batch_size (int, optional): Test batch size.
-            Defaults to ``32``.
-        num_workers (int, optional): Number of workers.
-            Defaults to ``8``.
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
-            Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
-            Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
-            Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-            Defaults to ``ValSplitMode.SAME_AS_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-            Defaults to ``0.5``.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
-            Defaults to ``None``.
-    """
-
-    def __init__(
-        self,
-        root: Path | str = "./datasets/MVTec3D",
-        category: str = "bagel",
-        train_batch_size: int = 32,
-        eval_batch_size: int = 32,
-        num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
-        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
-        test_split_ratio: float = 0.2,
-        val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
-        val_split_ratio: float = 0.5,
-        seed: int | None = None,
-    ) -> None:
-        super().__init__(
-            train_batch_size=train_batch_size,
-            eval_batch_size=eval_batch_size,
-            num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
-            test_split_mode=test_split_mode,
-            test_split_ratio=test_split_ratio,
-            val_split_mode=val_split_mode,
-            val_split_ratio=val_split_ratio,
-            seed=seed,
-        )
-
-        self.task = TaskType(task)
-        self.root = Path(root)
-        self.category = category
-
-    def _setup(self, _stage: str | None = None) -> None:
-        self.train_data = MVTec3DDataset(
-            task=self.task,
-            transform=self.train_transform,
-            split=Split.TRAIN,
-            root=self.root,
-            category=self.category,
-        )
-        self.test_data = MVTec3DDataset(
-            task=self.task,
-            transform=self.eval_transform,
-            split=Split.TEST,
-            root=self.root,
-            category=self.category,
-        )
-
-    def prepare_data(self) -> None:
-        """Download the dataset if not available."""
-        if (self.root / self.category).is_dir():
-            logger.info("Found the dataset.")
-        else:
-            download_and_extract(self.root, DOWNLOAD_INFO)
diff --git a/src/anomalib/data/datasets/image/__init__.py b/src/anomalib/data/datasets/image/__init__.py
new file mode 100644
index 0000000000..c3b5c41dc7
--- /dev/null
+++ b/src/anomalib/data/datasets/image/__init__.py
@@ -0,0 +1,18 @@
+"""Torch Dataset Implementations of Anomalib Image Datasets."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .btech import BTechDataset
+from .folder import FolderDataset
+from .kolektor import KolektorDataset
+from .mvtec import MVTecDataset
+from .visa import VisaDataset
+
+__all__ = [
+    "BTechDataset",
+    "FolderDataset",
+    "KolektorDataset",
+    "MVTecDataset",
+    "VisaDataset",
+]
diff --git a/src/anomalib/data/datasets/image/btech.py b/src/anomalib/data/datasets/image/btech.py
new file mode 100644
index 0000000000..412097c912
--- /dev/null
+++ b/src/anomalib/data/datasets/image/btech.py
@@ -0,0 +1,158 @@
+"""BTech Dataset.
+
+This script contains PyTorch Dataset for the BTech dataset.
+
+If the dataset is not on the file system, the script downloads and
+extracts the dataset and create PyTorch data objects.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+import pandas as pd
+from pandas.core.frame import DataFrame
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datasets.base.image import AnomalibDataset
+from anomalib.data.utils import LabelName, Split, validate_path
+
+CATEGORIES = ("01", "02", "03")
+
+
+class BTechDataset(AnomalibDataset):
+    """Btech Dataset class.
+
+    Args:
+        root: Path to the BTech dataset
+        category: Name of the BTech category.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        split: 'train', 'val' or 'test'
+        task: ``classification``, ``detection`` or ``segmentation``
+        create_validation_set: Create a validation subset in addition to the train and test subsets
+
+    Examples:
+        >>> from anomalib.data.image.btech import BTechDataset
+        >>> from anomalib.data.utils.transforms import get_transforms
+        >>> transform = get_transforms(image_size=256)
+        >>> dataset = BTechDataset(
+        ...     task="classification",
+        ...     transform=transform,
+        ...     root='./datasets/BTech',
+        ...     category='01',
+        ... )
+        >>> dataset[0].keys()
+        >>> dataset.setup()
+        dict_keys(['image'])
+
+        >>> dataset.split = "test"
+        >>> dataset[0].keys()
+        dict_keys(['image', 'image_path', 'label'])
+
+        >>> dataset.task = "segmentation"
+        >>> dataset.split = "train"
+        >>> dataset[0].keys()
+        dict_keys(['image'])
+
+        >>> dataset.split = "test"
+        >>> dataset[0].keys()
+        dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
+
+        >>> dataset[0]["image"].shape, dataset[0]["mask"].shape
+        (torch.Size([3, 256, 256]), torch.Size([256, 256]))
+    """
+
+    def __init__(
+        self,
+        root: str | Path,
+        category: str,
+        transform: Transform | None = None,
+        split: str | Split | None = None,
+        task: TaskType | str = TaskType.SEGMENTATION,
+    ) -> None:
+        super().__init__(task, transform)
+
+        self.root_category = Path(root) / category
+        self.split = split
+        self.samples = make_btech_dataset(path=self.root_category, split=self.split)
+
+
+def make_btech_dataset(path: Path, split: str | Split | None = None) -> DataFrame:
+    """Create BTech samples by parsing the BTech data file structure.
+
+    The files are expected to follow the structure:
+
+        .. code-block:: bash
+
+            path/to/dataset/split/category/image_filename.png
+            path/to/dataset/ground_truth/category/mask_filename.png
+
+    Args:
+        path (Path): Path to dataset
+        split (str | Split | None, optional): Dataset split (ie., either train or test).
+            Defaults to ``None``.
+
+    Example:
+        The following example shows how to get training samples from BTech 01 category:
+
+        .. code-block:: python
+
+            >>> root = Path('./BTech')
+            >>> category = '01'
+            >>> path = root / category
+            >>> path
+            PosixPath('BTech/01')
+
+            >>> samples = make_btech_dataset(path, split='train')
+            >>> samples.head()
+            path     split label image_path                  mask_path                     label_index
+            0  BTech/01 train 01    BTech/01/train/ok/105.bmp BTech/01/ground_truth/ok/105.png      0
+            1  BTech/01 train 01    BTech/01/train/ok/017.bmp BTech/01/ground_truth/ok/017.png      0
+            ...
+
+    Returns:
+        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+    """
+    path = validate_path(path)
+
+    samples_list = [
+        (str(path),) + filename.parts[-3:] for filename in path.glob("**/*") if filename.suffix in {".bmp", ".png"}
+    ]
+    if not samples_list:
+        msg = f"Found 0 images in {path}"
+        raise RuntimeError(msg)
+
+    samples = pd.DataFrame(samples_list, columns=["path", "split", "label", "image_path"])
+    samples = samples[samples.split != "ground_truth"]
+
+    # Create mask_path column
+    # (safely handles cases where non-mask image_paths end with either .png or .bmp)
+    samples["mask_path"] = (
+        samples.path
+        + "/ground_truth/"
+        + samples.label
+        + "/"
+        + samples.image_path.str.rstrip("png").str.rstrip(".").str.rstrip("bmp").str.rstrip(".")
+        + ".png"
+    )
+
+    # Modify image_path column by converting to absolute path
+    samples["image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.image_path
+
+    # Good images don't have mask
+    samples.loc[(samples.split == "test") & (samples.label == "ok"), "mask_path"] = ""
+
+    # Create label index for normal (0) and anomalous (1) images.
+    samples.loc[(samples.label == "ok"), "label_index"] = LabelName.NORMAL
+    samples.loc[(samples.label != "ok"), "label_index"] = LabelName.ABNORMAL
+    samples.label_index = samples.label_index.astype(int)
+
+    # Get the data frame for the split.
+    if split:
+        samples = samples[samples.split == split]
+        samples = samples.reset_index(drop=True)
+
+    return samples
diff --git a/src/anomalib/data/image/folder.py b/src/anomalib/data/datasets/image/folder.py
similarity index 56%
rename from src/anomalib/data/image/folder.py
rename to src/anomalib/data/datasets/image/folder.py
index 61f853e8c2..48415c0867 100644
--- a/src/anomalib/data/image/folder.py
+++ b/src/anomalib/data/datasets/image/folder.py
@@ -1,9 +1,9 @@
 """Custom Folder Dataset.
 
-This script creates a custom dataset from a folder.
+This script creates a custom PyTorch Dataset from a folder.
 """
 
-# Copyright (C) 2022-2024 Intel Corporation
+# Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from collections.abc import Sequence
@@ -13,18 +13,107 @@
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibDataModule, AnomalibDataset
+from anomalib.data.datasets.base.image import AnomalibDataset
 from anomalib.data.errors import MisMatchError
-from anomalib.data.utils import (
-    DirType,
-    LabelName,
-    Split,
-    TestSplitMode,
-    ValSplitMode,
-)
+from anomalib.data.utils import DirType, LabelName, Split
 from anomalib.data.utils.path import _prepare_files_labels, validate_and_resolve_path
 
 
+class FolderDataset(AnomalibDataset):
+    """Folder dataset.
+
+    This class is used to create a dataset from a folder. The class utilizes the Torch Dataset class.
+
+    Args:
+        name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
+        task (TaskType): Task type. (``classification``, ``detection`` or ``segmentation``).
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        normal_dir (str | Path | Sequence): Path to the directory containing normal images.
+        root (str | Path | None): Root folder of the dataset.
+            Defaults to ``None``.
+        abnormal_dir (str | Path | Sequence | None, optional): Path to the directory containing abnormal images.
+            Defaults to ``None``.
+        normal_test_dir (str | Path | Sequence | None, optional): Path to the directory containing
+            normal images for the test dataset.
+            Defaults to ``None``.
+        mask_dir (str | Path | Sequence | None, optional): Path to the directory containing
+            the mask annotations.
+            Defaults to ``None``.
+        split (str | Split | None): Fixed subset split that follows from folder structure on file system.
+            Choose from [Split.FULL, Split.TRAIN, Split.TEST]
+            Defaults to ``None``.
+        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
+            Defaults to ``None``.
+
+    Raises:
+        ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is
+            provided, `task` should be set to `segmentation`.
+
+    Examples:
+        Assume that we would like to use this ``FolderDataset`` to create a dataset from a folder for a classification
+        task. We could first create the transforms,
+
+        >>> from anomalib.data.utils import InputNormalizationMethod, get_transforms
+        >>> transform = get_transforms(image_size=256, normalization=InputNormalizationMethod.NONE)
+
+        We could then create the dataset as follows,
+
+        .. code-block:: python
+
+            folder_dataset_classification_train = FolderDataset(
+                normal_dir=dataset_root / "good",
+                abnormal_dir=dataset_root / "crack",
+                split="train",
+                transform=transform,
+                task=TaskType.CLASSIFICATION,
+            )
+
+    """
+
+    def __init__(
+        self,
+        name: str,
+        task: TaskType,
+        normal_dir: str | Path | Sequence[str | Path],
+        transform: Transform | None = None,
+        root: str | Path | None = None,
+        abnormal_dir: str | Path | Sequence[str | Path] | None = None,
+        normal_test_dir: str | Path | Sequence[str | Path] | None = None,
+        mask_dir: str | Path | Sequence[str | Path] | None = None,
+        split: str | Split | None = None,
+        extensions: tuple[str, ...] | None = None,
+    ) -> None:
+        super().__init__(task, transform)
+
+        self._name = name
+        self.split = split
+        self.root = root
+        self.normal_dir = normal_dir
+        self.abnormal_dir = abnormal_dir
+        self.normal_test_dir = normal_test_dir
+        self.mask_dir = mask_dir
+        self.extensions = extensions
+
+        self.samples = make_folder_dataset(
+            root=self.root,
+            normal_dir=self.normal_dir,
+            abnormal_dir=self.abnormal_dir,
+            normal_test_dir=self.normal_test_dir,
+            mask_dir=self.mask_dir,
+            split=self.split,
+            extensions=self.extensions,
+        )
+
+    @property
+    def name(self) -> str:
+        """Name of the dataset.
+
+        Folder dataset overrides the name property to provide a custom name.
+        """
+        return self._name
+
+
 def make_folder_dataset(
     normal_dir: str | Path | Sequence[str | Path],
     root: str | Path | None = None,
@@ -180,299 +269,3 @@ def _resolve_path_and_convert_to_list(path: str | Path | Sequence[str | Path] |
         samples = samples.reset_index(drop=True)
 
     return samples
-
-
-class FolderDataset(AnomalibDataset):
-    """Folder dataset.
-
-    This class is used to create a dataset from a folder. The class utilizes the Torch Dataset class.
-
-    Args:
-        name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
-        task (TaskType): Task type. (``classification``, ``detection`` or ``segmentation``).
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        normal_dir (str | Path | Sequence): Path to the directory containing normal images.
-        root (str | Path | None): Root folder of the dataset.
-            Defaults to ``None``.
-        abnormal_dir (str | Path | Sequence | None, optional): Path to the directory containing abnormal images.
-            Defaults to ``None``.
-        normal_test_dir (str | Path | Sequence | None, optional): Path to the directory containing
-            normal images for the test dataset.
-            Defaults to ``None``.
-        mask_dir (str | Path | Sequence | None, optional): Path to the directory containing
-            the mask annotations.
-            Defaults to ``None``.
-        split (str | Split | None): Fixed subset split that follows from folder structure on file system.
-            Choose from [Split.FULL, Split.TRAIN, Split.TEST]
-            Defaults to ``None``.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
-            Defaults to ``None``.
-
-    Raises:
-        ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is
-            provided, `task` should be set to `segmentation`.
-
-    Examples:
-        Assume that we would like to use this ``FolderDataset`` to create a dataset from a folder for a classification
-        task. We could first create the transforms,
-
-        >>> from anomalib.data.utils import InputNormalizationMethod, get_transforms
-        >>> transform = get_transforms(image_size=256, normalization=InputNormalizationMethod.NONE)
-
-        We could then create the dataset as follows,
-
-        .. code-block:: python
-
-            folder_dataset_classification_train = FolderDataset(
-                normal_dir=dataset_root / "good",
-                abnormal_dir=dataset_root / "crack",
-                split="train",
-                transform=transform,
-                task=TaskType.CLASSIFICATION,
-            )
-
-    """
-
-    def __init__(
-        self,
-        name: str,
-        task: TaskType,
-        normal_dir: str | Path | Sequence[str | Path],
-        transform: Transform | None = None,
-        root: str | Path | None = None,
-        abnormal_dir: str | Path | Sequence[str | Path] | None = None,
-        normal_test_dir: str | Path | Sequence[str | Path] | None = None,
-        mask_dir: str | Path | Sequence[str | Path] | None = None,
-        split: str | Split | None = None,
-        extensions: tuple[str, ...] | None = None,
-    ) -> None:
-        super().__init__(task, transform)
-
-        self._name = name
-        self.split = split
-        self.root = root
-        self.normal_dir = normal_dir
-        self.abnormal_dir = abnormal_dir
-        self.normal_test_dir = normal_test_dir
-        self.mask_dir = mask_dir
-        self.extensions = extensions
-
-        self.samples = make_folder_dataset(
-            root=self.root,
-            normal_dir=self.normal_dir,
-            abnormal_dir=self.abnormal_dir,
-            normal_test_dir=self.normal_test_dir,
-            mask_dir=self.mask_dir,
-            split=self.split,
-            extensions=self.extensions,
-        )
-
-    @property
-    def name(self) -> str:
-        """Name of the dataset.
-
-        Folder dataset overrides the name property to provide a custom name.
-        """
-        return self._name
-
-
-class Folder(AnomalibDataModule):
-    """Folder DataModule.
-
-    Args:
-        name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
-        normal_dir (str | Path | Sequence): Name of the directory containing normal images.
-        root (str | Path | None): Path to the root folder containing normal and abnormal dirs.
-            Defaults to ``None``.
-        abnormal_dir (str | Path | None | Sequence): Name of the directory containing abnormal images.
-            Defaults to ``None``.
-        normal_test_dir (str | Path | Sequence | None, optional): Path to the directory containing
-            normal images for the test dataset.
-            Defaults to ``None``.
-        mask_dir (str | Path | Sequence | None, optional): Path to the directory containing
-            the mask annotations.
-            Defaults to ``None``.
-        normal_split_ratio (float, optional): Ratio to split normal training images and add to the
-            test set in case test set doesn't contain any normal images.
-            Defaults to 0.2.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the
-            directory.
-            Defaults to ``None``.
-        train_batch_size (int, optional): Training batch size.
-            Defaults to ``32``.
-        eval_batch_size (int, optional): Validation, test and predict batch size.
-            Defaults to ``32``.
-        num_workers (int, optional): Number of workers.
-            Defaults to ``8``.
-        task (TaskType, optional): Task type. Could be ``classification``, ``detection`` or ``segmentation``.
-            Defaults to ``segmentation``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
-            Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
-            Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-            Defaults to ``ValSplitMode.FROM_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-            Defaults to ``0.5``.
-        seed (int | None, optional): Seed used during random subset splitting.
-            Defaults to ``None``.
-
-    Examples:
-        The following code demonstrates how to use the ``Folder`` datamodule. Assume that the dataset is structured
-        as follows:
-
-        .. code-block:: bash
-
-            $ tree sample_dataset
-            sample_dataset
-            ├── colour
-            │   ├── 00.jpg
-            │   ├── ...
-            │   └── x.jpg
-            ├── crack
-            │   ├── 00.jpg
-            │   ├── ...
-            │   └── y.jpg
-            ├── good
-            │   ├── ...
-            │   └── z.jpg
-            ├── LICENSE
-            └── mask
-                ├── colour
-                │   ├── ...
-                │   └── x.jpg
-                └── crack
-                    ├── ...
-                    └── y.jpg
-
-        .. code-block:: python
-
-            folder_datamodule = Folder(
-                root=dataset_root,
-                normal_dir="good",
-                abnormal_dir="crack",
-                task=TaskType.SEGMENTATION,
-                mask_dir=dataset_root / "mask" / "crack",
-                image_size=256,
-                normalization=InputNormalizationMethod.NONE,
-            )
-            folder_datamodule.setup()
-
-        To access the training images,
-
-        .. code-block:: python
-
-            >> i, data = next(enumerate(folder_datamodule.train_dataloader()))
-            >> print(data.keys(), data["image"].shape)
-
-        To access the test images,
-
-        .. code-block:: python
-
-            >> i, data = next(enumerate(folder_datamodule.test_dataloader()))
-            >> print(data.keys(), data["image"].shape)
-    """
-
-    def __init__(
-        self,
-        name: str,
-        normal_dir: str | Path | Sequence[str | Path],
-        root: str | Path | None = None,
-        abnormal_dir: str | Path | Sequence[str | Path] | None = None,
-        normal_test_dir: str | Path | Sequence[str | Path] | None = None,
-        mask_dir: str | Path | Sequence[str | Path] | None = None,
-        normal_split_ratio: float = 0.2,
-        extensions: tuple[str] | None = None,
-        train_batch_size: int = 32,
-        eval_batch_size: int = 32,
-        num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
-        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
-        test_split_ratio: float = 0.2,
-        val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
-        val_split_ratio: float = 0.5,
-        seed: int | None = None,
-    ) -> None:
-        self._name = name
-        self.root = root
-        self.normal_dir = normal_dir
-        self.abnormal_dir = abnormal_dir
-        self.normal_test_dir = normal_test_dir
-        self.mask_dir = mask_dir
-        self.task = TaskType(task)
-        self.extensions = extensions
-        test_split_mode = TestSplitMode(test_split_mode)
-        val_split_mode = ValSplitMode(val_split_mode)
-        super().__init__(
-            train_batch_size=train_batch_size,
-            eval_batch_size=eval_batch_size,
-            num_workers=num_workers,
-            test_split_mode=test_split_mode,
-            test_split_ratio=test_split_ratio,
-            val_split_mode=val_split_mode,
-            val_split_ratio=val_split_ratio,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
-            seed=seed,
-        )
-
-        if task == TaskType.SEGMENTATION and test_split_mode == TestSplitMode.FROM_DIR and mask_dir is None:
-            msg = (
-                f"Segmentation task requires mask directory if test_split_mode is {test_split_mode}. "
-                "You could set test_split_mode to {TestSplitMode.NONE} or provide a mask directory."
-            )
-            raise ValueError(
-                msg,
-            )
-
-        self.normal_split_ratio = normal_split_ratio
-
-    def _setup(self, _stage: str | None = None) -> None:
-        self.train_data = FolderDataset(
-            name=self.name,
-            task=self.task,
-            transform=self.train_transform,
-            split=Split.TRAIN,
-            root=self.root,
-            normal_dir=self.normal_dir,
-            abnormal_dir=self.abnormal_dir,
-            normal_test_dir=self.normal_test_dir,
-            mask_dir=self.mask_dir,
-            extensions=self.extensions,
-        )
-
-        self.test_data = FolderDataset(
-            name=self.name,
-            task=self.task,
-            transform=self.eval_transform,
-            split=Split.TEST,
-            root=self.root,
-            normal_dir=self.normal_dir,
-            abnormal_dir=self.abnormal_dir,
-            normal_test_dir=self.normal_test_dir,
-            mask_dir=self.mask_dir,
-            extensions=self.extensions,
-        )
-
-    @property
-    def name(self) -> str:
-        """Name of the datamodule.
-
-        Folder datamodule overrides the name property to provide a custom name.
-        """
-        return self._name
diff --git a/src/anomalib/data/image/kolektor.py b/src/anomalib/data/datasets/image/kolektor.py
similarity index 57%
rename from src/anomalib/data/image/kolektor.py
rename to src/anomalib/data/datasets/image/kolektor.py
index 049c770c45..39e9380a03 100644
--- a/src/anomalib/data/image/kolektor.py
+++ b/src/anomalib/data/datasets/image/kolektor.py
@@ -1,7 +1,7 @@
-"""Kolektor Surface-Defect Dataset (CC BY-NC-SA 4.0).
+"""Kolektor Surface-Defect Dataset.
 
 Description:
-    This script provides a PyTorch Dataset, DataLoader, and PyTorch Lightning DataModule for the Kolektor
+    This script provides a PyTorch Dataset for the Kolektor
     Surface-Defect dataset. The dataset can be accessed at `Kolektor Surface-Defect Dataset `_.
 
 License:
@@ -14,10 +14,9 @@
     for surface-defect detection." Journal of Intelligent Manufacturing 31, no. 3 (2020): 759-776.
 """
 
-# Copyright (C) 2023-2024 Intel Corporation
+# Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import logging
 from pathlib import Path
 
 import numpy as np
@@ -27,51 +26,36 @@
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibDataModule, AnomalibDataset
+from anomalib.data.datasets import AnomalibDataset
 from anomalib.data.errors import MisMatchError
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    TestSplitMode,
-    ValSplitMode,
-    download_and_extract,
-    validate_path,
-)
+from anomalib.data.utils import Split, validate_path
 
-__all__ = ["Kolektor", "KolektorDataset", "make_kolektor_dataset"]
 
-logger = logging.getLogger(__name__)
-
-DOWNLOAD_INFO = DownloadInfo(
-    name="kolektor",
-    url="https://go.vicos.si/kolektorsdd",
-    hashsum="65dc621693418585de9c4467d1340ea7958a6181816f0dc2883a1e8b61f9d4dc",
-    filename="KolektorSDD.zip",
-)
-
-
-def is_mask_anomalous(path: str) -> int:
-    """Check if a mask shows defects.
+class KolektorDataset(AnomalibDataset):
+    """Kolektor dataset class.
 
     Args:
-        path (str): Path to the mask file.
-
-    Returns:
-        int: 1 if the mask shows defects, 0 otherwise.
+        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``
+        root (Path | str): Path to the root of the dataset
+            Defaults to ``./datasets/kolektor``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+            Defaults to ``None``.
+    """
 
-    Example:
-        Assume that the following image is a mask for a defective image.
-        Then the function will return 1.
+    def __init__(
+        self,
+        task: TaskType,
+        root: Path | str = "./datasets/kolektor",
+        transform: Transform | None = None,
+        split: str | Split | None = None,
+    ) -> None:
+        super().__init__(task=task, transform=transform)
 
-        >>> from anomalib.data.image.kolektor import is_mask_anomalous
-        >>> path = './KolektorSDD/kos01/Part0_label.bmp'
-        >>> is_mask_anomalous(path)
-        1
-    """
-    img_arr = imread(path)
-    if np.all(img_arr == 0):
-        return 0
-    return 1
+        self.root = root
+        self.split = split
+        self.samples = make_kolektor_dataset(self.root, train_split_ratio=0.8, split=self.split)
 
 
 def make_kolektor_dataset(
@@ -183,160 +167,25 @@ def make_kolektor_dataset(
     return samples
 
 
-class KolektorDataset(AnomalibDataset):
-    """Kolektor dataset class.
+def is_mask_anomalous(path: str) -> int:
+    """Check if a mask shows defects.
 
     Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``
-        root (Path | str): Path to the root of the dataset
-            Defaults to ``./datasets/kolektor``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
-            Defaults to ``None``.
-    """
-
-    def __init__(
-        self,
-        task: TaskType,
-        root: Path | str = "./datasets/kolektor",
-        transform: Transform | None = None,
-        split: str | Split | None = None,
-    ) -> None:
-        super().__init__(task=task, transform=transform)
-
-        self.root = root
-        self.split = split
-        self.samples = make_kolektor_dataset(self.root, train_split_ratio=0.8, split=self.split)
+        path (str): Path to the mask file.
 
+    Returns:
+        int: 1 if the mask shows defects, 0 otherwise.
 
-class Kolektor(AnomalibDataModule):
-    """Kolektor Datamodule.
+    Example:
+        Assume that the following image is a mask for a defective image.
+        Then the function will return 1.
 
-    Args:
-        root (Path | str): Path to the root of the dataset
-        train_batch_size (int, optional): Training batch size.
-            Defaults to ``32``.
-        eval_batch_size (int, optional): Test batch size.
-            Defaults to ``32``.
-        num_workers (int, optional): Number of workers.
-            Defaults to ``8``.
-        task TaskType): Task type, 'classification', 'detection' or 'segmentation'
-            Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
-            Defaults to ``TestSplitMode.FROM_DIR``
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
-            Defaults to ``0.2``
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-            Defaults to ``ValSplitMode.SAME_AS_TEST``
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-            Defaults to ``0.5``
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
-            Defaults to ``None``.
+        >>> from anomalib.data.image.kolektor import is_mask_anomalous
+        >>> path = './KolektorSDD/kos01/Part0_label.bmp'
+        >>> is_mask_anomalous(path)
+        1
     """
-
-    def __init__(
-        self,
-        root: Path | str = "./datasets/kolektor",
-        train_batch_size: int = 32,
-        eval_batch_size: int = 32,
-        num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
-        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
-        test_split_ratio: float = 0.2,
-        val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
-        val_split_ratio: float = 0.5,
-        seed: int | None = None,
-    ) -> None:
-        super().__init__(
-            train_batch_size=train_batch_size,
-            eval_batch_size=eval_batch_size,
-            num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
-            test_split_mode=test_split_mode,
-            test_split_ratio=test_split_ratio,
-            val_split_mode=val_split_mode,
-            val_split_ratio=val_split_ratio,
-            seed=seed,
-        )
-
-        self.task = TaskType(task)
-        self.root = Path(root)
-
-    def _setup(self, _stage: str | None = None) -> None:
-        self.train_data = KolektorDataset(
-            task=self.task,
-            transform=self.train_transform,
-            split=Split.TRAIN,
-            root=self.root,
-        )
-        self.test_data = KolektorDataset(
-            task=self.task,
-            transform=self.eval_transform,
-            split=Split.TEST,
-            root=self.root,
-        )
-
-    def prepare_data(self) -> None:
-        """Download the dataset if not available.
-
-        This method checks if the specified dataset is available in the file system.
-        If not, it downloads and extracts the dataset into the appropriate directory.
-
-        Example:
-            Assume the dataset is not available on the file system.
-            Here's how the directory structure looks before and after calling the
-            `prepare_data` method:
-
-            Before:
-
-            .. code-block:: bash
-
-                $ tree datasets
-                datasets
-                ├── dataset1
-                └── dataset2
-
-            Calling the method:
-
-            .. code-block:: python
-
-                >> datamodule = Kolektor(root="./datasets/kolektor")
-                >> datamodule.prepare_data()
-
-            After:
-
-            .. code-block:: bash
-
-                $ tree datasets
-                datasets
-                ├── dataset1
-                ├── dataset2
-                └── kolektor
-                    ├── kolektorsdd
-                    ├── kos01
-                    ├── ...
-                    └── kos50
-                        ├── Part0.jpg
-                        ├── Part0_label.bmp
-                        └── ...
-        """
-        if (self.root).is_dir():
-            logger.info("Found the dataset.")
-        else:
-            download_and_extract(self.root, DOWNLOAD_INFO)
+    img_arr = imread(path)
+    if np.all(img_arr == 0):
+        return 0
+    return 1
diff --git a/src/anomalib/data/datasets/image/mvtec.py b/src/anomalib/data/datasets/image/mvtec.py
new file mode 100644
index 0000000000..bb6fdf9e41
--- /dev/null
+++ b/src/anomalib/data/datasets/image/mvtec.py
@@ -0,0 +1,215 @@
+"""MVTec AD Dataset.
+
+Description:
+    This script contains PyTorch Dataset for the MVTec AD dataset.
+    If the dataset is not on the file system, the script downloads and extracts
+    the dataset and create PyTorch data objects.
+
+License:
+    MVTec AD dataset is released under the Creative Commons
+    Attribution-NonCommercial-ShareAlike 4.0 International License
+    (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
+
+References:
+    - Paul Bergmann, Kilian Batzner, Michael Fauser, David Sattlegger, Carsten Steger:
+      The MVTec Anomaly Detection Dataset: A Comprehensive Real-World Dataset for
+      Unsupervised Anomaly Detection; in: International Journal of Computer Vision
+      129(4):1038-1059, 2021, DOI: 10.1007/s11263-020-01400-4.
+
+    - Paul Bergmann, Michael Fauser, David Sattlegger, Carsten Steger: MVTec AD —
+      A Comprehensive Real-World Dataset for Unsupervised Anomaly Detection;
+      in: IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR),
+      9584-9592, 2019, DOI: 10.1109/CVPR.2019.00982.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+from pathlib import Path
+
+from pandas import DataFrame
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datasets.base import AnomalibDataset
+from anomalib.data.errors import MisMatchError
+from anomalib.data.utils import LabelName, Split, validate_path
+
+IMG_EXTENSIONS = (".png", ".PNG")
+CATEGORIES = (
+    "bottle",
+    "cable",
+    "capsule",
+    "carpet",
+    "grid",
+    "hazelnut",
+    "leather",
+    "metal_nut",
+    "pill",
+    "screw",
+    "tile",
+    "toothbrush",
+    "transistor",
+    "wood",
+    "zipper",
+)
+
+
+class MVTecDataset(AnomalibDataset):
+    """MVTec dataset class.
+
+    Args:
+        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
+        root (Path | str): Path to the root of the dataset.
+            Defaults to ``./datasets/MVTec``.
+        category (str): Sub-category of the dataset, e.g. 'bottle'
+            Defaults to ``bottle``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+            Defaults to ``None``.
+
+    Examples:
+        .. code-block:: python
+
+            from anomalib.data.image.mvtec import MVTecDataset
+            from anomalib.data.utils.transforms import get_transforms
+
+            transform = get_transforms(image_size=256)
+            dataset = MVTecDataset(
+                task="classification",
+                transform=transform,
+                root='./datasets/MVTec',
+                category='zipper',
+            )
+            dataset.setup()
+            print(dataset[0].keys())
+            # Output: dict_keys(['image_path', 'label', 'image'])
+
+        When the task is segmentation, the dataset will also contain the mask:
+
+        .. code-block:: python
+
+            dataset.task = "segmentation"
+            dataset.setup()
+            print(dataset[0].keys())
+            # Output: dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask'])
+
+        The image is a torch tensor of shape (C, H, W) and the mask is a torch tensor of shape (H, W).
+
+        .. code-block:: python
+
+            print(dataset[0]["image"].shape, dataset[0]["mask"].shape)
+            # Output: (torch.Size([3, 256, 256]), torch.Size([256, 256]))
+
+    """
+
+    def __init__(
+        self,
+        task: TaskType,
+        root: Path | str = "./datasets/MVTec",
+        category: str = "bottle",
+        transform: Transform | None = None,
+        split: str | Split | None = None,
+    ) -> None:
+        super().__init__(task=task, transform=transform)
+
+        self.root_category = Path(root) / Path(category)
+        self.category = category
+        self.split = split
+        self.samples = make_mvtec_dataset(self.root_category, split=self.split, extensions=IMG_EXTENSIONS)
+
+
+def make_mvtec_dataset(
+    root: str | Path,
+    split: str | Split | None = None,
+    extensions: Sequence[str] | None = None,
+) -> DataFrame:
+    """Create MVTec AD samples by parsing the MVTec AD data file structure.
+
+    The files are expected to follow the structure:
+        path/to/dataset/split/category/image_filename.png
+        path/to/dataset/ground_truth/category/mask_filename.png
+
+    This function creates a dataframe to store the parsed information based on the following format:
+
+    +---+---------------+-------+---------+---------------+---------------------------------------+-------------+
+    |   | path          | split | label   | image_path    | mask_path                             | label_index |
+    +===+===============+=======+=========+===============+=======================================+=============+
+    | 0 | datasets/name | test  | defect  | filename.png  | ground_truth/defect/filename_mask.png | 1           |
+    +---+---------------+-------+---------+---------------+---------------------------------------+-------------+
+
+    Args:
+        root (Path): Path to dataset
+        split (str | Split | None, optional): Dataset split (ie., either train or test).
+            Defaults to ``None``.
+        extensions (Sequence[str] | None, optional): List of file extensions to be included in the dataset.
+            Defaults to ``None``.
+
+    Examples:
+        The following example shows how to get training samples from MVTec AD bottle category:
+
+        >>> root = Path('./MVTec')
+        >>> category = 'bottle'
+        >>> path = root / category
+        >>> path
+        PosixPath('MVTec/bottle')
+
+        >>> samples = make_mvtec_dataset(path, split='train', split_ratio=0.1, seed=0)
+        >>> samples.head()
+           path         split label image_path                           mask_path                   label_index
+        0  MVTec/bottle train good MVTec/bottle/train/good/105.png MVTec/bottle/ground_truth/good/105_mask.png 0
+        1  MVTec/bottle train good MVTec/bottle/train/good/017.png MVTec/bottle/ground_truth/good/017_mask.png 0
+        2  MVTec/bottle train good MVTec/bottle/train/good/137.png MVTec/bottle/ground_truth/good/137_mask.png 0
+        3  MVTec/bottle train good MVTec/bottle/train/good/152.png MVTec/bottle/ground_truth/good/152_mask.png 0
+        4  MVTec/bottle train good MVTec/bottle/train/good/109.png MVTec/bottle/ground_truth/good/109_mask.png 0
+
+    Returns:
+        DataFrame: an output dataframe containing the samples of the dataset.
+    """
+    if extensions is None:
+        extensions = IMG_EXTENSIONS
+
+    root = validate_path(root)
+    samples_list = [(str(root),) + f.parts[-3:] for f in root.glob(r"**/*") if f.suffix in extensions]
+    if not samples_list:
+        msg = f"Found 0 images in {root}"
+        raise RuntimeError(msg)
+
+    samples = DataFrame(samples_list, columns=["path", "split", "label", "image_path"])
+
+    # Modify image_path column by converting to absolute path
+    samples["image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.image_path
+
+    # Create label index for normal (0) and anomalous (1) images.
+    samples.loc[(samples.label == "good"), "label_index"] = LabelName.NORMAL
+    samples.loc[(samples.label != "good"), "label_index"] = LabelName.ABNORMAL
+    samples.label_index = samples.label_index.astype(int)
+
+    # separate masks from samples
+    mask_samples = samples.loc[samples.split == "ground_truth"].sort_values(by="image_path", ignore_index=True)
+    samples = samples[samples.split != "ground_truth"].sort_values(by="image_path", ignore_index=True)
+
+    # assign mask paths to anomalous test images
+    samples["mask_path"] = ""
+    samples.loc[
+        (samples.split == "test") & (samples.label_index == LabelName.ABNORMAL),
+        "mask_path",
+    ] = mask_samples.image_path.to_numpy()
+
+    # assert that the right mask files are associated with the right test images
+    abnormal_samples = samples.loc[samples.label_index == LabelName.ABNORMAL]
+    if (
+        len(abnormal_samples)
+        and not abnormal_samples.apply(lambda x: Path(x.image_path).stem in Path(x.mask_path).stem, axis=1).all()
+    ):
+        msg = """Mismatch between anomalous images and ground truth masks. Make sure t
+        he mask files in 'ground_truth' folder follow the same naming convention as the
+        anomalous images in the dataset (e.g. image: '000.png', mask: '000.png' or '000_mask.png')."""
+        raise MisMatchError(msg)
+
+    if split:
+        samples = samples[samples.split == split].reset_index(drop=True)
+
+    return samples
diff --git a/src/anomalib/data/datasets/image/visa.py b/src/anomalib/data/datasets/image/visa.py
new file mode 100644
index 0000000000..9c5336ab05
--- /dev/null
+++ b/src/anomalib/data/datasets/image/visa.py
@@ -0,0 +1,119 @@
+"""Visual Anomaly (VisA) Dataset.
+
+Description:
+    This script contains PyTorch Dataset for the Visual Anomal
+    (VisA) dataset. If the dataset is not on the file system, the script
+    downloads and extracts the dataset and create PyTorch data objects.
+
+License:
+    The VisA dataset is released under the Creative Commons
+    Attribution-NonCommercial-ShareAlike 4.0 International License
+    (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
+
+Reference:
+    - Zou, Y., Jeong, J., Pemula, L., Zhang, D., & Dabeer, O. (2022). SPot-the-Difference
+      Self-supervised Pre-training for Anomaly Detection and Segmentation. In European
+      Conference on Computer Vision (pp. 392-408). Springer, Cham.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datasets import AnomalibDataset
+from anomalib.data.datasets.image.mvtec import make_mvtec_dataset
+from anomalib.data.utils import Split
+
+EXTENSIONS = (".png", ".jpg", ".JPG")
+CATEGORIES = (
+    "candle",
+    "capsules",
+    "cashew",
+    "chewinggum",
+    "fryum",
+    "macaroni1",
+    "macaroni2",
+    "pcb1",
+    "pcb2",
+    "pcb3",
+    "pcb4",
+    "pipe_fryum",
+)
+
+
+class VisaDataset(AnomalibDataset):
+    """VisA dataset class.
+
+    Args:
+        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``
+        root (str | Path): Path to the root of the dataset
+        category (str): Sub-category of the dataset, e.g. 'candle'
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+            Defaults to ``None``.
+
+    Examples:
+        To create a Visa dataset for classification:
+
+        .. code-block:: python
+
+            from anomalib.data.image.visa import VisaDataset
+            from anomalib.data.utils.transforms import get_transforms
+
+            transform = get_transforms(image_size=256)
+            dataset = VisaDataset(
+                task="classification",
+                transform=transform,
+                split="train",
+                root="./datasets/visa/visa_pytorch/",
+                category="candle",
+            )
+            dataset.setup()
+            dataset[0].keys()
+
+            # Output
+            dict_keys(['image_path', 'label', 'image'])
+
+        If you want to use the dataset for segmentation, you can use the same
+        code as above, with the task set to ``segmentation``. The dataset will
+        then have a ``mask`` key in the output dictionary.
+
+        .. code-block:: python
+
+            from anomalib.data.image.visa import VisaDataset
+            from anomalib.data.utils.transforms import get_transforms
+
+            transform = get_transforms(image_size=256)
+            dataset = VisaDataset(
+                task="segmentation",
+                transform=transform,
+                split="train",
+                root="./datasets/visa/visa_pytorch/",
+                category="candle",
+            )
+            dataset.setup()
+            dataset[0].keys()
+
+            # Output
+            dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask'])
+
+    """
+
+    def __init__(
+        self,
+        task: TaskType,
+        root: str | Path,
+        category: str,
+        transform: Transform | None = None,
+        split: str | Split | None = None,
+    ) -> None:
+        super().__init__(task=task, transform=transform)
+
+        self.root_category = Path(root) / category
+        self.split = split
+        self.samples = make_mvtec_dataset(self.root_category, split=self.split, extensions=EXTENSIONS)
diff --git a/src/anomalib/data/datasets/video/__init__.py b/src/anomalib/data/datasets/video/__init__.py
new file mode 100644
index 0000000000..189841257a
--- /dev/null
+++ b/src/anomalib/data/datasets/video/__init__.py
@@ -0,0 +1,10 @@
+"""Torch Dataset Implementations of Anomalib Video Datasets."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .avenue import AvenueDataset
+from .shanghaitech import ShanghaiTechDataset
+from .ucsd_ped import UCSDpedDataset
+
+__all__ = ["AvenueDataset", "ShanghaiTechDataset", "UCSDpedDataset"]
diff --git a/src/anomalib/data/datasets/video/avenue.py b/src/anomalib/data/datasets/video/avenue.py
new file mode 100644
index 0000000000..0d3bd741bf
--- /dev/null
+++ b/src/anomalib/data/datasets/video/avenue.py
@@ -0,0 +1,209 @@
+"""CUHK Avenue Dataset.
+
+Description:
+    This script contains PyTorch Dataset for the CUHK Avenue dataset.
+    If the dataset is not already present on the file system, the DataModule class will download and
+    extract the dataset, converting the .mat mask files to .png format.
+
+Reference:
+    - Lu, Cewu, Jianping Shi, and Jiaya Jia. "Abnormal event detection at 150 fps in Matlab."
+      In Proceedings of the IEEE International Conference on Computer Vision, 2013.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import numpy as np
+import scipy
+import torch
+from pandas import DataFrame
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datasets.base.video import AnomalibVideoDataset, VideoTargetFrame
+from anomalib.data.utils import Split, read_mask, validate_path
+from anomalib.data.utils.video import ClipsIndexer
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class AvenueDataset(AnomalibVideoDataset):
+    """Avenue Dataset class.
+
+    Args:
+        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
+        split (Split): Split of the dataset, usually Split.TRAIN or Split.TEST
+        root (Path | str): Path to the root of the dataset
+            Defaults to ``./datasets/avenue``.
+        gt_dir (Path | str): Path to the ground truth files
+            Defaults to ``./datasets/avenue/ground_truth_demo``.
+        clip_length_in_frames (int, optional): Number of video frames in each clip.
+            Defaults to ``2``.
+        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
+            Defaults to ``1``.
+        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
+            Defaults to ``VideoTargetFrame.LAST``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+
+    Examples:
+        To create an Avenue dataset to train a classification model:
+
+        .. code-block:: python
+
+            transform = A.Compose([A.Resize(256, 256), A.pytorch.ToTensorV2()])
+            dataset = AvenueDataset(
+                task="classification",
+                transform=transform,
+                split="train",
+                root="./datasets/avenue/",
+            )
+
+            dataset.setup()
+            dataset[0].keys()
+
+            # Output: dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image'])
+
+        If you would like to test a segmentation model, you can use the following code:
+
+        .. code-block:: python
+
+            dataset = AvenueDataset(
+                task="segmentation",
+                transform=transform,
+                split="test",
+                root="./datasets/avenue/",
+            )
+
+            dataset.setup()
+            dataset[0].keys()
+
+            # Output: dict_keys(['image', 'mask', 'video_path', 'frames', 'last_frame', 'original_image', 'label'])
+
+        Avenue video dataset can also be used as an image dataset if you set the clip length to 1. This means that each
+        video frame will be treated as a separate sample. This is useful for training a classification model on the
+        Avenue dataset. The following code shows how to create an image dataset for classification:
+
+        .. code-block:: python
+
+            dataset = AvenueDataset(
+                task="classification",
+                transform=transform,
+                split="test",
+                root="./datasets/avenue/",
+                clip_length_in_frames=1,
+            )
+
+            dataset.setup()
+            dataset[0].keys()
+            # Output: dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image', 'label'])
+
+            dataset[0]["image"].shape
+            # Output: torch.Size([3, 256, 256])
+    """
+
+    def __init__(
+        self,
+        task: TaskType,
+        split: Split,
+        root: Path | str = "./datasets/avenue",
+        gt_dir: Path | str = "./datasets/avenue/ground_truth_demo",
+        clip_length_in_frames: int = 2,
+        frames_between_clips: int = 1,
+        transform: Transform | None = None,
+        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
+    ) -> None:
+        super().__init__(
+            task=task,
+            clip_length_in_frames=clip_length_in_frames,
+            frames_between_clips=frames_between_clips,
+            target_frame=target_frame,
+            transform=transform,
+        )
+
+        self.root = root if isinstance(root, Path) else Path(root)
+        self.gt_dir = gt_dir if isinstance(gt_dir, Path) else Path(gt_dir)
+        self.split = split
+        self.indexer_cls: Callable = AvenueClipsIndexer
+        self.samples = make_avenue_dataset(self.root, self.gt_dir, self.split)
+
+
+def make_avenue_dataset(root: Path, gt_dir: Path, split: Split | str | None = None) -> DataFrame:
+    """Create CUHK Avenue dataset by parsing the file structure.
+
+    The files are expected to follow the structure:
+        - path/to/dataset/[training_videos|testing_videos]/video_filename.avi
+        - path/to/ground_truth/mask_filename.mat
+
+    Args:
+        root (Path): Path to dataset
+        gt_dir (Path): Path to the ground truth
+        split (Split | str | None = None, optional): Dataset split (ie., either train or test).
+            Defaults to ``None``.
+
+    Example:
+        The following example shows how to get testing samples from Avenue dataset:
+
+        >>> root = Path('./avenue')
+        >>> gt_dir = Path('./avenue/masks')
+        >>> samples = make_avenue_dataset(path, gt_dir, split='test')
+        >>> samples.head()
+           root     folder         image_path                      mask_path                   split
+        0  ./avenue testing_videos ./avenue/training_videos/01.avi ./avenue/masks/01_label.mat test
+        1  ./avenue testing_videos ./avenue/training_videos/02.avi ./avenue/masks/01_label.mat test
+        ...
+
+    Returns:
+        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+    """
+    root = validate_path(root)
+
+    samples_list = [(str(root),) + filename.parts[-2:] for filename in root.glob("**/*.avi")]
+    samples = DataFrame(samples_list, columns=["root", "folder", "image_path"])
+
+    samples.loc[samples.folder == "testing_videos", "mask_path"] = (
+        samples.image_path.str.split(".").str[0].str.lstrip("0") + "_label.mat"
+    )
+    samples.loc[samples.folder == "testing_videos", "mask_path"] = (
+        str(gt_dir) + "/testing_label_mask/" + samples.mask_path
+    )
+    samples.loc[samples.folder == "training_videos", "mask_path"] = ""
+
+    samples["image_path"] = samples.root + "/" + samples.folder + "/" + samples.image_path
+
+    samples.loc[samples.folder == "training_videos", "split"] = "train"
+    samples.loc[samples.folder == "testing_videos", "split"] = "test"
+
+    if split:
+        samples = samples[samples.split == split]
+        samples = samples.reset_index(drop=True)
+
+    return samples
+
+
+class AvenueClipsIndexer(ClipsIndexer):
+    """Clips class for Avenue dataset."""
+
+    def get_mask(self, idx: int) -> np.ndarray | None:
+        """Retrieve the masks from the file system."""
+        video_idx, frames_idx = self.get_clip_location(idx)
+        matfile = self.mask_paths[video_idx]
+        if matfile == "":  # no gt masks available for this clip
+            return None
+        frames = self.clips[video_idx][frames_idx]
+
+        # read masks from .png files if available, othwerise from mat files.
+        mask_folder = Path(matfile).with_suffix("")
+        if mask_folder.exists():
+            mask_frames = sorted(mask_folder.glob("*"))
+            mask_paths = [mask_frames[idx] for idx in frames.int()]
+            masks = torch.stack([read_mask(mask_path, as_tensor=True) for mask_path in mask_paths])
+        else:
+            mat = scipy.io.loadmat(matfile)
+            masks = np.vstack([np.stack(m) for m in mat["volLabel"]])
+            masks = np.take(masks, frames, 0)
+        return masks
diff --git a/src/anomalib/data/video/shanghaitech.py b/src/anomalib/data/datasets/video/shanghaitech.py
similarity index 53%
rename from src/anomalib/data/video/shanghaitech.py
rename to src/anomalib/data/datasets/video/shanghaitech.py
index 0a1b09bfe4..e90dbae482 100644
--- a/src/anomalib/data/video/shanghaitech.py
+++ b/src/anomalib/data/datasets/video/shanghaitech.py
@@ -1,8 +1,7 @@
 """ShanghaiTech Campus Dataset.
 
 Description:
-    This module contains PyTorch Dataset and PyTorch
-    Lightning DataModule for the ShanghaiTech Campus dataset.
+    This script contains PyTorch Dataset for the ShanghaiTech Campus dataset.
     If the dataset is not on the file system, the DataModule class downloads and
     extracts the dataset and converts video files to a format that is readable by pyav.
 
@@ -14,12 +13,10 @@
       IEEE Conference on Computer Vision and Pattern Recognition (CVPR). 2018.
 """
 
-# Copyright (C) 2023-2024 Intel Corporation
+# Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import logging
 from pathlib import Path
-from shutil import move
 from typing import Any
 
 import numpy as np
@@ -29,86 +26,50 @@
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibVideoDataModule, AnomalibVideoDataset
-from anomalib.data.base.video import VideoTargetFrame
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    ValSplitMode,
-    download_and_extract,
-    read_image,
-    validate_path,
-)
-from anomalib.data.utils.video import ClipsIndexer, convert_video
-
-logger = logging.getLogger(__name__)
-
-DATASET_DOWNLOAD_INFO = DownloadInfo(
-    name="ShanghaiTech Dataset",
-    url="http://101.32.75.151:8181/dataset/shanghaitech.tar.gz",
-    hashsum="c13a827043b259ccf8493c9d9130486872992153a9d714fe229e523cd4c94116",
-)
+from anomalib.data.datasets.base.video import AnomalibVideoDataset, VideoTargetFrame
+from anomalib.data.utils import Split, read_image, validate_path
+from anomalib.data.utils.video import ClipsIndexer
 
 
-def make_shanghaitech_dataset(root: Path, scene: int, split: Split | str | None = None) -> DataFrame:
-    """Create ShanghaiTech dataset by parsing the file structure.
-
-    The files are expected to follow the structure:
-        path/to/dataset/[training_videos|testing_videos]/video_filename.avi
-        path/to/ground_truth/mask_filename.mat
+class ShanghaiTechDataset(AnomalibVideoDataset):
+    """ShanghaiTech Dataset class.
 
     Args:
-        root (Path): Path to dataset
+        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
+        split (Split): Split of the dataset, usually Split.TRAIN or Split.TEST
+        root (Path | str): Path to the root of the dataset
         scene (int): Index of the dataset scene (category) in range [1, 13]
-        split (Split | str | None, optional): Dataset split (ie., either train or test). Defaults to None.
-
-    Example:
-        The following example shows how to get testing samples from ShanghaiTech dataset:
-
-        >>> root = Path('./shanghaiTech')
-        >>> scene = 1
-        >>> samples = make_avenue_dataset(path, scene, split='test')
-        >>> samples.head()
-            root            image_path                          split   mask_path
-        0	shanghaitech	shanghaitech/testing/frames/01_0014	test	shanghaitech/testing/test_pixel_mask/01_0014.npy
-        1	shanghaitech	shanghaitech/testing/frames/01_0015	test	shanghaitech/testing/test_pixel_mask/01_0015.npy
-        ...
-
-    Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+        clip_length_in_frames (int, optional): Number of video frames in each clip.
+        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
+        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
     """
-    scene_prefix = str(scene).zfill(2)
 
-    # get paths to training videos
-    root = validate_path(root)
-    train_root = root / "training/converted_videos"
-    train_list = [(str(train_root),) + filename.parts[-2:] for filename in train_root.glob(f"{scene_prefix}_*.avi")]
-    train_samples = DataFrame(train_list, columns=["root", "folder", "image_path"])
-    train_samples["split"] = "train"
-
-    # get paths to testing folders
-    test_root = Path(root) / "testing/frames"
-    test_folders = [filename for filename in sorted(test_root.glob(f"{scene_prefix}_*")) if filename.is_dir()]
-    test_folders = [folder for folder in test_folders if len(list(folder.glob("*.jpg"))) > 0]
-    test_list = [(str(test_root),) + folder.parts[-2:] for folder in test_folders]
-    test_samples = DataFrame(test_list, columns=["root", "folder", "image_path"])
-    test_samples["split"] = "test"
-
-    samples = pd.concat([train_samples, test_samples], ignore_index=True)
-
-    gt_root = Path(root) / "testing/test_pixel_mask"
-    samples["mask_path"] = ""
-    samples.loc[samples.root == str(test_root), "mask_path"] = (
-        str(gt_root) + "/" + samples.image_path.str.split(".").str[0] + ".npy"
-    )
-
-    samples["image_path"] = samples.root + "/" + samples.image_path
-
-    if split:
-        samples = samples[samples.split == split]
-        samples = samples.reset_index(drop=True)
+    def __init__(
+        self,
+        task: TaskType,
+        split: Split,
+        root: Path | str = "./datasets/shanghaitech",
+        scene: int = 1,
+        clip_length_in_frames: int = 2,
+        frames_between_clips: int = 1,
+        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
+        transform: Transform | None = None,
+    ) -> None:
+        super().__init__(
+            task=task,
+            clip_length_in_frames=clip_length_in_frames,
+            frames_between_clips=frames_between_clips,
+            target_frame=target_frame,
+            transform=transform,
+        )
 
-    return samples
+        self.root = Path(root)
+        self.scene = scene
+        self.split = split
+        self.indexer_cls = ShanghaiTechTrainClipsIndexer if self.split == Split.TRAIN else ShanghaiTechTestClipsIndexer
+        self.samples = make_shanghaitech_dataset(self.root, self.scene, self.split)
 
 
 class ShanghaiTechTrainClipsIndexer(ClipsIndexer):
@@ -179,173 +140,62 @@ def get_clip(self, idx: int) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]
         return video, torch.empty((1, 0)), {}, video_idx
 
 
-class ShanghaiTechDataset(AnomalibVideoDataset):
-    """ShanghaiTech Dataset class.
+def make_shanghaitech_dataset(root: Path, scene: int, split: Split | str | None = None) -> DataFrame:
+    """Create ShanghaiTech dataset by parsing the file structure.
+
+    The files are expected to follow the structure:
+        path/to/dataset/[training_videos|testing_videos]/video_filename.avi
+        path/to/ground_truth/mask_filename.mat
 
     Args:
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
-        split (Split): Split of the dataset, usually Split.TRAIN or Split.TEST
-        root (Path | str): Path to the root of the dataset
+        root (Path): Path to dataset
         scene (int): Index of the dataset scene (category) in range [1, 13]
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-    """
-
-    def __init__(
-        self,
-        task: TaskType,
-        split: Split,
-        root: Path | str = "./datasets/shanghaitech",
-        scene: int = 1,
-        clip_length_in_frames: int = 2,
-        frames_between_clips: int = 1,
-        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
-        transform: Transform | None = None,
-    ) -> None:
-        super().__init__(
-            task=task,
-            clip_length_in_frames=clip_length_in_frames,
-            frames_between_clips=frames_between_clips,
-            target_frame=target_frame,
-            transform=transform,
-        )
-
-        self.root = Path(root)
-        self.scene = scene
-        self.split = split
-        self.indexer_cls = ShanghaiTechTrainClipsIndexer if self.split == Split.TRAIN else ShanghaiTechTestClipsIndexer
-        self.samples = make_shanghaitech_dataset(self.root, self.scene, self.split)
+        split (Split | str | None, optional): Dataset split (ie., either train or test). Defaults to None.
 
+    Example:
+        The following example shows how to get testing samples from ShanghaiTech dataset:
 
-class ShanghaiTech(AnomalibVideoDataModule):
-    """ShanghaiTech DataModule class.
+        >>> root = Path('./shanghaiTech')
+        >>> scene = 1
+        >>> samples = make_avenue_dataset(path, scene, split='test')
+        >>> samples.head()
+            root            image_path                          split   mask_path
+        0	shanghaitech	shanghaitech/testing/frames/01_0014	test	shanghaitech/testing/test_pixel_mask/01_0014.npy
+        1	shanghaitech	shanghaitech/testing/frames/01_0015	test	shanghaitech/testing/test_pixel_mask/01_0015.npy
+        ...
 
-    Args:
-        root (Path | str): Path to the root of the dataset
-        scene (int): Index of the dataset scene (category) in range [1, 13]
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
-        task TaskType): Task type, 'classification', 'detection' or 'segmentation'
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
-        train_batch_size (int, optional): Training batch size. Defaults to 32.
-        eval_batch_size (int, optional): Test batch size. Defaults to 32.
-        num_workers (int, optional): Number of workers. Defaults to 8.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+    Returns:
+        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
     """
+    scene_prefix = str(scene).zfill(2)
 
-    def __init__(
-        self,
-        root: Path | str = "./datasets/shanghaitech",
-        scene: int = 1,
-        clip_length_in_frames: int = 2,
-        frames_between_clips: int = 1,
-        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
-        task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
-        train_batch_size: int = 32,
-        eval_batch_size: int = 32,
-        num_workers: int = 8,
-        val_split_mode: ValSplitMode = ValSplitMode.SAME_AS_TEST,
-        val_split_ratio: float = 0.5,
-        seed: int | None = None,
-    ) -> None:
-        super().__init__(
-            train_batch_size=train_batch_size,
-            eval_batch_size=eval_batch_size,
-            num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
-            val_split_mode=val_split_mode,
-            val_split_ratio=val_split_ratio,
-            seed=seed,
-        )
-
-        self.task = TaskType(task)
-        self.root = Path(root)
-        self.scene = scene
+    # get paths to training videos
+    root = validate_path(root)
+    train_root = root / "training/converted_videos"
+    train_list = [(str(train_root),) + filename.parts[-2:] for filename in train_root.glob(f"{scene_prefix}_*.avi")]
+    train_samples = DataFrame(train_list, columns=["root", "folder", "image_path"])
+    train_samples["split"] = "train"
 
-        self.clip_length_in_frames = clip_length_in_frames
-        self.frames_between_clips = frames_between_clips
-        self.target_frame = target_frame
-
-    def _setup(self, _stage: str | None = None) -> None:
-        self.train_data = ShanghaiTechDataset(
-            task=self.task,
-            transform=self.train_transform,
-            clip_length_in_frames=self.clip_length_in_frames,
-            frames_between_clips=self.frames_between_clips,
-            target_frame=self.target_frame,
-            root=self.root,
-            scene=self.scene,
-            split=Split.TRAIN,
-        )
+    # get paths to testing folders
+    test_root = Path(root) / "testing/frames"
+    test_folders = [filename for filename in sorted(test_root.glob(f"{scene_prefix}_*")) if filename.is_dir()]
+    test_folders = [folder for folder in test_folders if len(list(folder.glob("*.jpg"))) > 0]
+    test_list = [(str(test_root),) + folder.parts[-2:] for folder in test_folders]
+    test_samples = DataFrame(test_list, columns=["root", "folder", "image_path"])
+    test_samples["split"] = "test"
 
-        self.test_data = ShanghaiTechDataset(
-            task=self.task,
-            transform=self.eval_transform,
-            clip_length_in_frames=self.clip_length_in_frames,
-            frames_between_clips=self.frames_between_clips,
-            target_frame=self.target_frame,
-            root=self.root,
-            scene=self.scene,
-            split=Split.TEST,
-        )
+    samples = pd.concat([train_samples, test_samples], ignore_index=True)
 
-    def prepare_data(self) -> None:
-        """Download the dataset and convert video files."""
-        training_root = self.root / "training"
-        if training_root.is_dir():
-            logger.info("Found the dataset.")
-        else:
-            download_and_extract(self.root, DATASET_DOWNLOAD_INFO)
-
-            # move contents to root
-            extracted_folder = self.root / "shanghaitech"
-            for filename in extracted_folder.glob("*"):
-                move(str(filename), str(self.root / filename.name))
-            extracted_folder.rmdir()
-
-        # convert images if not done already
-        vid_dir = training_root / "videos"
-        converted_vid_dir = training_root / "converted_videos"
-        vid_count = len(list(vid_dir.glob("*")))
-        converted_vid_count = len(list(converted_vid_dir.glob("*")))
-        if vid_count != converted_vid_count:
-            self._convert_training_videos(vid_dir, converted_vid_dir)
+    gt_root = Path(root) / "testing/test_pixel_mask"
+    samples["mask_path"] = ""
+    samples.loc[samples.root == str(test_root), "mask_path"] = (
+        str(gt_root) + "/" + samples.image_path.str.split(".").str[0] + ".npy"
+    )
 
-    @staticmethod
-    def _convert_training_videos(video_folder: Path, target_folder: Path) -> None:
-        """Re-code the training videos to ensure correct reading of frames by torchvision.
+    samples["image_path"] = samples.root + "/" + samples.image_path
 
-        The encoding of the raw video files in the ShanghaiTech dataset causes some problems when
-        reading the frames using pyav. To prevent this, we read the frames from the video files using opencv,
-        and write them to a new video file that can be parsed correctly with pyav.
+    if split:
+        samples = samples[samples.split == split]
+        samples = samples.reset_index(drop=True)
 
-        Args:
-            video_folder (Path): Path to the folder of training videos.
-            target_folder (Path): File system location where the converted videos will be stored.
-        """
-        training_videos = sorted(video_folder.glob("*"))
-        for video_idx, video_path in enumerate(training_videos):
-            logger.info("Converting training video %s (%i/%i)...", video_path.name, video_idx + 1, len(training_videos))
-            file_name = video_path.name
-            target_path = target_folder / file_name
-            convert_video(video_path, target_path, codec="XVID")
+    return samples
diff --git a/src/anomalib/data/video/ucsd_ped.py b/src/anomalib/data/datasets/video/ucsd_ped.py
similarity index 55%
rename from src/anomalib/data/video/ucsd_ped.py
rename to src/anomalib/data/datasets/video/ucsd_ped.py
index ba7850ecda..960218e79e 100644
--- a/src/anomalib/data/video/ucsd_ped.py
+++ b/src/anomalib/data/datasets/video/ucsd_ped.py
@@ -1,11 +1,9 @@
-"""UCSD Pedestrian dataset."""
+"""UCSD Pedestrian Dataset."""
 
-# Copyright (C) 2023-2024 Intel Corporation
+# Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import logging
 from pathlib import Path
-from shutil import move
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
@@ -14,84 +12,54 @@
 from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
-from anomalib.data.base import AnomalibVideoDataModule, AnomalibVideoDataset
-from anomalib.data.base.video import VideoTargetFrame
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    ValSplitMode,
-    download_and_extract,
-    read_image,
-    read_mask,
-    validate_path,
-)
+from anomalib.data.datasets.base.video import AnomalibVideoDataset, VideoTargetFrame
+from anomalib.data.utils import Split, read_image, read_mask, validate_path
 from anomalib.data.utils.video import ClipsIndexer
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-logger = logging.getLogger(__name__)
-
-DOWNLOAD_INFO = DownloadInfo(
-    name="UCSD Pedestrian",
-    url="http://www.svcl.ucsd.edu/projects/anomaly/UCSD_Anomaly_Dataset.tar.gz",
-    hashsum="2329af326951f5097fdd114c50e853957d3e569493a49d22fc082a9fd791915b",
-)
-
 CATEGORIES = ("UCSDped1", "UCSDped2")
 
 
-def make_ucsd_dataset(path: Path, split: str | Split | None = None) -> DataFrame:
-    """Create UCSD Pedestrian dataset by parsing the file structure.
-
-    The files are expected to follow the structure:
-        path/to/dataset/category/split/video_id/image_filename.tif
-        path/to/dataset/category/split/video_id_gt/mask_filename.bmp
+class UCSDpedDataset(AnomalibVideoDataset):
+    """UCSDped Dataset class.
 
     Args:
-        path (Path): Path to dataset
-        split (str | Split | None, optional): Dataset split (ie., either train or test). Defaults to None.
-
-    Example:
-        The following example shows how to get testing samples from UCSDped2 category:
-
-        >>> root = Path('./UCSDped')
-        >>> category = 'UCSDped2'
-        >>> path = root / category
-        >>> path
-        PosixPath('UCSDped/UCSDped2')
-
-        >>> samples = make_ucsd_dataset(path, split='test')
-        >>> samples.head()
-           root             folder image_path                    mask_path                         split
-        0  UCSDped/UCSDped2 Test   UCSDped/UCSDped2/Test/Test001 UCSDped/UCSDped2/Test/Test001_gt  test
-        1  UCSDped/UCSDped2 Test   UCSDped/UCSDped2/Test/Test002 UCSDped/UCSDped2/Test/Test002_gt  test
-        ...
-
-    Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
+        root (Path | str): Path to the root of the dataset
+        category (str): Sub-category of the dataset, e.g. "UCSDped1" or "UCSDped2"
+        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+        clip_length_in_frames (int, optional): Number of video frames in each clip.
+        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
+        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
     """
-    path = validate_path(path)
-    folders = [filename for filename in sorted(path.glob("*/*")) if filename.is_dir()]
-    folders = [folder for folder in folders if list(folder.glob("*.tif"))]
-
-    samples_list = [(str(path),) + folder.parts[-2:] for folder in folders]
-    samples = DataFrame(samples_list, columns=["root", "folder", "image_path"])
-
-    samples.loc[samples.folder == "Test", "mask_path"] = samples.image_path.str.split(".").str[0] + "_gt"
-    samples.loc[samples.folder == "Test", "mask_path"] = samples.root + "/" + samples.folder + "/" + samples.mask_path
-    samples.loc[samples.folder == "Train", "mask_path"] = ""
-
-    samples["image_path"] = samples.root + "/" + samples.folder + "/" + samples.image_path
-
-    samples.loc[samples.folder == "Train", "split"] = "train"
-    samples.loc[samples.folder == "Test", "split"] = "test"
 
-    if split:
-        samples = samples[samples.split == split]
-        samples = samples.reset_index(drop=True)
+    def __init__(
+        self,
+        task: TaskType,
+        root: str | Path,
+        category: str,
+        split: Split,
+        clip_length_in_frames: int = 2,
+        frames_between_clips: int = 10,
+        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
+        transform: Transform | None = None,
+    ) -> None:
+        super().__init__(
+            task=task,
+            clip_length_in_frames=clip_length_in_frames,
+            frames_between_clips=frames_between_clips,
+            target_frame=target_frame,
+            transform=transform,
+        )
 
-    return samples
+        self.root_category = Path(root) / category
+        self.split = split
+        self.indexer_cls: Callable = UCSDpedClipsIndexer
+        self.samples = make_ucsd_dataset(self.root_category, self.split)
 
 
 class UCSDpedClipsIndexer(ClipsIndexer):
@@ -146,144 +114,54 @@ def get_clip(self, idx: int) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]
         return video, torch.empty((1, 0)), {}, video_idx
 
 
-class UCSDpedDataset(AnomalibVideoDataset):
-    """UCSDped Dataset class.
+def make_ucsd_dataset(path: Path, split: str | Split | None = None) -> DataFrame:
+    """Create UCSD Pedestrian dataset by parsing the file structure.
 
-    Args:
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
-        root (Path | str): Path to the root of the dataset
-        category (str): Sub-category of the dataset, e.g. "UCSDped1" or "UCSDped2"
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-    """
+    The files are expected to follow the structure:
+        path/to/dataset/category/split/video_id/image_filename.tif
+        path/to/dataset/category/split/video_id_gt/mask_filename.bmp
 
-    def __init__(
-        self,
-        task: TaskType,
-        root: str | Path,
-        category: str,
-        split: Split,
-        clip_length_in_frames: int = 2,
-        frames_between_clips: int = 10,
-        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
-        transform: Transform | None = None,
-    ) -> None:
-        super().__init__(
-            task=task,
-            clip_length_in_frames=clip_length_in_frames,
-            frames_between_clips=frames_between_clips,
-            target_frame=target_frame,
-            transform=transform,
-        )
+    Args:
+        path (Path): Path to dataset
+        split (str | Split | None, optional): Dataset split (ie., either train or test). Defaults to None.
 
-        self.root_category = Path(root) / category
-        self.split = split
-        self.indexer_cls: Callable = UCSDpedClipsIndexer
-        self.samples = make_ucsd_dataset(self.root_category, self.split)
+    Example:
+        The following example shows how to get testing samples from UCSDped2 category:
 
+        >>> root = Path('./UCSDped')
+        >>> category = 'UCSDped2'
+        >>> path = root / category
+        >>> path
+        PosixPath('UCSDped/UCSDped2')
 
-class UCSDped(AnomalibVideoDataModule):
-    """UCSDped DataModule class.
+        >>> samples = make_ucsd_dataset(path, split='test')
+        >>> samples.head()
+           root             folder image_path                    mask_path                         split
+        0  UCSDped/UCSDped2 Test   UCSDped/UCSDped2/Test/Test001 UCSDped/UCSDped2/Test/Test001_gt  test
+        1  UCSDped/UCSDped2 Test   UCSDped/UCSDped2/Test/Test002 UCSDped/UCSDped2/Test/Test002_gt  test
+        ...
 
-    Args:
-        root (Path | str): Path to the root of the dataset
-        category (str): Sub-category of the dataset, e.g. "UCSDped1" or "UCSDped2"
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
-        train_batch_size (int, optional): Training batch size. Defaults to 32.
-        eval_batch_size (int, optional): Test batch size. Defaults to 32.
-        num_workers (int, optional): Number of workers. Defaults to 8.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+    Returns:
+        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
     """
+    path = validate_path(path)
+    folders = [filename for filename in sorted(path.glob("*/*")) if filename.is_dir()]
+    folders = [folder for folder in folders if list(folder.glob("*.tif"))]
 
-    def __init__(
-        self,
-        root: Path | str = "./datasets/ucsd",
-        category: str = "UCSDped2",
-        clip_length_in_frames: int = 2,
-        frames_between_clips: int = 10,
-        target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
-        task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
-        train_batch_size: int = 8,
-        eval_batch_size: int = 8,
-        num_workers: int = 8,
-        val_split_mode: ValSplitMode = ValSplitMode.SAME_AS_TEST,
-        val_split_ratio: float = 0.5,
-        seed: int | None = None,
-    ) -> None:
-        super().__init__(
-            train_batch_size=train_batch_size,
-            eval_batch_size=eval_batch_size,
-            num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
-            val_split_mode=val_split_mode,
-            val_split_ratio=val_split_ratio,
-            seed=seed,
-        )
+    samples_list = [(str(path),) + folder.parts[-2:] for folder in folders]
+    samples = DataFrame(samples_list, columns=["root", "folder", "image_path"])
 
-        self.task = TaskType(task)
-        self.root = Path(root)
-        self.category = category
-
-        self.clip_length_in_frames = clip_length_in_frames
-        self.frames_between_clips = frames_between_clips
-        self.target_frame = VideoTargetFrame(target_frame)
-
-    def _setup(self, _stage: str | None = None) -> None:
-        self.train_data = UCSDpedDataset(
-            task=self.task,
-            transform=self.train_transform,
-            clip_length_in_frames=self.clip_length_in_frames,
-            frames_between_clips=self.frames_between_clips,
-            target_frame=self.target_frame,
-            root=self.root,
-            category=self.category,
-            split=Split.TRAIN,
-        )
+    samples.loc[samples.folder == "Test", "mask_path"] = samples.image_path.str.split(".").str[0] + "_gt"
+    samples.loc[samples.folder == "Test", "mask_path"] = samples.root + "/" + samples.folder + "/" + samples.mask_path
+    samples.loc[samples.folder == "Train", "mask_path"] = ""
 
-        self.test_data = UCSDpedDataset(
-            task=self.task,
-            transform=self.eval_transform,
-            clip_length_in_frames=self.clip_length_in_frames,
-            frames_between_clips=self.frames_between_clips,
-            target_frame=self.target_frame,
-            root=self.root,
-            category=self.category,
-            split=Split.TEST,
-        )
+    samples["image_path"] = samples.root + "/" + samples.folder + "/" + samples.image_path
+
+    samples.loc[samples.folder == "Train", "split"] = "train"
+    samples.loc[samples.folder == "Test", "split"] = "test"
 
-    def prepare_data(self) -> None:
-        """Download the dataset if not available."""
-        if (self.root / self.category).is_dir():
-            logger.info("Found the dataset.")
-        else:
-            download_and_extract(self.root, DOWNLOAD_INFO)
-
-            # move contents to root
-            extracted_folder = self.root / "UCSD_Anomaly_Dataset.v1p2"
-            for filename in extracted_folder.glob("*"):
-                move(str(filename), str(self.root / filename.name))
-            extracted_folder.rmdir()
+    if split:
+        samples = samples[samples.split == split]
+        samples = samples.reset_index(drop=True)
+
+    return samples
diff --git a/src/anomalib/data/predict.py b/src/anomalib/data/predict.py
index 857ddd218e..06c743b88f 100644
--- a/src/anomalib/data/predict.py
+++ b/src/anomalib/data/predict.py
@@ -9,8 +9,8 @@
 from torch.utils.data.dataset import Dataset
 from torchvision.transforms.v2 import Transform
 
+from anomalib.data import ImageBatch, ImageItem
 from anomalib.data.utils import get_image_filenames, read_image
-from anomalib.dataclasses import ImageBatch, ImageItem
 
 
 class PredictDataset(Dataset):
diff --git a/src/anomalib/data/utils/split.py b/src/anomalib/data/utils/split.py
index 6bfc089846..fe085ea1cf 100644
--- a/src/anomalib/data/utils/split.py
+++ b/src/anomalib/data/utils/split.py
@@ -20,7 +20,7 @@
 import torch
 
 if TYPE_CHECKING:
-    from anomalib import data
+    from anomalib.data import datasets as data
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/anomalib/data/utils/synthetic.py b/src/anomalib/data/utils/synthetic.py
index 20ba836bee..16aa20d83d 100644
--- a/src/anomalib/data/utils/synthetic.py
+++ b/src/anomalib/data/utils/synthetic.py
@@ -19,7 +19,7 @@
 from torchvision.transforms.v2 import Compose
 
 from anomalib import TaskType
-from anomalib.data.base.dataset import AnomalibDataset
+from anomalib.data.datasets.base.image import AnomalibDataset
 from anomalib.data.utils import Augmenter, Split, read_image
 
 logger = logging.getLogger(__name__)
diff --git a/src/anomalib/data/utils/video.py b/src/anomalib/data/utils/video.py
index 330f58948c..cc3d839dfa 100644
--- a/src/anomalib/data/utils/video.py
+++ b/src/anomalib/data/utils/video.py
@@ -11,7 +11,7 @@
 import torch
 from torchvision.datasets.video_utils import VideoClips
 
-from anomalib.dataclasses import VideoItem
+from anomalib.data import VideoItem
 
 
 class ClipsIndexer(VideoClips, ABC):
diff --git a/src/anomalib/dataclasses/torch.py b/src/anomalib/dataclasses/torch.py
deleted file mode 100644
index 7bc4e93c0c..0000000000
--- a/src/anomalib/dataclasses/torch.py
+++ /dev/null
@@ -1,687 +0,0 @@
-"""Torch-based dataclasses for Anomalib.
-
-This module provides PyTorch-based implementations of the generic dataclasses
-used in Anomalib. These classes are designed to work with PyTorch tensors for
-efficient data handling and processing in anomaly detection tasks.
-
-These classes extend the generic dataclasses defined in the Anomalib framework,
-providing concrete implementations that use PyTorch tensors for tensor-like data.
-They include methods for data validation and support operations specific to
-image, video, and depth data in the context of anomaly detection.
-
-Note:
-    When using these classes, ensure that the input data is in the correct
-    format (PyTorch tensors with appropriate shapes) to avoid validation errors.
-"""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from collections.abc import Callable, Sequence
-from dataclasses import asdict, dataclass, fields
-from typing import ClassVar, Generic, NamedTuple, TypeVar
-
-import numpy as np
-import torch
-from torchvision.transforms.v2.functional import to_dtype_image
-from torchvision.tv_tensors import Image, Mask, Video
-
-from .generic import (
-    BatchIterateMixin,
-    ImageT,
-    _DepthInputFields,
-    _GenericBatch,
-    _GenericItem,
-    _ImageInputFields,
-    _VideoInputFields,
-)
-from .numpy import NumpyImageBatch, NumpyImageItem, NumpyVideoBatch, NumpyVideoItem
-
-NumpyT = TypeVar("NumpyT")
-
-
-class InferenceBatch(NamedTuple):
-    """Batch for use in torch and inference models."""
-
-    pred_score: torch.Tensor | None = None
-    pred_label: torch.Tensor | None = None
-    anomaly_map: torch.Tensor | None = None
-    pred_mask: torch.Tensor | None = None
-
-
-@dataclass
-class ToNumpyMixin(Generic[NumpyT]):
-    """Mixin for converting torch-based dataclasses to numpy.
-
-    This mixin provides functionality to convert PyTorch tensor data to numpy arrays.
-    It requires the subclass to define a 'numpy_class' attribute specifying the
-    corresponding numpy-based class.
-
-    Examples:
-        >>> from anomalib.dataclasses.numpy import NumpyImageItem
-        >>> @dataclass
-        ... class TorchImageItem(ToNumpyMixin[NumpyImageItem]):
-        ...     numpy_class = NumpyImageItem
-        ...     image: torch.Tensor
-        ...     gt_label: torch.Tensor
-
-        >>> torch_item = TorchImageItem(image=torch.rand(3, 224, 224), gt_label=torch.tensor(1))
-        >>> numpy_item = torch_item.to_numpy()
-        >>> isinstance(numpy_item, NumpyImageItem)
-        True
-    """
-
-    numpy_class: ClassVar[Callable]
-
-    def __init_subclass__(cls, **kwargs) -> None:
-        """Ensure that the subclass has the required attributes."""
-        super().__init_subclass__(**kwargs)
-        if not hasattr(cls, "numpy_class"):
-            msg = f"{cls.__name__} must have a 'numpy_class' attribute."
-            raise AttributeError(msg)
-
-    def to_numpy(self) -> NumpyT:
-        """Convert the batch to a NumpyBatch object."""
-        batch_dict = asdict(self)
-        for key, value in batch_dict.items():
-            if isinstance(value, torch.Tensor):
-                batch_dict[key] = value.cpu().numpy()
-        return self.numpy_class(
-            **batch_dict,
-        )
-
-
-@dataclass
-class DatasetItem(Generic[ImageT], _GenericItem[torch.Tensor, ImageT, Mask, str]):
-    """Base dataclass for individual items in Anomalib datasets using PyTorch tensors.
-
-    This class extends the generic _GenericItem class to provide a PyTorch-specific
-    implementation for single data items in Anomalib datasets. It is designed to
-    handle various types of data (e.g., images, labels, masks) represented as
-    PyTorch tensors.
-
-    The class uses generic types to allow flexibility in the image representation,
-    which can vary depending on the specific use case (e.g., standard images, video clips).
-
-    Attributes:
-        Inherited from _GenericItem, with PyTorch tensor and Mask types.
-
-    Note:
-        This class is typically subclassed to create more specific item types
-        (e.g., ImageItem, VideoItem) with additional fields and methods.
-    """
-
-
-@dataclass
-class Batch(Generic[ImageT], _GenericBatch[torch.Tensor, ImageT, Mask, list[str]]):
-    """Base dataclass for batches of items in Anomalib datasets using PyTorch tensors.
-
-    This class extends the generic _GenericBatch class to provide a PyTorch-specific
-    implementation for batches of data in Anomalib datasets. It is designed to
-    handle collections of data items (e.g., multiple images, labels, masks)
-    represented as PyTorch tensors.
-
-    The class uses generic types to allow flexibility in the image representation,
-    which can vary depending on the specific use case (e.g., standard images, video clips).
-
-    Attributes:
-        Inherited from _GenericBatch, with PyTorch tensor and Mask types.
-
-    Note:
-        This class is typically subclassed to create more specific batch types
-        (e.g., ImageBatch, VideoBatch) with additional fields and methods.
-    """
-
-
-@dataclass
-class ImageItem(
-    ToNumpyMixin[NumpyImageItem],
-    _ImageInputFields[str],
-    DatasetItem[Image],
-):
-    """Dataclass for individual image items in Anomalib datasets using PyTorch tensors.
-
-    This class combines the functionality of ToNumpyMixin, _ImageInputFields, and
-    DatasetItem to represent single image data points in Anomalib. It includes
-    image-specific fields and provides methods for data validation and conversion
-    to numpy format.
-
-    The class is designed to work with PyTorch tensors and includes fields for
-    the image data, ground truth labels and masks, anomaly maps, and related metadata.
-
-    Attributes:
-        Inherited from _ImageInputFields and DatasetItem.
-
-    Methods:
-        Inherited from ToNumpyMixin, including to_numpy() for conversion to numpy format.
-
-    Examples:
-        >>> item = ImageItem(
-        ...     image=torch.rand(3, 224, 224),
-        ...     gt_label=torch.tensor(1),
-        ...     gt_mask=torch.rand(224, 224) > 0.5,
-        ...     image_path="path/to/image.jpg"
-        ... )
-
-        >>> print(item.image.shape)
-        torch.Size([3, 224, 224])
-
-        >>> numpy_item = item.to_numpy()
-        >>> print(type(numpy_item))
-        
-    """
-
-    numpy_class = NumpyImageItem
-
-    def _validate_image(self, image: torch.Tensor) -> Image:
-        assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
-        assert image.ndim == 3, f"Image must have shape [C, H, W], got shape {image.shape}."
-        assert image.shape[0] == 3, f"Image must have 3 channels, got {image.shape[0]}."
-        return to_dtype_image(image, torch.float32, scale=True)
-
-    def _validate_gt_label(self, gt_label: torch.Tensor | int | None) -> torch.Tensor:
-        if gt_label is None:
-            return None
-        if isinstance(gt_label, int):
-            gt_label = torch.tensor(gt_label)
-        assert isinstance(
-            gt_label,
-            torch.Tensor,
-        ), f"Ground truth label must be an integer or a torch.Tensor, got {type(gt_label)}."
-        assert gt_label.ndim == 0, f"Ground truth label must be a scalar, got shape {gt_label.shape}."
-        assert not torch.is_floating_point(gt_label), f"Ground truth label must be boolean or integer, got {gt_label}."
-        return gt_label.bool()
-
-    def _validate_gt_mask(self, gt_mask: torch.Tensor | None) -> Mask | None:
-        if gt_mask is None:
-            return None
-        assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
-        assert gt_mask.ndim in {
-            2,
-            3,
-        }, f"Ground truth mask must have shape [H, W] or [1, H, W] got shape {gt_mask.shape}."
-        if gt_mask.ndim == 3:
-            assert gt_mask.shape[0] == 1, f"Ground truth mask must have 1 channel, got {gt_mask.shape[0]}."
-            gt_mask = gt_mask.squeeze(0)
-        return Mask(gt_mask, dtype=torch.bool)
-
-    def _validate_mask_path(self, mask_path: str | None) -> str | None:
-        if mask_path is None:
-            return None
-        return str(mask_path)
-
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor | None) -> Mask | None:
-        if anomaly_map is None:
-            return None
-        assert isinstance(anomaly_map, torch.Tensor), f"Anomaly map must be a torch.Tensor, got {type(anomaly_map)}."
-        assert anomaly_map.ndim in {
-            2,
-            3,
-        }, f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
-        if anomaly_map.ndim == 3:
-            assert (
-                anomaly_map.shape[0] == 1
-            ), f"Anomaly map with 3 dimensions must have 1 channel, got {anomaly_map.shape[0]}."
-            anomaly_map = anomaly_map.squeeze(0)
-        return Mask(anomaly_map, dtype=torch.float32)
-
-    def _validate_pred_score(self, pred_score: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
-        if pred_score is None:
-            return torch.amax(self.anomaly_map, dim=(-2, -1)) if self.anomaly_map is not None else None
-        if not isinstance(pred_score, torch.Tensor):
-            try:
-                pred_score = torch.tensor(pred_score)
-            except Exception as e:
-                msg = "Failed to convert pred_score to a torch.Tensor."
-                raise ValueError(msg) from e
-        pred_score = pred_score.squeeze()
-        assert pred_score.ndim == 0, f"Predicted score must be a scalar, got shape {pred_score.shape}."
-        return pred_score.to(torch.float32)
-
-    def _validate_pred_mask(self, pred_mask: torch.Tensor | None) -> Mask | None:
-        if pred_mask is None:
-            return None
-        assert isinstance(pred_mask, torch.Tensor), f"Predicted mask must be a torch.Tensor, got {type(pred_mask)}."
-        assert pred_mask.ndim in {
-            2,
-            3,
-        }, f"Predicted mask must have shape [H, W] or [1, H, W] got shape {pred_mask.shape}."
-        if pred_mask.ndim == 3:
-            assert pred_mask.shape[0] == 1, f"Predicted mask must have 1 channel, got {pred_mask.shape[0]}."
-            pred_mask = pred_mask.squeeze(0)
-        return Mask(pred_mask, dtype=torch.bool)
-
-    def _validate_pred_label(self, pred_label: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
-        if pred_label is None:
-            return None
-        if not isinstance(pred_label, torch.Tensor):
-            try:
-                pred_label = torch.tensor(pred_label)
-            except Exception as e:
-                msg = "Failed to convert pred_score to a torch.Tensor."
-                raise ValueError(msg) from e
-        pred_label = pred_label.squeeze()
-        assert pred_label.ndim == 0, f"Predicted label must be a scalar, got shape {pred_label.shape}."
-        return pred_label.to(torch.bool)
-
-    def _validate_image_path(self, image_path: str | None) -> str | None:
-        if image_path is None:
-            return None
-        return str(image_path)
-
-
-@dataclass
-class ImageBatch(
-    ToNumpyMixin[NumpyImageBatch],
-    BatchIterateMixin[ImageItem],
-    _ImageInputFields[list[str]],
-    Batch[Image],
-):
-    """Dataclass for batches of image items in Anomalib datasets using PyTorch tensors.
-
-    This class combines the functionality of ``ToNumpyMixin``, ``BatchIterateMixin``,
-    ``_ImageInputFields``, and ``Batch`` to represent collections of image data points in Anomalib.
-    It includes image-specific fields and provides methods for batch operations,
-    iteration over individual items, and conversion to numpy format.
-
-    The class is designed to work with PyTorch tensors and includes fields for
-    batches of image data, ground truth labels and masks, anomaly maps, and related metadata.
-
-    Examples:
-        >>> batch = ImageBatch(
-        ...     image=torch.rand(32, 3, 224, 224),
-        ...     gt_label=torch.randint(0, 2, (32,)),
-        ...     gt_mask=torch.rand(32, 224, 224) > 0.5,
-        ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)]
-        ... )
-
-        >>> print(batch.image.shape)
-        torch.Size([32, 3, 224, 224])
-
-        >>> for item in batch:
-        ...     print(item.image.shape)
-        torch.Size([3, 224, 224])
-
-        >>> numpy_batch = batch.to_numpy()
-        >>> print(type(numpy_batch))
-        
-    """
-
-    item_class = ImageItem
-    numpy_class = NumpyImageBatch
-
-    def _validate_image(self, image: Image) -> Image:
-        assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
-        assert image.ndim in {3, 4}, f"Image must have shape [C, H, W] or [N, C, H, W], got shape {image.shape}."
-        if image.ndim == 3:
-            image = image.unsqueeze(0)  # add batch dimension
-        assert image.shape[1] == 3, f"Image must have 3 channels, got {image.shape[0]}."
-        return Image(image, dtype=torch.float32)
-
-    def _validate_gt_label(self, gt_label: torch.Tensor | Sequence[int] | None) -> torch.Tensor:
-        if gt_label is None:
-            return None
-        if isinstance(gt_label, Sequence):
-            gt_label = torch.tensor(gt_label)
-        assert isinstance(
-            gt_label,
-            torch.Tensor,
-        ), f"Ground truth label must be a sequence of integers or a torch.Tensor, got {type(gt_label)}."
-        assert gt_label.ndim == 1, f"Ground truth label must be a 1-dimensional vector, got shape {gt_label.shape}."
-        assert (
-            len(gt_label) == self.batch_size
-        ), f"Ground truth label must have length {self.batch_size}, got length {len(gt_label)}."
-        assert not torch.is_floating_point(gt_label), f"Ground truth label must be boolean or integer, got {gt_label}."
-        return gt_label.bool()
-
-    def _validate_gt_mask(self, gt_mask: Mask | None) -> Mask | None:
-        if gt_mask is None:
-            return None
-        assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
-        assert gt_mask.ndim in {
-            2,
-            3,
-            4,
-        }, f"Ground truth mask must have shape [H, W] or [N, H, W] or [N, 1, H, W] got shape {gt_mask.shape}."
-        if gt_mask.ndim == 2:
-            assert (
-                self.batch_size == 1
-            ), f"Invalid shape for gt_mask. Got mask shape {gt_mask.shape} for batch size {self.batch_size}."
-            gt_mask = gt_mask.unsqueeze(0)
-        if gt_mask.ndim == 3:
-            assert (
-                gt_mask.shape[0] == self.batch_size
-            ), f"Invalid shape for gt_mask. Got mask shape {gt_mask.shape} for batch size {self.batch_size}."
-        if gt_mask.ndim == 4:
-            assert gt_mask.shape[1] == 1, f"Ground truth mask must have 1 channel, got {gt_mask.shape[1]}."
-            gt_mask = gt_mask.squeeze(1)
-        return Mask(gt_mask, dtype=torch.bool)
-
-    def _validate_mask_path(self, mask_path: Sequence[str] | Sequence[str] | None) -> list[str] | None:
-        if mask_path is None:
-            return None
-        assert isinstance(
-            mask_path,
-            Sequence,
-        ), f"Mask path must be a sequence of paths or strings, got {type(mask_path)}."
-        assert (
-            len(mask_path) == self.batch_size
-        ), f"Invalid length for mask_path. Got length {len(mask_path)} for batch size {self.batch_size}."
-        return [str(path) for path in mask_path]
-
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
-        if anomaly_map is None:
-            return None
-        if not isinstance(anomaly_map, torch.Tensor):
-            try:
-                anomaly_map = torch.tensor(anomaly_map)
-            except Exception as e:
-                msg = "Failed to convert anomaly_map to a torch.Tensor."
-                raise ValueError(msg) from e
-        assert anomaly_map.ndim in {
-            2,
-            3,
-            4,
-        }, f"Anomaly map must have shape [H, W] or [N, H, W] or [N, 1, H, W], got shape {anomaly_map.shape}."
-        if anomaly_map.ndim == 2:
-            assert (
-                self.batch_size == 1
-            ), f"Invalid shape for anomaly_map. Got mask shape {anomaly_map.shape} for batch size {self.batch_size}."
-            anomaly_map = anomaly_map.unsqueeze(0)
-        if anomaly_map.ndim == 4:
-            assert anomaly_map.shape[1] == 1, f"Anomaly map must have 1 channel, got {anomaly_map.shape[1]}."
-            anomaly_map = anomaly_map.squeeze(1)
-        return Mask(anomaly_map, dtype=torch.float32)
-
-    def _validate_pred_score(self, pred_score: torch.Tensor | None) -> torch.Tensor | None:
-        if pred_score is None and self.anomaly_map is not None:
-            return torch.amax(self.anomaly_map, dim=(-2, -1))
-        return pred_score
-
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor | None:
-        return pred_mask
-
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor | None:
-        return pred_label
-
-    def _validate_image_path(self, image_path: list[str]) -> list[str] | None:
-        return image_path
-
-
-# torch video outputs
-@dataclass
-class VideoItem(
-    ToNumpyMixin[NumpyVideoItem],
-    _VideoInputFields[torch.Tensor, Video, Mask, str],
-    DatasetItem[Video],
-):
-    """Dataclass for individual video items in Anomalib datasets using PyTorch tensors.
-
-    This class represents a single video item in Anomalib datasets using PyTorch tensors.
-    It combines the functionality of ToNumpyMixin, _VideoInputFields, and DatasetItem
-    to handle video data, including frames, labels, masks, and metadata.
-
-    Examples:
-        >>> item = VideoItem(
-        ...     image=torch.rand(10, 3, 224, 224),  # 10 frames
-        ...     gt_label=torch.tensor(1),
-        ...     gt_mask=torch.rand(10, 224, 224) > 0.5,
-        ...     video_path="path/to/video.mp4"
-        ... )
-
-        >>> print(item.image.shape)
-        torch.Size([10, 3, 224, 224])
-
-        >>> numpy_item = item.to_numpy()
-        >>> print(type(numpy_item))
-        
-    """
-
-    numpy_class = NumpyVideoItem
-
-    def _validate_image(self, image: Image) -> Video:
-        return image
-
-    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
-        return gt_label
-
-    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
-        return gt_mask
-
-    def _validate_mask_path(self, mask_path: str) -> str:
-        return mask_path
-
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor | None:
-        return anomaly_map
-
-    def _validate_pred_score(self, pred_score: torch.Tensor | None) -> torch.Tensor | None:
-        return pred_score
-
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor | None:
-        return pred_mask
-
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor | None:
-        return pred_label
-
-    def _validate_original_image(self, original_image: Video) -> Video:
-        return original_image
-
-    def _validate_video_path(self, video_path: str) -> str:
-        return video_path
-
-    def _validate_target_frame(self, target_frame: torch.Tensor) -> torch.Tensor:
-        return target_frame
-
-    def _validate_frames(self, frames: torch.Tensor) -> torch.Tensor:
-        return frames
-
-    def _validate_last_frame(self, last_frame: torch.Tensor) -> torch.Tensor:
-        return last_frame
-
-    def to_image(self) -> ImageItem:
-        """Convert the video item to an image item."""
-        image_keys = [field.name for field in fields(ImageItem)]
-        return ImageItem(**{key: getattr(self, key, None) for key in image_keys})
-
-
-@dataclass
-class VideoBatch(
-    ToNumpyMixin[NumpyVideoBatch],
-    BatchIterateMixin[VideoItem],
-    _VideoInputFields[torch.Tensor, Video, Mask, list[str]],
-    Batch[Video],
-):
-    """Dataclass for batches of video items in Anomalib datasets using PyTorch tensors.
-
-    This class represents a batch of video items in Anomalib datasets using PyTorch tensors.
-    It combines the functionality of ToNumpyMixin, BatchIterateMixin, _VideoInputFields,
-    and Batch to handle batches of video data, including frames, labels, masks, and metadata.
-
-    Examples:
-        >>> batch = VideoBatch(
-        ...     image=torch.rand(32, 10, 3, 224, 224),  # 32 videos, 10 frames each
-        ...     gt_label=torch.randint(0, 2, (32,)),
-        ...     gt_mask=torch.rand(32, 10, 224, 224) > 0.5,
-        ...     video_path=["path/to/video_{}.mp4".format(i) for i in range(32)]
-        ... )
-
-        >>> print(batch.image.shape)
-        torch.Size([32, 10, 3, 224, 224])
-
-        >>> for item in batch:
-        ...     print(item.image.shape)
-        torch.Size([10, 3, 224, 224])
-
-        >>> numpy_batch = batch.to_numpy()
-        >>> print(type(numpy_batch))
-        
-    """
-
-    item_class = VideoItem
-    numpy_class = NumpyVideoBatch
-
-    def _validate_image(self, image: Image) -> Video:
-        return image
-
-    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
-        return gt_label
-
-    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
-        return gt_mask
-
-    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
-        return mask_path
-
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
-        return anomaly_map
-
-    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
-        return pred_score
-
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
-        return pred_mask
-
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
-        return pred_label
-
-    def _validate_original_image(self, original_image: Video) -> Video:
-        return original_image
-
-    def _validate_video_path(self, video_path: list[str]) -> list[str]:
-        return video_path
-
-    def _validate_target_frame(self, target_frame: torch.Tensor) -> torch.Tensor:
-        return target_frame
-
-    def _validate_frames(self, frames: torch.Tensor) -> torch.Tensor:
-        return frames
-
-    def _validate_last_frame(self, last_frame: torch.Tensor) -> torch.Tensor:
-        return last_frame
-
-
-# depth
-@dataclass
-class DepthItem(
-    ToNumpyMixin[NumpyImageItem],
-    _DepthInputFields[torch.Tensor, str],
-    DatasetItem[Image],
-):
-    """Dataclass for individual depth items in Anomalib datasets using PyTorch tensors.
-
-    This class represents a single depth item in Anomalib datasets using PyTorch tensors.
-    It combines the functionality of ToNumpyMixin, _DepthInputFields, and DatasetItem
-    to handle depth data, including depth maps, labels, and metadata.
-
-    Examples:
-        >>> item = DepthItem(
-        ...     image=torch.rand(3, 224, 224),
-        ...     gt_label=torch.tensor(1),
-        ...     depth_map=torch.rand(224, 224),
-        ...     image_path="path/to/image.jpg",
-        ...     depth_path="path/to/depth.png"
-        ... )
-
-        >>> print(item.image.shape, item.depth_map.shape)
-        torch.Size([3, 224, 224]) torch.Size([224, 224])
-    """
-
-    numpy_class = NumpyImageItem
-
-    def _validate_image(self, image: Image) -> Image:
-        return image
-
-    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
-        return gt_label
-
-    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
-        return gt_mask
-
-    def _validate_mask_path(self, mask_path: str) -> str:
-        return mask_path
-
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
-        return anomaly_map
-
-    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
-        return pred_score
-
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
-        return pred_mask
-
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
-        return pred_label
-
-    def _validate_image_path(self, image_path: str) -> str:
-        return image_path
-
-    def _validate_depth_map(self, depth_map: torch.Tensor) -> torch.Tensor:
-        return depth_map
-
-    def _validate_depth_path(self, depth_path: str) -> str:
-        return depth_path
-
-
-@dataclass
-class DepthBatch(
-    BatchIterateMixin[DepthItem],
-    _DepthInputFields[torch.Tensor, list[str]],
-    Batch[Image],
-):
-    """Dataclass for batches of depth items in Anomalib datasets using PyTorch tensors.
-
-    This class represents a batch of depth items in Anomalib datasets using PyTorch tensors.
-    It combines the functionality of BatchIterateMixin, _DepthInputFields, and Batch
-    to handle batches of depth data, including depth maps, labels, and metadata.
-
-    Examples:
-        >>> batch = DepthBatch(
-        ...     image=torch.rand(32, 3, 224, 224),
-        ...     gt_label=torch.randint(0, 2, (32,)),
-        ...     depth_map=torch.rand(32, 224, 224),
-        ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)],
-        ...     depth_path=["path/to/depth_{}.png".format(i) for i in range(32)]
-        ... )
-
-        >>> print(batch.image.shape, batch.depth_map.shape)
-        torch.Size([32, 3, 224, 224]) torch.Size([32, 224, 224])
-
-        >>> for item in batch:
-        ...     print(item.image.shape, item.depth_map.shape)
-        torch.Size([3, 224, 224]) torch.Size([224, 224])
-    """
-
-    item_class = DepthItem
-
-    def _validate_image(self, image: Image) -> Image:
-        return image
-
-    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
-        return gt_label
-
-    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
-        return gt_mask
-
-    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
-        return mask_path
-
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
-        return anomaly_map
-
-    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
-        return pred_score
-
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
-        return pred_mask
-
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
-        return pred_label
-
-    def _validate_image_path(self, image_path: list[str]) -> list[str]:
-        return image_path
-
-    def _validate_depth_map(self, depth_map: torch.Tensor) -> torch.Tensor:
-        return depth_map
-
-    def _validate_depth_path(self, depth_path: list[str]) -> list[str]:
-        return depth_path
diff --git a/src/anomalib/deploy/inferencers/openvino_inferencer.py b/src/anomalib/deploy/inferencers/openvino_inferencer.py
index 201ea78707..08ce792042 100644
--- a/src/anomalib/deploy/inferencers/openvino_inferencer.py
+++ b/src/anomalib/deploy/inferencers/openvino_inferencer.py
@@ -11,8 +11,8 @@
 import numpy as np
 from openvino.runtime.utils.data_helpers.wrappers import OVDict
 
+from anomalib.data import NumpyImageBatch
 from anomalib.data.utils import read_image
-from anomalib.dataclasses import NumpyImageBatch
 
 logger = logging.getLogger("anomalib")
 
diff --git a/src/anomalib/deploy/inferencers/torch_inferencer.py b/src/anomalib/deploy/inferencers/torch_inferencer.py
index c6f093a02a..ed4283ad82 100644
--- a/src/anomalib/deploy/inferencers/torch_inferencer.py
+++ b/src/anomalib/deploy/inferencers/torch_inferencer.py
@@ -8,8 +8,8 @@
 import torch
 from torch import nn
 
+from anomalib.data import ImageBatch
 from anomalib.data.utils import read_image
-from anomalib.dataclasses import ImageBatch
 
 
 class TorchInferencer:
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py
index d970f8840c..0baf47e564 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomaly_module.py
@@ -19,7 +19,7 @@
 from torchvision.transforms.v2 import Compose, Normalize, Resize, Transform
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch, InferenceBatch
+from anomalib.data import Batch, InferenceBatch
 from anomalib.metrics.threshold import Threshold
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 
diff --git a/src/anomalib/models/image/cfa/lightning_model.py b/src/anomalib/models/image/cfa/lightning_model.py
index 3960c4c7a1..e367762484 100644
--- a/src/anomalib/models/image/cfa/lightning_model.py
+++ b/src/anomalib/models/image/cfa/lightning_model.py
@@ -15,7 +15,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import CfaLoss
diff --git a/src/anomalib/models/image/cfa/torch_model.py b/src/anomalib/models/image/cfa/torch_model.py
index 4c92eeb39b..dfedb5c40c 100644
--- a/src/anomalib/models/image/cfa/torch_model.py
+++ b/src/anomalib/models/image/cfa/torch_model.py
@@ -20,7 +20,7 @@
 from torchvision.models.feature_extraction import create_feature_extractor
 from tqdm import tqdm
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import DynamicBufferMixin
 from anomalib.models.components.feature_extractors import dryrun_find_featuremap_dims
 
diff --git a/src/anomalib/models/image/cflow/lightning_model.py b/src/anomalib/models/image/cflow/lightning_model.py
index 620022fd74..edb4788111 100644
--- a/src/anomalib/models/image/cflow/lightning_model.py
+++ b/src/anomalib/models/image/cflow/lightning_model.py
@@ -22,7 +22,7 @@
 from torch.optim import Optimizer
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule
 
 from .torch_model import CflowModel
diff --git a/src/anomalib/models/image/cflow/torch_model.py b/src/anomalib/models/image/cflow/torch_model.py
index 57fbd37e15..98de7ea69e 100644
--- a/src/anomalib/models/image/cflow/torch_model.py
+++ b/src/anomalib/models/image/cflow/torch_model.py
@@ -9,7 +9,7 @@
 import torch
 from torch import nn
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerator
diff --git a/src/anomalib/models/image/csflow/lightning_model.py b/src/anomalib/models/image/csflow/lightning_model.py
index 14fd7697de..3244ef7da7 100644
--- a/src/anomalib/models/image/csflow/lightning_model.py
+++ b/src/anomalib/models/image/csflow/lightning_model.py
@@ -13,7 +13,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import CsFlowLoss
diff --git a/src/anomalib/models/image/csflow/torch_model.py b/src/anomalib/models/image/csflow/torch_model.py
index 6f2120ec38..d562fe79b3 100644
--- a/src/anomalib/models/image/csflow/torch_model.py
+++ b/src/anomalib/models/image/csflow/torch_model.py
@@ -20,7 +20,7 @@
 from torch.nn import functional as F  # noqa: N812
 from torchvision.models.efficientnet import EfficientNet_B5_Weights
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components.feature_extractors import TorchFXFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerator, AnomalyMapMode
diff --git a/src/anomalib/models/image/dfkde/lightning_model.py b/src/anomalib/models/image/dfkde/lightning_model.py
index f0d094696e..210242ec5f 100644
--- a/src/anomalib/models/image/dfkde/lightning_model.py
+++ b/src/anomalib/models/image/dfkde/lightning_model.py
@@ -11,7 +11,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.models.components.classification import FeatureScalingMethod
 
diff --git a/src/anomalib/models/image/dfkde/torch_model.py b/src/anomalib/models/image/dfkde/torch_model.py
index e235bcff92..4dc5fd58fe 100644
--- a/src/anomalib/models/image/dfkde/torch_model.py
+++ b/src/anomalib/models/image/dfkde/torch_model.py
@@ -10,7 +10,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 from anomalib.models.components.classification import FeatureScalingMethod, KDEClassifier
 
diff --git a/src/anomalib/models/image/dfm/lightning_model.py b/src/anomalib/models/image/dfm/lightning_model.py
index 107215437a..64777fda87 100644
--- a/src/anomalib/models/image/dfm/lightning_model.py
+++ b/src/anomalib/models/image/dfm/lightning_model.py
@@ -13,7 +13,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 
 from .torch_model import DFMModel
diff --git a/src/anomalib/models/image/dfm/torch_model.py b/src/anomalib/models/image/dfm/torch_model.py
index 46288457d7..a89e5749d1 100644
--- a/src/anomalib/models/image/dfm/torch_model.py
+++ b/src/anomalib/models/image/dfm/torch_model.py
@@ -9,7 +9,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import PCA, DynamicBufferMixin, TimmFeatureExtractor
 
 
diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py
index 68d6f68119..1ee025d117 100644
--- a/src/anomalib/models/image/draem/lightning_model.py
+++ b/src/anomalib/models/image/draem/lightning_model.py
@@ -14,8 +14,8 @@
 from torch import nn
 
 from anomalib import LearningType
+from anomalib.data import Batch
 from anomalib.data.utils import Augmenter
-from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import DraemLoss
diff --git a/src/anomalib/models/image/draem/torch_model.py b/src/anomalib/models/image/draem/torch_model.py
index d0df3fa0cc..2fd9e8c4cc 100644
--- a/src/anomalib/models/image/draem/torch_model.py
+++ b/src/anomalib/models/image/draem/torch_model.py
@@ -12,7 +12,7 @@
 import torch
 from torch import nn
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components.layers import SSPCAB
 
 
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index 8526699d27..a0c41bfc66 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -14,9 +14,9 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT, OptimizerLRScheduler
 
 from anomalib import LearningType
+from anomalib.data import Batch
 from anomalib.data.utils import DownloadInfo, download_and_extract
 from anomalib.data.utils.augmenter import Augmenter
-from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 from anomalib.models.image.dsr.anomaly_generator import DsrAnomalyGenerator
 from anomalib.models.image.dsr.loss import DsrSecondStageLoss, DsrThirdStageLoss
diff --git a/src/anomalib/models/image/dsr/torch_model.py b/src/anomalib/models/image/dsr/torch_model.py
index b44904cb19..2e6f6ac411 100644
--- a/src/anomalib/models/image/dsr/torch_model.py
+++ b/src/anomalib/models/image/dsr/torch_model.py
@@ -16,7 +16,7 @@
 import torch.nn.functional as F  # noqa: N812
 from torch import nn
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 
 
 class DsrModel(nn.Module):
diff --git a/src/anomalib/models/image/efficient_ad/lightning_model.py b/src/anomalib/models/image/efficient_ad/lightning_model.py
index db9b1fad4c..1fe6753438 100644
--- a/src/anomalib/models/image/efficient_ad/lightning_model.py
+++ b/src/anomalib/models/image/efficient_ad/lightning_model.py
@@ -18,8 +18,8 @@
 from torchvision.transforms.v2 import CenterCrop, Compose, Normalize, RandomGrayscale, Resize, ToTensor, Transform
 
 from anomalib import LearningType
+from anomalib.data import Batch
 from anomalib.data.utils import DownloadInfo, download_and_extract
-from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 
 from .torch_model import EfficientAdModel, EfficientAdModelSize, reduce_tensor_elems
diff --git a/src/anomalib/models/image/efficient_ad/torch_model.py b/src/anomalib/models/image/efficient_ad/torch_model.py
index 57b9c87340..16cb48ead7 100644
--- a/src/anomalib/models/image/efficient_ad/torch_model.py
+++ b/src/anomalib/models/image/efficient_ad/torch_model.py
@@ -13,7 +13,7 @@
 from torch.nn import functional as F  # noqa: N812
 from torchvision import transforms
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/anomalib/models/image/fastflow/lightning_model.py b/src/anomalib/models/image/fastflow/lightning_model.py
index 587f117f5b..577daaeb5f 100644
--- a/src/anomalib/models/image/fastflow/lightning_model.py
+++ b/src/anomalib/models/image/fastflow/lightning_model.py
@@ -13,7 +13,7 @@
 from torch import optim
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import FastflowLoss
diff --git a/src/anomalib/models/image/fastflow/torch_model.py b/src/anomalib/models/image/fastflow/torch_model.py
index 3c84b69fa2..b0eb35882a 100644
--- a/src/anomalib/models/image/fastflow/torch_model.py
+++ b/src/anomalib/models/image/fastflow/torch_model.py
@@ -18,7 +18,7 @@
 from timm.models.vision_transformer import VisionTransformer
 from torch import nn
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components.flow import AllInOneBlock
 
 from .anomaly_map import AnomalyMapGenerator
diff --git a/src/anomalib/models/image/fre/lightning_model.py b/src/anomalib/models/image/fre/lightning_model.py
index 7abcd8d0a8..20c383b128 100755
--- a/src/anomalib/models/image/fre/lightning_model.py
+++ b/src/anomalib/models/image/fre/lightning_model.py
@@ -14,7 +14,7 @@
 from torch import optim
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule
 
 from .torch_model import FREModel
diff --git a/src/anomalib/models/image/fre/torch_model.py b/src/anomalib/models/image/fre/torch_model.py
index fdb13fb9e2..c2eb0c3416 100755
--- a/src/anomalib/models/image/fre/torch_model.py
+++ b/src/anomalib/models/image/fre/torch_model.py
@@ -7,7 +7,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 
 
diff --git a/src/anomalib/models/image/ganomaly/lightning_model.py b/src/anomalib/models/image/ganomaly/lightning_model.py
index 495dbe294c..5633c003ac 100644
--- a/src/anomalib/models/image/ganomaly/lightning_model.py
+++ b/src/anomalib/models/image/ganomaly/lightning_model.py
@@ -14,7 +14,7 @@
 from torch import optim
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import DiscriminatorLoss, GeneratorLoss
diff --git a/src/anomalib/models/image/ganomaly/torch_model.py b/src/anomalib/models/image/ganomaly/torch_model.py
index 3703349997..3d791c8501 100644
--- a/src/anomalib/models/image/ganomaly/torch_model.py
+++ b/src/anomalib/models/image/ganomaly/torch_model.py
@@ -14,8 +14,8 @@
 import torch
 from torch import nn
 
+from anomalib.data import InferenceBatch
 from anomalib.data.utils.image import pad_nextpow2
-from anomalib.dataclasses import InferenceBatch
 
 
 class Encoder(nn.Module):
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index 819eb73cca..5b09edd1c0 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -13,7 +13,7 @@
 from torchvision.transforms.v2 import Compose, Normalize, Resize, Transform
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.post_processing.one_class import OneClassPostProcessor, PostProcessor
 
diff --git a/src/anomalib/models/image/padim/torch_model.py b/src/anomalib/models/image/padim/torch_model.py
index 14dc379eee..4f77344763 100644
--- a/src/anomalib/models/image/padim/torch_model.py
+++ b/src/anomalib/models/image/padim/torch_model.py
@@ -10,7 +10,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import MultiVariateGaussian, TimmFeatureExtractor
 from anomalib.models.components.feature_extractors import dryrun_find_featuremap_dims
 
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index 15126838bf..4d5fe514a8 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -15,7 +15,7 @@
 from torchvision.transforms.v2 import CenterCrop, Compose, Normalize, Resize, Transform
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.post_processing.one_class import OneClassPostProcessor
 
diff --git a/src/anomalib/models/image/patchcore/torch_model.py b/src/anomalib/models/image/patchcore/torch_model.py
index bde5607aae..80133b4bd2 100644
--- a/src/anomalib/models/image/patchcore/torch_model.py
+++ b/src/anomalib/models/image/patchcore/torch_model.py
@@ -10,7 +10,7 @@
 from torch import nn
 from torch.nn import functional as F  # noqa: N812
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import DynamicBufferMixin, KCenterGreedy, TimmFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerator
diff --git a/src/anomalib/models/image/reverse_distillation/lightning_model.py b/src/anomalib/models/image/reverse_distillation/lightning_model.py
index b68cfb8287..c1ba797a03 100644
--- a/src/anomalib/models/image/reverse_distillation/lightning_model.py
+++ b/src/anomalib/models/image/reverse_distillation/lightning_model.py
@@ -13,7 +13,7 @@
 from torch import optim
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule
 
 from .anomaly_map import AnomalyMapGenerationMode
diff --git a/src/anomalib/models/image/reverse_distillation/torch_model.py b/src/anomalib/models/image/reverse_distillation/torch_model.py
index 66e0d4415a..04739e14c9 100644
--- a/src/anomalib/models/image/reverse_distillation/torch_model.py
+++ b/src/anomalib/models/image/reverse_distillation/torch_model.py
@@ -9,7 +9,7 @@
 import torch
 from torch import nn
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerationMode, AnomalyMapGenerator
diff --git a/src/anomalib/models/image/stfpm/lightning_model.py b/src/anomalib/models/image/stfpm/lightning_model.py
index 21b8c49952..42fc3c0c3d 100644
--- a/src/anomalib/models/image/stfpm/lightning_model.py
+++ b/src/anomalib/models/image/stfpm/lightning_model.py
@@ -14,7 +14,7 @@
 from torch import optim
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import STFPMLoss
diff --git a/src/anomalib/models/image/stfpm/torch_model.py b/src/anomalib/models/image/stfpm/torch_model.py
index b501921705..ea169719e9 100644
--- a/src/anomalib/models/image/stfpm/torch_model.py
+++ b/src/anomalib/models/image/stfpm/torch_model.py
@@ -9,7 +9,7 @@
 import torch
 from torch import nn
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import TimmFeatureExtractor
 
 from .anomaly_map import AnomalyMapGenerator
diff --git a/src/anomalib/models/image/uflow/lightning_model.py b/src/anomalib/models/image/uflow/lightning_model.py
index d28188181a..b7368b1e4d 100644
--- a/src/anomalib/models/image/uflow/lightning_model.py
+++ b/src/anomalib/models/image/uflow/lightning_model.py
@@ -16,7 +16,7 @@
 from torchvision.transforms.v2 import Compose, Normalize, Resize, Transform
 
 from anomalib import LearningType
-from anomalib.dataclasses import Batch
+from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule
 
 from .loss import UFlowLoss
diff --git a/src/anomalib/models/image/uflow/torch_model.py b/src/anomalib/models/image/uflow/torch_model.py
index 659b21c755..69bec13ae1 100644
--- a/src/anomalib/models/image/uflow/torch_model.py
+++ b/src/anomalib/models/image/uflow/torch_model.py
@@ -8,7 +8,7 @@
 from FrEIA import modules as fm
 from torch import nn
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components.flow import AllInOneBlock
 
 from .anomaly_map import AnomalyMapGenerator
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index e422f42566..07af1ee852 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -16,8 +16,8 @@
 from torchvision.transforms.v2 import Compose, InterpolationMode, Normalize, Resize, Transform
 
 from anomalib import LearningType
+from anomalib.data import Batch
 from anomalib.data.predict import PredictDataset
-from anomalib.dataclasses import Batch
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import OneClassPostProcessor
 
diff --git a/src/anomalib/models/image/winclip/torch_model.py b/src/anomalib/models/image/winclip/torch_model.py
index 210b3446b0..8d2bfc69f9 100644
--- a/src/anomalib/models/image/winclip/torch_model.py
+++ b/src/anomalib/models/image/winclip/torch_model.py
@@ -13,7 +13,7 @@
 from torch.nn.modules.linear import Identity
 from torchvision.transforms import Compose, ToPILImage
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.models.components import BufferListMixin, DynamicBufferMixin
 
 from .prompting import create_prompt_ensemble
diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py
index 41127ccd48..7e683b8e35 100644
--- a/src/anomalib/models/video/ai_vad/lightning_model.py
+++ b/src/anomalib/models/video/ai_vad/lightning_model.py
@@ -14,7 +14,7 @@
 from torchvision.transforms.v2 import Transform
 
 from anomalib import LearningType
-from anomalib.dataclasses import VideoBatch
+from anomalib.data import VideoBatch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.post_processing.one_class import OneClassPostProcessor, PostProcessor
 
diff --git a/src/anomalib/models/video/ai_vad/torch_model.py b/src/anomalib/models/video/ai_vad/torch_model.py
index cc1305af90..2679470d01 100644
--- a/src/anomalib/models/video/ai_vad/torch_model.py
+++ b/src/anomalib/models/video/ai_vad/torch_model.py
@@ -9,7 +9,7 @@
 import torch
 from torch import nn
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 
 from .density import CombinedDensityEstimator
 from .features import FeatureExtractor
diff --git a/src/anomalib/post_processing/base.py b/src/anomalib/post_processing/base.py
index 027925f30d..f5b49bc8b1 100644
--- a/src/anomalib/post_processing/base.py
+++ b/src/anomalib/post_processing/base.py
@@ -8,7 +8,7 @@
 from lightning.pytorch import Callback
 from torch import nn
 
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 
 
 class PostProcessor(nn.Module, Callback, ABC):
diff --git a/src/anomalib/post_processing/one_class.py b/src/anomalib/post_processing/one_class.py
index 27d78c0853..c19ef85300 100644
--- a/src/anomalib/post_processing/one_class.py
+++ b/src/anomalib/post_processing/one_class.py
@@ -6,7 +6,7 @@
 import torch
 from lightning import LightningModule, Trainer
 
-from anomalib.dataclasses import Batch, InferenceBatch
+from anomalib.data import Batch, InferenceBatch
 from anomalib.metrics import F1AdaptiveThreshold, MinMax
 
 from .base import PostProcessor
diff --git a/src/anomalib/utils/visualization/image.py b/src/anomalib/utils/visualization/image.py
index f66f95a4b3..16b852235f 100644
--- a/src/anomalib/utils/visualization/image.py
+++ b/src/anomalib/utils/visualization/image.py
@@ -15,8 +15,8 @@
 from skimage.segmentation import mark_boundaries
 
 from anomalib import TaskType
+from anomalib.data import ImageItem, NumpyImageItem, VideoItem
 from anomalib.data.utils import read_image
-from anomalib.dataclasses import ImageItem, NumpyImageItem, VideoItem
 from anomalib.utils.post_processing import (
     add_anomalous_label,
     add_normal_label,
diff --git a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py b/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
index 74aec3293b..121420168b 100644
--- a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
+++ b/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
@@ -12,7 +12,7 @@
 
 from anomalib import LearningType
 from anomalib.callbacks.metrics import _MetricsCallback
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import InferenceBatch
 from anomalib.metrics import AnomalibMetricCollection
 from anomalib.metrics.threshold import F1AdaptiveThreshold
 from anomalib.models.components import AnomalyModule
diff --git a/tests/unit/data/test_inference.py b/tests/unit/data/test_inference.py
index 9c1ab941fb..f4cb4aaaf4 100644
--- a/tests/unit/data/test_inference.py
+++ b/tests/unit/data/test_inference.py
@@ -8,8 +8,7 @@
 import pytest
 from torchvision.transforms import v2
 
-from anomalib.data import PredictDataset
-from anomalib.dataclasses import ImageItem
+from anomalib.data import ImageItem, PredictDataset
 
 
 @pytest.fixture(scope="module")
diff --git a/tests/unit/data/utils/test_synthetic.py b/tests/unit/data/utils/test_synthetic.py
index 4d6ab0a3c7..67b421c90d 100644
--- a/tests/unit/data/utils/test_synthetic.py
+++ b/tests/unit/data/utils/test_synthetic.py
@@ -9,7 +9,7 @@
 import pytest
 
 from anomalib import TaskType
-from anomalib.data.image.folder import FolderDataset
+from anomalib.data.datasets.image.folder import FolderDataset
 from anomalib.data.utils.synthetic import SyntheticAnomalyDataset
 
 
diff --git a/tests/unit/engine/test_setup_transform.py b/tests/unit/engine/test_setup_transform.py
index bae883d742..cf3febd0ac 100644
--- a/tests/unit/engine/test_setup_transform.py
+++ b/tests/unit/engine/test_setup_transform.py
@@ -13,8 +13,7 @@
 from torchvision.transforms.v2 import Resize, Transform
 
 from anomalib import LearningType, TaskType
-from anomalib.data import AnomalibDataModule, AnomalibDataset
-from anomalib.dataclasses import InferenceBatch
+from anomalib.data import AnomalibDataModule, AnomalibDataset, InferenceBatch
 from anomalib.engine import Engine
 from anomalib.models import AnomalyModule
 from anomalib.post_processing import PostProcessor
diff --git a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
index 317e1c6a60..ed41825a14 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
@@ -10,7 +10,7 @@
 from torch import nn
 
 from anomalib import LearningType
-from anomalib.dataclasses import ImageBatch, InferenceBatch
+from anomalib.data import ImageBatch, InferenceBatch
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
 
diff --git a/tests/unit/utils/test_visualizer.py b/tests/unit/utils/test_visualizer.py
index e5fb1b97f9..977598e0e4 100644
--- a/tests/unit/utils/test_visualizer.py
+++ b/tests/unit/utils/test_visualizer.py
@@ -12,8 +12,7 @@
 from torch.utils.data import DataLoader
 
 from anomalib import TaskType
-from anomalib.data import MVTec, PredictDataset
-from anomalib.dataclasses import ImageBatch
+from anomalib.data import ImageBatch, MVTec, PredictDataset
 from anomalib.engine import Engine
 from anomalib.models import get_model
 from anomalib.utils.visualization.image import _ImageGrid

From 8543e24f21159091b8ebe5f8e00cfd61ea8991b2 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 18 Sep 2024 12:01:16 +0100
Subject: [PATCH 06/45] Restructure unit tests and fix ruff issues (#2306)

* Restructure data unit tests to follow the new data structure

* Fix ruff issues
---
 src/anomalib/data/dataclasses/numpy/image.py  | 54 ++++++++-----
 src/anomalib/data/dataclasses/numpy/video.py  | 27 ++++---
 src/anomalib/data/dataclasses/torch/depth.py  | 66 ++++++++++------
 src/anomalib/data/dataclasses/torch/image.py  | 36 ++++++---
 src/anomalib/data/dataclasses/torch/video.py  | 78 ++++++++++++-------
 src/anomalib/engine/engine.py                 |  2 +-
 .../models/components/base/anomaly_module.py  |  3 +-
 .../models/image/padim/lightning_model.py     |  5 +-
 .../models/image/patchcore/lightning_model.py |  3 +-
 .../models/image/winclip/lightning_model.py   |  3 +-
 .../models/video/ai_vad/lightning_model.py    |  3 +-
 .../test_metrics_configuration_callback.py    |  3 +-
 tests/unit/data/datamodule/__init__.py        |  4 +
 .../data/{ => datamodule}/base/__init__.py    |  0
 tests/unit/data/{ => datamodule}/base/base.py |  0
 .../unit/data/{ => datamodule}/base/depth.py  |  3 +-
 .../unit/data/{ => datamodule}/base/image.py  |  3 +-
 .../unit/data/{ => datamodule}/base/video.py  |  3 +-
 tests/unit/data/datamodule/depth/__init__.py  |  4 +
 .../depth}/test_folder_3d.py                  |  2 +-
 .../depth}/test_mvtec_3d.py                   |  2 +-
 tests/unit/data/datamodule/image/__init__.py  |  4 +
 .../data/{ => datamodule}/image/test_btech.py |  2 +-
 .../{ => datamodule}/image/test_folder.py     |  2 +-
 .../{ => datamodule}/image/test_kolektor.py   |  2 +-
 .../data/{ => datamodule}/image/test_mvtec.py |  2 +-
 .../data/{ => datamodule}/image/test_visa.py  |  2 +-
 tests/unit/data/datamodule/video/__init__.py  |  4 +
 .../{ => datamodule}/video/test_avenue.py     |  2 +-
 .../video/test_shanghaitech.py                |  2 +-
 .../{ => datamodule}/video/test_ucsdped.py    |  2 +-
 tests/unit/data/image/__init__.py             |  4 -
 tests/unit/data/test_inference.py             | 51 ------------
 tests/unit/data/video/__init__.py             |  4 -
 tests/unit/engine/test_setup_transform.py     |  6 +-
 .../dummy_lightning_model.py                  |  6 +-
 36 files changed, 225 insertions(+), 174 deletions(-)
 create mode 100644 tests/unit/data/datamodule/__init__.py
 rename tests/unit/data/{ => datamodule}/base/__init__.py (100%)
 rename tests/unit/data/{ => datamodule}/base/base.py (100%)
 rename tests/unit/data/{ => datamodule}/base/depth.py (95%)
 rename tests/unit/data/{ => datamodule}/base/image.py (97%)
 rename tests/unit/data/{ => datamodule}/base/video.py (97%)
 create mode 100644 tests/unit/data/datamodule/depth/__init__.py
 rename tests/unit/data/{image => datamodule/depth}/test_folder_3d.py (95%)
 rename tests/unit/data/{image => datamodule/depth}/test_mvtec_3d.py (92%)
 create mode 100644 tests/unit/data/datamodule/image/__init__.py
 rename tests/unit/data/{ => datamodule}/image/test_btech.py (92%)
 rename tests/unit/data/{ => datamodule}/image/test_folder.py (94%)
 rename tests/unit/data/{ => datamodule}/image/test_kolektor.py (92%)
 rename tests/unit/data/{ => datamodule}/image/test_mvtec.py (92%)
 rename tests/unit/data/{ => datamodule}/image/test_visa.py (92%)
 create mode 100644 tests/unit/data/datamodule/video/__init__.py
 rename tests/unit/data/{ => datamodule}/video/test_avenue.py (94%)
 rename tests/unit/data/{ => datamodule}/video/test_shanghaitech.py (94%)
 rename tests/unit/data/{ => datamodule}/video/test_ucsdped.py (94%)
 delete mode 100644 tests/unit/data/image/__init__.py
 delete mode 100644 tests/unit/data/test_inference.py
 delete mode 100644 tests/unit/data/video/__init__.py

diff --git a/src/anomalib/data/dataclasses/numpy/image.py b/src/anomalib/data/dataclasses/numpy/image.py
index 80db77b465..c25f98506d 100644
--- a/src/anomalib/data/dataclasses/numpy/image.py
+++ b/src/anomalib/data/dataclasses/numpy/image.py
@@ -36,22 +36,27 @@ class NumpyImageItem(_ImageInputFields[str], NumpyItem):
         >>> path = item.image_path
     """
 
-    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_image(image: np.ndarray) -> np.ndarray:
         assert image.ndim == 3, f"Expected 3D image, got {image.ndim}D image."
         if image.shape[0] == 3:
             image = image.transpose(1, 2, 0)
         return image
 
-    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_gt_label(gt_label: np.ndarray) -> np.ndarray:
         return gt_label
 
-    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_gt_mask(gt_mask: np.ndarray) -> np.ndarray:
         return gt_mask
 
-    def _validate_mask_path(self, mask_path: str) -> str:
+    @staticmethod
+    def _validate_mask_path(mask_path: str) -> str:
         return mask_path
 
-    def _validate_anomaly_map(self, anomaly_map: np.ndarray | None) -> np.ndarray | None:
+    @staticmethod
+    def _validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
         if anomaly_map is None:
             return None
         assert isinstance(anomaly_map, np.ndarray), f"Anomaly map must be a numpy array, got {type(anomaly_map)}."
@@ -66,7 +71,8 @@ def _validate_anomaly_map(self, anomaly_map: np.ndarray | None) -> np.ndarray |
             anomaly_map = anomaly_map.squeeze(0)
         return anomaly_map.astype(np.float32)
 
-    def _validate_pred_score(self, pred_score: np.ndarray | None) -> np.ndarray | None:
+    @staticmethod
+    def _validate_pred_score(pred_score: np.ndarray | None) -> np.ndarray | None:
         if pred_score is None:
             return None
         if pred_score.ndim == 1:
@@ -74,13 +80,16 @@ def _validate_pred_score(self, pred_score: np.ndarray | None) -> np.ndarray | No
             pred_score = pred_score[0]
         return pred_score
 
-    def _validate_pred_mask(self, pred_mask: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_pred_mask(pred_mask: np.ndarray) -> np.ndarray:
         return pred_mask
 
-    def _validate_pred_label(self, pred_label: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_pred_label(pred_label: np.ndarray) -> np.ndarray:
         return pred_label
 
-    def _validate_image_path(self, image_path: str) -> str:
+    @staticmethod
+    def _validate_image_path(image_path: str) -> str:
         return image_path
 
 
@@ -115,29 +124,38 @@ class NumpyImageBatch(BatchIterateMixin[NumpyImageItem], _ImageInputFields[list[
 
     item_class = NumpyImageItem
 
-    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_image(image: np.ndarray) -> np.ndarray:
         return image
 
-    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_gt_label(gt_label: np.ndarray) -> np.ndarray:
         return gt_label
 
-    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_gt_mask(gt_mask: np.ndarray) -> np.ndarray:
         return gt_mask
 
-    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+    @staticmethod
+    def _validate_mask_path(mask_path: list[str]) -> list[str]:
         return mask_path
 
-    def _validate_anomaly_map(self, anomaly_map: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_anomaly_map(anomaly_map: np.ndarray) -> np.ndarray:
         return anomaly_map
 
-    def _validate_pred_score(self, pred_score: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_pred_score(pred_score: np.ndarray) -> np.ndarray:
         return pred_score
 
-    def _validate_pred_mask(self, pred_mask: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_pred_mask(pred_mask: np.ndarray) -> np.ndarray:
         return pred_mask
 
-    def _validate_pred_label(self, pred_label: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_pred_label(pred_label: np.ndarray) -> np.ndarray:
         return pred_label
 
-    def _validate_image_path(self, image_path: list[str]) -> list[str]:
+    @staticmethod
+    def _validate_image_path(image_path: list[str]) -> list[str]:
         return image_path
diff --git a/src/anomalib/data/dataclasses/numpy/video.py b/src/anomalib/data/dataclasses/numpy/video.py
index 8998d4c557..940ee32204 100644
--- a/src/anomalib/data/dataclasses/numpy/video.py
+++ b/src/anomalib/data/dataclasses/numpy/video.py
@@ -20,16 +20,20 @@ class NumpyVideoItem(_VideoInputFields[np.ndarray, np.ndarray, np.ndarray, str],
     for Anomalib's video-based models.
     """
 
-    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_image(image: np.ndarray) -> np.ndarray:
         return image
 
-    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_gt_label(gt_label: np.ndarray) -> np.ndarray:
         return gt_label
 
-    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_gt_mask(gt_mask: np.ndarray) -> np.ndarray:
         return gt_mask
 
-    def _validate_mask_path(self, mask_path: str) -> str:
+    @staticmethod
+    def _validate_mask_path(mask_path: str) -> str:
         return mask_path
 
 
@@ -48,17 +52,22 @@ class NumpyVideoBatch(
 
     item_class = NumpyVideoItem
 
-    def _validate_image(self, image: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_image(image: np.ndarray) -> np.ndarray:
         return image
 
-    def _validate_gt_label(self, gt_label: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_gt_label(gt_label: np.ndarray) -> np.ndarray:
         return gt_label
 
-    def _validate_gt_mask(self, gt_mask: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_gt_mask(gt_mask: np.ndarray) -> np.ndarray:
         return gt_mask
 
-    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+    @staticmethod
+    def _validate_mask_path(mask_path: list[str]) -> list[str]:
         return mask_path
 
-    def _validate_anomaly_map(self, anomaly_map: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _validate_anomaly_map(anomaly_map: np.ndarray) -> np.ndarray:
         return anomaly_map
diff --git a/src/anomalib/data/dataclasses/torch/depth.py b/src/anomalib/data/dataclasses/torch/depth.py
index 1d5e230b52..9de7d0e3be 100644
--- a/src/anomalib/data/dataclasses/torch/depth.py
+++ b/src/anomalib/data/dataclasses/torch/depth.py
@@ -45,37 +45,48 @@ class DepthItem(
 
     numpy_class = NumpyImageItem
 
-    def _validate_image(self, image: Image) -> Image:
+    @staticmethod
+    def _validate_image(image: Image) -> Image:
         return image
 
-    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_gt_label(gt_label: torch.Tensor) -> torch.Tensor:
         return gt_label
 
-    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+    @staticmethod
+    def _validate_gt_mask(gt_mask: Mask) -> Mask:
         return gt_mask
 
-    def _validate_mask_path(self, mask_path: str) -> str:
+    @staticmethod
+    def _validate_mask_path(mask_path: str) -> str:
         return mask_path
 
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_anomaly_map(anomaly_map: torch.Tensor) -> torch.Tensor:
         return anomaly_map
 
-    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_pred_score(pred_score: torch.Tensor) -> torch.Tensor:
         return pred_score
 
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor:
         return pred_mask
 
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor:
         return pred_label
 
-    def _validate_image_path(self, image_path: str) -> str:
+    @staticmethod
+    def _validate_image_path(image_path: str) -> str:
         return image_path
 
-    def _validate_depth_map(self, depth_map: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_depth_map(depth_map: torch.Tensor) -> torch.Tensor:
         return depth_map
 
-    def _validate_depth_path(self, depth_path: str) -> str:
+    @staticmethod
+    def _validate_depth_path(depth_path: str) -> str:
         return depth_path
 
 
@@ -110,35 +121,46 @@ class DepthBatch(
 
     item_class = DepthItem
 
-    def _validate_image(self, image: Image) -> Image:
+    @staticmethod
+    def _validate_image(image: Image) -> Image:
         return image
 
-    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_gt_label(gt_label: torch.Tensor) -> torch.Tensor:
         return gt_label
 
-    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+    @staticmethod
+    def _validate_gt_mask(gt_mask: Mask) -> Mask:
         return gt_mask
 
-    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+    @staticmethod
+    def _validate_mask_path(mask_path: list[str]) -> list[str]:
         return mask_path
 
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_anomaly_map(anomaly_map: torch.Tensor) -> torch.Tensor:
         return anomaly_map
 
-    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_pred_score(pred_score: torch.Tensor) -> torch.Tensor:
         return pred_score
 
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor:
         return pred_mask
 
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor:
         return pred_label
 
-    def _validate_image_path(self, image_path: list[str]) -> list[str]:
+    @staticmethod
+    def _validate_image_path(image_path: list[str]) -> list[str]:
         return image_path
 
-    def _validate_depth_map(self, depth_map: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_depth_map(depth_map: torch.Tensor) -> torch.Tensor:
         return depth_map
 
-    def _validate_depth_path(self, depth_path: list[str]) -> list[str]:
+    @staticmethod
+    def _validate_depth_path(depth_path: list[str]) -> list[str]:
         return depth_path
diff --git a/src/anomalib/data/dataclasses/torch/image.py b/src/anomalib/data/dataclasses/torch/image.py
index 13d6dc52ed..a8a3219727 100644
--- a/src/anomalib/data/dataclasses/torch/image.py
+++ b/src/anomalib/data/dataclasses/torch/image.py
@@ -61,13 +61,15 @@ class ImageItem(
 
     numpy_class = NumpyImageItem
 
-    def _validate_image(self, image: torch.Tensor) -> Image:
+    @staticmethod
+    def _validate_image(image: torch.Tensor) -> Image:
         assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
         assert image.ndim == 3, f"Image must have shape [C, H, W], got shape {image.shape}."
         assert image.shape[0] == 3, f"Image must have 3 channels, got {image.shape[0]}."
         return to_dtype_image(image, torch.float32, scale=True)
 
-    def _validate_gt_label(self, gt_label: torch.Tensor | int | None) -> torch.Tensor:
+    @staticmethod
+    def _validate_gt_label(gt_label: torch.Tensor | int | None) -> torch.Tensor:
         if gt_label is None:
             return None
         if isinstance(gt_label, int):
@@ -80,7 +82,8 @@ def _validate_gt_label(self, gt_label: torch.Tensor | int | None) -> torch.Tenso
         assert not torch.is_floating_point(gt_label), f"Ground truth label must be boolean or integer, got {gt_label}."
         return gt_label.bool()
 
-    def _validate_gt_mask(self, gt_mask: torch.Tensor | None) -> Mask | None:
+    @staticmethod
+    def _validate_gt_mask(gt_mask: torch.Tensor | None) -> Mask | None:
         if gt_mask is None:
             return None
         assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
@@ -93,12 +96,14 @@ def _validate_gt_mask(self, gt_mask: torch.Tensor | None) -> Mask | None:
             gt_mask = gt_mask.squeeze(0)
         return Mask(gt_mask, dtype=torch.bool)
 
-    def _validate_mask_path(self, mask_path: str | None) -> str | None:
+    @staticmethod
+    def _validate_mask_path(mask_path: str | None) -> str | None:
         if mask_path is None:
             return None
         return str(mask_path)
 
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor | None) -> Mask | None:
+    @staticmethod
+    def _validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
         if anomaly_map is None:
             return None
         assert isinstance(anomaly_map, torch.Tensor), f"Anomaly map must be a torch.Tensor, got {type(anomaly_map)}."
@@ -126,7 +131,8 @@ def _validate_pred_score(self, pred_score: torch.Tensor | np.ndarray | None) ->
         assert pred_score.ndim == 0, f"Predicted score must be a scalar, got shape {pred_score.shape}."
         return pred_score.to(torch.float32)
 
-    def _validate_pred_mask(self, pred_mask: torch.Tensor | None) -> Mask | None:
+    @staticmethod
+    def _validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
         if pred_mask is None:
             return None
         assert isinstance(pred_mask, torch.Tensor), f"Predicted mask must be a torch.Tensor, got {type(pred_mask)}."
@@ -139,7 +145,8 @@ def _validate_pred_mask(self, pred_mask: torch.Tensor | None) -> Mask | None:
             pred_mask = pred_mask.squeeze(0)
         return Mask(pred_mask, dtype=torch.bool)
 
-    def _validate_pred_label(self, pred_label: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
+    @staticmethod
+    def _validate_pred_label(pred_label: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
         if pred_label is None:
             return None
         if not isinstance(pred_label, torch.Tensor):
@@ -152,7 +159,8 @@ def _validate_pred_label(self, pred_label: torch.Tensor | np.ndarray | None) ->
         assert pred_label.ndim == 0, f"Predicted label must be a scalar, got shape {pred_label.shape}."
         return pred_label.to(torch.bool)
 
-    def _validate_image_path(self, image_path: str | None) -> str | None:
+    @staticmethod
+    def _validate_image_path(image_path: str | None) -> str | None:
         if image_path is None:
             return None
         return str(image_path)
@@ -198,7 +206,8 @@ class ImageBatch(
     item_class = ImageItem
     numpy_class = NumpyImageBatch
 
-    def _validate_image(self, image: Image) -> Image:
+    @staticmethod
+    def _validate_image(image: Image) -> Image:
         assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
         assert image.ndim in {3, 4}, f"Image must have shape [C, H, W] or [N, C, H, W], got shape {image.shape}."
         if image.ndim == 3:
@@ -286,11 +295,14 @@ def _validate_pred_score(self, pred_score: torch.Tensor | None) -> torch.Tensor
             return torch.amax(self.anomaly_map, dim=(-2, -1))
         return pred_score
 
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor | None:
+    @staticmethod
+    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor | None:
         return pred_mask
 
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor | None:
+    @staticmethod
+    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor | None:
         return pred_label
 
-    def _validate_image_path(self, image_path: list[str]) -> list[str] | None:
+    @staticmethod
+    def _validate_image_path(image_path: list[str]) -> list[str] | None:
         return image_path
diff --git a/src/anomalib/data/dataclasses/torch/video.py b/src/anomalib/data/dataclasses/torch/video.py
index 12a32dd471..4fce275c6f 100644
--- a/src/anomalib/data/dataclasses/torch/video.py
+++ b/src/anomalib/data/dataclasses/torch/video.py
@@ -49,43 +49,56 @@ class VideoItem(
 
     numpy_class = NumpyVideoItem
 
-    def _validate_image(self, image: Image) -> Video:
+    @staticmethod
+    def _validate_image(image: Image) -> Video:
         return image
 
-    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_gt_label(gt_label: torch.Tensor) -> torch.Tensor:
         return gt_label
 
-    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+    @staticmethod
+    def _validate_gt_mask(gt_mask: Mask) -> Mask:
         return gt_mask
 
-    def _validate_mask_path(self, mask_path: str) -> str:
+    @staticmethod
+    def _validate_mask_path(mask_path: str) -> str:
         return mask_path
 
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor | None:
+    @staticmethod
+    def _validate_anomaly_map(anomaly_map: torch.Tensor) -> torch.Tensor | None:
         return anomaly_map
 
-    def _validate_pred_score(self, pred_score: torch.Tensor | None) -> torch.Tensor | None:
+    @staticmethod
+    def _validate_pred_score(pred_score: torch.Tensor | None) -> torch.Tensor | None:
         return pred_score
 
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor | None:
+    @staticmethod
+    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor | None:
         return pred_mask
 
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor | None:
+    @staticmethod
+    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor | None:
         return pred_label
 
-    def _validate_original_image(self, original_image: Video) -> Video:
+    @staticmethod
+    def _validate_original_image(original_image: Video) -> Video:
         return original_image
 
-    def _validate_video_path(self, video_path: str) -> str:
+    @staticmethod
+    def _validate_video_path(video_path: str) -> str:
         return video_path
 
-    def _validate_target_frame(self, target_frame: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_target_frame(target_frame: torch.Tensor) -> torch.Tensor:
         return target_frame
 
-    def _validate_frames(self, frames: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_frames(frames: torch.Tensor) -> torch.Tensor:
         return frames
 
-    def _validate_last_frame(self, last_frame: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_last_frame(last_frame: torch.Tensor) -> torch.Tensor:
         return last_frame
 
     def to_image(self) -> ImageItem:
@@ -130,41 +143,54 @@ class VideoBatch(
     item_class = VideoItem
     numpy_class = NumpyVideoBatch
 
-    def _validate_image(self, image: Image) -> Video:
+    @staticmethod
+    def _validate_image(image: Image) -> Video:
         return image
 
-    def _validate_gt_label(self, gt_label: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_gt_label(gt_label: torch.Tensor) -> torch.Tensor:
         return gt_label
 
-    def _validate_gt_mask(self, gt_mask: Mask) -> Mask:
+    @staticmethod
+    def _validate_gt_mask(gt_mask: Mask) -> Mask:
         return gt_mask
 
-    def _validate_mask_path(self, mask_path: list[str]) -> list[str]:
+    @staticmethod
+    def _validate_mask_path(mask_path: list[str]) -> list[str]:
         return mask_path
 
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_anomaly_map(anomaly_map: torch.Tensor) -> torch.Tensor:
         return anomaly_map
 
-    def _validate_pred_score(self, pred_score: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_pred_score(pred_score: torch.Tensor) -> torch.Tensor:
         return pred_score
 
-    def _validate_pred_mask(self, pred_mask: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor:
         return pred_mask
 
-    def _validate_pred_label(self, pred_label: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor:
         return pred_label
 
-    def _validate_original_image(self, original_image: Video) -> Video:
+    @staticmethod
+    def _validate_original_image(original_image: Video) -> Video:
         return original_image
 
-    def _validate_video_path(self, video_path: list[str]) -> list[str]:
+    @staticmethod
+    def _validate_video_path(video_path: list[str]) -> list[str]:
         return video_path
 
-    def _validate_target_frame(self, target_frame: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_target_frame(target_frame: torch.Tensor) -> torch.Tensor:
         return target_frame
 
-    def _validate_frames(self, frames: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_frames(frames: torch.Tensor) -> torch.Tensor:
         return frames
 
-    def _validate_last_frame(self, last_frame: torch.Tensor) -> torch.Tensor:
+    @staticmethod
+    def _validate_last_frame(last_frame: torch.Tensor) -> torch.Tensor:
         return last_frame
diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index d6f22cd5d0..e7612e6e57 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -391,8 +391,8 @@ def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None:
         # Combine the callbacks, and update the trainer callbacks.
         self._cache.args["callbacks"] = _callbacks + self._cache.args["callbacks"]
 
+    @staticmethod
     def _should_run_validation(
-        self,
         model: AnomalyModule,
         ckpt_path: str | Path | None,
     ) -> bool:
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py
index 0baf47e564..a27b77baf2 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomaly_module.py
@@ -157,7 +157,8 @@ def _save_to_state_dict(self, destination: OrderedDict, prefix: str, keep_vars:
 
         return super()._save_to_state_dict(destination, prefix, keep_vars)
 
-    def _get_instance(self, state_dict: OrderedDict[str, Any], dict_key: str) -> Threshold:
+    @staticmethod
+    def _get_instance(state_dict: OrderedDict[str, Any], dict_key: str) -> Threshold:
         """Get the threshold class from the ``state_dict``."""
         class_path = state_dict.pop(dict_key)
         module = importlib.import_module(".".join(class_path.split(".")[:-1]))
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index 5b09edd1c0..9cd326cf83 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -15,7 +15,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
-from anomalib.post_processing.one_class import OneClassPostProcessor, PostProcessor
+from anomalib.post_processing.one_class import OneClassPostProcessor
 
 from .torch_model import PadimModel
 
@@ -135,6 +135,7 @@ def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform
             ],
         )
 
-    def default_post_processor(self) -> PostProcessor:
+    @staticmethod
+    def default_post_processor() -> OneClassPostProcessor:
         """Return the default post-processor for PADIM."""
         return OneClassPostProcessor()
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index 4d5fe514a8..6b3b76e920 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -140,7 +140,8 @@ def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform
             ],
         )
 
-    def default_post_processor(self) -> OneClassPostProcessor:
+    @staticmethod
+    def default_post_processor() -> OneClassPostProcessor:
         """Return the default post-processor for the model.
 
         Returns:
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index 07af1ee852..222d887017 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -182,6 +182,7 @@ def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform
             ],
         )
 
-    def default_post_processor(self) -> OneClassPostProcessor:
+    @staticmethod
+    def default_post_processor() -> OneClassPostProcessor:
         """Return the default post-processor for WinCLIP."""
         return OneClassPostProcessor()
diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py
index 7e683b8e35..6b4ea8785e 100644
--- a/src/anomalib/models/video/ai_vad/lightning_model.py
+++ b/src/anomalib/models/video/ai_vad/lightning_model.py
@@ -170,6 +170,7 @@ def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform
         del image_size
         return None
 
-    def default_post_processor(self) -> PostProcessor:
+    @staticmethod
+    def default_post_processor() -> PostProcessor:
         """Return the default post-processor for AI-VAD."""
         return OneClassPostProcessor()
diff --git a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py b/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
index 121420168b..7ed1feca95 100644
--- a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
+++ b/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
@@ -22,7 +22,8 @@
 class DummyPostProcessor(PostProcessor):
     """Dummy post-processor for testing."""
 
-    def forward(self, batch: InferenceBatch) -> InferenceBatch:
+    @staticmethod
+    def forward(batch: InferenceBatch) -> InferenceBatch:
         """Dummy forward method."""
         return batch
 
diff --git a/tests/unit/data/datamodule/__init__.py b/tests/unit/data/datamodule/__init__.py
new file mode 100644
index 0000000000..86b351b953
--- /dev/null
+++ b/tests/unit/data/datamodule/__init__.py
@@ -0,0 +1,4 @@
+"""Unit Tests for Data Modules."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/data/base/__init__.py b/tests/unit/data/datamodule/base/__init__.py
similarity index 100%
rename from tests/unit/data/base/__init__.py
rename to tests/unit/data/datamodule/base/__init__.py
diff --git a/tests/unit/data/base/base.py b/tests/unit/data/datamodule/base/base.py
similarity index 100%
rename from tests/unit/data/base/base.py
rename to tests/unit/data/datamodule/base/base.py
diff --git a/tests/unit/data/base/depth.py b/tests/unit/data/datamodule/base/depth.py
similarity index 95%
rename from tests/unit/data/base/depth.py
rename to tests/unit/data/datamodule/base/depth.py
index e4b201cb3d..cc8685077c 100644
--- a/tests/unit/data/base/depth.py
+++ b/tests/unit/data/datamodule/base/depth.py
@@ -8,8 +8,7 @@
 import pytest
 
 from anomalib.data import AnomalibDataModule
-
-from .base import _TestAnomalibDataModule
+from tests.unit.data.datamodule.base.base import _TestAnomalibDataModule
 
 
 class _TestAnomalibDepthDatamodule(_TestAnomalibDataModule):
diff --git a/tests/unit/data/base/image.py b/tests/unit/data/datamodule/base/image.py
similarity index 97%
rename from tests/unit/data/base/image.py
rename to tests/unit/data/datamodule/base/image.py
index 682c611fb3..964eba161e 100644
--- a/tests/unit/data/base/image.py
+++ b/tests/unit/data/datamodule/base/image.py
@@ -7,8 +7,7 @@
 import pytest
 
 from anomalib.data import AnomalibDataModule
-
-from .base import _TestAnomalibDataModule
+from tests.unit.data.datamodule.base.base import _TestAnomalibDataModule
 
 
 class _TestAnomalibImageDatamodule(_TestAnomalibDataModule):
diff --git a/tests/unit/data/base/video.py b/tests/unit/data/datamodule/base/video.py
similarity index 97%
rename from tests/unit/data/base/video.py
rename to tests/unit/data/datamodule/base/video.py
index 83e7b6267e..ab9ff73d29 100644
--- a/tests/unit/data/base/video.py
+++ b/tests/unit/data/datamodule/base/video.py
@@ -9,8 +9,7 @@
 import torch
 
 from anomalib.data import AnomalibDataModule
-
-from .base import _TestAnomalibDataModule
+from tests.unit.data.datamodule.base.base import _TestAnomalibDataModule
 
 
 class _TestAnomalibVideoDatamodule(_TestAnomalibDataModule):
diff --git a/tests/unit/data/datamodule/depth/__init__.py b/tests/unit/data/datamodule/depth/__init__.py
new file mode 100644
index 0000000000..76174e907e
--- /dev/null
+++ b/tests/unit/data/datamodule/depth/__init__.py
@@ -0,0 +1,4 @@
+"""Unit Tests for Depth Datamodules."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/data/image/test_folder_3d.py b/tests/unit/data/datamodule/depth/test_folder_3d.py
similarity index 95%
rename from tests/unit/data/image/test_folder_3d.py
rename to tests/unit/data/datamodule/depth/test_folder_3d.py
index c3d1dd6991..6ed01bfff5 100644
--- a/tests/unit/data/image/test_folder_3d.py
+++ b/tests/unit/data/datamodule/depth/test_folder_3d.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import Folder3D
-from tests.unit.data.base import _TestAnomalibDepthDatamodule
+from tests.unit.data.datamodule.base.depth import _TestAnomalibDepthDatamodule
 
 
 class TestFolder3D(_TestAnomalibDepthDatamodule):
diff --git a/tests/unit/data/image/test_mvtec_3d.py b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
similarity index 92%
rename from tests/unit/data/image/test_mvtec_3d.py
rename to tests/unit/data/datamodule/depth/test_mvtec_3d.py
index 1e50c61795..70966b7774 100644
--- a/tests/unit/data/image/test_mvtec_3d.py
+++ b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import MVTec3D
-from tests.unit.data.base import _TestAnomalibDepthDatamodule
+from tests.unit.data.datamodule.base.depth import _TestAnomalibDepthDatamodule
 
 
 class TestMVTec3D(_TestAnomalibDepthDatamodule):
diff --git a/tests/unit/data/datamodule/image/__init__.py b/tests/unit/data/datamodule/image/__init__.py
new file mode 100644
index 0000000000..12afa35574
--- /dev/null
+++ b/tests/unit/data/datamodule/image/__init__.py
@@ -0,0 +1,4 @@
+"""Unit Tests for Image Datamodules."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/data/image/test_btech.py b/tests/unit/data/datamodule/image/test_btech.py
similarity index 92%
rename from tests/unit/data/image/test_btech.py
rename to tests/unit/data/datamodule/image/test_btech.py
index 02ec81b889..cf7b207e1d 100644
--- a/tests/unit/data/image/test_btech.py
+++ b/tests/unit/data/datamodule/image/test_btech.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import BTech
-from tests.unit.data.base.image import _TestAnomalibImageDatamodule
+from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
 
 class TestBTech(_TestAnomalibImageDatamodule):
diff --git a/tests/unit/data/image/test_folder.py b/tests/unit/data/datamodule/image/test_folder.py
similarity index 94%
rename from tests/unit/data/image/test_folder.py
rename to tests/unit/data/datamodule/image/test_folder.py
index 61cb2fd0c3..a11cc4b725 100644
--- a/tests/unit/data/image/test_folder.py
+++ b/tests/unit/data/datamodule/image/test_folder.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import Folder
-from tests.unit.data.base.image import _TestAnomalibImageDatamodule
+from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
 
 class TestFolder(_TestAnomalibImageDatamodule):
diff --git a/tests/unit/data/image/test_kolektor.py b/tests/unit/data/datamodule/image/test_kolektor.py
similarity index 92%
rename from tests/unit/data/image/test_kolektor.py
rename to tests/unit/data/datamodule/image/test_kolektor.py
index f2b86253d6..703c3927a3 100644
--- a/tests/unit/data/image/test_kolektor.py
+++ b/tests/unit/data/datamodule/image/test_kolektor.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import Kolektor
-from tests.unit.data.base.image import _TestAnomalibImageDatamodule
+from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
 
 class TestKolektor(_TestAnomalibImageDatamodule):
diff --git a/tests/unit/data/image/test_mvtec.py b/tests/unit/data/datamodule/image/test_mvtec.py
similarity index 92%
rename from tests/unit/data/image/test_mvtec.py
rename to tests/unit/data/datamodule/image/test_mvtec.py
index d4c6852563..2df701a3b1 100644
--- a/tests/unit/data/image/test_mvtec.py
+++ b/tests/unit/data/datamodule/image/test_mvtec.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import MVTec
-from tests.unit.data.base.image import _TestAnomalibImageDatamodule
+from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
 
 class TestMVTec(_TestAnomalibImageDatamodule):
diff --git a/tests/unit/data/image/test_visa.py b/tests/unit/data/datamodule/image/test_visa.py
similarity index 92%
rename from tests/unit/data/image/test_visa.py
rename to tests/unit/data/datamodule/image/test_visa.py
index 1bb251b00c..0c663a6e54 100644
--- a/tests/unit/data/image/test_visa.py
+++ b/tests/unit/data/datamodule/image/test_visa.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import Visa
-from tests.unit.data.base.image import _TestAnomalibImageDatamodule
+from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
 
 class TestVisa(_TestAnomalibImageDatamodule):
diff --git a/tests/unit/data/datamodule/video/__init__.py b/tests/unit/data/datamodule/video/__init__.py
new file mode 100644
index 0000000000..3a2e61c36c
--- /dev/null
+++ b/tests/unit/data/datamodule/video/__init__.py
@@ -0,0 +1,4 @@
+"""Unit Tests for Video Datamodules."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/data/video/test_avenue.py b/tests/unit/data/datamodule/video/test_avenue.py
similarity index 94%
rename from tests/unit/data/video/test_avenue.py
rename to tests/unit/data/datamodule/video/test_avenue.py
index 6c098b5026..42365d059f 100644
--- a/tests/unit/data/video/test_avenue.py
+++ b/tests/unit/data/datamodule/video/test_avenue.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import Avenue
-from tests.unit.data.base.video import _TestAnomalibVideoDatamodule
+from tests.unit.data.datamodule.base.video import _TestAnomalibVideoDatamodule
 
 
 class TestAvenue(_TestAnomalibVideoDatamodule):
diff --git a/tests/unit/data/video/test_shanghaitech.py b/tests/unit/data/datamodule/video/test_shanghaitech.py
similarity index 94%
rename from tests/unit/data/video/test_shanghaitech.py
rename to tests/unit/data/datamodule/video/test_shanghaitech.py
index 1ebbc2c537..fda0d1a84d 100644
--- a/tests/unit/data/video/test_shanghaitech.py
+++ b/tests/unit/data/datamodule/video/test_shanghaitech.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import ShanghaiTech
-from tests.unit.data.base.video import _TestAnomalibVideoDatamodule
+from tests.unit.data.datamodule.base.video import _TestAnomalibVideoDatamodule
 
 
 class TestShanghaiTech(_TestAnomalibVideoDatamodule):
diff --git a/tests/unit/data/video/test_ucsdped.py b/tests/unit/data/datamodule/video/test_ucsdped.py
similarity index 94%
rename from tests/unit/data/video/test_ucsdped.py
rename to tests/unit/data/datamodule/video/test_ucsdped.py
index 64411bfc84..1148e9313a 100644
--- a/tests/unit/data/video/test_ucsdped.py
+++ b/tests/unit/data/datamodule/video/test_ucsdped.py
@@ -9,7 +9,7 @@
 
 from anomalib import TaskType
 from anomalib.data import UCSDped
-from tests.unit.data.base.video import _TestAnomalibVideoDatamodule
+from tests.unit.data.datamodule.base.video import _TestAnomalibVideoDatamodule
 
 
 class TestUCSDped(_TestAnomalibVideoDatamodule):
diff --git a/tests/unit/data/image/__init__.py b/tests/unit/data/image/__init__.py
deleted file mode 100644
index 3da374de39..0000000000
--- a/tests/unit/data/image/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-"""Unit tests - Image Datamodules."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/data/test_inference.py b/tests/unit/data/test_inference.py
deleted file mode 100644
index f4cb4aaaf4..0000000000
--- a/tests/unit/data/test_inference.py
+++ /dev/null
@@ -1,51 +0,0 @@
-"""Unit tests - Predict Dataset Tests."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from pathlib import Path
-
-import pytest
-from torchvision.transforms import v2
-
-from anomalib.data import ImageItem, PredictDataset
-
-
-@pytest.fixture(scope="module")
-def predict_dataset_path(dataset_path: Path) -> Path:
-    """Fixture that returns the path to the bad test samples of the dummy MVTec AD dataset."""
-    return dataset_path / "mvtec" / "dummy" / "test" / "bad"
-
-
-class TestPredictDataset:
-    """Test PredictDataset class."""
-
-    @staticmethod
-    def test_inference_dataset(predict_dataset_path: Path) -> None:
-        """Test the PredictDataset class."""
-        # Use the bad images from the dummy MVTec AD dataset.
-        dataset = PredictDataset(path=predict_dataset_path, image_size=(256, 256))
-
-        # Dummy MVtec AD dataset has 5 abnormal images in the test set.
-        assert len(dataset) == 5
-
-        # Check the first sample.
-        sample = dataset[0]
-        assert isinstance(sample, ImageItem)
-        assert getattr(sample, "image", None) is not None
-        assert getattr(sample, "image_path", None) is not None
-        assert sample.image.shape == (3, 256, 256)
-        assert Path(sample.image_path).suffix == ".png"
-
-    @staticmethod
-    def test_transforms_applied(predict_dataset_path: Path) -> None:
-        """Test whether the transforms are applied to the images."""
-        # Create a transform that resizes the image to 512x512.
-        transform = v2.Compose([v2.Resize(512)])
-        dataset = PredictDataset(path=predict_dataset_path, transform=transform)
-
-        # Check the first sample.
-        sample = dataset[0]
-
-        # Check that the image is resized to 512x512.
-        assert sample.image.shape == (3, 512, 512)
diff --git a/tests/unit/data/video/__init__.py b/tests/unit/data/video/__init__.py
deleted file mode 100644
index 2147aa2165..0000000000
--- a/tests/unit/data/video/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-"""Unit tests - Video Datamodules."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/engine/test_setup_transform.py b/tests/unit/engine/test_setup_transform.py
index cf3febd0ac..ebb60f81c0 100644
--- a/tests/unit/engine/test_setup_transform.py
+++ b/tests/unit/engine/test_setup_transform.py
@@ -38,7 +38,8 @@ def __len__(self) -> int:
 class DummyPostProcessor(PostProcessor):
     """Dummy post-processor for testing the setup_transform method."""
 
-    def forward(self, batch: InferenceBatch) -> InferenceBatch:
+    @staticmethod
+    def forward(batch: InferenceBatch) -> InferenceBatch:
         """Return the batch unmodified."""
         return batch
 
@@ -67,7 +68,8 @@ def learning_type() -> LearningType:
         """Return the learning type."""
         return LearningType.ZERO_SHOT
 
-    def default_post_processor(self) -> PostProcessor:
+    @staticmethod
+    def default_post_processor() -> PostProcessor:
         """Return a dummy post-processor."""
         return DummyPostProcessor()
 
diff --git a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
index ed41825a14..f907e3f37c 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
@@ -21,7 +21,8 @@ class _DummyModel(nn.Module): ...
 class DummyPostProcessor(PostProcessor):
     """Dummy post-processor for testing."""
 
-    def forward(self, batch: InferenceBatch) -> InferenceBatch:
+    @staticmethod
+    def forward(batch: InferenceBatch) -> InferenceBatch:
         """Dummy forward method."""
         return batch
 
@@ -71,6 +72,7 @@ def learning_type(self) -> LearningType:
         """Returns the learning type."""
         return LearningType.ZERO_SHOT
 
-    def default_post_processor(self) -> PostProcessor:
+    @staticmethod
+    def default_post_processor() -> PostProcessor:
         """Returns a dummy post-processor."""
         return DummyPostProcessor()

From 99b4e9d03f51fffc95e2ae9e8b46b1697c3d883b Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 2 Oct 2024 09:25:36 +0100
Subject: [PATCH 07/45] Add dataclass validators (#2307)

* Add validators

* Add depth validators to depth classes

* Add image validators to depth classes

* Add video validators to depth classes

* Add numpy validators and update dataclasses

* Run all the tests on the ci

* Fix the tests

* Created validator tests and added numpy video tests

* Add numpy image tests

* Add numpy depth tests

* Add torch validator tests

* Fix numpy validation tests

* Convet private _validate methods to public validate method

* Revert "Convet private _validate methods to public validate method"

This reverts commit 47f183a8495b13085f2046ccd719eb4d3c4add48.

* Convert private _validate methods to public validate method

* Remove batch_size arg from validators

* Remove anomaly_map from validators

* Use validators as mixins

* convert abstractmethods to static abstractmethods

* Move pred-score computation to model implementations

* Add missing pred_score implemenations in models

* Fix the numpy validation tests

Signed-off-by: Samet Akcay 

* Fix visualization tests

Signed-off-by: Samet Akcay 

* Add numpy video validator mixin to numpy video item, and remove validation methods

Signed-off-by: Samet Akcay 

* Add np.bool_ to validate np label

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 
---
 src/anomalib/data/dataclasses/generic.py      | 102 +-
 src/anomalib/data/dataclasses/numpy/depth.py  |  33 +
 src/anomalib/data/dataclasses/numpy/image.py  | 108 +-
 src/anomalib/data/dataclasses/numpy/video.py  |  44 +-
 src/anomalib/data/dataclasses/torch/depth.py  |  93 +-
 src/anomalib/data/dataclasses/torch/image.py  | 214 +---
 src/anomalib/data/dataclasses/torch/video.py  | 109 +-
 .../data/validators/numpy/__init__.py         |  17 +
 src/anomalib/data/validators/numpy/depth.py   | 158 +++
 src/anomalib/data/validators/numpy/image.py   | 679 +++++++++++++
 src/anomalib/data/validators/numpy/video.py   | 694 +++++++++++++
 src/anomalib/data/validators/path.py          |  82 ++
 .../data/validators/torch/__init__.py         |  17 +
 src/anomalib/data/validators/torch/depth.py   | 443 +++++++++
 src/anomalib/data/validators/torch/image.py   | 619 ++++++++++++
 src/anomalib/data/validators/torch/video.py   | 937 ++++++++++++++++++
 src/anomalib/models/image/cfa/torch_model.py  |   8 +-
 .../models/image/cflow/torch_model.py         |   5 +-
 .../models/image/csflow/torch_model.py        |   3 +-
 src/anomalib/models/image/dfm/torch_model.py  |   8 +-
 .../models/image/draem/torch_model.py         |   4 +-
 src/anomalib/models/image/dsr/torch_model.py  |   4 +-
 .../models/image/efficient_ad/torch_model.py  |   6 +-
 .../models/image/fastflow/torch_model.py      |   3 +-
 .../models/image/padim/torch_model.py         |  10 +-
 .../image/reverse_distillation/torch_model.py |   5 +-
 .../models/image/stfpm/torch_model.py         |   5 +-
 .../models/image/uflow/torch_model.py         |   4 +-
 tests/integration/model/test_models.py        |   2 +-
 tests/unit/data/datamodule/base/depth.py      |   5 +-
 tests/unit/data/validators/__init__.py        |   4 +
 tests/unit/data/validators/numpy/__init__.py  |   4 +
 .../unit/data/validators/numpy/test_depth.py  | 112 +++
 .../unit/data/validators/numpy/test_image.py  | 215 ++++
 .../unit/data/validators/numpy/test_video.py  | 164 +++
 tests/unit/data/validators/torch/__init__.py  |   4 +
 .../unit/data/validators/torch/test_depth.py  | 238 +++++
 .../unit/data/validators/torch/test_image.py  | 243 +++++
 .../unit/data/validators/torch/test_video.py  | 239 +++++
 .../dummy_lightning_model.py                  |   1 +
 tox.ini                                       |   4 +-
 41 files changed, 5038 insertions(+), 611 deletions(-)
 create mode 100644 src/anomalib/data/validators/numpy/__init__.py
 create mode 100644 src/anomalib/data/validators/numpy/depth.py
 create mode 100644 src/anomalib/data/validators/numpy/image.py
 create mode 100644 src/anomalib/data/validators/numpy/video.py
 create mode 100644 src/anomalib/data/validators/path.py
 create mode 100644 src/anomalib/data/validators/torch/__init__.py
 create mode 100644 src/anomalib/data/validators/torch/depth.py
 create mode 100644 src/anomalib/data/validators/torch/image.py
 create mode 100644 src/anomalib/data/validators/torch/video.py
 create mode 100644 tests/unit/data/validators/__init__.py
 create mode 100644 tests/unit/data/validators/numpy/__init__.py
 create mode 100644 tests/unit/data/validators/numpy/test_depth.py
 create mode 100644 tests/unit/data/validators/numpy/test_image.py
 create mode 100644 tests/unit/data/validators/numpy/test_video.py
 create mode 100644 tests/unit/data/validators/torch/__init__.py
 create mode 100644 tests/unit/data/validators/torch/test_depth.py
 create mode 100644 tests/unit/data/validators/torch/test_image.py
 create mode 100644 tests/unit/data/validators/torch/test_video.py

diff --git a/src/anomalib/data/dataclasses/generic.py b/src/anomalib/data/dataclasses/generic.py
index 7d6ea72777..3244fce6cf 100644
--- a/src/anomalib/data/dataclasses/generic.py
+++ b/src/anomalib/data/dataclasses/generic.py
@@ -128,28 +128,32 @@ class _InputFields(Generic[T, ImageT, MaskT, PathT], ABC):
         methods.
     """
 
-    image: FieldDescriptor[ImageT] = FieldDescriptor(validator_name="_validate_image")
-    gt_label: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_gt_label")
-    gt_mask: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="_validate_gt_mask")
-    mask_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_mask_path")
+    image: FieldDescriptor[ImageT] = FieldDescriptor(validator_name="validate_image")
+    gt_label: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_gt_label")
+    gt_mask: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="validate_gt_mask")
+    mask_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="validate_mask_path")
 
+    @staticmethod
     @abstractmethod
-    def _validate_image(self, image: ImageT) -> ImageT:
+    def validate_image(image: ImageT) -> ImageT:
         """Validate the image."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_gt_mask(self, gt_mask: MaskT) -> MaskT | None:
+    def validate_gt_mask(gt_mask: MaskT) -> MaskT | None:
         """Validate the ground truth mask."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_mask_path(self, mask_path: PathT) -> PathT | None:
+    def validate_mask_path(mask_path: PathT) -> PathT | None:
         """Validate the mask path."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_gt_label(self, gt_label: T) -> T | None:
+    def validate_gt_label(gt_label: T) -> T | None:
         """Validate the ground truth label."""
         raise NotImplementedError
 
@@ -163,7 +167,7 @@ class _ImageInputFields(Generic[PathT], ABC):
     with disk-stored image datasets, facilitating custom data loading strategies.
 
     The ``image_path`` field uses a ``FieldDescriptor`` with a validation method.
-    Subclasses must implement ``_validate_image_path`` to ensure path validity
+    Subclasses must implement ``validate_image_path`` to ensure path validity
     according to specific Anomalib model or dataset requirements.
 
     This class is designed to complement ``_InputFields`` for comprehensive
@@ -172,7 +176,7 @@ class _ImageInputFields(Generic[PathT], ABC):
     Examples:
         Assuming a concrete implementation ``DummyImageInput``:
         >>> class DummyImageInput(_ImageInputFields):
-        ...     def _validate_image_path(self, image_path):
+        ...     def validate_image_path(self, image_path):
         ...         return image_path  # Implement actual validation
         ...     # Implement other required methods
 
@@ -190,10 +194,11 @@ class _ImageInputFields(Generic[PathT], ABC):
         methods.
     """
 
-    image_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_image_path")
+    image_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="validate_image_path")
 
+    @staticmethod
     @abstractmethod
-    def _validate_image_path(self, image_path: PathT) -> PathT | None:
+    def validate_image_path(image_path: PathT) -> PathT | None:
         """Validate the image path."""
         raise NotImplementedError
 
@@ -217,7 +222,7 @@ class _VideoInputFields(Generic[T, ImageT, MaskT, PathT], ABC):
         Assuming a concrete implementation ``DummyVideoInput``:
 
         >>> class DummyVideoInput(_VideoInputFields):
-        ...     def _validate_original_image(self, original_image):
+        ...     def validate_original_image(self, original_image):
         ...         return original_image  # Implement actual validation
         ...     # Implement other required methods
 
@@ -243,34 +248,39 @@ class _VideoInputFields(Generic[T, ImageT, MaskT, PathT], ABC):
         methods.
     """
 
-    original_image: FieldDescriptor[ImageT | None] = FieldDescriptor(validator_name="_validate_original_image")
-    video_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_video_path")
-    target_frame: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_target_frame")
-    frames: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_frames")
-    last_frame: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_last_frame")
+    original_image: FieldDescriptor[ImageT | None] = FieldDescriptor(validator_name="validate_original_image")
+    video_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="validate_video_path")
+    target_frame: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_target_frame")
+    frames: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_frames")
+    last_frame: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_last_frame")
 
+    @staticmethod
     @abstractmethod
-    def _validate_original_image(self, original_image: ImageT) -> ImageT | None:
+    def validate_original_image(original_image: ImageT) -> ImageT | None:
         """Validate the original image."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_video_path(self, video_path: PathT) -> PathT | None:
+    def validate_video_path(video_path: PathT) -> PathT | None:
         """Validate the video path."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_target_frame(self, target_frame: T) -> T | None:
+    def validate_target_frame(target_frame: T) -> T | None:
         """Validate the target frame."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_frames(self, frames: T) -> T | None:
+    def validate_frames(frames: T) -> T | None:
         """Validate the frames."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_last_frame(self, last_frame: T) -> T | None:
+    def validate_last_frame(last_frame: T) -> T | None:
         """Validate the last frame."""
         raise NotImplementedError
 
@@ -293,9 +303,9 @@ class _DepthInputFields(Generic[T, PathT], _ImageInputFields[PathT], ABC):
         Assuming a concrete implementation ``DummyDepthInput``:
 
         >>> class DummyDepthInput(_DepthInputFields):
-        ...     def _validate_depth_map(self, depth_map):
+        ...     def validate_depth_map(self, depth_map):
         ...         return depth_map  # Implement actual validation
-        ...     def _validate_depth_path(self, depth_path):
+        ...     def validate_depth_path(self, depth_path):
         ...         return depth_path  # Implement actual validation
         ...     # Implement other required methods
 
@@ -316,16 +326,18 @@ class _DepthInputFields(Generic[T, PathT], _ImageInputFields[PathT], ABC):
         methods.
     """
 
-    depth_map: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_depth_map")
-    depth_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="_validate_depth_path")
+    depth_map: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_depth_map")
+    depth_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="validate_depth_path")
 
+    @staticmethod
     @abstractmethod
-    def _validate_depth_map(self, depth_map: ImageT) -> ImageT | None:
+    def validate_depth_map(depth_map: ImageT) -> ImageT | None:
         """Validate the depth map."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_depth_path(self, depth_path: PathT) -> PathT | None:
+    def validate_depth_path(depth_path: PathT) -> PathT | None:
         """Validate the depth path."""
         raise NotImplementedError
 
@@ -345,13 +357,13 @@ class _OutputFields(Generic[T, MaskT], ABC):
         Assuming a concrete implementation ``DummyOutput``:
 
         >>> class DummyOutput(_OutputFields):
-        ...     def _validate_anomaly_map(self, anomaly_map):
+        ...     def validate_anomaly_map(self, anomaly_map):
         ...         return anomaly_map  # Implement actual validation
-        ...     def _validate_pred_score(self, pred_score):
+        ...     def validate_pred_score(self, pred_score):
         ...         return pred_score  # Implement actual validation
-        ...     def _validate_pred_mask(self, pred_mask):
+        ...     def validate_pred_mask(self, pred_mask):
         ...         return pred_mask  # Implement actual validation
-        ...     def _validate_pred_label(self, pred_label):
+        ...     def validate_pred_label(self, pred_label):
         ...         return pred_label  # Implement actual validation
 
         >>> # Create an output instance with predictions
@@ -374,28 +386,32 @@ class _OutputFields(Generic[T, MaskT], ABC):
         methods.
     """
 
-    anomaly_map: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="_validate_anomaly_map")
-    pred_score: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_pred_score")
-    pred_mask: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="_validate_pred_mask")
-    pred_label: FieldDescriptor[T | None] = FieldDescriptor(validator_name="_validate_pred_label")
+    anomaly_map: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="validate_anomaly_map")
+    pred_score: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_pred_score")
+    pred_mask: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="validate_pred_mask")
+    pred_label: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_pred_label")
 
+    @staticmethod
     @abstractmethod
-    def _validate_anomaly_map(self, anomaly_map: MaskT) -> MaskT | None:
+    def validate_anomaly_map(anomaly_map: MaskT) -> MaskT | None:
         """Validate the anomaly map."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_pred_score(self, pred_score: T) -> T | None:
+    def validate_pred_score(pred_score: T) -> T | None:
         """Validate the predicted score."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_pred_mask(self, pred_mask: MaskT) -> MaskT | None:
+    def validate_pred_mask(pred_mask: MaskT) -> MaskT | None:
         """Validate the predicted mask."""
         raise NotImplementedError
 
+    @staticmethod
     @abstractmethod
-    def _validate_pred_label(self, pred_label: T) -> T | None:
+    def validate_pred_label(pred_label: T) -> T | None:
         """Validate the predicted label."""
         raise NotImplementedError
 
@@ -477,7 +493,7 @@ class _GenericItem(
         Assuming a concrete implementation ``DummyItem``:
 
         >>> class DummyItem(_GenericItem):
-        ...     def _validate_image(self, image):
+        ...     def validate_image(self, image):
         ...         return image  # Implement actual validation
         ...     # Implement other required methods
 
@@ -522,7 +538,7 @@ class _GenericBatch(
         Assuming a concrete implementation ``DummyBatch``:
 
         >>> class DummyBatch(_GenericBatch):
-        ...     def _validate_image(self, image):
+        ...     def validate_image(self, image):
         ...         return image  # Implement actual validation
         ...     # Implement other required methods
 
diff --git a/src/anomalib/data/dataclasses/numpy/depth.py b/src/anomalib/data/dataclasses/numpy/depth.py
index 8275b9c90f..f8bd924c84 100644
--- a/src/anomalib/data/dataclasses/numpy/depth.py
+++ b/src/anomalib/data/dataclasses/numpy/depth.py
@@ -2,3 +2,36 @@
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from anomalib.data.dataclasses.generic import BatchIterateMixin, _DepthInputFields
+from anomalib.data.dataclasses.numpy.base import NumpyBatch, NumpyItem
+from anomalib.data.validators.numpy.depth import NumpyDepthBatchValidator, NumpyDepthValidator
+
+
+@dataclass
+class NumpyDepthItem(
+    NumpyDepthValidator,
+    _DepthInputFields[np.ndarray, str],
+    NumpyItem,
+):
+    """Dataclass for a single depth item in Anomalib datasets using numpy arrays.
+
+    This class combines _DepthInputFields and NumpyItem for depth-based anomaly detection.
+    It includes depth-specific fields and validation methods to ensure proper formatting
+    for Anomalib's depth-based models.
+    """
+
+
+class NumpyDepthBatch(
+    BatchIterateMixin[NumpyDepthItem],
+    NumpyDepthBatchValidator,
+    _DepthInputFields[np.ndarray, list[str]],
+    NumpyBatch,
+):
+    """Dataclass for a batch of depth items in Anomalib datasets using numpy arrays."""
+
+    item_class = NumpyDepthItem
diff --git a/src/anomalib/data/dataclasses/numpy/image.py b/src/anomalib/data/dataclasses/numpy/image.py
index c25f98506d..ad71bb4bd8 100644
--- a/src/anomalib/data/dataclasses/numpy/image.py
+++ b/src/anomalib/data/dataclasses/numpy/image.py
@@ -5,14 +5,17 @@
 
 from dataclasses import dataclass
 
-import numpy as np
-
 from anomalib.data.dataclasses.generic import BatchIterateMixin, _ImageInputFields
 from anomalib.data.dataclasses.numpy.base import NumpyBatch, NumpyItem
+from anomalib.data.validators.numpy.image import NumpyImageBatchValidator, NumpyImageValidator
 
 
 @dataclass
-class NumpyImageItem(_ImageInputFields[str], NumpyItem):
+class NumpyImageItem(
+    NumpyImageValidator,
+    _ImageInputFields[str],
+    NumpyItem,
+):
     """Dataclass for a single image item in Anomalib datasets using numpy arrays.
 
     This class combines _ImageInputFields and NumpyItem for image-based anomaly detection.
@@ -36,65 +39,14 @@ class NumpyImageItem(_ImageInputFields[str], NumpyItem):
         >>> path = item.image_path
     """
 
-    @staticmethod
-    def _validate_image(image: np.ndarray) -> np.ndarray:
-        assert image.ndim == 3, f"Expected 3D image, got {image.ndim}D image."
-        if image.shape[0] == 3:
-            image = image.transpose(1, 2, 0)
-        return image
-
-    @staticmethod
-    def _validate_gt_label(gt_label: np.ndarray) -> np.ndarray:
-        return gt_label
-
-    @staticmethod
-    def _validate_gt_mask(gt_mask: np.ndarray) -> np.ndarray:
-        return gt_mask
-
-    @staticmethod
-    def _validate_mask_path(mask_path: str) -> str:
-        return mask_path
-
-    @staticmethod
-    def _validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
-        if anomaly_map is None:
-            return None
-        assert isinstance(anomaly_map, np.ndarray), f"Anomaly map must be a numpy array, got {type(anomaly_map)}."
-        assert anomaly_map.ndim in {
-            2,
-            3,
-        }, f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
-        if anomaly_map.ndim == 3:
-            assert (
-                anomaly_map.shape[0] == 1
-            ), f"Anomaly map with 3 dimensions must have 1 channel, got {anomaly_map.shape[0]}."
-            anomaly_map = anomaly_map.squeeze(0)
-        return anomaly_map.astype(np.float32)
-
-    @staticmethod
-    def _validate_pred_score(pred_score: np.ndarray | None) -> np.ndarray | None:
-        if pred_score is None:
-            return None
-        if pred_score.ndim == 1:
-            assert len(pred_score) == 1, f"Expected single value for pred_score, got {len(pred_score)}."
-            pred_score = pred_score[0]
-        return pred_score
-
-    @staticmethod
-    def _validate_pred_mask(pred_mask: np.ndarray) -> np.ndarray:
-        return pred_mask
-
-    @staticmethod
-    def _validate_pred_label(pred_label: np.ndarray) -> np.ndarray:
-        return pred_label
-
-    @staticmethod
-    def _validate_image_path(image_path: str) -> str:
-        return image_path
-
 
 @dataclass
-class NumpyImageBatch(BatchIterateMixin[NumpyImageItem], _ImageInputFields[list[str]], NumpyBatch):
+class NumpyImageBatch(
+    BatchIterateMixin[NumpyImageItem],
+    NumpyImageBatchValidator,
+    _ImageInputFields[list[str]],
+    NumpyBatch,
+):
     """Dataclass for a batch of image items in Anomalib datasets using numpy arrays.
 
     This class combines BatchIterateMixin, _ImageInputFields, and NumpyBatch for batches
@@ -123,39 +75,3 @@ class NumpyImageBatch(BatchIterateMixin[NumpyImageItem], _ImageInputFields[list[
     """
 
     item_class = NumpyImageItem
-
-    @staticmethod
-    def _validate_image(image: np.ndarray) -> np.ndarray:
-        return image
-
-    @staticmethod
-    def _validate_gt_label(gt_label: np.ndarray) -> np.ndarray:
-        return gt_label
-
-    @staticmethod
-    def _validate_gt_mask(gt_mask: np.ndarray) -> np.ndarray:
-        return gt_mask
-
-    @staticmethod
-    def _validate_mask_path(mask_path: list[str]) -> list[str]:
-        return mask_path
-
-    @staticmethod
-    def _validate_anomaly_map(anomaly_map: np.ndarray) -> np.ndarray:
-        return anomaly_map
-
-    @staticmethod
-    def _validate_pred_score(pred_score: np.ndarray) -> np.ndarray:
-        return pred_score
-
-    @staticmethod
-    def _validate_pred_mask(pred_mask: np.ndarray) -> np.ndarray:
-        return pred_mask
-
-    @staticmethod
-    def _validate_pred_label(pred_label: np.ndarray) -> np.ndarray:
-        return pred_label
-
-    @staticmethod
-    def _validate_image_path(image_path: list[str]) -> list[str]:
-        return image_path
diff --git a/src/anomalib/data/dataclasses/numpy/video.py b/src/anomalib/data/dataclasses/numpy/video.py
index 940ee32204..34998c00d1 100644
--- a/src/anomalib/data/dataclasses/numpy/video.py
+++ b/src/anomalib/data/dataclasses/numpy/video.py
@@ -9,10 +9,15 @@
 
 from anomalib.data.dataclasses.generic import BatchIterateMixin, _VideoInputFields
 from anomalib.data.dataclasses.numpy.base import NumpyBatch, NumpyItem
+from anomalib.data.validators.numpy.video import NumpyVideoBatchValidator, NumpyVideoValidator
 
 
 @dataclass
-class NumpyVideoItem(_VideoInputFields[np.ndarray, np.ndarray, np.ndarray, str], NumpyItem):
+class NumpyVideoItem(
+    NumpyVideoValidator,
+    _VideoInputFields[np.ndarray, np.ndarray, np.ndarray, str],
+    NumpyItem,
+):
     """Dataclass for a single video item in Anomalib datasets using numpy arrays.
 
     This class combines _VideoInputFields and NumpyItem for video-based anomaly detection.
@@ -20,26 +25,11 @@ class NumpyVideoItem(_VideoInputFields[np.ndarray, np.ndarray, np.ndarray, str],
     for Anomalib's video-based models.
     """
 
-    @staticmethod
-    def _validate_image(image: np.ndarray) -> np.ndarray:
-        return image
-
-    @staticmethod
-    def _validate_gt_label(gt_label: np.ndarray) -> np.ndarray:
-        return gt_label
-
-    @staticmethod
-    def _validate_gt_mask(gt_mask: np.ndarray) -> np.ndarray:
-        return gt_mask
-
-    @staticmethod
-    def _validate_mask_path(mask_path: str) -> str:
-        return mask_path
-
 
 @dataclass
 class NumpyVideoBatch(
     BatchIterateMixin[NumpyVideoItem],
+    NumpyVideoBatchValidator,
     _VideoInputFields[np.ndarray, np.ndarray, np.ndarray, list[str]],
     NumpyBatch,
 ):
@@ -51,23 +41,3 @@ class NumpyVideoBatch(
     """
 
     item_class = NumpyVideoItem
-
-    @staticmethod
-    def _validate_image(image: np.ndarray) -> np.ndarray:
-        return image
-
-    @staticmethod
-    def _validate_gt_label(gt_label: np.ndarray) -> np.ndarray:
-        return gt_label
-
-    @staticmethod
-    def _validate_gt_mask(gt_mask: np.ndarray) -> np.ndarray:
-        return gt_mask
-
-    @staticmethod
-    def _validate_mask_path(mask_path: list[str]) -> list[str]:
-        return mask_path
-
-    @staticmethod
-    def _validate_anomaly_map(anomaly_map: np.ndarray) -> np.ndarray:
-        return anomaly_map
diff --git a/src/anomalib/data/dataclasses/torch/depth.py b/src/anomalib/data/dataclasses/torch/depth.py
index 9de7d0e3be..209d5eaf9d 100644
--- a/src/anomalib/data/dataclasses/torch/depth.py
+++ b/src/anomalib/data/dataclasses/torch/depth.py
@@ -11,16 +11,18 @@
 from dataclasses import dataclass
 
 import torch
-from torchvision.tv_tensors import Image, Mask
+from torchvision.tv_tensors import Image
 
 from anomalib.data.dataclasses.generic import BatchIterateMixin, _DepthInputFields
 from anomalib.data.dataclasses.numpy.image import NumpyImageItem
 from anomalib.data.dataclasses.torch.base import Batch, DatasetItem, ToNumpyMixin
+from anomalib.data.validators.torch.depth import DepthBatchValidator, DepthValidator
 
 
 @dataclass
 class DepthItem(
     ToNumpyMixin[NumpyImageItem],
+    DepthValidator,
     _DepthInputFields[torch.Tensor, str],
     DatasetItem[Image],
 ):
@@ -45,54 +47,11 @@ class DepthItem(
 
     numpy_class = NumpyImageItem
 
-    @staticmethod
-    def _validate_image(image: Image) -> Image:
-        return image
-
-    @staticmethod
-    def _validate_gt_label(gt_label: torch.Tensor) -> torch.Tensor:
-        return gt_label
-
-    @staticmethod
-    def _validate_gt_mask(gt_mask: Mask) -> Mask:
-        return gt_mask
-
-    @staticmethod
-    def _validate_mask_path(mask_path: str) -> str:
-        return mask_path
-
-    @staticmethod
-    def _validate_anomaly_map(anomaly_map: torch.Tensor) -> torch.Tensor:
-        return anomaly_map
-
-    @staticmethod
-    def _validate_pred_score(pred_score: torch.Tensor) -> torch.Tensor:
-        return pred_score
-
-    @staticmethod
-    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor:
-        return pred_mask
-
-    @staticmethod
-    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor:
-        return pred_label
-
-    @staticmethod
-    def _validate_image_path(image_path: str) -> str:
-        return image_path
-
-    @staticmethod
-    def _validate_depth_map(depth_map: torch.Tensor) -> torch.Tensor:
-        return depth_map
-
-    @staticmethod
-    def _validate_depth_path(depth_path: str) -> str:
-        return depth_path
-
 
 @dataclass
 class DepthBatch(
     BatchIterateMixin[DepthItem],
+    DepthBatchValidator,
     _DepthInputFields[torch.Tensor, list[str]],
     Batch[Image],
 ):
@@ -120,47 +79,3 @@ class DepthBatch(
     """
 
     item_class = DepthItem
-
-    @staticmethod
-    def _validate_image(image: Image) -> Image:
-        return image
-
-    @staticmethod
-    def _validate_gt_label(gt_label: torch.Tensor) -> torch.Tensor:
-        return gt_label
-
-    @staticmethod
-    def _validate_gt_mask(gt_mask: Mask) -> Mask:
-        return gt_mask
-
-    @staticmethod
-    def _validate_mask_path(mask_path: list[str]) -> list[str]:
-        return mask_path
-
-    @staticmethod
-    def _validate_anomaly_map(anomaly_map: torch.Tensor) -> torch.Tensor:
-        return anomaly_map
-
-    @staticmethod
-    def _validate_pred_score(pred_score: torch.Tensor) -> torch.Tensor:
-        return pred_score
-
-    @staticmethod
-    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor:
-        return pred_mask
-
-    @staticmethod
-    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor:
-        return pred_label
-
-    @staticmethod
-    def _validate_image_path(image_path: list[str]) -> list[str]:
-        return image_path
-
-    @staticmethod
-    def _validate_depth_map(depth_map: torch.Tensor) -> torch.Tensor:
-        return depth_map
-
-    @staticmethod
-    def _validate_depth_path(depth_path: list[str]) -> list[str]:
-        return depth_path
diff --git a/src/anomalib/data/dataclasses/torch/image.py b/src/anomalib/data/dataclasses/torch/image.py
index a8a3219727..3f9cdcc9f0 100644
--- a/src/anomalib/data/dataclasses/torch/image.py
+++ b/src/anomalib/data/dataclasses/torch/image.py
@@ -8,22 +8,20 @@
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from collections.abc import Sequence
 from dataclasses import dataclass
 
-import numpy as np
-import torch
-from torchvision.transforms.v2.functional import to_dtype_image
-from torchvision.tv_tensors import Image, Mask
+from torchvision.tv_tensors import Image
 
 from anomalib.data.dataclasses.generic import BatchIterateMixin, _ImageInputFields
 from anomalib.data.dataclasses.numpy.image import NumpyImageBatch, NumpyImageItem
 from anomalib.data.dataclasses.torch.base import Batch, DatasetItem, ToNumpyMixin
+from anomalib.data.validators.torch.image import ImageBatchValidator, ImageValidator
 
 
 @dataclass
 class ImageItem(
     ToNumpyMixin[NumpyImageItem],
+    ImageValidator,
     _ImageInputFields[str],
     DatasetItem[Image],
 ):
@@ -61,115 +59,12 @@ class ImageItem(
 
     numpy_class = NumpyImageItem
 
-    @staticmethod
-    def _validate_image(image: torch.Tensor) -> Image:
-        assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
-        assert image.ndim == 3, f"Image must have shape [C, H, W], got shape {image.shape}."
-        assert image.shape[0] == 3, f"Image must have 3 channels, got {image.shape[0]}."
-        return to_dtype_image(image, torch.float32, scale=True)
-
-    @staticmethod
-    def _validate_gt_label(gt_label: torch.Tensor | int | None) -> torch.Tensor:
-        if gt_label is None:
-            return None
-        if isinstance(gt_label, int):
-            gt_label = torch.tensor(gt_label)
-        assert isinstance(
-            gt_label,
-            torch.Tensor,
-        ), f"Ground truth label must be an integer or a torch.Tensor, got {type(gt_label)}."
-        assert gt_label.ndim == 0, f"Ground truth label must be a scalar, got shape {gt_label.shape}."
-        assert not torch.is_floating_point(gt_label), f"Ground truth label must be boolean or integer, got {gt_label}."
-        return gt_label.bool()
-
-    @staticmethod
-    def _validate_gt_mask(gt_mask: torch.Tensor | None) -> Mask | None:
-        if gt_mask is None:
-            return None
-        assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
-        assert gt_mask.ndim in {
-            2,
-            3,
-        }, f"Ground truth mask must have shape [H, W] or [1, H, W] got shape {gt_mask.shape}."
-        if gt_mask.ndim == 3:
-            assert gt_mask.shape[0] == 1, f"Ground truth mask must have 1 channel, got {gt_mask.shape[0]}."
-            gt_mask = gt_mask.squeeze(0)
-        return Mask(gt_mask, dtype=torch.bool)
-
-    @staticmethod
-    def _validate_mask_path(mask_path: str | None) -> str | None:
-        if mask_path is None:
-            return None
-        return str(mask_path)
-
-    @staticmethod
-    def _validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
-        if anomaly_map is None:
-            return None
-        assert isinstance(anomaly_map, torch.Tensor), f"Anomaly map must be a torch.Tensor, got {type(anomaly_map)}."
-        assert anomaly_map.ndim in {
-            2,
-            3,
-        }, f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
-        if anomaly_map.ndim == 3:
-            assert (
-                anomaly_map.shape[0] == 1
-            ), f"Anomaly map with 3 dimensions must have 1 channel, got {anomaly_map.shape[0]}."
-            anomaly_map = anomaly_map.squeeze(0)
-        return Mask(anomaly_map, dtype=torch.float32)
-
-    def _validate_pred_score(self, pred_score: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
-        if pred_score is None:
-            return torch.amax(self.anomaly_map, dim=(-2, -1)) if self.anomaly_map is not None else None
-        if not isinstance(pred_score, torch.Tensor):
-            try:
-                pred_score = torch.tensor(pred_score)
-            except Exception as e:
-                msg = "Failed to convert pred_score to a torch.Tensor."
-                raise ValueError(msg) from e
-        pred_score = pred_score.squeeze()
-        assert pred_score.ndim == 0, f"Predicted score must be a scalar, got shape {pred_score.shape}."
-        return pred_score.to(torch.float32)
-
-    @staticmethod
-    def _validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
-        if pred_mask is None:
-            return None
-        assert isinstance(pred_mask, torch.Tensor), f"Predicted mask must be a torch.Tensor, got {type(pred_mask)}."
-        assert pred_mask.ndim in {
-            2,
-            3,
-        }, f"Predicted mask must have shape [H, W] or [1, H, W] got shape {pred_mask.shape}."
-        if pred_mask.ndim == 3:
-            assert pred_mask.shape[0] == 1, f"Predicted mask must have 1 channel, got {pred_mask.shape[0]}."
-            pred_mask = pred_mask.squeeze(0)
-        return Mask(pred_mask, dtype=torch.bool)
-
-    @staticmethod
-    def _validate_pred_label(pred_label: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
-        if pred_label is None:
-            return None
-        if not isinstance(pred_label, torch.Tensor):
-            try:
-                pred_label = torch.tensor(pred_label)
-            except Exception as e:
-                msg = "Failed to convert pred_score to a torch.Tensor."
-                raise ValueError(msg) from e
-        pred_label = pred_label.squeeze()
-        assert pred_label.ndim == 0, f"Predicted label must be a scalar, got shape {pred_label.shape}."
-        return pred_label.to(torch.bool)
-
-    @staticmethod
-    def _validate_image_path(image_path: str | None) -> str | None:
-        if image_path is None:
-            return None
-        return str(image_path)
-
 
 @dataclass
 class ImageBatch(
     ToNumpyMixin[NumpyImageBatch],
     BatchIterateMixin[ImageItem],
+    ImageBatchValidator,
     _ImageInputFields[list[str]],
     Batch[Image],
 ):
@@ -205,104 +100,3 @@ class ImageBatch(
 
     item_class = ImageItem
     numpy_class = NumpyImageBatch
-
-    @staticmethod
-    def _validate_image(image: Image) -> Image:
-        assert isinstance(image, torch.Tensor), f"Image must be a torch.Tensor, got {type(image)}."
-        assert image.ndim in {3, 4}, f"Image must have shape [C, H, W] or [N, C, H, W], got shape {image.shape}."
-        if image.ndim == 3:
-            image = image.unsqueeze(0)  # add batch dimension
-        assert image.shape[1] == 3, f"Image must have 3 channels, got {image.shape[0]}."
-        return Image(image, dtype=torch.float32)
-
-    def _validate_gt_label(self, gt_label: torch.Tensor | Sequence[int] | None) -> torch.Tensor:
-        if gt_label is None:
-            return None
-        if isinstance(gt_label, Sequence):
-            gt_label = torch.tensor(gt_label)
-        assert isinstance(
-            gt_label,
-            torch.Tensor,
-        ), f"Ground truth label must be a sequence of integers or a torch.Tensor, got {type(gt_label)}."
-        assert gt_label.ndim == 1, f"Ground truth label must be a 1-dimensional vector, got shape {gt_label.shape}."
-        assert (
-            len(gt_label) == self.batch_size
-        ), f"Ground truth label must have length {self.batch_size}, got length {len(gt_label)}."
-        assert not torch.is_floating_point(gt_label), f"Ground truth label must be boolean or integer, got {gt_label}."
-        return gt_label.bool()
-
-    def _validate_gt_mask(self, gt_mask: Mask | None) -> Mask | None:
-        if gt_mask is None:
-            return None
-        assert isinstance(gt_mask, torch.Tensor), f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
-        assert gt_mask.ndim in {
-            2,
-            3,
-            4,
-        }, f"Ground truth mask must have shape [H, W] or [N, H, W] or [N, 1, H, W] got shape {gt_mask.shape}."
-        if gt_mask.ndim == 2:
-            assert (
-                self.batch_size == 1
-            ), f"Invalid shape for gt_mask. Got mask shape {gt_mask.shape} for batch size {self.batch_size}."
-            gt_mask = gt_mask.unsqueeze(0)
-        if gt_mask.ndim == 3:
-            assert (
-                gt_mask.shape[0] == self.batch_size
-            ), f"Invalid shape for gt_mask. Got mask shape {gt_mask.shape} for batch size {self.batch_size}."
-        if gt_mask.ndim == 4:
-            assert gt_mask.shape[1] == 1, f"Ground truth mask must have 1 channel, got {gt_mask.shape[1]}."
-            gt_mask = gt_mask.squeeze(1)
-        return Mask(gt_mask, dtype=torch.bool)
-
-    def _validate_mask_path(self, mask_path: Sequence[str] | Sequence[str] | None) -> list[str] | None:
-        if mask_path is None:
-            return None
-        assert isinstance(
-            mask_path,
-            Sequence,
-        ), f"Mask path must be a sequence of paths or strings, got {type(mask_path)}."
-        assert (
-            len(mask_path) == self.batch_size
-        ), f"Invalid length for mask_path. Got length {len(mask_path)} for batch size {self.batch_size}."
-        return [str(path) for path in mask_path]
-
-    def _validate_anomaly_map(self, anomaly_map: torch.Tensor | np.ndarray | None) -> torch.Tensor | None:
-        if anomaly_map is None:
-            return None
-        if not isinstance(anomaly_map, torch.Tensor):
-            try:
-                anomaly_map = torch.tensor(anomaly_map)
-            except Exception as e:
-                msg = "Failed to convert anomaly_map to a torch.Tensor."
-                raise ValueError(msg) from e
-        assert anomaly_map.ndim in {
-            2,
-            3,
-            4,
-        }, f"Anomaly map must have shape [H, W] or [N, H, W] or [N, 1, H, W], got shape {anomaly_map.shape}."
-        if anomaly_map.ndim == 2:
-            assert (
-                self.batch_size == 1
-            ), f"Invalid shape for anomaly_map. Got mask shape {anomaly_map.shape} for batch size {self.batch_size}."
-            anomaly_map = anomaly_map.unsqueeze(0)
-        if anomaly_map.ndim == 4:
-            assert anomaly_map.shape[1] == 1, f"Anomaly map must have 1 channel, got {anomaly_map.shape[1]}."
-            anomaly_map = anomaly_map.squeeze(1)
-        return Mask(anomaly_map, dtype=torch.float32)
-
-    def _validate_pred_score(self, pred_score: torch.Tensor | None) -> torch.Tensor | None:
-        if pred_score is None and self.anomaly_map is not None:
-            return torch.amax(self.anomaly_map, dim=(-2, -1))
-        return pred_score
-
-    @staticmethod
-    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor | None:
-        return pred_mask
-
-    @staticmethod
-    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor | None:
-        return pred_label
-
-    @staticmethod
-    def _validate_image_path(image_path: list[str]) -> list[str] | None:
-        return image_path
diff --git a/src/anomalib/data/dataclasses/torch/video.py b/src/anomalib/data/dataclasses/torch/video.py
index 4fce275c6f..324fb45ca1 100644
--- a/src/anomalib/data/dataclasses/torch/video.py
+++ b/src/anomalib/data/dataclasses/torch/video.py
@@ -11,17 +11,19 @@
 from dataclasses import dataclass, fields
 
 import torch
-from torchvision.tv_tensors import Image, Mask, Video
+from torchvision.tv_tensors import Mask, Video
 
 from anomalib.data.dataclasses.generic import BatchIterateMixin, _VideoInputFields
 from anomalib.data.dataclasses.numpy.video import NumpyVideoBatch, NumpyVideoItem
 from anomalib.data.dataclasses.torch.base import Batch, DatasetItem, ToNumpyMixin
 from anomalib.data.dataclasses.torch.image import ImageItem
+from anomalib.data.validators.torch.video import VideoBatchValidator, VideoValidator
 
 
 @dataclass
 class VideoItem(
     ToNumpyMixin[NumpyVideoItem],
+    VideoValidator,
     _VideoInputFields[torch.Tensor, Video, Mask, str],
     DatasetItem[Video],
 ):
@@ -49,58 +51,6 @@ class VideoItem(
 
     numpy_class = NumpyVideoItem
 
-    @staticmethod
-    def _validate_image(image: Image) -> Video:
-        return image
-
-    @staticmethod
-    def _validate_gt_label(gt_label: torch.Tensor) -> torch.Tensor:
-        return gt_label
-
-    @staticmethod
-    def _validate_gt_mask(gt_mask: Mask) -> Mask:
-        return gt_mask
-
-    @staticmethod
-    def _validate_mask_path(mask_path: str) -> str:
-        return mask_path
-
-    @staticmethod
-    def _validate_anomaly_map(anomaly_map: torch.Tensor) -> torch.Tensor | None:
-        return anomaly_map
-
-    @staticmethod
-    def _validate_pred_score(pred_score: torch.Tensor | None) -> torch.Tensor | None:
-        return pred_score
-
-    @staticmethod
-    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor | None:
-        return pred_mask
-
-    @staticmethod
-    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor | None:
-        return pred_label
-
-    @staticmethod
-    def _validate_original_image(original_image: Video) -> Video:
-        return original_image
-
-    @staticmethod
-    def _validate_video_path(video_path: str) -> str:
-        return video_path
-
-    @staticmethod
-    def _validate_target_frame(target_frame: torch.Tensor) -> torch.Tensor:
-        return target_frame
-
-    @staticmethod
-    def _validate_frames(frames: torch.Tensor) -> torch.Tensor:
-        return frames
-
-    @staticmethod
-    def _validate_last_frame(last_frame: torch.Tensor) -> torch.Tensor:
-        return last_frame
-
     def to_image(self) -> ImageItem:
         """Convert the video item to an image item."""
         image_keys = [field.name for field in fields(ImageItem)]
@@ -111,6 +61,7 @@ def to_image(self) -> ImageItem:
 class VideoBatch(
     ToNumpyMixin[NumpyVideoBatch],
     BatchIterateMixin[VideoItem],
+    VideoBatchValidator,
     _VideoInputFields[torch.Tensor, Video, Mask, list[str]],
     Batch[Video],
 ):
@@ -142,55 +93,3 @@ class VideoBatch(
 
     item_class = VideoItem
     numpy_class = NumpyVideoBatch
-
-    @staticmethod
-    def _validate_image(image: Image) -> Video:
-        return image
-
-    @staticmethod
-    def _validate_gt_label(gt_label: torch.Tensor) -> torch.Tensor:
-        return gt_label
-
-    @staticmethod
-    def _validate_gt_mask(gt_mask: Mask) -> Mask:
-        return gt_mask
-
-    @staticmethod
-    def _validate_mask_path(mask_path: list[str]) -> list[str]:
-        return mask_path
-
-    @staticmethod
-    def _validate_anomaly_map(anomaly_map: torch.Tensor) -> torch.Tensor:
-        return anomaly_map
-
-    @staticmethod
-    def _validate_pred_score(pred_score: torch.Tensor) -> torch.Tensor:
-        return pred_score
-
-    @staticmethod
-    def _validate_pred_mask(pred_mask: torch.Tensor) -> torch.Tensor:
-        return pred_mask
-
-    @staticmethod
-    def _validate_pred_label(pred_label: torch.Tensor) -> torch.Tensor:
-        return pred_label
-
-    @staticmethod
-    def _validate_original_image(original_image: Video) -> Video:
-        return original_image
-
-    @staticmethod
-    def _validate_video_path(video_path: list[str]) -> list[str]:
-        return video_path
-
-    @staticmethod
-    def _validate_target_frame(target_frame: torch.Tensor) -> torch.Tensor:
-        return target_frame
-
-    @staticmethod
-    def _validate_frames(frames: torch.Tensor) -> torch.Tensor:
-        return frames
-
-    @staticmethod
-    def _validate_last_frame(last_frame: torch.Tensor) -> torch.Tensor:
-        return last_frame
diff --git a/src/anomalib/data/validators/numpy/__init__.py b/src/anomalib/data/validators/numpy/__init__.py
new file mode 100644
index 0000000000..759f7322bd
--- /dev/null
+++ b/src/anomalib/data/validators/numpy/__init__.py
@@ -0,0 +1,17 @@
+"""Anomalib Numpy data validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .depth import NumpyDepthBatchValidator, NumpyDepthValidator
+from .image import NumpyImageBatchValidator, NumpyImageValidator
+from .video import NumpyVideoBatchValidator, NumpyVideoValidator
+
+__all__ = [
+    "NumpyImageBatchValidator",
+    "NumpyImageValidator",
+    "NumpyVideoBatchValidator",
+    "NumpyVideoValidator",
+    "NumpyDepthBatchValidator",
+    "NumpyDepthValidator",
+]
diff --git a/src/anomalib/data/validators/numpy/depth.py b/src/anomalib/data/validators/numpy/depth.py
new file mode 100644
index 0000000000..d43c1e1750
--- /dev/null
+++ b/src/anomalib/data/validators/numpy/depth.py
@@ -0,0 +1,158 @@
+"""Validate numpy depth data."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+
+import numpy as np
+from anomalib.data.validators.numpy.image import NumpyImageBatchValidator, NumpyImageValidator
+from anomalib.data.validators.path import validate_path
+
+
+class NumpyDepthValidator:
+    """Validate numpy.ndarray data for depth images."""
+
+    @staticmethod
+    def validate_image(image: np.ndarray) -> np.ndarray:
+        """Validate the image array."""
+        return NumpyImageValidator.validate_image(image)
+
+    @staticmethod
+    def validate_gt_label(label: int | np.ndarray | None) -> np.ndarray | None:
+        """Validate the ground truth label."""
+        return NumpyImageValidator.validate_gt_label(label)
+
+    @staticmethod
+    def validate_gt_mask(mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the ground truth mask."""
+        return NumpyImageValidator.validate_gt_mask(mask)
+
+    @staticmethod
+    def validate_mask_path(mask_path: str | None) -> str | None:
+        """Validate the mask path."""
+        return NumpyImageValidator.validate_mask_path(mask_path)
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
+        """Validate the anomaly map."""
+        return NumpyImageValidator.validate_anomaly_map(anomaly_map)
+
+    @staticmethod
+    def validate_pred_score(
+        pred_score: np.ndarray | float | None,
+        anomaly_map: np.ndarray | None = None,
+    ) -> np.ndarray | None:
+        """Validate the prediction score."""
+        return NumpyImageValidator.validate_pred_score(pred_score, anomaly_map)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction mask."""
+        return NumpyImageValidator.validate_pred_mask(pred_mask)
+
+    @staticmethod
+    def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction label."""
+        return NumpyImageValidator.validate_pred_label(pred_label)
+
+    @staticmethod
+    def validate_image_path(image_path: str | None) -> str | None:
+        """Validate the image path."""
+        return NumpyImageValidator.validate_image_path(image_path)
+
+    @staticmethod
+    def validate_depth_map(depth_map: np.ndarray | None) -> np.ndarray | None:
+        """Validate the depth map."""
+        if depth_map is None:
+            return None
+        if not isinstance(depth_map, np.ndarray):
+            msg = f"Depth map must be a numpy array, got {type(depth_map)}."
+            raise TypeError(msg)
+        if depth_map.ndim not in {2, 3}:
+            msg = f"Depth map must have shape [H, W] or [H, W, 1], got shape {depth_map.shape}."
+            raise ValueError(msg)
+        if depth_map.ndim == 3 and depth_map.shape[2] != 1:
+            msg = f"Depth map with 3 dimensions must have 1 channel, got {depth_map.shape[2]}."
+            raise ValueError(msg)
+        return depth_map.astype(np.float32)
+
+    @staticmethod
+    def validate_depth_path(depth_path: str | None) -> str | None:
+        """Validate the depth path."""
+        return validate_path(depth_path) if depth_path else None
+
+
+class NumpyDepthBatchValidator:
+    """Validate numpy.ndarray data for batches of depth images."""
+
+    @staticmethod
+    def validate_image(image: np.ndarray) -> np.ndarray:
+        """Validate the image batch array."""
+        return NumpyImageBatchValidator.validate_image(image)
+
+    @staticmethod
+    def validate_gt_label(gt_label: np.ndarray | Sequence[int] | None) -> np.ndarray | None:
+        """Validate the ground truth label batch."""
+        return NumpyImageBatchValidator.validate_gt_label(gt_label)
+
+    @staticmethod
+    def validate_gt_mask(gt_mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the ground truth mask batch."""
+        return NumpyImageBatchValidator.validate_gt_mask(gt_mask)
+
+    @staticmethod
+    def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
+        """Validate the mask paths for a batch."""
+        return NumpyImageBatchValidator.validate_mask_path(mask_path)
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
+        """Validate the anomaly map batch."""
+        return NumpyImageBatchValidator.validate_anomaly_map(anomaly_map)
+
+    @staticmethod
+    def validate_pred_score(pred_score: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction scores for a batch."""
+        return NumpyImageBatchValidator.validate_pred_score(pred_score)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction mask batch."""
+        return NumpyImageBatchValidator.validate_pred_mask(pred_mask)
+
+    @staticmethod
+    def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction label batch."""
+        return NumpyImageBatchValidator.validate_pred_label(pred_label)
+
+    @staticmethod
+    def validate_image_path(image_path: list[str] | None) -> list[str] | None:
+        """Validate the image paths for a batch."""
+        return NumpyImageBatchValidator.validate_image_path(image_path)
+
+    @staticmethod
+    def validate_depth_map(depth_map: np.ndarray | None) -> np.ndarray | None:
+        """Validate the depth map batch."""
+        if depth_map is None:
+            return None
+        if not isinstance(depth_map, np.ndarray):
+            msg = f"Depth map batch must be a numpy array, got {type(depth_map)}."
+            raise TypeError(msg)
+        if depth_map.ndim not in {3, 4}:
+            msg = f"Depth map batch must have shape [N, H, W] or [N, H, W, 1], got shape {depth_map.shape}."
+            raise ValueError(msg)
+        if depth_map.ndim == 4 and depth_map.shape[3] != 1:
+            msg = f"Depth map batch with 4 dimensions must have 1 channel, got {depth_map.shape[3]}."
+            raise ValueError(msg)
+        return depth_map.astype(np.float32)
+
+    @staticmethod
+    def validate_depth_path(depth_path: list[str] | None) -> list[str] | None:
+        """Validate the depth paths for a batch."""
+        if depth_path is None:
+            return None
+        if not isinstance(depth_path, list):
+            msg = f"Depth path must be a list of strings, got {type(depth_path)}."
+            raise TypeError(msg)
+        return [validate_path(path) for path in depth_path]
diff --git a/src/anomalib/data/validators/numpy/image.py b/src/anomalib/data/validators/numpy/image.py
new file mode 100644
index 0000000000..b560bd5f20
--- /dev/null
+++ b/src/anomalib/data/validators/numpy/image.py
@@ -0,0 +1,679 @@
+"""Validate numpy image data."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+
+import numpy as np
+from anomalib.data.validators.path import validate_path
+
+
+class NumpyImageValidator:
+    """Validate numpy.ndarray data for images."""
+
+    @staticmethod
+    def validate_image(image: np.ndarray) -> np.ndarray:
+        """Validate the image array.
+
+        Args:
+            image (np.ndarray): Input image array.
+
+        Returns:
+            np.ndarray: Validated image array.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the image array does not have the correct shape.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
+            >>> rgb_image = np.random.rand(256, 256, 3)
+            >>> validated_rgb = NumpyImageValidator.validate_image(rgb_image)
+            >>> validated_rgb.shape
+            (256, 256, 3)
+            >>> gray_image = np.random.rand(256, 256)
+            >>> validated_gray = NumpyImageValidator.validate_image(gray_image)
+            >>> validated_gray.shape
+            (256, 256, 1)
+        """
+        if not isinstance(image, np.ndarray):
+            msg = f"Image must be a numpy.ndarray, got {type(image)}."
+            raise TypeError(msg)
+
+        # Handle 2D grayscale images
+        if image.ndim == 2:
+            image = image[..., np.newaxis]
+
+        if image.ndim != 3:
+            msg = f"Image must have 2 or 3 dimensions, got shape {image.shape}."
+            raise ValueError(msg)
+
+        # Check if the image is in torch style (C, H, W) and rearrange if necessary
+        if image.shape[0] in {1, 3} and image.shape[2] not in {1, 3}:
+            image = np.transpose(image, (1, 2, 0))
+
+        if image.shape[2] not in {1, 3}:
+            msg = f"Image must have 1 or 3 channels, got {image.shape[2]}."
+            raise ValueError(msg)
+
+        return image.astype(np.float32)
+
+    @staticmethod
+    def validate_gt_label(label: int | np.ndarray | None) -> np.ndarray | None:
+        """Validate the ground truth label.
+
+        Args:
+            label (int | np.ndarray | None): Input ground truth label.
+
+        Returns:
+            np.ndarray | None: Validated ground truth label as a boolean array, or None.
+
+        Raises:
+            TypeError: If the input is neither an integer nor a numpy.ndarray.
+            ValueError: If the label shape or dtype is invalid.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
+            >>> label_int = 1
+            >>> validated_label = NumpyImageValidator.validate_gt_label(label_int)
+            >>> validated_label
+            array(True)
+            >>> label_array = np.array(0)
+            >>> validated_label = NumpyImageValidator.validate_gt_label(label_array)
+            >>> validated_label
+            array(False)
+        """
+        if label is None:
+            return None
+        if isinstance(label, int | np.bool_):
+            label = np.array(label)
+        if not isinstance(label, np.ndarray):
+            msg = f"Ground truth label must be an integer or a numpy.ndarray, got {type(label)}."
+            raise TypeError(msg)
+        if label.ndim != 0:
+            msg = f"Ground truth label must be a scalar, got shape {label.shape}."
+            raise ValueError(msg)
+        if not np.issubdtype(label.dtype, np.integer) and not np.issubdtype(label.dtype, bool):
+            msg = f"Ground truth label must be boolean or integer, got {label.dtype}."
+            raise TypeError(msg)
+        return label.astype(bool)
+
+    @staticmethod
+    def validate_gt_mask(mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the ground truth mask.
+
+        Args:
+            mask (np.ndarray | None): Input ground truth mask.
+
+        Returns:
+            np.ndarray | None: Validated ground truth mask, or None.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the mask shape is invalid.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
+            >>> mask = np.random.randint(0, 2, (224, 224))
+            >>> validated_mask = NumpyImageValidator.validate_gt_mask(mask)
+            >>> validated_mask.shape
+            (224, 224)
+        """
+        if mask is None:
+            return None
+        if not isinstance(mask, np.ndarray):
+            msg = f"Mask must be a numpy.ndarray, got {type(mask)}."
+            raise TypeError(msg)
+        if mask.ndim not in {2, 3}:
+            msg = f"Mask must have shape [H, W] or [H, W, 1] got shape {mask.shape}."
+            raise ValueError(msg)
+        if mask.ndim == 3:
+            if mask.shape[2] != 1:
+                msg = f"Mask must have 1 channel, got {mask.shape[2]}."
+                raise ValueError(msg)
+            mask = mask.squeeze(2)
+        return mask.astype(bool)
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
+        """Validate the anomaly map.
+
+        Args:
+            anomaly_map (np.ndarray | None): Input anomaly map.
+
+        Returns:
+            np.ndarray | None: Validated anomaly map, or None.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the anomaly map shape is invalid.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
+            >>> anomaly_map = np.random.rand(224, 224)
+            >>> validated_map = NumpyImageValidator.validate_anomaly_map(anomaly_map)
+            >>> validated_map.shape
+            (224, 224)
+        """
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, np.ndarray):
+            msg = f"Anomaly map must be a numpy array, got {type(anomaly_map)}."
+            raise TypeError(msg)
+        if anomaly_map.ndim not in {2, 3}:
+            msg = f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
+            raise ValueError(msg)
+        if anomaly_map.ndim == 3:
+            if anomaly_map.shape[0] != 1:
+                msg = f"Anomaly map with 3 dimensions must have 1 channel, got {anomaly_map.shape[0]}."
+                raise ValueError(msg)
+            anomaly_map = anomaly_map.squeeze(0)
+        return anomaly_map.astype(np.float32)
+
+    @staticmethod
+    def validate_image_path(image_path: str | None) -> str | None:
+        """Validate the image path.
+
+        Args:
+            image_path (str | None): Input image path.
+
+        Returns:
+            str | None: Validated image path, or None.
+
+        Examples:
+            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
+            >>> path = "/path/to/image.jpg"
+            >>> validated_path = NumpyImageValidator.validate_image_path(path)
+            >>> validated_path == path
+            True
+        """
+        return validate_path(image_path) if image_path else None
+
+    @staticmethod
+    def validate_mask_path(mask_path: str | None) -> str | None:
+        """Validate the mask path.
+
+        Args:
+            mask_path (str | None): Input mask path.
+
+        Returns:
+            str | None: Validated mask path, or None.
+
+        Examples:
+            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
+            >>> path = "/path/to/mask.png"
+            >>> validated_path = NumpyImageValidator.validate_mask_path(path)
+            >>> validated_path == path
+            True
+        """
+        return validate_path(mask_path) if mask_path else None
+
+    @staticmethod
+    def validate_pred_score(
+        pred_score: np.ndarray | float | None,
+        anomaly_map: np.ndarray | None = None,
+    ) -> np.ndarray | None:
+        """Validate the prediction score.
+
+        Args:
+            pred_score (np.ndarray | float | None): Input prediction score.
+            anomaly_map (np.ndarray | None): Input anomaly map.
+
+        Returns:
+            np.ndarray | None: Validated prediction score as a float32 array, or None.
+
+        Raises:
+            TypeError: If the input is neither a float, numpy.ndarray, nor None.
+            ValueError: If the prediction score is not a scalar.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
+            >>> score = 0.8
+            >>> validated_score = NumpyImageValidator.validate_pred_score(score)
+            >>> validated_score
+            array(0.8, dtype=float32)
+            >>> score_array = np.array(0.7)
+            >>> validated_score = NumpyImageValidator.validate_pred_score(score_array)
+            >>> validated_score
+            array(0.7, dtype=float32)
+        """
+        if pred_score is None:
+            return np.amax(anomaly_map) if anomaly_map is not None else None
+
+        if not isinstance(pred_score, np.ndarray):
+            try:
+                pred_score = np.array(pred_score)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a numpy.ndarray."
+                raise ValueError(msg) from e
+        pred_score = pred_score.squeeze()
+        if pred_score.ndim != 0:
+            msg = f"Predicted score must be a scalar, got shape {pred_score.shape}."
+            raise ValueError(msg)
+
+        return pred_score.astype(np.float32)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction mask.
+
+        Args:
+            pred_mask (np.ndarray | None): Input prediction mask.
+
+        Returns:
+            np.ndarray | None: Validated prediction mask, or None.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
+            >>> mask = np.random.randint(0, 2, (224, 224))
+            >>> validated_mask = NumpyImageValidator.validate_pred_mask(mask)
+            >>> validated_mask.shape
+            (224, 224)
+        """
+        return NumpyImageValidator.validate_gt_mask(pred_mask)  # We can reuse the gt_mask validation
+
+    @staticmethod
+    def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction label.
+
+        Args:
+            pred_label (np.ndarray | None): Input prediction label.
+
+        Returns:
+            np.ndarray | None: Validated prediction label as a boolean array, or None.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the prediction label is not a scalar.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
+            >>> label = np.array(1)
+            >>> validated_label = NumpyImageValidator.validate_pred_label(label)
+            >>> validated_label
+            array(True)
+        """
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, np.ndarray):
+            try:
+                pred_label = np.array(pred_label)
+            except Exception as e:
+                msg = "Failed to convert pred_label to a numpy.ndarray."
+                raise ValueError(msg) from e
+        pred_label = pred_label.squeeze()
+        if pred_label.ndim != 0:
+            msg = f"Predicted label must be a scalar, got shape {pred_label.shape}."
+            raise ValueError(msg)
+        return pred_label.astype(bool)
+
+
+class NumpyImageBatchValidator:
+    """Validate numpy.ndarray data for batches of images."""
+
+    @staticmethod
+    def validate_image(image: np.ndarray) -> np.ndarray:
+        """Validate the image batch array.
+
+        Args:
+            image (np.ndarray): Input image batch array.
+
+        Returns:
+            np.ndarray: Validated image batch array.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the image batch array does not have the correct shape.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
+            >>> batch = np.random.rand(32, 224, 224, 3)
+            >>> validated_batch = NumpyImageBatchValidator.validate_image(batch)
+            >>> validated_batch.shape
+            (32, 224, 224, 3)
+            >>> grayscale_batch = np.random.rand(32, 224, 224)
+            >>> validated_grayscale = NumpyImageBatchValidator.validate_image(grayscale_batch)
+            >>> validated_grayscale.shape
+            (32, 224, 224, 1)
+            >>> torch_style_batch = np.random.rand(32, 3, 224, 224)
+            >>> validated_torch_style = NumpyImageBatchValidator.validate_image(torch_style_batch)
+            >>> validated_torch_style.shape
+            (32, 224, 224, 3)
+            >>> single_image = np.zeros((224, 224, 3))
+            >>> validated_single = NumpyImageBatchValidator.validate_image(single_image)
+            >>> validated_single.shape
+            (1, 224, 224, 3)
+        """
+        # Check if the image is a numpy array
+        if not isinstance(image, np.ndarray):
+            msg = f"Image batch must be a numpy.ndarray, got {type(image)}."
+            raise TypeError(msg)
+
+        # Handle single image input
+        if image.ndim == 2 or (image.ndim == 3 and image.shape[-1] in {1, 3}):
+            image = image[np.newaxis, ...]
+
+        # Check if the image has the correct number of dimensions
+        if image.ndim not in {3, 4}:
+            msg = f"Image batch must have shape [N, H, W] or [N, H, W, C], got shape {image.shape}."
+            raise ValueError(msg)
+
+        # Handle 3D grayscale images
+        if image.ndim == 3:
+            image = image[..., np.newaxis]
+
+        # Handle torch style (N, C, H, W) and rearrange if necessary
+        if image.shape[1] in {1, 3} and image.shape[3] not in {1, 3}:
+            image = np.transpose(image, (0, 2, 3, 1))
+
+        # Check if the image has the correct number of channels
+        if image.shape[-1] not in {1, 3}:
+            msg = f"Image batch must have 1 or 3 channels, got {image.shape[-1]}."
+            raise ValueError(msg)
+
+        return image.astype(np.float32)
+
+    @staticmethod
+    def validate_gt_label(gt_label: np.ndarray | Sequence[int] | None) -> np.ndarray | None:
+        """Validate the ground truth label batch.
+
+        Args:
+            gt_label (np.ndarray | Sequence[int] | None): Input ground truth label batch.
+
+        Returns:
+            np.ndarray | None: Validated ground truth label batch as a boolean array, or None.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray or Sequence[int].
+            ValueError: If the label batch shape is invalid.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
+            >>> labels = np.array([0, 1, 1, 0])
+            >>> validated_labels = NumpyImageBatchValidator.validate_gt_label(labels)
+            >>> validated_labels
+            array([False,  True,  True, False])
+            >>> list_labels = [1, 0, 1, 1]
+            >>> validated_list = NumpyImageBatchValidator.validate_gt_label(list_labels)
+            >>> validated_list
+            array([ True, False,  True,  True])
+        """
+        if gt_label is None:
+            return None
+        if isinstance(gt_label, Sequence) and not isinstance(gt_label, np.ndarray):
+            gt_label = np.array(gt_label)
+        if not isinstance(gt_label, np.ndarray):
+            msg = f"Ground truth label batch must be a numpy.ndarray or Sequence[int], got {type(gt_label)}."
+            raise TypeError(msg)
+        if gt_label.ndim != 1:
+            msg = f"Ground truth label batch must be 1-dimensional, got shape {gt_label.shape}."
+            raise ValueError(msg)
+        return gt_label.astype(bool)
+
+    @staticmethod
+    def validate_gt_mask(gt_mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the ground truth mask batch.
+
+        Args:
+            gt_mask (np.ndarray | None): Input ground truth mask batch.
+
+        Returns:
+            np.ndarray | None: Validated ground truth mask batch as a boolean array, or None.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the mask batch shape is invalid.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
+            >>> masks = np.random.randint(0, 2, (4, 224, 224))
+            >>> validated_masks = NumpyImageBatchValidator.validate_gt_mask(masks)
+            >>> validated_masks.shape
+            (4, 224, 224)
+            >>> validated_masks.dtype
+            dtype('bool')
+            >>> torch_style_masks = np.random.randint(0, 2, (4, 1, 224, 224))
+            >>> validated_torch_style = NumpyImageBatchValidator.validate_gt_mask(torch_style_masks)
+            >>> validated_torch_style.shape
+            (4, 224, 224, 1)
+        """
+        if gt_mask is None:
+            return None
+        if not isinstance(gt_mask, np.ndarray):
+            msg = f"Ground truth mask batch must be a numpy.ndarray, got {type(gt_mask)}."
+            raise TypeError(msg)
+        if gt_mask.ndim not in {3, 4}:
+            msg = f"Ground truth mask batch must have shape [N, H, W] or [N, H, W, 1], got shape {gt_mask.shape}."
+            raise ValueError(msg)
+
+        # Check if the mask is in [N, H, W, 1] format and rearrange if necessary
+        if gt_mask.ndim == 4 and gt_mask.shape[3] != 1:
+            gt_mask = np.transpose(gt_mask, (0, 2, 3, 1))
+
+        if gt_mask.ndim == 4 and gt_mask.shape[3] != 1:
+            msg = f"Ground truth mask batch must have 1 channel, got {gt_mask.shape[3]}."
+            raise ValueError(msg)
+
+        return gt_mask.astype(bool)
+
+    @staticmethod
+    def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
+        """Validate the mask paths for a batch.
+
+        Args:
+            mask_path (Sequence[str] | None): Input sequence of mask paths.
+
+        Returns:
+            list[str] | None: Validated list of mask paths, or None.
+
+        Raises:
+            TypeError: If the input is not a sequence of strings.
+            ValueError: If the number of paths doesn't match the batch size.
+
+        Examples:
+            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
+            >>> paths = ['mask1.png', 'mask2.png', 'mask3.png', 'mask4.png']
+            >>> validated_paths = NumpyImageBatchValidator.validate_mask_path(paths)
+            >>> validated_paths
+            ['mask1.png', 'mask2.png', 'mask3.png', 'mask4.png']
+            >>> NumpyImageBatchValidator.validate_mask_path(['mask1.png', 'mask2.png'], 4)
+            Traceback (most recent call last):
+                ...
+            ValueError: Invalid length for mask_path. Got length 2 for batch size 4.
+        """
+        if mask_path is None:
+            return None
+        if not isinstance(mask_path, Sequence):
+            msg = f"Mask path must be a sequence of paths or strings, got {type(mask_path)}."
+            raise TypeError(msg)
+        return [str(path) for path in mask_path]
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
+        """Validate the anomaly map batch.
+
+        Args:
+            anomaly_map (np.ndarray | None): Input anomaly map batch.
+
+        Returns:
+            np.ndarray | None: Validated anomaly map batch, or None.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the anomaly map batch shape is invalid.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
+            >>> anomaly_maps = np.random.rand(4, 224, 224)
+            >>> validated_maps = NumpyImageBatchValidator.validate_anomaly_map(anomaly_maps)
+            >>> validated_maps.shape
+            (4, 224, 224)
+            >>> validated_maps.dtype
+            dtype('float32')
+            >>> torch_style_maps = np.random.rand(4, 1, 224, 224)
+            >>> validated_torch_style = NumpyImageBatchValidator.validate_anomaly_map(torch_style_maps)
+            >>> validated_torch_style.shape
+            (4, 224, 224, 1)
+        """
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, np.ndarray):
+            msg = f"Anomaly map batch must be a numpy.ndarray, got {type(anomaly_map)}."
+            raise TypeError(msg)
+        if anomaly_map.ndim not in {3, 4}:
+            msg = f"Anomaly map batch must have shape [N, H, W] or [N, H, W, 1], got shape {anomaly_map.shape}."
+            raise ValueError(msg)
+        # Check if the anomaly map is in [N, C, H, W] format and rearrange if necessary
+        if anomaly_map.ndim == 4 and anomaly_map.shape[1] not in {1, 3}:
+            anomaly_map = np.transpose(anomaly_map, (0, 2, 3, 1))
+        return anomaly_map.astype(np.float32)
+
+    @staticmethod
+    def validate_pred_score(pred_score: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction scores for a batch.
+
+        Args:
+            pred_score (np.ndarray | None): Input prediction score batch.
+
+        Returns:
+            np.ndarray | None: Validated prediction score batch, or None.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the prediction score batch is not 1-dimensional or 2-dimensional.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
+            >>> scores = np.array([0.1, 0.8, 0.3, 0.6])
+            >>> validated_scores = NumpyImageBatchValidator.validate_pred_score(scores)
+            >>> validated_scores
+            array([0.1, 0.8, 0.3, 0.6], dtype=float32)
+            >>> scores_2d = np.array([[0.1], [0.8], [0.3], [0.6]])
+            >>> validated_scores_2d = NumpyImageBatchValidator.validate_pred_score(scores_2d)
+            >>> validated_scores_2d
+            array([[0.1],
+                   [0.8],
+                   [0.3],
+                   [0.6]], dtype=float32)
+        """
+        if pred_score is None:
+            return None
+        if not isinstance(pred_score, np.ndarray):
+            msg = f"Prediction score batch must be a numpy.ndarray, got {type(pred_score)}."
+            raise TypeError(msg)
+        if pred_score.ndim not in {1, 2}:
+            msg = f"Prediction score batch must be 1D or 2D, got shape {pred_score.shape}."
+            raise ValueError(msg)
+
+        return pred_score.astype(np.float32)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction mask batch.
+
+        Args:
+            pred_mask (np.ndarray | None): Input prediction mask batch.
+
+        Returns:
+            np.ndarray | None: Validated prediction mask batch, or None.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the prediction mask batch shape is invalid.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
+            >>> masks = np.random.randint(0, 2, (4, 224, 224))
+            >>> validated_masks = NumpyImageBatchValidator.validate_pred_mask(masks)
+            >>> validated_masks.shape
+            (4, 224, 224)
+            >>> validated_masks.dtype
+            dtype('bool')
+            >>> torch_style_masks = np.random.randint(0, 2, (4, 1, 224, 224))
+            >>> validated_torch_style = NumpyImageBatchValidator.validate_pred_mask(torch_style_masks)
+            >>> validated_torch_style.shape
+            (4, 224, 224, 1)
+        """
+        return NumpyImageBatchValidator.validate_gt_mask(pred_mask)
+
+    @staticmethod
+    def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction label batch.
+
+        Args:
+            pred_label (np.ndarray | None): Input prediction label batch.
+
+        Returns:
+            np.ndarray | None: Validated prediction label batch as a boolean array, or None.
+
+        Raises:
+            TypeError: If the input is not a numpy.ndarray.
+            ValueError: If the prediction label batch is not 1-dimensional or 2-dimensional.
+
+        Examples:
+            >>> import numpy as np
+            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
+            >>> labels = np.array([0, 1, 1, 0])
+            >>> validated_labels = NumpyImageBatchValidator.validate_pred_label(labels)
+            >>> validated_labels
+            array([False,  True,  True, False])
+            >>> labels_2d = np.array([[0], [1], [1], [0]])
+            >>> validated_labels_2d = NumpyImageBatchValidator.validate_pred_label(labels_2d)
+            >>> validated_labels_2d
+            array([[False],
+                   [ True],
+                   [ True],
+                   [False]])
+        """
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, np.ndarray):
+            msg = f"Prediction label batch must be a numpy.ndarray, got {type(pred_label)}."
+            raise TypeError(msg)
+        if pred_label.ndim not in {1, 2}:
+            msg = f"Prediction label batch must be 1D or 2D, got shape {pred_label.shape}."
+            raise ValueError(msg)
+        return pred_label.astype(bool)
+
+    @staticmethod
+    def validate_image_path(image_path: list[str] | None) -> list[str] | None:
+        """Validate the image paths for a batch.
+
+        Args:
+            image_path (list[str] | None): Input list of image paths.
+
+        Returns:
+            list[str] | None: Validated list of image paths, or None.
+
+        Raises:
+            TypeError: If the input is not a list of strings.
+
+        Examples:
+            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
+            >>> paths = ['image1.jpg', 'image2.jpg', 'image3.jpg']
+            >>> validated_paths = NumpyImageBatchValidator.validate_image_path(paths)
+            >>> validated_paths
+            ['image1.jpg', 'image2.jpg', 'image3.jpg']
+            >>> NumpyImageBatchValidator.validate_image_path(['image1.jpg', 2, 'image3.jpg'])
+            ['image1.jpg', '2', 'image3.jpg']
+        """
+        if image_path is None:
+            return None
+        if not isinstance(image_path, list):
+            msg = f"Image path must be a list of strings, got {type(image_path)}."
+            raise TypeError(msg)
+        return [str(path) for path in image_path]
diff --git a/src/anomalib/data/validators/numpy/video.py b/src/anomalib/data/validators/numpy/video.py
new file mode 100644
index 0000000000..a75f17d546
--- /dev/null
+++ b/src/anomalib/data/validators/numpy/video.py
@@ -0,0 +1,694 @@
+"""Validate numpy video data."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+
+import numpy as np
+from anomalib.data.validators.path import validate_batch_path, validate_path
+
+
+class NumpyVideoValidator:
+    """Validate numpy.ndarray data for videos."""
+
+    @staticmethod
+    def validate_image(image: np.ndarray) -> np.ndarray:
+        """Validate the video array.
+
+        Args:
+            image (np.ndarray): Input video array to validate.
+
+        Returns:
+            np.ndarray: Validated video array as float32 with an added time dimension if not present.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the array dimensions or channel count are invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoValidator()
+            >>> video = np.random.rand(10, 224, 224, 3)  # [T, H, W, C]
+            >>> validated_video = validator.validate_image(video)
+            >>> print(validated_video.shape, validated_video.dtype)
+            (10, 224, 224, 3) float32
+        """
+        if not isinstance(image, np.ndarray):
+            msg = f"Video must be a numpy.ndarray, got {type(image)}."
+            raise TypeError(msg)
+
+        if image.ndim == 3:
+            # Add time dimension for single frame
+            image = np.expand_dims(image, axis=0)
+
+        if image.ndim != 4:
+            msg = f"Video must have 4 dimensions [T, H, W, C], got shape {image.shape}."
+            raise ValueError(msg)
+
+        if image.shape[3] not in {1, 3}:
+            msg = f"Video must have 1 or 3 channels, got {image.shape[3]}."
+            raise ValueError(msg)
+
+        return image.astype(np.float32)
+
+    @staticmethod
+    def validate_gt_label(label: int | np.ndarray | None) -> np.ndarray | None:
+        """Validate the ground truth label.
+
+        Args:
+            label (int | np.ndarray | None): Input label to validate.
+
+        Returns:
+            np.ndarray | None: Validated label as boolean numpy array, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not an integer or numpy array.
+            ValueError: If the label is not a scalar.
+
+        Example:
+            >>> validator = NumpyVideoValidator()
+            >>> label = 1
+            >>> validated_label = validator.validate_gt_label(label)
+            >>> print(validated_label, validated_label.dtype)
+            True bool
+        """
+        if label is None:
+            return None
+        if isinstance(label, int):
+            label = np.array(label)
+        if not isinstance(label, np.ndarray):
+            msg = f"Ground truth label must be an integer or a numpy.ndarray, got {type(label)}."
+            raise TypeError(msg)
+        if label.ndim != 0:
+            msg = f"Ground truth label must be a scalar, got shape {label.shape}."
+            raise ValueError(msg)
+        if not np.issubdtype(label.dtype, np.integer):
+            msg = f"Ground truth label must be boolean or integer, got {label.dtype}."
+            raise TypeError(msg)
+        return label.astype(bool)
+
+    @staticmethod
+    def validate_gt_mask(mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the ground truth mask.
+
+        Args:
+            mask (np.ndarray | None): Input mask to validate.
+
+        Returns:
+            np.ndarray | None: Validated mask as boolean numpy array, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the mask dimensions or channel count are invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoValidator()
+            >>> mask = np.random.randint(0, 2, size=(5, 224, 224))  # [T, H, W]
+            >>> validated_mask = validator.validate_gt_mask(mask)
+            >>> print(validated_mask.shape, validated_mask.dtype)
+            (5, 224, 224) bool
+        """
+        if mask is None:
+            return None
+        if not isinstance(mask, np.ndarray):
+            msg = f"Mask must be a numpy.ndarray, got {type(mask)}."
+            raise TypeError(msg)
+        if mask.ndim not in {3, 4}:
+            msg = f"Mask must have shape [T, H, W] or [T, H, W, 1] got shape {mask.shape}."
+            raise ValueError(msg)
+        if mask.ndim == 4 and mask.shape[3] != 1:
+            msg = f"Mask must have 1 channel, got {mask.shape[3]}."
+            raise ValueError(msg)
+        return mask.astype(bool)
+
+    @staticmethod
+    def validate_mask_path(mask_path: str | None) -> str | None:
+        """Validate the mask path.
+
+        Args:
+            mask_path (str | None): Input mask path to validate.
+
+        Returns:
+            str | None: Validated mask path, or None if input is None.
+
+        Example:
+            >>> validator = NumpyVideoValidator()
+            >>> path = "/path/to/mask.png"
+            >>> validated_path = validator.validate_mask_path(path)
+            >>> print(validated_path)
+            /path/to/mask.png
+        """
+        return validate_path(mask_path) if mask_path else None
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
+        """Validate the anomaly map.
+
+        Args:
+            anomaly_map (np.ndarray | None): Input anomaly map to validate.
+
+        Returns:
+            np.ndarray | None: Validated anomaly map as float32 numpy array, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the anomaly map dimensions or channel count are invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoValidator()
+            >>> amap = np.random.rand(5, 224, 224)  # [T, H, W]
+            >>> validated_amap = validator.validate_anomaly_map(amap)
+            >>> print(validated_amap.shape, validated_amap.dtype)
+            (5, 224, 224) float32
+        """
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, np.ndarray):
+            msg = f"Anomaly map must be a numpy.ndarray, got {type(anomaly_map)}."
+            raise TypeError(msg)
+        if anomaly_map.ndim not in {3, 4}:
+            msg = f"Anomaly map must have shape [T, H, W] or [T, H, W, 1], got shape {anomaly_map.shape}."
+            raise ValueError(msg)
+        if anomaly_map.ndim == 4 and anomaly_map.shape[3] != 1:
+            msg = f"Anomaly map must have 1 channel, got {anomaly_map.shape[3]}."
+            raise ValueError(msg)
+        return anomaly_map.astype(np.float32)
+
+    @staticmethod
+    def validate_pred_score(pred_score: np.ndarray | float | None) -> np.ndarray | None:
+        """Validate the prediction score.
+
+        Args:
+            pred_score (np.ndarray | float | None): Input prediction score to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction score as float32 numpy array, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a float or numpy array.
+            ValueError: If the prediction score is not a scalar.
+
+        Example:
+            >>> validator = NumpyVideoValidator()
+            >>> score = 0.75
+            >>> validated_score = validator.validate_pred_score(score)
+            >>> print(validated_score, validated_score.dtype)
+            0.75 float32
+        """
+        if pred_score is None:
+            return None
+        if isinstance(pred_score, float):
+            pred_score = np.array(pred_score)
+        if not isinstance(pred_score, np.ndarray):
+            msg = f"Prediction score must be a float or numpy.ndarray, got {type(pred_score)}."
+            raise TypeError(msg)
+        if pred_score.ndim != 0:
+            msg = f"Prediction score must be a scalar, got shape {pred_score.shape}."
+            raise ValueError(msg)
+        return pred_score.astype(np.float32)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction mask.
+
+        Args:
+            pred_mask (np.ndarray | None): Input prediction mask to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction mask as boolean numpy array, or None if input is None.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoValidator()
+            >>> mask = np.random.randint(0, 2, size=(5, 224, 224))  # [T, H, W]
+            >>> validated_mask = validator.validate_pred_mask(mask)
+            >>> print(validated_mask.shape, validated_mask.dtype)
+            (5, 224, 224) bool
+        """
+        return NumpyVideoValidator.validate_gt_mask(pred_mask)
+
+    @staticmethod
+    def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction label.
+
+        Args:
+            pred_label (np.ndarray | None): Input prediction label to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction label as boolean numpy array, or None if input is None.
+
+        Raises:
+            ValueError: If the input cannot be converted to a numpy array or is not a scalar.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoValidator()
+            >>> label = np.array(1)
+            >>> validated_label = validator.validate_pred_label(label)
+            >>> print(validated_label, validated_label.dtype)
+            True bool
+        """
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, np.ndarray):
+            try:
+                pred_label = np.array(pred_label)
+            except Exception as e:
+                msg = "Failed to convert pred_label to a numpy.ndarray."
+                raise ValueError(msg) from e
+        pred_label = pred_label.squeeze()
+        if pred_label.ndim != 0:
+            msg = f"Predicted label must be a scalar, got shape {pred_label.shape}."
+            raise ValueError(msg)
+        return pred_label.astype(bool)
+
+    @staticmethod
+    def validate_video_path(video_path: str | None) -> str | None:
+        """Validate the video path.
+
+        Args:
+            video_path (str | None): Input video path to validate.
+
+        Returns:
+            str | None: Validated video path, or None if input is None.
+
+        Example:
+            >>> validator = NumpyVideoValidator()
+            >>> path = "/path/to/video.mp4"
+            >>> validated_path = validator.validate_video_path(path)
+            >>> print(validated_path)
+            /path/to/video.mp4
+        """
+        return validate_path(video_path) if video_path else None
+
+    @staticmethod
+    def validate_original_image(original_image: np.ndarray | None) -> np.ndarray | None:
+        """Validate the original video.
+
+        Args:
+            original_image (np.ndarray | None): Input original video to validate.
+
+        Returns:
+            np.ndarray | None: Validated original video, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the original video dimensions or channel count are invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoValidator()
+            >>> video = np.random.rand(10, 224, 224, 3)  # [T, H, W, C]
+            >>> validated_video = validator.validate_original_image(video)
+            >>> print(validated_video.shape, validated_video.dtype)
+            (10, 224, 224, 3) float64
+        """
+        if original_image is None:
+            return None
+        if not isinstance(original_image, np.ndarray):
+            msg = f"Original image must be a numpy.ndarray, got {type(original_image)}."
+            raise TypeError(msg)
+        if original_image.ndim not in {3, 4}:
+            msg = f"Original image must have shape [T, H, W, C] or [H, W, C], got shape {original_image.shape}."
+            raise ValueError(msg)
+        if original_image.shape[-1] != 3:
+            msg = f"Original image must have 3 channels, got {original_image.shape[-1]}."
+            raise ValueError(msg)
+        return original_image
+
+    @staticmethod
+    def validate_target_frame(target_frame: int | None) -> int | None:
+        """Validate the target frame index.
+
+        Args:
+            target_frame (int | None): Input target frame index to validate.
+
+        Returns:
+            int | None: Validated target frame index, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not an integer.
+            ValueError: If the target frame index is negative.
+
+        Example:
+            >>> validator = NumpyVideoValidator()
+            >>> frame = 5
+            >>> validated_frame = validator.validate_target_frame(frame)
+            >>> print(validated_frame)
+            5
+        """
+        if target_frame is None:
+            return None
+        if not isinstance(target_frame, int):
+            msg = f"Target frame must be an integer, got {type(target_frame)}."
+            raise TypeError(msg)
+        if target_frame < 0:
+            msg = "Target frame index must be non-negative."
+            raise ValueError(msg)
+        return target_frame
+
+
+class NumpyVideoBatchValidator:
+    """Validate numpy.ndarray data for batches of videos."""
+
+    @staticmethod
+    def validate_image(image: np.ndarray) -> np.ndarray:
+        """Validate the video batch array.
+
+        Args:
+            image (np.ndarray): Input video batch array to validate.
+
+        Returns:
+            np.ndarray: Validated video batch array as float32.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the array dimensions or channel count are invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoBatchValidator()
+            >>> video_batch = np.random.rand(2, 10, 224, 224, 3)  # [N, T, H, W, C]
+            >>> validated_batch = validator.validate_image(video_batch)
+            >>> print(validated_batch.shape, validated_batch.dtype)
+            (2, 10, 224, 224, 3) float32
+        """
+        if not isinstance(image, np.ndarray):
+            msg = f"Video batch must be a numpy.ndarray, got {type(image)}."
+            raise TypeError(msg)
+        if image.ndim not in {4, 5}:
+            msg = f"Video batch must have 4 or 5 dimensions, got shape {image.shape}."
+            raise ValueError(msg)
+        if image.ndim == 4:
+            if image.shape[3] not in {1, 3}:
+                msg = f"Video batch must have 1 or 3 channels for single frame, got {image.shape[3]}."
+                raise ValueError(msg)
+        elif image.ndim == 5 and image.shape[4] not in {1, 3}:
+            msg = f"Video batch must have 1 or 3 channels, got {image.shape[4]}."
+            raise ValueError(msg)
+        return image.astype(np.float32)
+
+    @staticmethod
+    def validate_gt_label(gt_label: np.ndarray | Sequence[int] | None) -> np.ndarray | None:
+        """Validate the ground truth label batch.
+
+        Args:
+            gt_label (np.ndarray | Sequence[int] | None): Input ground truth label batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated ground truth label batch as boolean numpy array, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array or sequence of integers.
+            ValueError: If the label batch shape is invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoBatchValidator()
+            >>> labels = [0, 1, 1, 0]
+            >>> validated_labels = validator.validate_gt_label(labels)
+            >>> print(validated_labels, validated_labels.dtype)
+            [False  True  True False] bool
+        """
+        if gt_label is None:
+            return None
+        if isinstance(gt_label, Sequence):
+            gt_label = np.array(gt_label)
+        if not isinstance(gt_label, np.ndarray):
+            msg = f"Ground truth label batch must be a numpy.ndarray, got {type(gt_label)}."
+            raise TypeError(msg)
+        if gt_label.ndim != 1:
+            msg = f"Ground truth label batch must be 1-dimensional, got shape {gt_label.shape}."
+            raise ValueError(msg)
+        return gt_label.astype(bool)
+
+    @staticmethod
+    def validate_gt_mask(gt_mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the ground truth mask batch.
+
+        Args:
+            gt_mask (np.ndarray | None): Input ground truth mask batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated ground truth mask batch as boolean numpy array, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the mask batch shape is invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoBatchValidator()
+            >>> masks = np.random.randint(0, 2, size=(2, 5, 224, 224))  # [N, T, H, W]
+            >>> validated_masks = validator.validate_gt_mask(masks)
+            >>> print(validated_masks.shape, validated_masks.dtype)
+            (2, 5, 224, 224) bool
+        """
+        if gt_mask is None:
+            return None
+        if not isinstance(gt_mask, np.ndarray):
+            msg = f"Ground truth mask batch must be a numpy.ndarray, got {type(gt_mask)}."
+            raise TypeError(msg)
+        if gt_mask.ndim not in {4, 5}:
+            msg = f"Ground truth mask batch must have shape [N, T, H, W] or [N, T, H, W, 1], got shape {gt_mask.shape}."
+            raise ValueError(msg)
+        if gt_mask.ndim == 5 and gt_mask.shape[4] != 1:
+            msg = f"Ground truth mask batch must have 1 channel, got {gt_mask.shape[4]}."
+            raise ValueError(msg)
+        return gt_mask.astype(bool)
+
+    @staticmethod
+    def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
+        """Validate the mask paths for a batch.
+
+        Args:
+            mask_path (Sequence[str] | None): Input mask paths to validate.
+
+        Returns:
+            list[str] | None: Validated mask paths, or None if input is None.
+
+        Example:
+            >>> validator = NumpyVideoBatchValidator()
+            >>> paths = ["/path/to/mask1.png", "/path/to/mask2.png"]
+            >>> validated_paths = validator.validate_mask_path(paths)
+            >>> print(validated_paths)
+            ['/path/to/mask1.png', '/path/to/mask2.png']
+        """
+        return validate_batch_path(mask_path)
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
+        """Validate the anomaly map batch.
+
+        Args:
+            anomaly_map (np.ndarray | None): Input anomaly map batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated anomaly map batch as float32 numpy array, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the anomaly map batch shape is invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoBatchValidator()
+            >>> anomaly_maps = np.random.rand(2, 5, 224, 224)  # [N, T, H, W]
+            >>> validated_maps = validator.validate_anomaly_map(anomaly_maps)
+            >>> print(validated_maps.shape, validated_maps.dtype)
+            (2, 5, 224, 224) float32
+        """
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, np.ndarray):
+            msg = f"Anomaly map batch must be a numpy.ndarray, got {type(anomaly_map)}."
+            raise TypeError(msg)
+        if anomaly_map.ndim not in {4, 5}:
+            msg = f"Anomaly map batch must have shape [N, T, H, W] or [N, T, H, W, 1], got shape {anomaly_map.shape}."
+            raise ValueError(msg)
+        if anomaly_map.ndim == 5 and anomaly_map.shape[4] != 1:
+            msg = f"Anomaly map batch must have 1 channel, got {anomaly_map.shape[4]}."
+            raise ValueError(msg)
+        return anomaly_map.astype(np.float32)
+
+    @staticmethod
+    def validate_pred_score(pred_score: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction scores for a batch.
+
+        Args:
+            pred_score (np.ndarray | None): Input prediction scores to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction scores as float32 numpy array, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the prediction score batch shape is invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoBatchValidator()
+            >>> scores = np.array([0.1, 0.8, 0.3, 0.6])
+            >>> validated_scores = validator.validate_pred_score(scores)
+            >>> print(validated_scores, validated_scores.dtype)
+            [0.1 0.8 0.3 0.6] float32
+        """
+        if pred_score is None:
+            return None
+        if not isinstance(pred_score, np.ndarray):
+            msg = f"Prediction score batch must be a numpy.ndarray, got {type(pred_score)}."
+            raise TypeError(msg)
+        if pred_score.ndim != 1:
+            msg = f"Prediction score batch must be 1-dimensional, got shape {pred_score.shape}."
+            raise ValueError(msg)
+        return pred_score.astype(np.float32)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction mask batch.
+
+        Args:
+            pred_mask (np.ndarray | None): Input prediction mask batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction mask batch as boolean numpy array, or None if input is None.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoBatchValidator()
+            >>> masks = np.random.randint(0, 2, size=(2, 5, 224, 224))  # [N, T, H, W]
+            >>> validated_masks = validator.validate_pred_mask(masks)
+            >>> print(validated_masks.shape, validated_masks.dtype)
+            (2, 5, 224, 224) bool
+        """
+        return NumpyVideoBatchValidator.validate_gt_mask(pred_mask)
+
+    @staticmethod
+    def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
+        """Validate the prediction label batch.
+
+        Args:
+            pred_label (np.ndarray | None): Input prediction label batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction label batch as boolean numpy array, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the prediction label batch shape is invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoBatchValidator()
+            >>> labels = np.array([0, 1, 1, 0])
+            >>> validated_labels = validator.validate_pred_label(labels)
+            >>> print(validated_labels, validated_labels.dtype)
+            [False  True  True False] bool
+        """
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, np.ndarray):
+            msg = f"Prediction label batch must be a numpy.ndarray, got {type(pred_label)}."
+            raise TypeError(msg)
+        if pred_label.ndim != 1:
+            msg = f"Prediction label batch must be 1-dimensional, got shape {pred_label.shape}."
+            raise ValueError(msg)
+        return pred_label.astype(bool)
+
+    @staticmethod
+    def validate_video_path(video_path: list[str] | None) -> list[str] | None:
+        """Validate the video paths for a batch.
+
+        Args:
+            video_path (list[str] | None): Input video paths to validate.
+
+        Returns:
+            list[str] | None: Validated video paths, or None if input is None.
+
+        Example:
+            >>> validator = NumpyVideoBatchValidator()
+            >>> paths = ["/path/to/video1.mp4", "/path/to/video2.mp4"]
+            >>> validated_paths = validator.validate_video_path(paths)
+            >>> print(validated_paths)
+            ['/path/to/video1.mp4', '/path/to/video2.mp4']
+        """
+        return validate_batch_path(video_path)
+
+    @staticmethod
+    def validate_original_image(original_image: np.ndarray | None) -> np.ndarray | None:
+        """Validate the original video batch.
+
+        Args:
+            original_image (np.ndarray | None): Input original video batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated original video batch, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array.
+            ValueError: If the original image batch shape is invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoBatchValidator()
+            >>> original_batch = np.random.rand(2, 10, 224, 224, 3)  # [N, T, H, W, C]
+            >>> validated_batch = validator.validate_original_image(original_batch)
+            >>> print(validated_batch.shape, validated_batch.dtype)
+            (2, 10, 224, 224, 3) float64
+        """
+        if original_image is None:
+            return None
+        if not isinstance(original_image, np.ndarray):
+            msg = f"Original image batch must be a numpy.ndarray, got {type(original_image)}."
+            raise TypeError(msg)
+        if original_image.ndim not in {4, 5}:
+            msg = (
+                "Original image batch must have shape [N, T, H, W, C] or [N, H, W, C], "
+                f"got shape {original_image.shape}."
+            )
+            raise ValueError(msg)
+        if original_image.shape[-1] != 3:
+            msg = f"Original image batch must have 3 channels, got {original_image.shape[-1]}."
+            raise ValueError(msg)
+        return original_image
+
+    @staticmethod
+    def validate_target_frame(target_frame: np.ndarray | None) -> np.ndarray | None:
+        """Validate the target frame indices for a batch.
+
+        Args:
+            target_frame (np.ndarray | None): Input target frame indices to validate.
+
+        Returns:
+            np.ndarray | None: Validated target frame indices, or None if input is None.
+
+        Raises:
+            TypeError: If the input is not a numpy array of integers.
+            ValueError: If the target frame indices are negative or the shape is invalid.
+
+        Example:
+            >>> import numpy as np
+            >>> validator = NumpyVideoBatchValidator()
+            >>> frames = np.array([0, 5, 2, 7])
+            >>> validated_frames = validator.validate_target_frame(frames)
+            >>> print(validated_frames, validated_frames.dtype)
+            [0 5 2 7] int64
+        """
+        if target_frame is None:
+            return None
+        if not isinstance(target_frame, np.ndarray):
+            msg = f"Target frame batch must be a numpy.ndarray, got {type(target_frame)}."
+            raise TypeError(msg)
+        if target_frame.ndim != 1:
+            msg = f"Target frame batch must be 1-dimensional, got shape {target_frame.shape}."
+            raise ValueError(msg)
+        if not np.issubdtype(target_frame.dtype, np.integer):
+            msg = f"Target frame batch must be integer type, got {target_frame.dtype}."
+            raise TypeError(msg)
+        if np.any(target_frame < 0):
+            msg = "Target frame indices must be non-negative."
+            raise ValueError(msg)
+        return target_frame
diff --git a/src/anomalib/data/validators/path.py b/src/anomalib/data/validators/path.py
new file mode 100644
index 0000000000..0ee5080710
--- /dev/null
+++ b/src/anomalib/data/validators/path.py
@@ -0,0 +1,82 @@
+"""Validate IO path data."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+from pathlib import Path
+
+
+def validate_path(path: str | Path) -> str:
+    """Validate a single input path.
+
+    Args:
+        path: The input path to validate. Can be None, a string, or a Path object.
+
+    Returns:
+        - None if the input is None
+        - A string representing the validated path
+
+    Raises:
+        TypeError: If the input is not None, a string, or a Path object.
+
+    Examples:
+        >>> validate_path(None)
+        None
+        >>> validate_path("/path/to/file.png")
+        '/path/to/file.png'
+        >>> from pathlib import Path
+        >>> validate_path(Path("/path/to/file.png"))
+        '/path/to/file.png'
+    """
+    if isinstance(path, str | Path):
+        return str(path)
+    msg = f"Path must be None, a string, or Path object, got {type(path)}."
+    raise TypeError(msg)
+
+
+def validate_batch_path(
+    paths: Sequence[str | Path] | None,
+    batch_size: int | None = None,
+) -> list[str] | None:
+    """Validate a batch of input paths.
+
+    Args:
+        paths: A sequence of paths to validate, or None.
+        batch_size: The expected number of paths. Defaults to None, in which case no batch size check is performed.
+
+    Returns:
+        - None if the input is None
+        - A list of strings representing validated paths
+
+    Raises:
+        TypeError: If the input is not None or a sequence of strings or Path objects.
+        ValueError: If a batch_size is specified and the number of paths doesn't match it.
+
+    Examples:
+        >>> paths = ["/path/to/file1.png", Path("/path/to/file2.png")]
+        >>> validate_batch_path(paths, batch_size=2)
+        ['/path/to/file1.png', '/path/to/file2.png']
+        >>> validate_batch_path(paths)  # Without specifying batch_size
+        ['/path/to/file1.png', '/path/to/file2.png']
+        >>> validate_batch_path(paths, batch_size=3)
+        Traceback (most recent call last):
+            ...
+        ValueError: Number of paths (2) does not match the specified batch size (3).
+    """
+    if paths is None:
+        return None
+    if not isinstance(paths, Sequence):
+        msg = f"Paths must be None or a sequence of strings or Path objects, got {type(paths)}."
+        raise TypeError(msg)
+    if batch_size is not None and len(paths) != batch_size:
+        msg = f"Number of paths ({len(paths)}) does not match the specified batch size ({batch_size})."
+        raise ValueError(msg)
+
+    validated_paths: list[str] = []
+    for p in paths:
+        if not isinstance(p, str | Path):
+            msg = f"Each path in the sequence must be a string or Path object, got {type(p)}."
+            raise TypeError(msg)
+        validated_paths.append(str(p))
+    return validated_paths
diff --git a/src/anomalib/data/validators/torch/__init__.py b/src/anomalib/data/validators/torch/__init__.py
new file mode 100644
index 0000000000..14253a93c7
--- /dev/null
+++ b/src/anomalib/data/validators/torch/__init__.py
@@ -0,0 +1,17 @@
+"""Anomalib Torch data validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .depth import DepthBatchValidator, DepthValidator
+from .image import ImageBatchValidator, ImageValidator
+from .video import VideoBatchValidator, VideoValidator
+
+__all__ = [
+    "DepthBatchValidator",
+    "DepthValidator",
+    "ImageBatchValidator",
+    "ImageValidator",
+    "VideoBatchValidator",
+    "VideoValidator",
+]
diff --git a/src/anomalib/data/validators/torch/depth.py b/src/anomalib/data/validators/torch/depth.py
new file mode 100644
index 0000000000..a91e3f69ee
--- /dev/null
+++ b/src/anomalib/data/validators/torch/depth.py
@@ -0,0 +1,443 @@
+"""Validate torch depth data."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+
+import numpy as np
+from torchvision.transforms.v2.functional import to_dtype_image
+from torchvision.tv_tensors import Image, Mask
+
+import torch
+from anomalib.data.validators.path import validate_path
+from anomalib.data.validators.torch.image import ImageBatchValidator, ImageValidator
+
+
+class DepthValidator:
+    """Validate torch.Tensor data for depth images."""
+
+    @staticmethod
+    def validate_image(image: torch.Tensor) -> Image:
+        """Validate the image tensor.
+
+        Args:
+            image (torch.Tensor): Input image tensor.
+
+        Returns:
+            Image: Validated image as a torchvision Image object.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the image tensor does not have the correct shape.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import DepthValidator
+            >>> image = torch.rand(3, 256, 256)
+            >>> validated_image = DepthValidator.validate_image(image)
+            >>> validated_image.shape
+            torch.Size([3, 256, 256])
+        """
+        if not isinstance(image, torch.Tensor):
+            msg = f"Image must be a torch.Tensor, got {type(image)}."
+            raise TypeError(msg)
+        if image.ndim != 3:
+            msg = f"Image must have shape [C, H, W], got shape {image.shape}."
+            raise ValueError(msg)
+        if image.shape[0] != 3:
+            msg = f"Image must have 3 channels, got {image.shape[0]}."
+            raise ValueError(msg)
+        return Image(to_dtype_image(image, torch.float32, scale=True))
+
+    @staticmethod
+    def validate_gt_label(label: int | torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the ground truth label.
+
+        Args:
+            label (int | torch.Tensor | None): Input ground truth label.
+
+        Returns:
+            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+
+        Raises:
+            TypeError: If the input is neither an integer nor a torch.Tensor.
+            ValueError: If the label shape or dtype is invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import DepthValidator
+            >>> label_int = 1
+            >>> validated_label = DepthValidator.validate_gt_label(label_int)
+            >>> validated_label
+            tensor(True)
+            >>> label_tensor = torch.tensor(0)
+            >>> validated_label = DepthValidator.validate_gt_label(label_tensor)
+            >>> validated_label
+            tensor(False)
+        """
+        if label is None:
+            return None
+        if isinstance(label, int | np.integer):
+            label = torch.tensor(int(label))
+        if not isinstance(label, torch.Tensor):
+            msg = f"Ground truth label must be an integer or a torch.Tensor, got {type(label)}."
+            raise TypeError(msg)
+        if label.ndim != 0:
+            msg = f"Ground truth label must be a scalar, got shape {label.shape}."
+            raise ValueError(msg)
+        if torch.is_floating_point(label):
+            msg = f"Ground truth label must be boolean or integer, got {label.dtype}."
+            raise TypeError(msg)
+        return label.bool()
+
+    @staticmethod
+    def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
+        """Validate the ground truth mask.
+
+        Args:
+            mask (torch.Tensor | None): Input ground truth mask.
+
+        Returns:
+            Mask | None: Validated ground truth mask, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the mask shape is invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import DepthValidator
+            >>> mask = torch.randint(0, 2, (1, 224, 224))
+            >>> validated_mask = DepthValidator.validate_gt_mask(mask)
+            >>> isinstance(validated_mask, Mask)
+            True
+            >>> validated_mask.shape
+            torch.Size([224, 224])
+        """
+        if mask is None:
+            return None
+        if not isinstance(mask, torch.Tensor):
+            msg = f"Mask must be a torch.Tensor, got {type(mask)}."
+            raise TypeError(msg)
+        if mask.ndim not in {2, 3}:
+            msg = f"Mask must have shape [H, W] or [1, H, W] got shape {mask.shape}."
+            raise ValueError(msg)
+        if mask.ndim == 3:
+            if mask.shape[0] != 1:
+                msg = f"Mask must have 1 channel, got {mask.shape[0]}."
+                raise ValueError(msg)
+            mask = mask.squeeze(0)
+        return Mask(mask, dtype=torch.bool)
+
+    @staticmethod
+    def validate_image_path(image_path: str | None) -> str | None:
+        """Validate the image path.
+
+        Args:
+            image_path (str | None): Input image path.
+
+        Returns:
+            str | None: Validated image path, or None.
+
+        Examples:
+            >>> from anomalib.data.validators import DepthValidator
+            >>> path = "/path/to/image.jpg"
+            >>> validated_path = DepthValidator.validate_image_path(path)
+            >>> validated_path == path
+            True
+        """
+        return validate_path(image_path) if image_path else None
+
+    @staticmethod
+    def validate_depth_map(depth_map: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the depth map.
+
+        Args:
+            depth_map (torch.Tensor | None): Input depth map.
+
+        Returns:
+            torch.Tensor | None: Validated depth map, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the depth map shape is invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import DepthValidator
+            >>> depth_map = torch.rand(224, 224)
+            >>> validated_map = DepthValidator.validate_depth_map(depth_map)
+            >>> validated_map.shape
+            torch.Size([224, 224])
+        """
+        if depth_map is None:
+            return None
+        if not isinstance(depth_map, torch.Tensor):
+            msg = f"Depth map must be a torch.Tensor, got {type(depth_map)}."
+            raise TypeError(msg)
+        if depth_map.ndim not in {2, 3}:
+            msg = f"Depth map must have shape [H, W] or [C, H, W], got shape {depth_map.shape}."
+            raise ValueError(msg)
+        if depth_map.ndim == 3 and depth_map.shape[0] not in {1, 3}:
+            msg = f"Depth map with 3 dimensions must have 1 or 3 channels, got {depth_map.shape[0]}."
+            raise ValueError(msg)
+        return depth_map.to(torch.float32)
+
+    @staticmethod
+    def validate_depth_path(depth_path: str | None) -> str | None:
+        """Validate the depth path.
+
+        Args:
+            depth_path (str | None): Input depth path.
+
+        Returns:
+            str | None: Validated depth path, or None.
+
+        Examples:
+            >>> from anomalib.data.validators import DepthValidator
+            >>> path = "/path/to/depth.png"
+            >>> validated_path = DepthValidator.validate_depth_path(path)
+            >>> validated_path == path
+            True
+        """
+        return validate_path(depth_path) if depth_path else None
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
+        """Validate the anomaly map."""
+        return ImageValidator.validate_anomaly_map(anomaly_map)
+
+    @staticmethod
+    def validate_pred_score(pred_score: torch.Tensor | float | None) -> torch.Tensor | None:
+        """Validate the prediction score."""
+        return ImageValidator.validate_pred_score(pred_score)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
+        """Validate the prediction mask."""
+        return ImageValidator.validate_pred_mask(pred_mask)
+
+    @staticmethod
+    def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the prediction label."""
+        return ImageValidator.validate_pred_label(pred_label)
+
+    @staticmethod
+    def validate_mask_path(mask_path: str | None) -> str | None:
+        """Validate the mask path."""
+        return ImageValidator.validate_mask_path(mask_path)
+
+
+class DepthBatchValidator:
+    """Validate torch.Tensor data for batches of depth images."""
+
+    @staticmethod
+    def validate_image(image: torch.Tensor) -> Image:
+        """Validate the image tensor for a batch.
+
+        Args:
+            image (torch.Tensor): Input image tensor.
+
+        Returns:
+            Image: Validated image as a torchvision Image object.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the image tensor does not have the correct shape.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import DepthBatchValidator
+            >>> image = torch.rand(32, 3, 256, 256)
+            >>> validated_image = DepthBatchValidator.validate_image(image)
+            >>> validated_image.shape
+            torch.Size([32, 3, 256, 256])
+        """
+        if not isinstance(image, torch.Tensor):
+            msg = f"Image must be a torch.Tensor, got {type(image)}."
+            raise TypeError(msg)
+        if image.ndim != 4:
+            msg = f"Image must have shape [N, C, H, W], got shape {image.shape}."
+            raise ValueError(msg)
+        if image.shape[1] != 3:
+            msg = f"Image must have 3 channels, got {image.shape[1]}."
+            raise ValueError(msg)
+        return Image(to_dtype_image(image, torch.float32, scale=True))
+
+    @staticmethod
+    def validate_gt_label(gt_label: torch.Tensor | Sequence[int] | None) -> torch.Tensor | None:
+        """Validate the ground truth label for a batch.
+
+        Args:
+            gt_label (torch.Tensor | Sequence[int] | None): Input ground truth label.
+
+        Returns:
+            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+
+        Raises:
+            TypeError: If the input is not a sequence of integers or a torch.Tensor.
+            ValueError: If the ground truth label does not match the expected batch size or data type.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import DepthBatchValidator
+            >>> gt_label = torch.tensor([0, 1, 1, 0])
+            >>> validated_label = DepthBatchValidator.validate_gt_label(gt_label)
+            >>> print(validated_label)
+            tensor([False,  True,  True, False])
+        """
+        return ImageBatchValidator.validate_gt_label(gt_label)
+
+    @staticmethod
+    def validate_gt_mask(gt_mask: torch.Tensor | None) -> Mask | None:
+        """Validate the ground truth mask for a batch.
+
+        Args:
+            gt_mask (torch.Tensor | None): Input ground truth mask.
+
+        Returns:
+            Mask | None: Validated ground truth mask as a torchvision Mask object, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the ground truth mask does not have the correct shape or batch size.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import DepthBatchValidator
+            >>> gt_mask = torch.randint(0, 2, (4, 224, 224))
+            >>> validated_mask = DepthBatchValidator.validate_gt_mask(gt_mask)
+            >>> print(validated_mask.shape)
+            torch.Size([4, 224, 224])
+        """
+        return ImageBatchValidator.validate_gt_mask(gt_mask)
+
+    @staticmethod
+    def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
+        """Validate the mask paths for a batch.
+
+        Args:
+            mask_path (Sequence[str] | None): Input sequence of mask paths.
+
+        Returns:
+            list[str] | None: Validated list of mask paths, or None.
+
+        Raises:
+            TypeError: If the input is not a sequence of strings.
+            ValueError: If the number of mask paths does not match the expected batch size.
+
+        Examples:
+            >>> from anomalib.data.validators import DepthBatchValidator
+            >>> mask_paths = ["path/to/mask_1.png", "path/to/mask_2.png"]
+            >>> validated_paths = DepthBatchValidator.validate_mask_path(mask_paths)
+            >>> print(validated_paths)
+            ['path/to/mask_1.png', 'path/to/mask_2.png']
+        """
+        return ImageBatchValidator.validate_mask_path(mask_path)
+
+    @staticmethod
+    def validate_image_path(image_path: list[str] | None) -> list[str] | None:
+        """Validate the image paths for a batch.
+
+        Args:
+            image_path (list[str] | None): Input list of image paths.
+
+        Returns:
+            list[str] | None: Validated list of image paths, or None.
+
+        Raises:
+            TypeError: If the input is not a list of strings.
+
+        Examples:
+            >>> from anomalib.data.validators import DepthBatchValidator
+            >>> image_paths = ["path/to/image_1.jpg", "path/to/image_2.jpg"]
+            >>> validated_paths = DepthBatchValidator.validate_image_path(image_paths)
+            >>> print(validated_paths)
+            ['path/to/image_1.jpg', 'path/to/image_2.jpg']
+        """
+        return ImageBatchValidator.validate_image_path(image_path)
+
+    @staticmethod
+    def validate_depth_map(depth_map: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the depth map for a batch.
+
+        Args:
+            depth_map (torch.Tensor | None): Input depth map.
+
+        Returns:
+            torch.Tensor | None: Validated depth map, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the depth map shape is invalid or doesn't match the batch size.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import DepthBatchValidator
+            >>> depth_map = torch.rand(4, 224, 224)
+            >>> validated_map = DepthBatchValidator.validate_depth_map(depth_map)
+            >>> print(validated_map.shape)
+            torch.Size([4, 224, 224])
+        """
+        if depth_map is None:
+            return None
+        if not isinstance(depth_map, torch.Tensor):
+            msg = f"Depth map must be a torch.Tensor, got {type(depth_map)}."
+            raise TypeError(msg)
+        if depth_map.ndim not in {3, 4}:
+            msg = f"Depth map must have shape [N, H, W] or [N, C, H, W], got shape {depth_map.shape}."
+            raise ValueError(msg)
+        if depth_map.ndim == 4 and depth_map.shape[1] != 1 and depth_map.shape[1] != 3:
+            msg = f"Depth map with 4 dimensions must have 1 or 3 channels, got {depth_map.shape[1]}."
+            raise ValueError(msg)
+        return depth_map.to(torch.float32)
+
+    @staticmethod
+    def validate_depth_path(depth_path: list[str] | None) -> list[str] | None:
+        """Validate the depth paths for a batch.
+
+        Args:
+            depth_path (list[str] | None): Input list of depth paths.
+
+        Returns:
+            list[str] | None: Validated list of depth paths, or None.
+
+        Raises:
+            TypeError: If the input is not a list of strings.
+
+        Examples:
+            >>> from anomalib.data.validators import DepthBatchValidator
+            >>> depth_paths = ["path/to/depth_1.png", "path/to/depth_2.png"]
+            >>> validated_paths = DepthBatchValidator.validate_depth_path(depth_paths)
+            >>> print(validated_paths)
+            ['path/to/depth_1.png', 'path/to/depth_2.png']
+        """
+        if depth_path is None:
+            return None
+        if not isinstance(depth_path, list):
+            msg = f"Depth path must be a list of strings, got {type(depth_path)}."
+            raise TypeError(msg)
+        return [validate_path(path) for path in depth_path]
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: torch.Tensor | np.ndarray | None) -> Mask | None:
+        """Validate the anomaly map for a batch."""
+        return ImageBatchValidator.validate_anomaly_map(anomaly_map)
+
+    @staticmethod
+    def validate_pred_score(
+        pred_score: torch.Tensor | np.ndarray | float | None,
+    ) -> torch.Tensor | None:
+        """Validate the prediction scores for a batch."""
+        return ImageBatchValidator.validate_pred_score(pred_score)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
+        """Validate the prediction mask for a batch."""
+        return ImageBatchValidator.validate_pred_mask(pred_mask)
+
+    @staticmethod
+    def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the prediction label for a batch."""
+        return ImageBatchValidator.validate_pred_label(pred_label)
diff --git a/src/anomalib/data/validators/torch/image.py b/src/anomalib/data/validators/torch/image.py
new file mode 100644
index 0000000000..a9c7cafe06
--- /dev/null
+++ b/src/anomalib/data/validators/torch/image.py
@@ -0,0 +1,619 @@
+"""Validate torch image data."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+
+import numpy as np
+from torchvision.transforms.v2.functional import to_dtype_image
+from torchvision.tv_tensors import Image, Mask
+
+import torch
+from anomalib.data.validators.path import validate_path
+
+
+class ImageValidator:
+    """Validate torch.Tensor data for images."""
+
+    @staticmethod
+    def validate_image(image: torch.Tensor) -> torch.Tensor:
+        """Validate the image tensor.
+
+        Args:
+            image (torch.Tensor): Input image tensor.
+
+        Returns:
+            torch.Tensor: Validated image tensor.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the image tensor does not have the correct shape.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import ImageValidator
+            >>> image = torch.rand(3, 256, 256)
+            >>> validated_image = ImageValidator.validate_image(image)
+            >>> validated_image.shape
+            torch.Size([3, 256, 256])
+        """
+        if not isinstance(image, torch.Tensor):
+            msg = f"Image must be a torch.Tensor, got {type(image)}."
+            raise TypeError(msg)
+        if image.ndim != 3:
+            msg = f"Image must have shape [C, H, W], got shape {image.shape}."
+            raise ValueError(msg)
+        if image.shape[0] != 3:
+            msg = f"Image must have 3 channels, got {image.shape[0]}."
+            raise ValueError(msg)
+        return to_dtype_image(image, torch.float32, scale=True)
+
+    @staticmethod
+    def validate_gt_label(label: int | torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the ground truth label.
+
+        Args:
+            label (int | torch.Tensor | None): Input ground truth label.
+
+        Returns:
+            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+
+        Raises:
+            TypeError: If the input is neither an integer nor a torch.Tensor.
+            ValueError: If the label shape or dtype is invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> label_int = 1
+            >>> validated_label = ImageValidator.validate_gt_label(label_int)
+            >>> validated_label
+            tensor(True)
+            >>> label_tensor = torch.tensor(0)
+            >>> validated_label = ImageValidator.validate_gt_label(label_tensor)
+            >>> validated_label
+            tensor(False)
+        """
+        if label is None:
+            return None
+        if isinstance(label, int):
+            label = torch.tensor(label)
+        if not isinstance(label, torch.Tensor):
+            msg = f"Ground truth label must be an integer or a torch.Tensor, got {type(label)}."
+            raise TypeError(msg)
+        if label.ndim != 0:
+            msg = f"Ground truth label must be a scalar, got shape {label.shape}."
+            raise ValueError(msg)
+        if torch.is_floating_point(label):
+            msg = f"Ground truth label must be boolean or integer, got {label.dtype}."
+            raise TypeError(msg)
+        return label.bool()
+
+    @staticmethod
+    def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
+        """Validate the ground truth mask.
+
+        Args:
+            mask (torch.Tensor | None): Input ground truth mask.
+
+        Returns:
+            Mask | None: Validated ground truth mask, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the mask shape is invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> mask = torch.randint(0, 2, (1, 224, 224))
+            >>> validated_mask = ImageValidator.validate_gt_mask(mask)
+            >>> isinstance(validated_mask, Mask)
+            True
+            >>> validated_mask.shape
+            torch.Size([224, 224])
+        """
+        if mask is None:
+            return None
+        if not isinstance(mask, torch.Tensor):
+            msg = f"Mask must be a torch.Tensor, got {type(mask)}."
+            raise TypeError(msg)
+        if mask.ndim not in {2, 3}:
+            msg = f"Mask must have shape [H, W] or [1, H, W] got shape {mask.shape}."
+            raise ValueError(msg)
+        if mask.ndim == 3:
+            if mask.shape[0] != 1:
+                msg = f"Mask must have 1 channel, got {mask.shape[0]}."
+                raise ValueError(msg)
+            mask = mask.squeeze(0)
+        return Mask(mask, dtype=torch.bool)
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
+        """Validate the anomaly map.
+
+        Args:
+            anomaly_map (torch.Tensor | None): Input anomaly map.
+
+        Returns:
+            Mask | None: Validated anomaly map as a Mask, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the anomaly map shape is invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> anomaly_map = torch.rand(1, 224, 224)
+            >>> validated_map = ImageValidator.validate_anomaly_map(anomaly_map)
+            >>> isinstance(validated_map, Mask)
+            True
+            >>> validated_map.shape
+            torch.Size([224, 224])
+        """
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, torch.Tensor):
+            msg = f"Anomaly map must be a torch.Tensor, got {type(anomaly_map)}."
+            raise TypeError(msg)
+        if anomaly_map.ndim not in {2, 3}:
+            msg = f"Anomaly map must have shape [H, W] or [1, H, W], got shape {anomaly_map.shape}."
+            raise ValueError(msg)
+        if anomaly_map.ndim == 3:
+            if anomaly_map.shape[0] != 1:
+                msg = f"Anomaly map with 3 dimensions must have 1 channel, got {anomaly_map.shape[0]}."
+                raise ValueError(msg)
+            anomaly_map = anomaly_map.squeeze(0)
+
+        return Mask(anomaly_map, dtype=torch.float32)
+
+    @staticmethod
+    def validate_image_path(image_path: str | None) -> str | None:
+        """Validate the image path.
+
+        Args:
+            image_path (str | None): Input image path.
+
+        Returns:
+            str | None: Validated image path, or None.
+
+        Examples:
+            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> path = "/path/to/image.jpg"
+            >>> validated_path = ImageValidator.validate_image_path(path)
+            >>> validated_path == path
+            True
+        """
+        return validate_path(image_path) if image_path else None
+
+    @staticmethod
+    def validate_mask_path(mask_path: str | None) -> str | None:
+        """Validate the mask path.
+
+        Args:
+            mask_path (str | None): Input mask path.
+
+        Returns:
+            str | None: Validated mask path, or None.
+
+        Examples:
+            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> path = "/path/to/mask.png"
+            >>> validated_path = ImageValidator.validate_mask_path(path)
+            >>> validated_path == path
+            True
+        """
+        return validate_path(mask_path) if mask_path else None
+
+    @staticmethod
+    def validate_pred_score(
+        pred_score: torch.Tensor | np.ndarray | float | None,
+    ) -> torch.Tensor | None:
+        """Validate the prediction score.
+
+        Args:
+            pred_score (torch.Tensor | float | None): Input prediction score.
+
+        Returns:
+            torch.Tensor | None: Validated prediction score as a float32 tensor, or None.
+
+        Raises:
+            TypeError: If the input is neither a float, torch.Tensor, nor None.
+            ValueError: If the prediction score is not a scalar.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import ImageValidator
+            >>> score = 0.8
+            >>> validated_score = ImageValidator.validate_pred_score(score)
+            >>> validated_score
+            tensor(0.8000)
+            >>> score_tensor = torch.tensor(0.7)
+            >>> validated_score = ImageValidator.validate_pred_score(score_tensor)
+            >>> validated_score
+            tensor(0.7000)
+            >>> validated_score = ImageValidator.validate_pred_score(None)
+            >>> validated_score is None
+            True
+        """
+        if pred_score is None:
+            return None
+
+        if not isinstance(pred_score, torch.Tensor):
+            try:
+                pred_score = torch.tensor(pred_score)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a torch.Tensor."
+                raise ValueError(msg) from e
+
+        return pred_score.to(torch.float32)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
+        """Validate the prediction mask.
+
+        Args:
+            pred_mask (torch.Tensor | None): Input prediction mask.
+
+        Returns:
+            Mask | None: Validated prediction mask, or None.
+
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> mask = torch.randint(0, 2, (1, 224, 224))
+            >>> validated_mask = ImageValidator.validate_pred_mask(mask)
+            >>> isinstance(validated_mask, Mask)
+            True
+            >>> validated_mask.shape
+            torch.Size([224, 224])
+        """
+        return ImageValidator.validate_gt_mask(pred_mask)  # We can reuse the gt_mask validation
+
+    @staticmethod
+    def validate_pred_label(pred_label: torch.Tensor | np.ndarray | float | None) -> torch.Tensor | None:
+        """Validate the prediction label.
+
+        Args:
+            pred_label (torch.Tensor | None): Input prediction label.
+
+        Returns:
+            torch.Tensor | None: Validated prediction label as a boolean tensor, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the prediction label is not a scalar.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> label = torch.tensor(1)
+            >>> validated_label = ImageValidator.validate_pred_label(label)
+            >>> validated_label
+            tensor(True)
+        """
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, torch.Tensor):
+            try:
+                pred_label = torch.tensor(pred_label)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a torch.Tensor."
+                raise ValueError(msg) from e
+        pred_label = pred_label.squeeze()
+        if pred_label.ndim != 0:
+            msg = f"Predicted label must be a scalar, got shape {pred_label.shape}."
+            raise ValueError(msg)
+        return pred_label.to(torch.bool)
+
+
+class ImageBatchValidator:
+    """Validate torch.Tensor data for batches of images."""
+
+    @staticmethod
+    def validate_image(image: torch.Tensor) -> Image:
+        """Validate the image for a batch.
+
+        Args:
+            image (torch.Tensor): Input image tensor.
+
+        Returns:
+            Image: Validated image as a torchvision Image object.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the image tensor does not have the correct shape or number of channels.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> image = torch.rand(32, 3, 224, 224)
+            >>> validated_image = ImageBatchValidator.validate_image(image)
+            >>> print(validated_image.shape)
+            torch.Size([32, 3, 224, 224])
+        """
+        if not isinstance(image, torch.Tensor):
+            msg = f"Image must be a torch.Tensor, got {type(image)}."
+            raise TypeError(msg)
+        if image.ndim not in {3, 4}:
+            msg = f"Image must have shape [C, H, W] or [N, C, H, W], got shape {image.shape}."
+            raise ValueError(msg)
+        if image.ndim == 3:
+            image = image.unsqueeze(0)  # add batch dimension
+        if image.shape[1] != 3:
+            msg = f"Image must have 3 channels, got {image.shape[1]}."
+            raise ValueError(msg)
+        return Image(image, dtype=torch.float32)
+
+    @staticmethod
+    def validate_gt_label(gt_label: torch.Tensor | Sequence[int] | None) -> torch.Tensor | None:
+        """Validate the ground truth label for a batch.
+
+        Args:
+            gt_label (torch.Tensor | Sequence[int] | None): Input ground truth label.
+
+        Returns:
+            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+
+        Raises:
+            TypeError: If the input is not a sequence of integers or a torch.Tensor.
+            ValueError: If the ground truth label does not match the expected batch size or data type.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> gt_label = torch.tensor([0, 1, 1, 0])
+            >>> validated_label = ImageBatchValidator.validate_gt_label(gt_label)
+            >>> print(validated_label)
+            tensor([False,  True,  True, False])
+        """
+        if gt_label is None:
+            return None
+        if isinstance(gt_label, Sequence):
+            gt_label = torch.tensor(gt_label)
+        if not isinstance(gt_label, torch.Tensor):
+            msg = f"Ground truth label must be a sequence of integers or a torch.Tensor, got {type(gt_label)}."
+            raise TypeError(msg)
+        if gt_label.ndim != 1:
+            msg = f"Ground truth label must be a 1-dimensional vector, got shape {gt_label.shape}."
+            raise ValueError(msg)
+        if torch.is_floating_point(gt_label):
+            msg = f"Ground truth label must be boolean or integer, got {gt_label}."
+            raise ValueError(msg)
+        return gt_label.bool()
+
+    @staticmethod
+    def validate_gt_mask(gt_mask: torch.Tensor | None) -> Mask | None:
+        """Validate the ground truth mask for a batch.
+
+        Args:
+            gt_mask (torch.Tensor | None): Input ground truth mask.
+
+        Returns:
+            Mask | None: Validated ground truth mask as a torchvision Mask object, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the ground truth mask does not have the correct shape or batch size.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> gt_mask = torch.randint(0, 2, (4, 224, 224))
+            >>> validated_mask = ImageBatchValidator.validate_gt_mask(gt_mask)
+            >>> print(validated_mask.shape)
+            torch.Size([4, 224, 224])
+        """
+        if gt_mask is None:
+            return None
+        if not isinstance(gt_mask, torch.Tensor):
+            msg = f"Ground truth mask must be a torch.Tensor, got {type(gt_mask)}."
+            raise TypeError(msg)
+        if gt_mask.ndim not in {2, 3, 4}:
+            msg = f"Ground truth mask must have shape [H, W] or [N, H, W] or [N, 1, H, W] got shape {gt_mask.shape}."
+            raise ValueError(msg)
+        if gt_mask.ndim == 2:
+            gt_mask = gt_mask.unsqueeze(0)
+        if gt_mask.ndim == 4:
+            if gt_mask.shape[1] != 1:
+                msg = f"Ground truth mask must have 1 channel, got {gt_mask.shape[1]}."
+                raise ValueError(msg)
+            gt_mask = gt_mask.squeeze(1)
+        return Mask(gt_mask, dtype=torch.bool)
+
+    @staticmethod
+    def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
+        """Validate the mask paths for a batch.
+
+        Args:
+            mask_path (Sequence[str] | None): Input sequence of mask paths.
+
+        Returns:
+            list[str] | None: Validated list of mask paths, or None.
+
+        Raises:
+            TypeError: If the input is not a sequence of strings.
+            ValueError: If the number of mask paths does not match the expected batch size.
+
+        Examples:
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> mask_paths = ["path/to/mask_1.png", "path/to/mask_2.png"]
+            >>> validated_paths = ImageBatchValidator.validate_mask_path(mask_paths)
+            >>> print(validated_paths)
+            ['path/to/mask_1.png', 'path/to/mask_2.png']
+        """
+        if mask_path is None:
+            return None
+        if not isinstance(mask_path, Sequence):
+            msg = f"Mask path must be a sequence of paths or strings, got {type(mask_path)}."
+            raise TypeError(msg)
+        return [str(path) for path in mask_path]
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: torch.Tensor | np.ndarray | None) -> Mask | None:
+        """Validate the anomaly map for a batch.
+
+        Args:
+            anomaly_map (torch.Tensor | np.ndarray | None): Input anomaly map.
+
+        Returns:
+            Mask | None: Validated anomaly map as a torchvision Mask object, or None.
+
+        Raises:
+            ValueError: If the anomaly map cannot be converted to a torch.Tensor or has an invalid shape.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> anomaly_map = torch.rand(4, 224, 224)
+            >>> validated_map = ImageBatchValidator.validate_anomaly_map(anomaly_map)
+            >>> print(validated_map.shape)
+            torch.Size([4, 224, 224])
+        """
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, torch.Tensor):
+            try:
+                anomaly_map = torch.tensor(anomaly_map)
+            except Exception as e:
+                msg = "Failed to convert anomaly_map to a torch.Tensor."
+                raise ValueError(msg) from e
+        if anomaly_map.ndim not in {2, 3, 4}:
+            msg = f"Anomaly map must have shape [H, W] or [N, H, W] or [N, 1, H, W], got shape {anomaly_map.shape}."
+            raise ValueError(msg)
+        if anomaly_map.ndim == 2:
+            anomaly_map = anomaly_map.unsqueeze(0)
+        if anomaly_map.ndim == 4:
+            if anomaly_map.shape[1] != 1:
+                msg = f"Anomaly map must have 1 channel, got {anomaly_map.shape[1]}."
+                raise ValueError(msg)
+            anomaly_map = anomaly_map.squeeze(1)
+        return Mask(anomaly_map, dtype=torch.float32)
+
+    @staticmethod
+    def validate_pred_score(
+        pred_score: torch.Tensor | np.ndarray | Sequence[float] | None,
+    ) -> torch.Tensor | None:
+        """Validate the prediction scores for a batch.
+
+        Args:
+            pred_score (torch.Tensor | Sequence[float] | None): Input prediction scores.
+
+        Returns:
+            torch.Tensor | None: Validated prediction scores as a float32 tensor, or None.
+
+        Raises:
+            TypeError: If the input is neither a sequence of floats, torch.Tensor, nor None.
+            ValueError: If the prediction scores are not a 1-dimensional tensor or sequence.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> scores = [0.8, 0.7, 0.9]
+            >>> validated_scores = ImageBatchValidator.validate_pred_score(scores)
+            >>> validated_scores
+            tensor([0.8000, 0.7000, 0.9000])
+            >>> score_tensor = torch.tensor([0.8, 0.7, 0.9])
+            >>> validated_scores = ImageBatchValidator.validate_pred_score(score_tensor)
+            >>> validated_scores
+            tensor([0.8000, 0.7000, 0.9000])
+        """
+        if pred_score is None:
+            return None
+
+        if isinstance(pred_score, Sequence):
+            pred_score = torch.tensor(pred_score)
+        if not isinstance(pred_score, torch.Tensor):
+            try:
+                pred_score = torch.tensor(pred_score)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a torch.Tensor."
+                raise ValueError(msg) from e
+
+        return pred_score.to(torch.float32)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
+        """Validate the prediction mask for a batch.
+
+        Args:
+            pred_mask (torch.Tensor | None): Input prediction mask.
+
+        Returns:
+            Mask | None: Validated prediction mask as a torchvision Mask object, or None.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> pred_mask = torch.randint(0, 2, (4, 224, 224))
+            >>> validated_mask = ImageBatchValidator.validate_pred_mask(pred_mask)
+            >>> print(validated_mask.shape)
+            torch.Size([4, 224, 224])
+        """
+        return ImageBatchValidator.validate_gt_mask(pred_mask)  # We can reuse the gt_mask validation
+
+    @staticmethod
+    def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the prediction label for a batch.
+
+        Args:
+            pred_label (torch.Tensor | None): Input prediction label.
+
+        Returns:
+            torch.Tensor | None: Validated prediction label as a boolean tensor, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the prediction label has an invalid shape.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> pred_label = torch.tensor([[1], [0], [1], [1]])
+            >>> validated_label = ImageBatchValidator.validate_pred_label(pred_label)
+            >>> print(validated_label)
+            tensor([ True, False,  True,  True])
+        """
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, torch.Tensor):
+            msg = f"Predicted label must be a torch.Tensor, got {type(pred_label)}."
+            raise TypeError(msg)
+        if pred_label.ndim > 2:
+            msg = f"Predicted label must be 1-dimensional or 2-dimensional, got shape {pred_label.shape}."
+            raise ValueError(msg)
+        if pred_label.ndim == 2 and pred_label.shape[1] != 1:
+            msg = f"Predicted label with 2 dimensions must have shape [N, 1], got shape {pred_label.shape}."
+            raise ValueError(msg)
+
+        return pred_label.to(torch.bool)
+
+    @staticmethod
+    def validate_image_path(image_path: list[str] | None) -> list[str] | None:
+        """Validate the image paths for a batch.
+
+        Args:
+            image_path (list[str] | None): Input list of image paths.
+
+        Returns:
+            list[str] | None: Validated list of image paths, or None.
+
+        Raises:
+            TypeError: If the input is not a list of strings.
+
+        Examples:
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> image_paths = ["path/to/image_1.jpg", "path/to/image_2.jpg"]
+            >>> validated_paths = ImageBatchValidator.validate_image_path(image_paths)
+            >>> print(validated_paths)
+            ['path/to/image_1.jpg', 'path/to/image_2.jpg']
+        """
+        if image_path is None:
+            return None
+        if not isinstance(image_path, list):
+            msg = f"Image path must be a list of strings, got {type(image_path)}."
+            raise TypeError(msg)
+        return [str(path) for path in image_path]
diff --git a/src/anomalib/data/validators/torch/video.py b/src/anomalib/data/validators/torch/video.py
new file mode 100644
index 0000000000..0719eb46f2
--- /dev/null
+++ b/src/anomalib/data/validators/torch/video.py
@@ -0,0 +1,937 @@
+"""Validate torch video data."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from torchvision.transforms.v2.functional import to_dtype_image
+from torchvision.tv_tensors import Mask, Video
+
+import torch
+from anomalib.data.validators.path import validate_batch_path, validate_path
+
+
+class VideoValidator:
+    """Validate torch.Tensor data for videos."""
+
+    @staticmethod
+    def validate_image(image: torch.Tensor) -> torch.Tensor:
+        """Validate the video tensor.
+
+        Args:
+            image (Image): Input tensor.
+
+        Returns:
+            Image: Validated tensor.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the video tensor does not have the correct shape.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoValidator
+            >>> video = torch.rand(10, 3, 256, 256)  # 10 frames, RGB
+            >>> validated_video = VideoValidator.validate_image(video)
+            >>> validated_video.shape
+            torch.Size([10, 3, 256, 256])
+            >>> single_frame_rgb = torch.rand(3, 256, 256)  # Single RGB frame
+            >>> validated_single_frame_rgb = VideoValidator.validate_image(single_frame_rgb)
+            >>> validated_single_frame_rgb.shape
+            torch.Size([1, 3, 256, 256])
+            >>> single_frame_gray = torch.rand(1, 256, 256)  # Single grayscale frame
+            >>> validated_single_frame_gray = VideoValidator.validate_image(single_frame_gray)
+            >>> validated_single_frame_gray.shape
+            torch.Size([1, 1, 256, 256])
+        """
+        if not isinstance(image, torch.Tensor):
+            msg = f"Video must be a torch.Tensor, got {type(image)}."
+            raise TypeError(msg)
+
+        if image.dim() == 3:  # Single frame case (C, H, W)
+            if image.shape[0] not in {1, 3}:
+                msg = f"Video must have 1 or 3 channels for single frame, got {image.shape[0]}."
+                raise ValueError(msg)
+        elif image.dim() == 4:  # Multiple frames case (T, C, H, W)
+            if image.shape[1] not in {1, 3}:
+                msg = f"Video must have 1 or 3 channels, got {image.shape[1]}."
+                raise ValueError(msg)
+        else:
+            msg = f"Video must have 3 or 4 dimensions, got {image.dim()}."
+            raise ValueError(msg)
+
+        return to_dtype_image(image, torch.float32, scale=True)
+
+    @staticmethod
+    def validate_gt_label(label: int | torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the ground truth label.
+
+        Args:
+            label (int | torch.Tensor | None): Input ground truth label.
+
+        Returns:
+            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+
+        Raises:
+            TypeError: If the input is neither an integer nor a torch.Tensor.
+            ValueError: If the label shape or dtype is invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoValidator
+            >>> label_int = 1
+            >>> validated_label = VideoValidator.validate_gt_label(label_int)
+            >>> validated_label
+            tensor(True)
+            >>> label_tensor = torch.tensor([0, 0], dtype=torch.int32)
+            >>> validated_label = VideoValidator.validate_gt_label(label_tensor)
+            >>> validated_label
+            tensor([False, False])
+        """
+        if label is None:
+            return None
+        if isinstance(label, int):
+            label = torch.tensor(label)
+        if not isinstance(label, torch.Tensor):
+            msg = f"Ground truth label must be an integer or a torch.Tensor, got {type(label)}."
+            raise TypeError(msg)
+        if torch.is_floating_point(label):
+            msg = f"Ground truth label must be boolean or integer, got {label.dtype}."
+            raise TypeError(msg)
+        return label.bool()
+
+    @staticmethod
+    def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
+        """Validate the ground truth mask.
+
+        Args:
+            mask (torch.Tensor | None): Input ground truth mask.
+
+        Returns:
+            Mask | None: Validated ground truth mask, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the mask shape is invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoValidator
+            >>> mask = torch.randint(0, 2, (10, 1, 224, 224))  # 10 frames
+            >>> validated_mask = VideoValidator.validate_gt_mask(mask)
+            >>> isinstance(validated_mask, Mask)
+            True
+            >>> validated_mask.shape
+            torch.Size([10, 224, 224])
+        """
+        if mask is None:
+            return None
+        if not isinstance(mask, torch.Tensor):
+            msg = f"Mask must be a torch.Tensor, got {type(mask)}."
+            raise TypeError(msg)
+        if mask.ndim not in {2, 3, 4}:
+            msg = f"Mask must have shape [H, W], [T, H, W] or [T, 1, H, W] got shape {mask.shape}."
+            raise ValueError(msg)
+        if mask.ndim == 4:
+            if mask.shape[1] != 1:
+                msg = f"Mask must have 1 channel, got {mask.shape[1]}."
+                raise ValueError(msg)
+            mask = mask.squeeze(1)
+        return Mask(mask, dtype=torch.bool)
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
+        """Validate the anomaly map.
+
+        Args:
+            anomaly_map (torch.Tensor | None): Input anomaly map.
+
+        Returns:
+            Mask | None: Validated anomaly map as a Mask, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the anomaly map shape is invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoValidator
+            >>> anomaly_map = torch.rand(10, 1, 224, 224)  # 10 frames
+            >>> validated_map = VideoValidator.validate_anomaly_map(anomaly_map)
+            >>> isinstance(validated_map, Mask)
+            True
+            >>> validated_map.shape
+            torch.Size([10, 224, 224])
+        """
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, torch.Tensor):
+            msg = f"Anomaly map must be a torch.Tensor, got {type(anomaly_map)}."
+            raise TypeError(msg)
+        if anomaly_map.ndim not in {3, 4}:
+            msg = f"Anomaly map must have shape [T, H, W] or [T, 1, H, W], got shape {anomaly_map.shape}."
+            raise ValueError(msg)
+        if anomaly_map.ndim == 4:
+            if anomaly_map.shape[1] != 1:
+                msg = f"Anomaly map with 4 dimensions must have 1 channel, got {anomaly_map.shape[1]}."
+                raise ValueError(msg)
+            anomaly_map = anomaly_map.squeeze(1)
+
+        return Mask(anomaly_map, dtype=torch.float32)
+
+    @staticmethod
+    def validate_video_path(video_path: str | None) -> str | None:
+        """Validate the video path.
+
+        Args:
+            video_path (str | None): Input video path.
+
+        Returns:
+            str | None: Validated video path, or None.
+
+        Examples:
+            >>> from anomalib.data.validators import VideoValidator
+            >>> path = "/path/to/video.mp4"
+            >>> validated_path = VideoValidator.validate_video_path(path)
+            >>> validated_path == path
+            True
+        """
+        return validate_path(video_path) if video_path else None
+
+    @staticmethod
+    def validate_mask_path(mask_path: str | None) -> str | None:
+        """Validate the mask path.
+
+        Args:
+            mask_path (str | None): Input mask path.
+
+        Returns:
+            str | None: Validated mask path, or None.
+
+        Examples:
+            >>> from anomalib.data.validators import VideoValidator
+            >>> path = "/path/to/mask.mp4"
+            >>> validated_path = VideoValidator.validate_mask_path(path)
+            >>> validated_path == path
+            True
+        """
+        return validate_path(mask_path) if mask_path else None
+
+    @staticmethod
+    def validate_pred_score(
+        pred_score: torch.Tensor | float | None,
+        anomaly_map: torch.Tensor | None = None,
+    ) -> torch.Tensor | None:
+        """Validate the prediction score.
+
+        Args:
+            pred_score (torch.Tensor | float | None): Input prediction score.
+            anomaly_map (torch.Tensor | None): Input anomaly map.
+
+        Returns:
+            torch.Tensor | None: Validated prediction score as a float32 tensor, or None.
+
+        Raises:
+            TypeError: If the input is neither a float, torch.Tensor, nor None.
+            ValueError: If the prediction score is not a scalar.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoValidator
+            >>> score = 0.8
+            >>> validated_score = VideoValidator.validate_pred_score(score)
+            >>> validated_score
+            tensor(0.8000)
+        """
+        if pred_score is None:
+            return torch.amax(anomaly_map, dim=(-3, -2, -1)) if anomaly_map is not None else None
+
+        if not isinstance(pred_score, torch.Tensor):
+            try:
+                pred_score = torch.tensor(pred_score)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a torch.Tensor."
+                raise ValueError(msg) from e
+        pred_score = pred_score.squeeze()
+        if pred_score.ndim != 0:
+            msg = f"Predicted score must be a scalar, got shape {pred_score.shape}."
+            raise ValueError(msg)
+
+        return pred_score.to(torch.float32)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
+        """Validate the prediction mask.
+
+        Args:
+            pred_mask (torch.Tensor | None): Input prediction mask.
+
+        Returns:
+            Mask | None: Validated prediction mask, or None.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoValidator
+            >>> mask = torch.randint(0, 2, (10, 1, 224, 224))  # 10 frames
+            >>> validated_mask = VideoValidator.validate_pred_mask(mask)
+            >>> isinstance(validated_mask, Mask)
+            True
+            >>> validated_mask.shape
+            torch.Size([10, 224, 224])
+        """
+        return VideoValidator.validate_gt_mask(pred_mask)  # We can reuse the gt_mask validation
+
+    @staticmethod
+    def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the prediction label.
+
+        Args:
+            pred_label (torch.Tensor | None): Input prediction label.
+
+        Returns:
+            torch.Tensor | None: Validated prediction label as a boolean tensor, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the prediction label is not a scalar.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoValidator
+            >>> label = torch.tensor(1)
+            >>> validated_label = VideoValidator.validate_pred_label(label)
+            >>> validated_label
+            tensor(True)
+        """
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, torch.Tensor):
+            try:
+                pred_label = torch.tensor(pred_label)
+            except Exception as e:
+                msg = "Failed to convert pred_label to a torch.Tensor."
+                raise ValueError(msg) from e
+        pred_label = pred_label.squeeze()
+        if pred_label.ndim != 0:
+            msg = f"Predicted label must be a scalar, got shape {pred_label.shape}."
+            raise ValueError(msg)
+        return pred_label.to(torch.bool)
+
+    @staticmethod
+    def validate_original_image(original_image: torch.Tensor | Video | None) -> torch.Tensor | Video | None:
+        """Validate the original video or image.
+
+        Args:
+            original_image (torch.Tensor | Video | None): Input original video or image.
+
+        Returns:
+            torch.Tensor | Video | None: Validated original video or image.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor or torchvision Video object.
+            ValueError: If the tensor does not have the correct shape.
+
+        Examples:
+            >>> import torch
+            >>> from torchvision.tv_tensors import Video
+            >>> from anomalib.data.validators import VideoValidator
+            >>> video = Video(torch.rand(10, 3, 224, 224))  # 10 frames
+            >>> validated_video = VideoValidator.validate_original_image(video)
+            >>> validated_video.shape
+            torch.Size([10, 3, 224, 224])
+            >>> image = torch.rand(3, 256, 256)  # Single image
+            >>> validated_image = VideoValidator.validate_original_image(image)
+            >>> validated_image.shape
+            torch.Size([3, 256, 256])
+        """
+        if original_image is None:
+            return None
+
+        if not isinstance(original_image, torch.Tensor | Video):
+            msg = f"Original image must be a torch.Tensor or torchvision Video object, got {type(original_image)}."
+            raise TypeError(msg)
+
+        if original_image.ndim == 3:
+            # Single image case
+            if original_image.shape[0] != 3:
+                msg = f"Original image must have 3 channels, got {original_image.shape[0]}."
+                raise ValueError(msg)
+        elif original_image.ndim == 4:
+            # Video case
+            if original_image.shape[1] != 3:
+                msg = f"Original video must have 3 channels, got {original_image.shape[1]}."
+                raise ValueError(msg)
+        else:
+            msg = f"Original image/video must have shape [C, H, W] or [T, C, H, W], got shape {original_image.shape}."
+            raise ValueError(msg)
+
+        return original_image
+
+    @staticmethod
+    def validate_target_frame(target_frame: int | None) -> int | None:
+        """Validate the target frame index.
+
+        Args:
+            target_frame (int | None): Input target frame index.
+
+        Returns:
+            int | None: Validated target frame index, or None.
+
+        Raises:
+            TypeError: If the input is not an integer.
+            ValueError: If the target frame index is negative.
+
+        Examples:
+            >>> from anomalib.data.validators import VideoValidator
+            >>> validated_frame = VideoValidator.validate_target_frame(31)
+            >>> print(validated_frame)
+            31
+        """
+        if target_frame is None:
+            return None
+        if not isinstance(target_frame, int):
+            msg = f"Target frame must be an integer, got {type(target_frame)}."
+            raise TypeError(msg)
+        if target_frame < 0:
+            msg = f"Target frame index must be non-negative, got {target_frame}."
+            raise ValueError(msg)
+        return target_frame
+
+    @staticmethod
+    def validate_frames(frames: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the frames tensor.
+
+        Args:
+            frames (torch.Tensor | None): Input frames tensor or frame indices.
+
+        Returns:
+            torch.Tensor | None: Validated frames tensor, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the frames tensor is not a 1D tensor of indices.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoValidator
+            >>> frame_indices = torch.tensor([0, 5, 10])
+            >>> validated_indices = VideoValidator.validate_frames(frame_indices)
+            >>> validated_indices
+            tensor([0, 5, 10])
+        """
+        if frames is None:
+            return None
+        if not isinstance(frames, torch.Tensor):
+            msg = f"Frames must be a torch.Tensor, got {type(frames)}."
+            raise TypeError(msg)
+
+        # Ensure frames is a 1D tensor of indices
+        if frames.ndim != 1 and frames.numel() != 1:
+            msg = f"Frames must be a 1D tensor of indices or a single scalar tensor, got shape {frames.shape}."
+            raise ValueError(msg)
+        if frames.numel() == 1:
+            frames = frames.view(1)
+        # Ensure all indices are non-negative integers
+        if not torch.all(frames >= 0) or not frames.dtype.is_floating_point:
+            if not frames.dtype.is_floating_point:
+                frames = frames.to(torch.int64)
+            else:
+                msg = "All frame indices must be non-negative integers."
+                raise ValueError(msg)
+        return frames
+
+    @staticmethod
+    def validate_last_frame(last_frame: torch.Tensor | int | float | None) -> torch.Tensor | int | None:
+        """Validate the last frame index.
+
+        Args:
+            last_frame (torch.Tensor | int | float | None): Input last frame index.
+
+        Returns:
+            torch.Tensor | int | None: Validated last frame index, or None.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor, int, or float.
+            ValueError: If the last frame index is negative.
+
+        Examples:
+            >>> from anomalib.data.validators import VideoValidator
+            >>> validated_frame = VideoValidator.validate_last_frame(5)
+            >>> print(validated_frame)
+            5
+            >>> validated_float = VideoValidator.validate_last_frame(5.7)
+            >>> print(validated_float)
+            5
+            >>> import torch
+            >>> tensor_frame = torch.tensor(10.3)
+            >>> validated_tensor = VideoValidator.validate_last_frame(tensor_frame)
+            >>> print(validated_tensor)
+            tensor(10)
+        """
+        if last_frame is None:
+            return None
+        if isinstance(last_frame, int | float):
+            last_frame = int(last_frame)
+            if last_frame < 0:
+                msg = f"Last frame index must be non-negative, got {last_frame}."
+                raise ValueError(msg)
+            return last_frame
+        if isinstance(last_frame, torch.Tensor):
+            if last_frame.numel() != 1:
+                msg = f"Last frame must be a scalar tensor, got shape {last_frame.shape}."
+                raise ValueError(msg)
+            last_frame = last_frame.int()
+            if last_frame.item() < 0:
+                msg = f"Last frame index must be non-negative, got {last_frame.item()}."
+                raise ValueError(msg)
+            return last_frame
+        msg = f"Last frame must be an int, float, or a torch.Tensor, got {type(last_frame)}."
+        raise TypeError(msg)
+
+
+class VideoBatchValidator:
+    """Validate torch.Tensor data for video batches."""
+
+    @staticmethod
+    def validate_image(image: Video) -> Video:
+        """Validate the video batch tensor.
+
+        Args:
+            image (Video): Input video batch tensor.
+
+        Returns:
+            Video: Validated video batch tensor.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the tensor does not have the correct dimensions or number of channels.
+
+        Examples:
+            >>> import torch
+            >>> from torchvision.tv_tensors import Video
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> video_batch = Video(torch.rand(2, 10, 3, 224, 224))  # 2 videos, 10 frames each
+            >>> validated_batch = VideoBatchValidator.validate_image(video_batch)
+            >>> print(validated_batch.shape)
+            torch.Size([2, 10, 3, 224, 224])
+        """
+        if not isinstance(image, torch.Tensor):
+            msg = f"Video batch must be a torch.Tensor, got {type(image)}."
+            raise TypeError(msg)
+
+        if image.dim() not in {4, 5}:  # (B, C, H, W) or (B, T, C, H, W)
+            msg = (
+                "Video batch must have 4 dimensions (B, C, H, W) for single frame images "
+                f"or 5 dimensions (B, T, C, H, W) for multi-frame videos, got {image.dim()}."
+            )
+            raise ValueError(msg)
+
+        if image.dim() == 5 and image.shape[2] not in {1, 3}:
+            msg = f"Video batch must have 1 or 3 channels, got {image.shape[2]}."
+            raise ValueError(msg)
+        if image.dim() == 4 and image.shape[1] not in {1, 3}:
+            msg = f"Image batch must have 1 or 3 channels, got {image.shape[1]}."
+            raise ValueError(msg)
+
+        return to_dtype_image(image, torch.float32, scale=True)
+
+    @staticmethod
+    def validate_gt_label(label: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the ground truth labels for a batch.
+
+        Args:
+            label (torch.Tensor | None): Input ground truth labels.
+
+        Returns:
+            torch.Tensor | None: Validated ground truth labels.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor or has an invalid dtype.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> gt_labels = torch.tensor([0, 1, 1, 0])
+            >>> validated_labels = VideoBatchValidator.validate_gt_label(gt_labels)
+            >>> print(validated_labels)
+            tensor([False,  True,  True, False])
+        """
+        if label is None:
+            return None
+        if not isinstance(label, torch.Tensor):
+            msg = f"Ground truth labels must be a torch.Tensor, got {type(label)}."
+            raise TypeError(msg)
+        if torch.is_floating_point(label):
+            msg = f"Ground truth labels must be boolean or integer, got {label.dtype}."
+            raise TypeError(msg)
+        return label.bool()
+
+    @staticmethod
+    def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
+        """Validate the ground truth masks for a batch.
+
+        Args:
+            mask (torch.Tensor | None): Input ground truth masks.
+
+        Returns:
+            Mask | None: Validated ground truth masks.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the mask has an invalid shape.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> gt_masks = torch.rand(2, 10, 224, 224) > 0.5  # 2 videos, 10 frames each
+            >>> validated_masks = VideoBatchValidator.validate_gt_mask(gt_masks)
+            >>> print(validated_masks.shape)
+            torch.Size([2, 10, 224, 224])
+            >>> single_frame_masks = torch.rand(4, 456, 256) > 0.5  # 4 single-frame images
+            >>> validated_single_frame = VideoBatchValidator.validate_gt_mask(single_frame_masks)
+            >>> print(validated_single_frame.shape)
+            torch.Size([4, 456, 256])
+        """
+        if mask is None:
+            return None
+        if not isinstance(mask, torch.Tensor):
+            msg = f"Masks must be a torch.Tensor, got {type(mask)}."
+            raise TypeError(msg)
+        if mask.ndim not in {3, 4, 5}:
+            msg = f"Masks must have shape [B, H, W], [B, T, H, W] or [B, T, 1, H, W], got shape {mask.shape}."
+            raise ValueError(msg)
+        if mask.ndim == 5:
+            if mask.shape[2] != 1:
+                msg = f"Masks must have 1 channel, got {mask.shape[2]}."
+                raise ValueError(msg)
+            mask = mask.squeeze(2)
+
+        return Mask(mask, dtype=torch.bool)
+
+    @staticmethod
+    def validate_mask_path(mask_path: list[str] | None) -> list[str] | None:
+        """Validate the mask paths for a batch.
+
+        Args:
+            mask_path (list[str] | None): Input mask paths.
+
+        Returns:
+            list[str] | None: Validated mask paths.
+
+        Raises:
+            TypeError: If the input is not a list of strings.
+
+        Examples:
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> mask_paths = ["path/to/mask1.png", "path/to/mask2.png"]
+            >>> validated_paths = VideoBatchValidator.validate_mask_path(mask_paths)
+            >>> print(validated_paths)
+            ['path/to/mask1.png', 'path/to/mask2.png']
+        """
+        return validate_batch_path(mask_path)
+
+    @staticmethod
+    def validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
+        """Validate the anomaly maps for a batch.
+
+        Args:
+            anomaly_map (torch.Tensor | None): Input anomaly maps.
+
+        Returns:
+            Mask | None: Validated anomaly maps.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the anomaly map has an invalid shape.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> anomaly_maps = torch.rand(2, 10, 224, 224)  # 2 videos, 10 frames each
+            >>> validated_maps = VideoBatchValidator.validate_anomaly_map(anomaly_maps)
+            >>> print(validated_maps.shape)
+            torch.Size([2, 10, 224, 224])
+        """
+        if anomaly_map is None:
+            return None
+        if not isinstance(anomaly_map, torch.Tensor):
+            msg = f"Anomaly maps must be a torch.Tensor, got {type(anomaly_map)}."
+            raise TypeError(msg)
+        if anomaly_map.ndim not in {4, 5}:
+            msg = f"Anomaly maps must have shape [B, T, H, W] or [B, T, 1, H, W], got shape {anomaly_map.shape}."
+            raise ValueError(msg)
+        if anomaly_map.ndim == 5:
+            if anomaly_map.shape[2] != 1:
+                msg = f"Anomaly maps must have 1 channel, got {anomaly_map.shape[2]}."
+                raise ValueError(msg)
+            anomaly_map = anomaly_map.squeeze(2)
+        return Mask(anomaly_map, dtype=torch.float32)
+
+    @staticmethod
+    def validate_pred_score(
+        pred_score: torch.Tensor | None,
+        anomaly_map: torch.Tensor | None = None,
+    ) -> torch.Tensor | None:
+        """Validate the prediction scores for a batch.
+
+        Args:
+            pred_score (torch.Tensor | None): Input prediction scores.
+            anomaly_map (torch.Tensor | None): Input anomaly map (optional).
+
+        Returns:
+            torch.Tensor | None: Validated prediction scores.
+
+        Raises:
+            ValueError: If the prediction scores have an invalid shape or cannot be converted to a tensor.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> pred_scores = torch.tensor([0.1, 0.9, 0.3, 0.7])
+            >>> validated_scores = VideoBatchValidator.validate_pred_score(pred_scores)
+            >>> print(validated_scores)
+            tensor([0.1000, 0.9000, 0.3000, 0.7000])
+        """
+        if pred_score is None:
+            return torch.amax(anomaly_map, dim=(-3, -2, -1)) if anomaly_map is not None else None
+
+        if not isinstance(pred_score, torch.Tensor):
+            try:
+                pred_score = torch.tensor(pred_score)
+            except Exception as e:
+                msg = "Failed to convert pred_score to a torch.Tensor."
+                raise ValueError(msg) from e
+        if pred_score.ndim != 1:
+            msg = f"Predicted scores must be a 1D tensor, got shape {pred_score.shape}."
+            raise ValueError(msg)
+
+        return pred_score.to(torch.float32)
+
+    @staticmethod
+    def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
+        """Validate the prediction masks for a batch.
+
+        Args:
+            pred_mask (torch.Tensor | None): Input prediction masks.
+
+        Returns:
+            Mask | None: Validated prediction masks.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> pred_masks = torch.rand(2, 10, 224, 224) > 0.5  # 2 videos, 10 frames each
+            >>> validated_masks = VideoBatchValidator.validate_pred_mask(pred_masks)
+            >>> print(validated_masks.shape)
+            torch.Size([2, 10, 224, 224])
+        """
+        return VideoBatchValidator.validate_gt_mask(pred_mask)  # Reuse gt_mask validation
+
+    @staticmethod
+    def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the prediction labels for a batch.
+
+        Args:
+            pred_label (torch.Tensor | None): Input prediction labels.
+
+        Returns:
+            torch.Tensor | None: Validated prediction labels.
+
+        Raises:
+            ValueError: If the prediction labels have an invalid shape or cannot be converted to a tensor.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> pred_labels = torch.tensor([0, 1, 1, 0])
+            >>> validated_labels = VideoBatchValidator.validate_pred_label(pred_labels)
+            >>> print(validated_labels)
+            tensor([False,  True,  True, False])
+        """
+        if pred_label is None:
+            return None
+        if not isinstance(pred_label, torch.Tensor):
+            try:
+                pred_label = torch.tensor(pred_label)
+            except Exception as e:
+                msg = "Failed to convert pred_label to a torch.Tensor."
+                raise ValueError(msg) from e
+        if pred_label.ndim != 1:
+            msg = f"Predicted labels must be a 1D tensor, got shape {pred_label.shape}."
+            raise ValueError(msg)
+        return pred_label.to(torch.bool)
+
+    @staticmethod
+    def validate_original_image(original_image: torch.Tensor | Video | None) -> torch.Tensor | Video | None:
+        """Validate the original videos for a batch.
+
+        Args:
+            original_image (torch.Tensor | Video | None): Input original videos.
+
+        Returns:
+            torch.Tensor | Video | None: Validated original videos.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor or torchvision Video object.
+            ValueError: If the video has an invalid shape or number of channels.
+
+        Examples:
+            >>> import torch
+            >>> from torchvision.tv_tensors import Video
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> original_videos = Video(torch.rand(2, 10, 3, 224, 224))  # 2 videos, 10 frames each
+            >>> validated_videos = VideoBatchValidator.validate_original_image(original_videos)
+            >>> print(validated_videos.shape)
+            torch.Size([2, 10, 3, 224, 224])
+        """
+        if original_image is None:
+            return None
+
+        if not isinstance(original_image, torch.Tensor | Video):
+            msg = f"Original image must be a torch.Tensor or torchvision Video object, got {type(original_image)}."
+            raise TypeError(msg)
+
+        if original_image.ndim not in {4, 5}:  # (B, C, H, W) or (B, T, C, H, W)
+            msg = (
+                "Original image/video must have shape [B, C, H, W] for single frame or "
+                f"[B, T, C, H, W] for multi-frame, got shape {original_image.shape}."
+            )
+            raise ValueError(msg)
+
+        if original_image.ndim == 4:
+            # Add a temporal dimension for single frame videos
+            original_image = original_image.unsqueeze(1)
+        if original_image.shape[2] != 3:
+            msg = f"Original video must have 3 channels, got {original_image.shape[2]}."
+            raise ValueError(msg)
+
+        return original_image
+
+    @staticmethod
+    def validate_video_path(video_path: list[str] | None) -> list[str] | None:
+        """Validate the video paths for a batch.
+
+        Args:
+            video_path (list[str] | None): Input video paths.
+
+        Returns:
+            list[str] | None: Validated video paths.
+
+        Raises:
+            TypeError: If the input is not a list of strings.
+
+        Examples:
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> video_paths = ["path/to/video1.mp4", "path/to/video2.mp4"]
+            >>> validated_paths = VideoBatchValidator.validate_video_path(video_paths)
+            >>> print(validated_paths)
+            ['path/to/video1.mp4', 'path/to/video2.mp4']
+        """
+        return validate_batch_path(video_path)
+
+    @staticmethod
+    def validate_target_frame(target_frame: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the target frame indices for a batch.
+
+        Args:
+            target_frame (torch.Tensor | None): Input target frame indices.
+
+        Returns:
+            torch.Tensor | None: Validated target frame indices.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the target frame indices are invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> target_frames = torch.tensor([5, 8, 3, 7])
+            >>> validated_frames = VideoBatchValidator.validate_target_frame(target_frames)
+            >>> print(validated_frames)
+            tensor([5, 8, 3, 7])
+        """
+        if target_frame is None:
+            return None
+        if not isinstance(target_frame, torch.Tensor):
+            msg = f"Target frame must be a torch.Tensor, got {type(target_frame)}."
+            raise TypeError(msg)
+        if target_frame.ndim != 1:
+            msg = f"Target frame must be a 1D tensor, got shape {target_frame.shape}."
+            raise ValueError(msg)
+        if not torch.all(target_frame >= 0):
+            msg = "Target frame indices must be non-negative."
+            raise ValueError(msg)
+        return target_frame.to(torch.int64)
+
+    @staticmethod
+    def validate_frames(frames: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the frame indices for a batch.
+
+        Args:
+            frames (torch.Tensor | None): Input frame indices.
+
+        Returns:
+            torch.Tensor | None: Validated frame indices.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the frame indices are invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> frame_indices = torch.tensor([[0], [1], [2], [3], [4], [5]])
+            >>> validated_indices = VideoBatchValidator.validate_frames(frame_indices)
+            >>> print(validated_indices)
+            tensor([0, 1, 2, 3, 4, 5])
+        """
+        if frames is None:
+            return None
+        if not isinstance(frames, torch.Tensor):
+            msg = f"Frames must be a torch.Tensor, got {type(frames)}."
+            raise TypeError(msg)
+        if frames.ndim == 2 and frames.shape[1] == 1:
+            frames = frames.squeeze(1)
+        if frames.ndim != 1:
+            msg = f"Frames must be a 1D tensor or a 2D tensor with shape (N, 1), got shape {frames.shape}."
+            raise ValueError(msg)
+        if not torch.all(frames >= 0):
+            msg = "All frame indices must be non-negative."
+            raise ValueError(msg)
+        return frames.to(torch.int64)
+
+    @staticmethod
+    def validate_last_frame(last_frame: torch.Tensor | None) -> torch.Tensor | None:
+        """Validate the last frame indices for a batch.
+
+        Args:
+            last_frame (torch.Tensor | None): Input last frame indices.
+
+        Returns:
+            torch.Tensor | None: Validated last frame indices.
+
+        Raises:
+            TypeError: If the input is not a torch.Tensor.
+            ValueError: If the last frame indices are invalid.
+
+        Examples:
+            >>> import torch
+            >>> from anomalib.data.validators import VideoBatchValidator
+            >>> last_frames = torch.tensor([9.5, 12.2, 15.8, 10.0])
+            >>> validated_last_frames = VideoBatchValidator.validate_last_frame(last_frames)
+            >>> print(validated_last_frames)
+            tensor([ 9, 12, 15, 10])
+        """
+        if last_frame is None:
+            return None
+        if not isinstance(last_frame, torch.Tensor):
+            msg = f"Last frame must be a torch.Tensor, got {type(last_frame)}."
+            raise TypeError(msg)
+        if last_frame.ndim != 1:
+            msg = f"Last frame must be a 1D tensor, got shape {last_frame.shape}."
+            raise ValueError(msg)
+        last_frame = last_frame.int()
+        if not torch.all(last_frame >= 0):
+            msg = "Last frame indices must be non-negative."
+            raise ValueError(msg)
+        return last_frame
diff --git a/src/anomalib/models/image/cfa/torch_model.py b/src/anomalib/models/image/cfa/torch_model.py
index dfedb5c40c..2fecfa4948 100644
--- a/src/anomalib/models/image/cfa/torch_model.py
+++ b/src/anomalib/models/image/cfa/torch_model.py
@@ -196,7 +196,7 @@ def compute_distance(self, target_oriented_features: torch.Tensor) -> torch.Tens
         f_c = 2 * torch.matmul(target_oriented_features, (self.memory_bank.to(features.device)))
         return features + centers - f_c
 
-    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
+    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
         """Forward pass.
 
         Args:
@@ -222,16 +222,14 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
 
         if self.training:
             return distance
+
         anomaly_map = self.anomaly_map_generator(
             distance=distance,
             scale=target_features.shape[-2:],
             image_size=input_tensor.shape[-2:],
         )
         pred_score = torch.amax(anomaly_map, dim=(-2, -1))
-        return InferenceBatch(
-            anomaly_map=anomaly_map,
-            pred_score=pred_score,
-        )
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
 
 class Descriptor(nn.Module):
diff --git a/src/anomalib/models/image/cflow/torch_model.py b/src/anomalib/models/image/cflow/torch_model.py
index 98de7ea69e..dcfdcfa7fc 100644
--- a/src/anomalib/models/image/cflow/torch_model.py
+++ b/src/anomalib/models/image/cflow/torch_model.py
@@ -143,7 +143,7 @@ def forward(self, images: torch.Tensor) -> InferenceBatch:
                 log_prob = decoder_log_prob / dim_feature_vector  # likelihood per dim
                 distribution[layer_idx] = torch.cat((distribution[layer_idx], log_prob))
 
-        output = self.anomaly_map_generator(
+        anomaly_map = self.anomaly_map_generator(
             distribution=distribution,
             height=height,
             width=width,
@@ -151,4 +151,5 @@ def forward(self, images: torch.Tensor) -> InferenceBatch:
         )
         self.decoders.train()
 
-        return InferenceBatch(anomaly_map=output.to(images.device))
+        pred_score = torch.amax(anomaly_map, dim=(-2, -1))
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
diff --git a/src/anomalib/models/image/csflow/torch_model.py b/src/anomalib/models/image/csflow/torch_model.py
index d562fe79b3..a4703d9b4c 100644
--- a/src/anomalib/models/image/csflow/torch_model.py
+++ b/src/anomalib/models/image/csflow/torch_model.py
@@ -587,10 +587,11 @@ def forward(self, images: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor] | I
         features = self.feature_extractor(images)
         if self.training:
             return self.graph(features)
+
         z_dist, _ = self.graph(features)  # Ignore Jacobians
         anomaly_scores = self._compute_anomaly_scores(z_dist)
         anomaly_maps = self.anomaly_map_generator(z_dist)
-        return InferenceBatch(anomaly_map=anomaly_maps, pred_score=anomaly_scores)
+        return InferenceBatch(pred_score=anomaly_scores, anomaly_map=anomaly_maps)
 
     @staticmethod
     def _compute_anomaly_scores(z_dists: torch.Tensor) -> torch.Tensor:
diff --git a/src/anomalib/models/image/dfm/torch_model.py b/src/anomalib/models/image/dfm/torch_model.py
index a89e5749d1..ab133d045f 100644
--- a/src/anomalib/models/image/dfm/torch_model.py
+++ b/src/anomalib/models/image/dfm/torch_model.py
@@ -174,7 +174,7 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor | InferenceBatch:
             Tensor: Scores
         """
         feature_vector, feature_shapes = self.get_features(batch)
-        score, score_map = self.score(feature_vector.view(feature_vector.shape[:2]), feature_shapes)
-        if score_map is not None:
-            score_map = F.interpolate(score_map, size=batch.shape[-2:], mode="bilinear", align_corners=False)
-        return InferenceBatch(pred_score=score, anomaly_map=score_map)
+        pred_score, anomaly_map = self.score(feature_vector.view(feature_vector.shape[:2]), feature_shapes)
+        if anomaly_map is not None:
+            anomaly_map = F.interpolate(anomaly_map, size=batch.shape[-2:], mode="bilinear", align_corners=False)
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
diff --git a/src/anomalib/models/image/draem/torch_model.py b/src/anomalib/models/image/draem/torch_model.py
index 2fd9e8c4cc..3ce080aca5 100644
--- a/src/anomalib/models/image/draem/torch_model.py
+++ b/src/anomalib/models/image/draem/torch_model.py
@@ -44,8 +44,10 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, tor
         prediction = self.discriminative_subnetwork(concatenated_inputs)
         if self.training:
             return reconstruction, prediction
+
         anomaly_map = torch.softmax(prediction, dim=1)[:, 1, ...]
-        return InferenceBatch(anomaly_map=anomaly_map)
+        pred_score = torch.amax(anomaly_map, dim=(-2, -1))
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
 
 class ReconstructiveSubNetwork(nn.Module):
diff --git a/src/anomalib/models/image/dsr/torch_model.py b/src/anomalib/models/image/dsr/torch_model.py
index 2e6f6ac411..4fe036ea5c 100644
--- a/src/anomalib/models/image/dsr/torch_model.py
+++ b/src/anomalib/models/image/dsr/torch_model.py
@@ -166,9 +166,9 @@ def forward(
             if image_score.size() == torch.Size([]):
                 image_score = image_score.unsqueeze(0)
 
-            out_mask_cv = out_mask_sm_up[:, 1, :, :]
+            anomaly_map = out_mask_sm_up[:, 1, :, :]
 
-            return InferenceBatch(anomaly_map=out_mask_cv, pred_score=image_score)
+            return InferenceBatch(pred_score=image_score, anomaly_map=anomaly_map)
 
         if anomaly_map_to_generate is not None and self.training:
             # we are in phase two
diff --git a/src/anomalib/models/image/efficient_ad/torch_model.py b/src/anomalib/models/image/efficient_ad/torch_model.py
index 16cb48ead7..74f2a507bb 100644
--- a/src/anomalib/models/image/efficient_ad/torch_model.py
+++ b/src/anomalib/models/image/efficient_ad/torch_model.py
@@ -372,9 +372,11 @@ def forward(
         student_output, distance_st = self.compute_student_teacher_distance(batch)
         if self.training:
             return self.compute_losses(batch, batch_imagenet, distance_st)
+
         map_st, map_stae = self.compute_maps(batch, student_output, distance_st, normalize)
-        map_combined = 0.5 * map_st + 0.5 * map_stae
-        return InferenceBatch(anomaly_map=map_combined)
+        anomaly_map = 0.5 * map_st + 0.5 * map_stae
+        pred_score = torch.amax(anomaly_map, dim=(-2, -1))
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
     def compute_student_teacher_distance(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         """Compute the student-teacher distance vectors.
diff --git a/src/anomalib/models/image/fastflow/torch_model.py b/src/anomalib/models/image/fastflow/torch_model.py
index b0eb35882a..7b2a780eae 100644
--- a/src/anomalib/models/image/fastflow/torch_model.py
+++ b/src/anomalib/models/image/fastflow/torch_model.py
@@ -204,7 +204,8 @@ def forward(self, input_tensor: torch.Tensor) -> tuple[list[torch.Tensor], list[
             return hidden_variables, log_jacobians
 
         anomaly_map = self.anomaly_map_generator(hidden_variables)
-        return InferenceBatch(anomaly_map=anomaly_map)
+        pred_score = torch.amax(anomaly_map, dim=(-2, -1))
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
     def _get_cnn_features(self, input_tensor: torch.Tensor) -> list[torch.Tensor]:
         """Get CNN-based features.
diff --git a/src/anomalib/models/image/padim/torch_model.py b/src/anomalib/models/image/padim/torch_model.py
index 4f77344763..e537d87ca3 100644
--- a/src/anomalib/models/image/padim/torch_model.py
+++ b/src/anomalib/models/image/padim/torch_model.py
@@ -106,15 +106,15 @@ def __init__(
 
         self.gaussian = MultiVariateGaussian()
 
-    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
+    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
         """Forward-pass image-batch (N, C, H, W) into model to extract features.
 
         Args:
             input_tensor: Image-batch (N, C, H, W)
-            input_tensor: torch.Tensor:
 
         Returns:
-            Features from single/multiple layers.
+            If training, returns the embeddings.
+            If inference, returns the prediction score and the anomaly map.
 
         Example:
             >>> x = torch.randn(32, 3, 224, 224)
@@ -140,13 +140,15 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
 
         if self.training:
             return embeddings
+
         anomaly_map = self.anomaly_map_generator(
             embedding=embeddings,
             mean=self.gaussian.mean,
             inv_covariance=self.gaussian.inv_covariance,
             image_size=output_size,
         )
-        return InferenceBatch(anomaly_map=anomaly_map)
+        pred_score = torch.amax(anomaly_map, dim=(-2, -1))
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
     def generate_embedding(self, features: dict[str, torch.Tensor]) -> torch.Tensor:
         """Generate embedding from hierarchical feature map.
diff --git a/src/anomalib/models/image/reverse_distillation/torch_model.py b/src/anomalib/models/image/reverse_distillation/torch_model.py
index 04739e14c9..b20e19b02f 100644
--- a/src/anomalib/models/image/reverse_distillation/torch_model.py
+++ b/src/anomalib/models/image/reverse_distillation/torch_model.py
@@ -81,6 +81,7 @@ def forward(self, images: torch.Tensor) -> tuple[list[torch.Tensor], list[torch.
 
         if self.training:
             return encoder_features, decoder_features
-        anomaly_map = self.anomaly_map_generator(encoder_features, decoder_features)
 
-        return InferenceBatch(anomaly_map=anomaly_map)
+        anomaly_map = self.anomaly_map_generator(encoder_features, decoder_features)
+        pred_score = torch.amax(anomaly_map, dim=(-2, -1))
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
diff --git a/src/anomalib/models/image/stfpm/torch_model.py b/src/anomalib/models/image/stfpm/torch_model.py
index ea169719e9..72638b1531 100644
--- a/src/anomalib/models/image/stfpm/torch_model.py
+++ b/src/anomalib/models/image/stfpm/torch_model.py
@@ -79,10 +79,11 @@ def forward(
 
         if self.training:
             return teacher_features, student_features
+
         anomaly_map = self.anomaly_map_generator(
             teacher_features=teacher_features,
             student_features=student_features,
             image_size=output_size,
         )
-
-        return InferenceBatch(anomaly_map=anomaly_map)
+        pred_score = torch.amax(anomaly_map, dim=(-2, -1))
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
diff --git a/src/anomalib/models/image/uflow/torch_model.py b/src/anomalib/models/image/uflow/torch_model.py
index 69bec13ae1..7c376328b9 100644
--- a/src/anomalib/models/image/uflow/torch_model.py
+++ b/src/anomalib/models/image/uflow/torch_model.py
@@ -179,8 +179,10 @@ def forward(self, image: torch.Tensor) -> torch.Tensor | InferenceBatch:
 
         if self.training:
             return z, ljd
+
         anomaly_map = self.anomaly_map_generator(z)
-        return InferenceBatch(anomaly_map=anomaly_map)
+        pred_score = torch.amax(anomaly_map, dim=(-2, -1))
+        return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
     def encode(self, features: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         """Return"""
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index fc360b0463..9c344976f0 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -19,7 +19,7 @@
 
 def models() -> set[str]:
     """Return all available models."""
-    return [model for model in get_available_models() if model != "rkde"]
+    return {model for model in get_available_models() if model != "rkde"}
 
 
 def export_types() -> list[ExportType]:
diff --git a/tests/unit/data/datamodule/base/depth.py b/tests/unit/data/datamodule/base/depth.py
index cc8685077c..6d6a1a784a 100644
--- a/tests/unit/data/datamodule/base/depth.py
+++ b/tests/unit/data/datamodule/base/depth.py
@@ -26,7 +26,10 @@ def test_get_item_returns_correct_keys_and_shapes(subset: str, datamodule: Anoma
         expected_fields = {"image_path", "depth_path", "gt_label", "image", "depth_map"}
 
         if dataloader.dataset.task == "segmentation":
-            expected_fields |= {"mask_path", "gt_mask"}
+            expected_fields.add("gt_mask")
+            # Add mask_path to expected fields if it's present in the batch
+            if hasattr(batch, "mask_path") and batch.mask_path is not None:
+                expected_fields.add("mask_path")
 
         batch_fields = {field.name for field in fields(batch) if getattr(batch, field.name) is not None}
         assert batch_fields == expected_fields
diff --git a/tests/unit/data/validators/__init__.py b/tests/unit/data/validators/__init__.py
new file mode 100644
index 0000000000..cc4a5e4ac4
--- /dev/null
+++ b/tests/unit/data/validators/__init__.py
@@ -0,0 +1,4 @@
+"""Test Data Validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/data/validators/numpy/__init__.py b/tests/unit/data/validators/numpy/__init__.py
new file mode 100644
index 0000000000..a9ceded75c
--- /dev/null
+++ b/tests/unit/data/validators/numpy/__init__.py
@@ -0,0 +1,4 @@
+"""Test Numpy Validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/data/validators/numpy/test_depth.py b/tests/unit/data/validators/numpy/test_depth.py
new file mode 100644
index 0000000000..cf01dd97f7
--- /dev/null
+++ b/tests/unit/data/validators/numpy/test_depth.py
@@ -0,0 +1,112 @@
+"""Test Numpy Depth Validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+import pytest
+
+from anomalib.data.validators.numpy.depth import NumpyDepthBatchValidator, NumpyDepthValidator
+
+
+class TestNumpyDepthValidator:
+    """Test NumpyDepthValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = NumpyDepthValidator()
+
+    def test_validate_depth_map_valid(self) -> None:
+        """Test validation of a valid depth map."""
+        depth_map = np.zeros((224, 224), dtype=np.float32)
+        validated_depth_map = self.validator.validate_depth_map(depth_map)
+        assert isinstance(validated_depth_map, np.ndarray)
+        assert validated_depth_map.shape == (224, 224)
+        assert validated_depth_map.dtype == np.float32
+
+    def test_validate_depth_map_invalid_type(self) -> None:
+        """Test validation of a depth map with invalid type."""
+        with pytest.raises(TypeError, match="Depth map must be a numpy array"):
+            self.validator.validate_depth_map([1, 2, 3])
+
+    def test_validate_depth_map_invalid_dimensions(self) -> None:
+        """Test validation of a depth map with invalid dimensions."""
+        with pytest.raises(ValueError, match="Depth map with 3 dimensions must have 1 channel, got 2."):
+            self.validator.validate_depth_map(np.zeros((224, 224, 2)))
+
+    def test_validate_depth_map_3d_valid(self) -> None:
+        """Test validation of a valid 3D depth map."""
+        depth_map = np.zeros((224, 224, 1), dtype=np.float32)
+        validated_depth_map = self.validator.validate_depth_map(depth_map)
+        assert isinstance(validated_depth_map, np.ndarray)
+        assert validated_depth_map.shape == (224, 224, 1)
+        assert validated_depth_map.dtype == np.float32
+
+    def test_validate_depth_map_3d_invalid(self) -> None:
+        """Test validation of an invalid 3D depth map."""
+        with pytest.raises(ValueError, match="Depth map with 3 dimensions must have 1 channel"):
+            self.validator.validate_depth_map(np.zeros((224, 224, 3)))
+
+    def test_validate_depth_path_valid(self) -> None:
+        """Test validation of a valid depth path."""
+        depth_path = "/path/to/depth.png"
+        validated_path = self.validator.validate_depth_path(depth_path)
+        assert validated_path == depth_path
+
+    def test_validate_depth_path_none(self) -> None:
+        """Test validation of a None depth path."""
+        assert self.validator.validate_depth_path(None) is None
+
+
+class TestNumpyDepthBatchValidator:
+    """Test NumpyDepthBatchValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = NumpyDepthBatchValidator()
+
+    def test_validate_depth_map_valid(self) -> None:
+        """Test validation of a valid depth map batch."""
+        depth_map_batch = np.zeros((32, 224, 224), dtype=np.float32)
+        validated_batch = self.validator.validate_depth_map(depth_map_batch)
+        assert isinstance(validated_batch, np.ndarray)
+        assert validated_batch.shape == (32, 224, 224)
+        assert validated_batch.dtype == np.float32
+
+    def test_validate_depth_map_invalid_type(self) -> None:
+        """Test validation of a depth map batch with invalid type."""
+        with pytest.raises(TypeError, match="Depth map batch must be a numpy array"):
+            self.validator.validate_depth_map([1, 2, 3])
+
+    def test_validate_depth_map_invalid_dimensions(self) -> None:
+        """Test validation of a depth map batch with invalid dimensions."""
+        with pytest.raises(ValueError, match="Depth map batch must have shape"):
+            self.validator.validate_depth_map(np.zeros((32, 224)))
+
+    def test_validate_depth_map_4d_valid(self) -> None:
+        """Test validation of a valid 4D depth map batch."""
+        depth_map_batch = np.zeros((32, 224, 224, 1), dtype=np.float32)
+        validated_batch = self.validator.validate_depth_map(depth_map_batch)
+        assert isinstance(validated_batch, np.ndarray)
+        assert validated_batch.shape == (32, 224, 224, 1)
+        assert validated_batch.dtype == np.float32
+
+    def test_validate_depth_map_4d_invalid(self) -> None:
+        """Test validation of an invalid 4D depth map batch."""
+        with pytest.raises(ValueError, match="Depth map batch with 4 dimensions must have 1 channel"):
+            self.validator.validate_depth_map(np.zeros((32, 224, 224, 3)))
+
+    def test_validate_depth_path_valid(self) -> None:
+        """Test validation of valid depth paths."""
+        depth_paths = ["/path/to/depth1.png", "/path/to/depth2.png"]
+        validated_paths = self.validator.validate_depth_path(depth_paths)
+        assert validated_paths == depth_paths
+
+    def test_validate_depth_path_none(self) -> None:
+        """Test validation of None depth paths."""
+        assert self.validator.validate_depth_path(None) is None
+
+    def test_validate_depth_path_invalid_type(self) -> None:
+        """Test validation of depth paths with invalid type."""
+        with pytest.raises(TypeError, match="Depth path must be a list of strings"):
+            self.validator.validate_depth_path("not_a_list")
diff --git a/tests/unit/data/validators/numpy/test_image.py b/tests/unit/data/validators/numpy/test_image.py
new file mode 100644
index 0000000000..008bc4dff6
--- /dev/null
+++ b/tests/unit/data/validators/numpy/test_image.py
@@ -0,0 +1,215 @@
+"""Test Numpy Image Validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+import pytest
+
+from anomalib.data.validators.numpy.image import NumpyImageBatchValidator, NumpyImageValidator
+
+
+class TestNumpyImageValidator:
+    """Test NumpyImageValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = NumpyImageValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid image."""
+        image = np.zeros((224, 224, 3), dtype=np.uint8)
+        validated_image = self.validator.validate_image(image)
+        assert isinstance(validated_image, np.ndarray)
+        assert validated_image.shape == (224, 224, 3)
+        assert validated_image.dtype == np.float32
+        np.testing.assert_array_equal(validated_image, image.astype(np.float32))
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of an image with invalid type."""
+        with pytest.raises(TypeError, match="Image must be a numpy.ndarray, got "):
+            self.validator.validate_image([1, 2, 3])
+
+    def test_validate_image_adds_channel_dimension(self) -> None:
+        """Test validation of an image without channel dimension."""
+        # Create a 2D image without channel dimension
+        input_image = np.zeros((224, 224))
+
+        # Validate the image
+        validated_image = self.validator.validate_image(input_image)
+        # Check if channel dimension is added
+        assert validated_image.shape == (224, 224, 1), "Channel dimension should be added"
+        # Ensure the dtype is converted to float32
+        assert validated_image.dtype == np.float32, "Image should be converted to float32"
+        # Verify that the image content is preserved
+        assert pytest.approx(validated_image[:, :, 0]) == input_image.astype(
+            np.float32,
+        ), "Image content should be preserved"
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of an image with invalid number of channels."""
+        with pytest.raises(ValueError, match="Image must have 1 or 3 channels"):
+            self.validator.validate_image(np.zeros((224, 224, 2)))
+
+    def test_validate_image_valid_single_channel(self) -> None:
+        """Test validation of a valid single-channel image."""
+        image = np.zeros((224, 224, 1), dtype=np.uint8)
+        validated_image = self.validator.validate_image(image)
+        assert isinstance(validated_image, np.ndarray)
+        assert validated_image.shape == (224, 224, 1)
+        assert validated_image.dtype == np.float32
+
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of a valid ground truth label."""
+        label = 1
+        validated_label = self.validator.validate_gt_label(label)
+        assert isinstance(validated_label, np.ndarray)
+        assert validated_label.dtype == bool
+        assert validated_label.item() is True  # Use .item() to compare the scalar value
+
+    def test_validate_gt_label_none(self) -> None:
+        """Test validation of a None ground truth label."""
+        assert self.validator.validate_gt_label(None) is None
+
+    def test_validate_gt_label_invalid_type(self) -> None:
+        """Test validation of a ground truth label with invalid type."""
+        with pytest.raises(TypeError, match="Ground truth label must be an integer or a numpy.ndarray"):
+            self.validator.validate_gt_label("1")
+
+    def test_validate_gt_label_invalid_shape(self) -> None:
+        """Test validation of a ground truth label with invalid shape."""
+        with pytest.raises(ValueError, match="Ground truth label must be a scalar"):
+            self.validator.validate_gt_label(np.array([0, 1]))
+
+    def test_validate_gt_mask_valid(self) -> None:
+        """Test validation of a valid ground truth mask."""
+        mask = np.zeros((224, 224), dtype=np.uint8)
+        validated_mask = self.validator.validate_gt_mask(mask)
+        assert isinstance(validated_mask, np.ndarray)
+        assert validated_mask.shape == (224, 224)
+        assert validated_mask.dtype == bool
+
+    def test_validate_gt_mask_none(self) -> None:
+        """Test validation of a None ground truth mask."""
+        assert self.validator.validate_gt_mask(None) is None
+
+    def test_validate_gt_mask_invalid_type(self) -> None:
+        """Test validation of a ground truth mask with invalid type."""
+        with pytest.raises(TypeError, match="Mask must be a numpy.ndarray"):
+            self.validator.validate_gt_mask([1, 2, 3])
+
+    def test_validate_gt_mask_invalid_shape(self) -> None:
+        """Test validation of a ground truth mask with invalid shape."""
+        with pytest.raises(ValueError, match="Mask must have 1 channel, got 2."):
+            self.validator.validate_gt_mask(np.zeros((224, 224, 2)))
+
+
+class TestNumpyImageBatchValidator:
+    """Test NumpyImageBatchValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = NumpyImageBatchValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid image batch."""
+        image_batch = np.zeros((32, 224, 224, 3), dtype=np.uint8)
+        validated_batch = self.validator.validate_image(image_batch)
+        assert isinstance(validated_batch, np.ndarray)
+        assert validated_batch.shape == (32, 224, 224, 3)
+        assert validated_batch.dtype == np.float32
+
+    def test_validate_image_adds_channel_dimension(self) -> None:
+        """Test validation of an image batch without channel dimension."""
+        # Create a 3D image batch without channel dimension
+        input_batch = np.zeros((32, 224, 224))
+
+        # Validate the image batch
+        validated_batch = self.validator.validate_image(input_batch)
+        # Check if channel dimension is added
+        assert validated_batch.shape == (32, 224, 224, 1), "Channel dimension should be added"
+        # Ensure the dtype is converted to float32
+        assert validated_batch.dtype == np.float32, "Image batch should be converted to float32"
+        # Verify that the image content is preserved
+        assert pytest.approx(validated_batch[:, :, :, 0]) == input_batch.astype(
+            np.float32,
+        ), "Image content should be preserved"
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of an image batch with invalid type."""
+        with pytest.raises(TypeError, match="Image batch must be a numpy.ndarray, got "):
+            self.validator.validate_image([1, 2, 3])
+
+    def test_validate_image_adds_batch_dimension(self) -> None:
+        """Test validation of an image without batch dimension."""
+        # Create a 3D image without batch dimension
+        input_image = np.zeros((224, 224, 3))
+
+        # Validate the image
+        validated_image = self.validator.validate_image(input_image)
+
+        # Check if batch dimension is added
+        assert validated_image.shape == (1, 224, 224, 3), "Batch dimension should be added"
+        # Ensure the dtype is converted to float32
+        assert validated_image.dtype == np.float32, "Image should be converted to float32"
+        # Verify that the image content is preserved
+        assert np.array_equal(validated_image[0], input_image.astype(np.float32)), "Image content should be preserved"
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of an image batch with invalid number of channels."""
+        with pytest.raises(ValueError, match="Image batch must have 1 or 3 channels"):
+            self.validator.validate_image(np.zeros((32, 224, 224, 2)))
+
+    def test_validate_image_valid_single_channel(self) -> None:
+        """Test validation of a valid single-channel image batch."""
+        image_batch = np.zeros((32, 224, 224, 1), dtype=np.uint8)
+        validated_batch = self.validator.validate_image(image_batch)
+        assert isinstance(validated_batch, np.ndarray)
+        assert validated_batch.shape == (32, 224, 224, 1)
+        assert validated_batch.dtype == np.float32
+
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of valid ground truth labels."""
+        labels = np.array([0, 1, 1, 0])
+        validated_labels = self.validator.validate_gt_label(labels)
+        assert isinstance(validated_labels, np.ndarray)
+        assert validated_labels.dtype == bool
+        assert np.array_equal(validated_labels, np.array([False, True, True, False]))
+
+    def test_validate_gt_label_none(self) -> None:
+        """Test validation of None ground truth labels."""
+        assert self.validator.validate_gt_label(None) is None
+
+    def test_validate_gt_label_valid_string_input(self) -> None:
+        """Test validation of ground truth labels with string input."""
+        validated_labels = self.validator.validate_gt_label(["0", "1"])
+        assert isinstance(validated_labels, np.ndarray)
+        assert validated_labels.dtype == bool
+        assert np.array_equal(validated_labels, np.array([False, True]))
+
+    def test_validate_gt_label_invalid_dimensions(self) -> None:
+        """Test validation of ground truth labels with invalid dimensions."""
+        with pytest.raises(ValueError, match="Ground truth label batch must be 1-dimensional"):
+            self.validator.validate_gt_label(np.array([[0, 1], [1, 0]]))
+
+    def test_validate_gt_mask_valid(self) -> None:
+        """Test validation of valid ground truth masks."""
+        masks = np.zeros((4, 224, 224), dtype=np.uint8)
+        validated_masks = self.validator.validate_gt_mask(masks)
+        assert isinstance(validated_masks, np.ndarray)
+        assert validated_masks.shape == (4, 224, 224)
+        assert validated_masks.dtype == bool
+
+    def test_validate_gt_mask_none(self) -> None:
+        """Test validation of None ground truth masks."""
+        assert self.validator.validate_gt_mask(None) is None
+
+    def test_validate_gt_mask_invalid_type(self) -> None:
+        """Test validation of ground truth masks with invalid type."""
+        with pytest.raises(TypeError, match="Ground truth mask batch must be a numpy.ndarray"):
+            self.validator.validate_gt_mask([np.zeros((224, 224))])
+
+    def test_validate_gt_mask_invalid_dimensions(self) -> None:
+        """Test validation of ground truth masks with invalid dimensions."""
+        with pytest.raises(ValueError, match="Ground truth mask batch must have 1 channel, got 224"):
+            self.validator.validate_gt_mask(np.zeros((4, 224, 224, 224)))
diff --git a/tests/unit/data/validators/numpy/test_video.py b/tests/unit/data/validators/numpy/test_video.py
new file mode 100644
index 0000000000..abf29d31d9
--- /dev/null
+++ b/tests/unit/data/validators/numpy/test_video.py
@@ -0,0 +1,164 @@
+"""Test Numpy Video Validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+import pytest
+
+from anomalib.data.validators.numpy.video import NumpyVideoBatchValidator, NumpyVideoValidator
+
+
+class TestNumpyVideoValidator:
+    """Test NumpyVideoValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = NumpyVideoValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid image."""
+        image = np.zeros((10, 224, 224, 3), dtype=np.uint8)
+        validated_image = self.validator.validate_image(image)
+        assert isinstance(validated_image, np.ndarray)
+        assert validated_image.shape == (10, 224, 224, 3)
+        assert validated_image.dtype == np.float32
+        np.testing.assert_array_equal(validated_image, image.astype(np.float32))
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of an image with invalid type."""
+        with pytest.raises(TypeError, match="Video must be a numpy.ndarray, got "):
+            self.validator.validate_image([1, 2, 3])
+
+    def test_validate_image_adds_time_dimension(self) -> None:
+        """Test validation of an image without time dimension."""
+        # Create a 3D image without time dimension
+        input_image = np.zeros((224, 224, 3))
+
+        # Validate the image
+        validated_image = self.validator.validate_image(input_image)
+        # Check if time dimension is added
+        assert validated_image.shape == (1, 224, 224, 3), "Time dimension should be added"
+        # Ensure the dtype is converted to float32
+        assert validated_image.dtype == np.float32, "Image should be converted to float32"
+        # Verify that the image content is preserved
+        assert pytest.approx(validated_image[0]) == input_image.astype(np.float32), "Image content should be preserved"
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of an image with invalid number of channels."""
+        with pytest.raises(ValueError, match="Video must have 1 or 3 channels"):
+            self.validator.validate_image(np.zeros((10, 224, 224, 2)))
+
+    def test_validate_image_valid_single_channel(self) -> None:
+        """Test validation of a valid single-channel image."""
+        image = np.zeros((10, 224, 224, 1), dtype=np.uint8)
+        validated_image = self.validator.validate_image(image)
+        assert isinstance(validated_image, np.ndarray)
+        assert validated_image.shape == (10, 224, 224, 1)
+        assert validated_image.dtype == np.float32
+
+    def test_validate_target_frame_valid(self) -> None:
+        """Test validation of a valid target frame."""
+        target_frame = 5
+        assert self.validator.validate_target_frame(target_frame) == target_frame
+
+    def test_validate_target_frame_none(self) -> None:
+        """Test validation of a None target frame."""
+        assert self.validator.validate_target_frame(None) is None
+
+    def test_validate_target_frame_invalid_type(self) -> None:
+        """Test validation of a target frame with invalid type."""
+        with pytest.raises(TypeError, match="Target frame must be an integer"):
+            self.validator.validate_target_frame("5")
+
+    def test_validate_target_frame_negative(self) -> None:
+        """Test validation of a negative target frame."""
+        with pytest.raises(ValueError, match="Target frame index must be non-negative"):
+            self.validator.validate_target_frame(-1)
+
+
+class TestNumpyVideoBatchValidator:
+    """Test NumpyVideoBatchValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = NumpyVideoBatchValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid image batch."""
+        image_batch = np.zeros((2, 10, 224, 224, 3), dtype=np.uint8)
+        validated_batch = self.validator.validate_image(image_batch)
+        assert isinstance(validated_batch, np.ndarray)
+        assert validated_batch.shape == (2, 10, 224, 224, 3)
+        assert validated_batch.dtype == np.float32
+
+    def test_validate_image_adds_time_dimension(self) -> None:
+        """Test validation of an image batch without time dimension."""
+        # Create a 4D image batch without time dimension
+        input_batch = np.zeros((2, 224, 224, 3))
+
+        # Validate the image batch
+        validated_batch = self.validator.validate_image(input_batch)
+        # Check if time dimension is added
+        assert validated_batch.shape == (2, 224, 224, 3), "Time dimension should not be added for batch input"
+        # Ensure the dtype is converted to float32
+        assert validated_batch.dtype == np.float32, "Image batch should be converted to float32"
+        # Verify that the image content is preserved
+        assert pytest.approx(validated_batch) == input_batch.astype(np.float32), "Image content should be preserved"
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of an image batch with invalid type."""
+        with pytest.raises(TypeError, match="Video batch must be a numpy.ndarray, got "):
+            self.validator.validate_image([1, 2, 3])
+
+    def test_validate_image_invalid_dimensions(self) -> None:
+        """Test validation of an image batch with invalid dimensions."""
+        with pytest.raises(ValueError, match="Video batch must have 4 or 5 dimensions, got shape \\(224, 224, 3\\)"):
+            self.validator.validate_image(np.zeros((224, 224, 3)))
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of an image batch with invalid number of channels."""
+        with pytest.raises(ValueError, match="Video batch must have 1 or 3 channels, got 2"):
+            self.validator.validate_image(np.zeros((2, 10, 224, 224, 2)))
+
+    def test_validate_image_valid_single_channel(self) -> None:
+        """Test validation of a valid single-channel image batch."""
+        image_batch = np.zeros((2, 10, 224, 224, 1), dtype=np.uint8)
+        validated_batch = self.validator.validate_image(image_batch)
+        assert isinstance(validated_batch, np.ndarray)
+        assert validated_batch.shape == (2, 10, 224, 224, 1)
+        assert validated_batch.dtype == np.float32
+
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of valid ground truth labels."""
+        labels = np.array([0, 1])
+        validated_labels = self.validator.validate_gt_label(labels)
+        assert isinstance(validated_labels, np.ndarray)
+        assert validated_labels.dtype == bool
+        assert np.array_equal(validated_labels, np.array([False, True]))
+
+    def test_validate_gt_label_none(self) -> None:
+        """Test validation of None ground truth labels."""
+        assert self.validator.validate_gt_label(None) is None
+
+    def test_validate_gt_label_invalid_type(self) -> None:
+        """Test validation of ground truth labels with invalid type."""
+        validated_labels = self.validator.validate_gt_label(["0", "1"])
+        assert validated_labels is not None
+        assert isinstance(validated_labels, np.ndarray)
+        assert validated_labels.dtype == bool
+        assert np.array_equal(validated_labels, np.array([False, True]))
+
+    def test_validate_gt_label_invalid_dimensions(self) -> None:
+        """Test validation of ground truth labels with invalid dimensions."""
+        with pytest.raises(ValueError, match="Ground truth label batch must be 1-dimensional, got shape \\(2, 2\\)"):
+            self.validator.validate_gt_label(np.array([[0, 1], [1, 0]]))
+
+    def test_validate_gt_label_invalid_dtype(self) -> None:
+        """Test validation of ground truth labels with invalid dtype."""
+        # Test that float labels are converted to boolean
+        labels = np.array([0.5, 1.5])
+        validated_labels = self.validator.validate_gt_label(labels)
+        assert isinstance(validated_labels, np.ndarray)
+        assert validated_labels.dtype == bool
+        assert np.array_equal(validated_labels, np.array([True, True]))
diff --git a/tests/unit/data/validators/torch/__init__.py b/tests/unit/data/validators/torch/__init__.py
new file mode 100644
index 0000000000..43fd4646fe
--- /dev/null
+++ b/tests/unit/data/validators/torch/__init__.py
@@ -0,0 +1,4 @@
+"""Test Torch Validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/data/validators/torch/test_depth.py b/tests/unit/data/validators/torch/test_depth.py
new file mode 100644
index 0000000000..e9f372b277
--- /dev/null
+++ b/tests/unit/data/validators/torch/test_depth.py
@@ -0,0 +1,238 @@
+"""Test Torch Depth Validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+import pytest
+import torch
+from torchvision.tv_tensors import Image, Mask
+
+from anomalib.data.validators.torch.depth import DepthBatchValidator, DepthValidator
+
+
+class TestDepthValidator:
+    """Test DepthValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = DepthValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid depth image."""
+        image = torch.rand(3, 224, 224)
+        validated_image = self.validator.validate_image(image)
+        assert isinstance(validated_image, Image)
+        assert validated_image.shape == (3, 224, 224)
+        assert validated_image.dtype == torch.float32
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of a depth image with invalid type."""
+        with pytest.raises(TypeError, match="Image must be a torch.Tensor"):
+            self.validator.validate_image(np.random.default_rng().random((3, 224, 224)))
+
+    def test_validate_image_invalid_dimensions(self) -> None:
+        """Test validation of a depth image with invalid dimensions."""
+        with pytest.raises(ValueError, match="Image must have shape"):
+            self.validator.validate_image(torch.rand(224, 224))
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of a depth image with invalid number of channels."""
+        with pytest.raises(ValueError, match="Image must have 3 channels"):
+            self.validator.validate_image(torch.rand(1, 224, 224))
+
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of a valid ground truth label."""
+        label = torch.tensor(1)
+        validated_label = self.validator.validate_gt_label(label)
+        assert isinstance(validated_label, torch.Tensor)
+        assert validated_label.dtype == torch.bool
+        assert validated_label.item() is True
+
+    def test_validate_gt_label_none(self) -> None:
+        """Test validation of a None ground truth label."""
+        assert self.validator.validate_gt_label(None) is None
+
+    def test_validate_gt_label_invalid_type(self) -> None:
+        """Test validation of a ground truth label with invalid type."""
+        with pytest.raises(TypeError, match="Ground truth label must be an integer or a torch.Tensor"):
+            self.validator.validate_gt_label("1")
+
+    def test_validate_gt_mask_valid(self) -> None:
+        """Test validation of a valid ground truth mask."""
+        mask = torch.randint(0, 2, (1, 224, 224))
+        validated_mask = self.validator.validate_gt_mask(mask)
+        assert isinstance(validated_mask, Mask)
+        assert validated_mask.shape == (224, 224)
+        assert validated_mask.dtype == torch.bool
+
+    def test_validate_gt_mask_none(self) -> None:
+        """Test validation of a None ground truth mask."""
+        assert self.validator.validate_gt_mask(None) is None
+
+    def test_validate_gt_mask_invalid_type(self) -> None:
+        """Test validation of a ground truth mask with invalid type."""
+        with pytest.raises(TypeError, match="Mask must be a torch.Tensor"):
+            self.validator.validate_gt_mask(np.random.default_rng().integers(0, 2, (224, 224)))
+
+    def test_validate_gt_mask_invalid_shape(self) -> None:
+        """Test validation of a ground truth mask with invalid shape."""
+        with pytest.raises(ValueError, match="Mask must have 1 channel, got 2."):
+            self.validator.validate_gt_mask(torch.randint(0, 2, (2, 224, 224)))
+
+    def test_validate_anomaly_map_valid(self) -> None:
+        """Test validation of a valid anomaly map."""
+        anomaly_map = torch.rand(1, 224, 224)
+        validated_map = self.validator.validate_anomaly_map(anomaly_map)
+        assert isinstance(validated_map, Mask)
+        assert validated_map.shape == (224, 224)
+        assert validated_map.dtype == torch.float32
+
+    def test_validate_anomaly_map_none(self) -> None:
+        """Test validation of a None anomaly map."""
+        assert self.validator.validate_anomaly_map(None) is None
+
+    def test_validate_anomaly_map_invalid_type(self) -> None:
+        """Test validation of an anomaly map with invalid type."""
+        with pytest.raises(TypeError, match="Anomaly map must be a torch.Tensor"):
+            self.validator.validate_anomaly_map(np.random.default_rng().random((224, 224)))
+
+    def test_validate_anomaly_map_invalid_shape(self) -> None:
+        """Test validation of an anomaly map with invalid shape."""
+        with pytest.raises(ValueError, match="Anomaly map with 3 dimensions must have 1 channel, got 2."):
+            self.validator.validate_anomaly_map(torch.rand(2, 224, 224))
+
+    def test_validate_pred_score_valid(self) -> None:
+        """Test validation of a valid prediction score."""
+        score = torch.tensor(0.8)
+        validated_score = self.validator.validate_pred_score(score)
+        assert isinstance(validated_score, torch.Tensor)
+        assert validated_score.dtype == torch.float32
+        assert validated_score.item() == pytest.approx(0.8)
+
+    def test_validate_pred_score_none(self) -> None:
+        """Test validation of a None prediction score."""
+        assert self.validator.validate_pred_score(None) is None
+
+
+class TestDepthBatchValidator:  # noqa: PLR0904
+    """Test DepthBatchValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = DepthBatchValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid depth image batch."""
+        image_batch = torch.rand(32, 3, 224, 224)
+        validated_batch = self.validator.validate_image(image_batch)
+        assert isinstance(validated_batch, Image)
+        assert validated_batch.shape == (32, 3, 224, 224)
+        assert validated_batch.dtype == torch.float32
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of a depth image batch with invalid type."""
+        with pytest.raises(TypeError, match="Image must be a torch.Tensor"):
+            self.validator.validate_image(np.random.default_rng().random((32, 3, 224, 224)))
+
+    def test_validate_image_invalid_dimensions(self) -> None:
+        """Test validation of a depth image batch with invalid dimensions."""
+        with pytest.raises(ValueError, match="Image must have shape"):
+            self.validator.validate_image(torch.rand(32, 224, 224))
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of a depth image batch with invalid number of channels."""
+        with pytest.raises(ValueError, match="Image must have 3 channels"):
+            self.validator.validate_image(torch.rand(32, 1, 224, 224))
+
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of valid ground truth labels."""
+        labels = torch.tensor([0, 1, 1, 0])
+        validated_labels = self.validator.validate_gt_label(labels)
+        assert isinstance(validated_labels, torch.Tensor)
+        assert validated_labels.dtype == torch.bool
+        assert torch.equal(validated_labels, torch.tensor([False, True, True, False]))
+
+    def test_validate_gt_label_none(self) -> None:
+        """Test validation of None ground truth labels."""
+        assert self.validator.validate_gt_label(None) is None
+
+    def test_validate_gt_label_invalid_type(self) -> None:
+        """Test validation of ground truth labels with invalid type."""
+        with pytest.raises(ValueError, match="too many dimensions 'str'"):
+            self.validator.validate_gt_label(["0", "1"])
+
+    def test_validate_gt_label_invalid_dimensions(self) -> None:
+        """Test validation of ground truth labels with invalid dimensions."""
+        with pytest.raises(ValueError, match="Ground truth label must be a 1-dimensional vector"):
+            self.validator.validate_gt_label(torch.tensor([[0, 1], [1, 0]]))
+
+    def test_validate_gt_mask_valid(self) -> None:
+        """Test validation of valid ground truth masks."""
+        masks = torch.randint(0, 2, (4, 224, 224))
+        validated_masks = self.validator.validate_gt_mask(masks)
+        assert isinstance(validated_masks, Mask)
+        assert validated_masks.shape == (4, 224, 224)
+        assert validated_masks.dtype == torch.bool
+
+    def test_validate_gt_mask_none(self) -> None:
+        """Test validation of None ground truth masks."""
+        assert self.validator.validate_gt_mask(None) is None
+
+    def test_validate_gt_mask_invalid_type(self) -> None:
+        """Test validation of ground truth masks with invalid type."""
+        with pytest.raises(TypeError, match="Ground truth mask must be a torch.Tensor"):
+            self.validator.validate_gt_mask([torch.zeros(224, 224)])
+
+    def test_validate_gt_mask_invalid_dimensions(self) -> None:
+        """Test validation of ground truth masks with invalid dimensions."""
+        with pytest.raises(ValueError, match="Ground truth mask must have 1 channel, got 2."):
+            self.validator.validate_gt_mask(torch.zeros(4, 2, 224, 224))
+
+    def test_validate_anomaly_map_valid(self) -> None:
+        """Test validation of a valid anomaly map batch."""
+        anomaly_map = torch.rand(4, 224, 224)
+        validated_map = self.validator.validate_anomaly_map(anomaly_map)
+        assert isinstance(validated_map, Mask)
+        assert validated_map.shape == (4, 224, 224)
+        assert validated_map.dtype == torch.float32
+
+    def test_validate_anomaly_map_none(self) -> None:
+        """Test validation of a None anomaly map batch."""
+        assert self.validator.validate_anomaly_map(None) is None
+
+    def test_validate_anomaly_map_invalid_shape(self) -> None:
+        """Test validation of an anomaly map batch with invalid shape."""
+        with pytest.raises(ValueError, match="Anomaly map must have 1 channel, got 2."):
+            self.validator.validate_anomaly_map(torch.rand(4, 2, 224, 224))
+
+    def test_validate_pred_score_valid(self) -> None:
+        """Test validation of valid prediction scores."""
+        scores = torch.tensor([0.1, 0.2, 0.3, 0.4])
+        validated_scores = self.validator.validate_pred_score(scores)
+        assert torch.equal(validated_scores, scores)
+
+    def test_validate_pred_score_none_with_anomaly_map(self) -> None:
+        """Test validation of None prediction scores with anomaly map."""
+        computed_scores = self.validator.validate_pred_score(None)
+        assert computed_scores is None
+
+    def test_validate_pred_label_valid(self) -> None:
+        """Test validation of valid prediction labels."""
+        labels = torch.tensor([[1], [0], [1], [1]])
+        validated_labels = self.validator.validate_pred_label(labels)
+        assert torch.equal(validated_labels, torch.tensor([[True], [False], [True], [True]]))
+
+    def test_validate_pred_label_none(self) -> None:
+        """Test validation of None prediction labels."""
+        assert self.validator.validate_pred_label(None) is None
+
+    def test_validate_pred_label_invalid_type(self) -> None:
+        """Test validation of prediction labels with invalid type."""
+        with pytest.raises(TypeError, match="Predicted label must be a torch.Tensor"):
+            self.validator.validate_pred_label([1, 0, 1, 1])
+
+    def test_validate_pred_label_invalid_shape(self) -> None:
+        """Test validation of prediction labels with invalid shape."""
+        with pytest.raises(ValueError, match="Predicted label must be 1-dimensional or 2-dimensional"):
+            self.validator.validate_pred_label(torch.tensor([[[1]], [[0]], [[1]], [[1]]]))
diff --git a/tests/unit/data/validators/torch/test_image.py b/tests/unit/data/validators/torch/test_image.py
new file mode 100644
index 0000000000..e1f6c0ec9a
--- /dev/null
+++ b/tests/unit/data/validators/torch/test_image.py
@@ -0,0 +1,243 @@
+"""Test Torch Image Validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+import pytest
+import torch
+from torchvision.tv_tensors import Image, Mask
+
+from anomalib.data.validators.torch.image import ImageBatchValidator, ImageValidator
+
+
+class TestImageValidator:
+    """Test ImageValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = ImageValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid image."""
+        image = torch.rand(3, 224, 224)
+        validated_image = self.validator.validate_image(image)
+        assert isinstance(validated_image, torch.Tensor)
+        assert validated_image.shape == (3, 224, 224)
+        assert validated_image.dtype == torch.float32
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of an image with invalid type."""
+        with pytest.raises(TypeError, match="Image must be a torch.Tensor"):
+            self.validator.validate_image(np.random.default_rng().random((3, 224, 224)))
+
+    def test_validate_image_invalid_dimensions(self) -> None:
+        """Test validation of an image with invalid dimensions."""
+        with pytest.raises(ValueError, match="Image must have shape"):
+            self.validator.validate_image(torch.rand(224, 224))
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of an image with invalid number of channels."""
+        with pytest.raises(ValueError, match="Image must have 3 channels"):
+            self.validator.validate_image(torch.rand(1, 224, 224))
+
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of a valid ground truth label."""
+        label = torch.tensor(1)
+        validated_label = self.validator.validate_gt_label(label)
+        assert isinstance(validated_label, torch.Tensor)
+        assert validated_label.dtype == torch.bool
+        assert validated_label.item() is True
+
+    def test_validate_gt_label_none(self) -> None:
+        """Test validation of a None ground truth label."""
+        assert self.validator.validate_gt_label(None) is None
+
+    def test_validate_gt_label_invalid_type(self) -> None:
+        """Test validation of a ground truth label with invalid type."""
+        with pytest.raises(TypeError, match="Ground truth label must be an integer or a torch.Tensor"):
+            self.validator.validate_gt_label("1")
+
+    def test_validate_gt_label_invalid_shape(self) -> None:
+        """Test validation of a ground truth label with invalid shape."""
+        with pytest.raises(ValueError, match="Ground truth label must be a scalar"):
+            self.validator.validate_gt_label(torch.tensor([0, 1]))
+
+    def test_validate_gt_mask_valid(self) -> None:
+        """Test validation of a valid ground truth mask."""
+        mask = torch.randint(0, 2, (1, 224, 224))
+        validated_mask = self.validator.validate_gt_mask(mask)
+        assert isinstance(validated_mask, Mask)
+        assert validated_mask.shape == (224, 224)
+        assert validated_mask.dtype == torch.bool
+
+    def test_validate_gt_mask_none(self) -> None:
+        """Test validation of a None ground truth mask."""
+        assert self.validator.validate_gt_mask(None) is None
+
+    def test_validate_gt_mask_invalid_type(self) -> None:
+        """Test validation of a ground truth mask with invalid type."""
+        with pytest.raises(TypeError, match="Mask must be a torch.Tensor"):
+            self.validator.validate_gt_mask(np.random.default_rng().integers(0, 2, (224, 224)))
+
+    def test_validate_gt_mask_invalid_shape(self) -> None:
+        """Test validation of a ground truth mask with invalid shape."""
+        with pytest.raises(ValueError, match="Mask must have 1 channel, got 2."):
+            self.validator.validate_gt_mask(torch.randint(0, 2, (2, 224, 224)))
+
+    def test_validate_anomaly_map_valid(self) -> None:
+        """Test validation of a valid anomaly map."""
+        anomaly_map = torch.rand(1, 224, 224)
+        validated_map = self.validator.validate_anomaly_map(anomaly_map)
+        assert isinstance(validated_map, Mask)
+        assert validated_map.shape == (224, 224)
+        assert validated_map.dtype == torch.float32
+
+    def test_validate_anomaly_map_none(self) -> None:
+        """Test validation of a None anomaly map."""
+        assert self.validator.validate_anomaly_map(None) is None
+
+    def test_validate_anomaly_map_invalid_type(self) -> None:
+        """Test validation of an anomaly map with invalid type."""
+        with pytest.raises(TypeError, match="Anomaly map must be a torch.Tensor"):
+            self.validator.validate_anomaly_map(np.random.default_rng().random((224, 224)))
+
+    def test_validate_anomaly_map_invalid_shape(self) -> None:
+        """Test validation of an anomaly map with invalid shape."""
+        with pytest.raises(ValueError, match="Anomaly map with 3 dimensions must have 1 channel, got 2."):
+            self.validator.validate_anomaly_map(torch.rand(2, 224, 224))
+
+    def test_validate_pred_score_valid(self) -> None:
+        """Test validation of a valid prediction score."""
+        score = torch.tensor(0.8)
+        validated_score = self.validator.validate_pred_score(score)
+        assert isinstance(validated_score, torch.Tensor)
+        assert validated_score.dtype == torch.float32
+        assert validated_score.item() == pytest.approx(0.8)
+
+    def test_validate_pred_score_none(self) -> None:
+        """Test validation of a None prediction score."""
+        assert self.validator.validate_pred_score(None) is None
+
+
+class TestImageBatchValidator:  # noqa: PLR0904
+    """Test ImageBatchValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = ImageBatchValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid image batch."""
+        image_batch = torch.rand(32, 3, 224, 224)
+        validated_batch = self.validator.validate_image(image_batch)
+        assert isinstance(validated_batch, Image)
+        assert validated_batch.shape == (32, 3, 224, 224)
+        assert validated_batch.dtype == torch.float32
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of an image batch with invalid type."""
+        with pytest.raises(TypeError, match="Image must be a torch.Tensor"):
+            self.validator.validate_image(np.random.default_rng().random((32, 3, 224, 224)))
+
+    def test_validate_image_invalid_dimensions(self) -> None:
+        """Test validation of an image batch with invalid dimensions."""
+        with pytest.raises(ValueError, match="Image must have 3 channels, got 32."):
+            self.validator.validate_image(torch.rand(32, 224, 224))
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of an image batch with invalid number of channels."""
+        with pytest.raises(ValueError, match="Image must have 3 channels"):
+            self.validator.validate_image(torch.rand(32, 1, 224, 224))
+
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of valid ground truth labels."""
+        labels = torch.tensor([0, 1, 1, 0])
+        validated_labels = self.validator.validate_gt_label(labels)
+        assert isinstance(validated_labels, torch.Tensor)
+        assert validated_labels.dtype == torch.bool
+        assert torch.equal(validated_labels, torch.tensor([False, True, True, False]))
+
+    def test_validate_gt_label_none(self) -> None:
+        """Test validation of None ground truth labels."""
+        assert self.validator.validate_gt_label(None) is None
+
+    def test_validate_gt_label_invalid_type(self) -> None:
+        """Test validation of ground truth labels with invalid type."""
+        with pytest.raises(ValueError, match="too many dimensions 'str'"):
+            self.validator.validate_gt_label(["0", "1"])
+
+    def test_validate_gt_label_invalid_dimensions(self) -> None:
+        """Test validation of ground truth labels with invalid dimensions."""
+        with pytest.raises(ValueError, match="Ground truth label must be a 1-dimensional vector"):
+            self.validator.validate_gt_label(torch.tensor([[0, 1], [1, 0]]))
+
+    def test_validate_gt_mask_valid(self) -> None:
+        """Test validation of valid ground truth masks."""
+        masks = torch.randint(0, 2, (4, 224, 224))
+        validated_masks = self.validator.validate_gt_mask(masks)
+        assert isinstance(validated_masks, Mask)
+        assert validated_masks.shape == (4, 224, 224)
+        assert validated_masks.dtype == torch.bool
+
+    def test_validate_gt_mask_none(self) -> None:
+        """Test validation of None ground truth masks."""
+        assert self.validator.validate_gt_mask(None) is None
+
+    def test_validate_gt_mask_invalid_type(self) -> None:
+        """Test validation of ground truth masks with invalid type."""
+        with pytest.raises(TypeError, match="Ground truth mask must be a torch.Tensor"):
+            self.validator.validate_gt_mask([torch.zeros(224, 224)])
+
+    def test_validate_gt_mask_invalid_dimensions(self) -> None:
+        """Test validation of ground truth masks with invalid dimensions."""
+        with pytest.raises(ValueError, match="Ground truth mask must have 1 channel, got 2."):
+            self.validator.validate_gt_mask(torch.zeros(4, 2, 224, 224))
+
+    def test_validate_anomaly_map_valid(self) -> None:
+        """Test validation of a valid anomaly map batch."""
+        anomaly_map = torch.rand(4, 224, 224)
+        validated_map = self.validator.validate_anomaly_map(anomaly_map)
+        assert isinstance(validated_map, Mask)
+        assert validated_map.shape == (4, 224, 224)
+        assert validated_map.dtype == torch.float32
+
+    def test_validate_anomaly_map_none(self) -> None:
+        """Test validation of a None anomaly map batch."""
+        assert self.validator.validate_anomaly_map(None) is None
+
+    def test_validate_anomaly_map_invalid_shape(self) -> None:
+        """Test validation of an anomaly map batch with invalid shape."""
+        with pytest.raises(ValueError, match="Anomaly map must have 1 channel, got 2."):
+            self.validator.validate_anomaly_map(torch.rand(4, 2, 224, 224))
+
+    def test_validate_pred_score_valid(self) -> None:
+        """Test validation of valid prediction scores."""
+        scores = torch.tensor([0.1, 0.2, 0.3, 0.4])
+        validated_scores = self.validator.validate_pred_score(scores)
+        assert torch.equal(validated_scores, scores)
+
+    def test_validate_pred_score_none(self) -> None:
+        """Test validation of None prediction scores."""
+        computed_scores = self.validator.validate_pred_score(None)
+        assert computed_scores is None
+
+    def test_validate_pred_label_valid(self) -> None:
+        """Test validation of valid prediction labels."""
+        labels = torch.tensor([[1], [0], [1], [1]])
+        validated_labels = self.validator.validate_pred_label(labels)
+        assert torch.equal(validated_labels, torch.tensor([[True], [False], [True], [True]]))
+
+    def test_validate_pred_label_none(self) -> None:
+        """Test validation of None prediction labels."""
+        assert self.validator.validate_pred_label(None) is None
+
+    def test_validate_pred_label_invalid_type(self) -> None:
+        """Test validation of prediction labels with invalid type."""
+        with pytest.raises(TypeError, match="Predicted label must be a torch.Tensor"):
+            self.validator.validate_pred_label([1, 0, 1, 1])
+
+    def test_validate_pred_label_invalid_shape(self) -> None:
+        """Test validation of prediction labels with invalid shape."""
+        with pytest.raises(ValueError, match="Predicted label must be 1-dimensional or 2-dimensional"):
+            self.validator.validate_pred_label(torch.tensor([[[1]], [[0]], [[1]], [[1]]]))
diff --git a/tests/unit/data/validators/torch/test_video.py b/tests/unit/data/validators/torch/test_video.py
new file mode 100644
index 0000000000..2933ddb7f4
--- /dev/null
+++ b/tests/unit/data/validators/torch/test_video.py
@@ -0,0 +1,239 @@
+"""Test Torch Video Validators."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+import pytest
+import torch
+from torchvision.tv_tensors import Mask
+
+from anomalib.data.validators.torch.video import VideoBatchValidator, VideoValidator
+
+
+class TestVideoValidator:
+    """Test VideoValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = VideoValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid video tensor."""
+        video = torch.rand(10, 3, 224, 224)
+        validated_video = self.validator.validate_image(video)
+        assert isinstance(validated_video, torch.Tensor)
+        assert validated_video.shape == (10, 3, 224, 224)
+        assert validated_video.dtype == torch.float32
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of a video tensor with invalid type."""
+        with pytest.raises(TypeError, match="Video must be a torch.Tensor"):
+            self.validator.validate_image(np.random.default_rng().random((10, 3, 224, 224)))
+
+    def test_validate_image_invalid_dimensions(self) -> None:
+        """Test validation of a video tensor with invalid dimensions."""
+        with pytest.raises(ValueError, match="Video must have 3 or 4 dimensions"):
+            self.validator.validate_image(torch.rand(224, 224))
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of a video tensor with invalid number of channels."""
+        with pytest.raises(ValueError, match="Video must have 1 or 3 channels"):
+            self.validator.validate_image(torch.rand(10, 2, 224, 224))
+
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of a valid ground truth label."""
+        label = torch.tensor(1)
+        validated_label = self.validator.validate_gt_label(label)
+        assert isinstance(validated_label, torch.Tensor)
+        assert validated_label.dtype == torch.bool
+        assert validated_label.item() is True
+
+    def test_validate_gt_label_none(self) -> None:
+        """Test validation of a None ground truth label."""
+        assert self.validator.validate_gt_label(None) is None
+
+    def test_validate_gt_label_invalid_type(self) -> None:
+        """Test validation of a ground truth label with invalid type."""
+        with pytest.raises(TypeError, match="Ground truth label must be an integer or a torch.Tensor"):
+            self.validator.validate_gt_label("1")
+
+    def test_validate_gt_mask_valid(self) -> None:
+        """Test validation of a valid ground truth mask."""
+        mask = torch.randint(0, 2, (10, 1, 224, 224))
+        validated_mask = self.validator.validate_gt_mask(mask)
+        assert isinstance(validated_mask, Mask)
+        assert validated_mask.shape == (10, 224, 224)
+        assert validated_mask.dtype == torch.bool
+
+    def test_validate_gt_mask_none(self) -> None:
+        """Test validation of a None ground truth mask."""
+        assert self.validator.validate_gt_mask(None) is None
+
+    def test_validate_gt_mask_invalid_type(self) -> None:
+        """Test validation of a ground truth mask with invalid type."""
+        with pytest.raises(TypeError, match="Mask must be a torch.Tensor"):
+            self.validator.validate_gt_mask(np.random.default_rng().integers(0, 2, (10, 224, 224)))
+
+    def test_validate_gt_mask_invalid_shape(self) -> None:
+        """Test validation of a ground truth mask with invalid shape."""
+        with pytest.raises(ValueError, match="Mask must have 1 channel, got 2."):
+            self.validator.validate_gt_mask(torch.randint(0, 2, (10, 2, 224, 224)))
+
+    def test_validate_anomaly_map_valid(self) -> None:
+        """Test validation of a valid anomaly map."""
+        anomaly_map = torch.rand(10, 1, 224, 224)
+        validated_map = self.validator.validate_anomaly_map(anomaly_map)
+        assert isinstance(validated_map, Mask)
+        assert validated_map.shape == (10, 224, 224)
+        assert validated_map.dtype == torch.float32
+
+    def test_validate_anomaly_map_none(self) -> None:
+        """Test validation of a None anomaly map."""
+        assert self.validator.validate_anomaly_map(None) is None
+
+    def test_validate_anomaly_map_invalid_type(self) -> None:
+        """Test validation of an anomaly map with invalid type."""
+        with pytest.raises(TypeError, match="Anomaly map must be a torch.Tensor"):
+            self.validator.validate_anomaly_map(np.random.default_rng().random((10, 224, 224)))
+
+    def test_validate_anomaly_map_invalid_shape(self) -> None:
+        """Test validation of an anomaly map with invalid shape."""
+        with pytest.raises(ValueError, match="Anomaly map with 4 dimensions must have 1 channel, got 2."):
+            self.validator.validate_anomaly_map(torch.rand(10, 2, 224, 224))
+
+    def test_validate_pred_score_valid(self) -> None:
+        """Test validation of a valid prediction score."""
+        score = torch.tensor(0.8)
+        validated_score = self.validator.validate_pred_score(score)
+        assert isinstance(validated_score, torch.Tensor)
+        assert validated_score.dtype == torch.float32
+        assert validated_score.item() == pytest.approx(0.8)
+
+    def test_validate_pred_score_none(self) -> None:
+        """Test validation of a None prediction score."""
+        assert self.validator.validate_pred_score(None) is None
+
+    def test_validate_pred_score_invalid_shape(self) -> None:
+        """Test validation of a prediction score with invalid shape."""
+        with pytest.raises(ValueError, match="Predicted score must be a scalar"):
+            self.validator.validate_pred_score(torch.tensor([0.8, 0.9]))
+
+
+class TestVideoBatchValidator:
+    """Test VideoBatchValidator."""
+
+    def setup_method(self) -> None:
+        """Set up the validator for each test method."""
+        self.validator = VideoBatchValidator()
+
+    def test_validate_image_valid(self) -> None:
+        """Test validation of a valid video batch."""
+        video_batch = torch.rand(2, 10, 3, 224, 224)
+        validated_batch = self.validator.validate_image(video_batch)
+        assert validated_batch.shape == (2, 10, 3, 224, 224)
+        assert validated_batch.dtype == torch.float32
+
+    def test_validate_image_invalid_type(self) -> None:
+        """Test validation of a video batch with invalid type."""
+        with pytest.raises(TypeError, match="Video batch must be a torch.Tensor"):
+            self.validator.validate_image(np.random.default_rng().random((2, 10, 3, 224, 224)))
+
+    def test_validate_image_invalid_dimensions(self) -> None:
+        """Test validation of a video batch with invalid dimensions."""
+        with pytest.raises(
+            ValueError,
+            match=(
+                r"Video batch must have 4 dimensions \(B, C, H, W\) for single frame images or "
+                r"5 dimensions \(B, T, C, H, W\) for multi-frame videos, got 2."
+            ),
+        ):
+            self.validator.validate_image(torch.rand(224, 224))
+
+    def test_validate_image_invalid_channels(self) -> None:
+        """Test validation of a video batch with invalid number of channels."""
+        with pytest.raises(ValueError, match="Video batch must have 1 or 3 channels"):
+            self.validator.validate_image(torch.rand(2, 10, 2, 224, 224))
+
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of valid ground truth labels."""
+        labels = torch.tensor([0, 1])
+        validated_labels = self.validator.validate_gt_label(labels)
+        assert isinstance(validated_labels, torch.Tensor)
+        assert validated_labels.dtype == torch.bool
+        assert torch.equal(validated_labels, torch.tensor([False, True]))
+
+    def test_validate_gt_label_none(self) -> None:
+        """Test validation of None ground truth labels."""
+        assert self.validator.validate_gt_label(None) is None
+
+    def test_validate_gt_label_invalid_type(self) -> None:
+        """Test validation of ground truth labels with invalid type."""
+        with pytest.raises(TypeError, match="Ground truth labels must be a torch.Tensor"):
+            self.validator.validate_gt_label(["0", "1"])
+
+    def test_validate_gt_mask_valid(self) -> None:
+        """Test validation of valid ground truth masks."""
+        masks = torch.randint(0, 2, (2, 10, 224, 224))
+        validated_masks = self.validator.validate_gt_mask(masks)
+        assert isinstance(validated_masks, Mask)
+        assert validated_masks.shape == (2, 10, 224, 224)
+        assert validated_masks.dtype == torch.bool
+
+    def test_validate_gt_mask_none(self) -> None:
+        """Test validation of None ground truth masks."""
+        assert self.validator.validate_gt_mask(None) is None
+
+    def test_validate_gt_mask_invalid_type(self) -> None:
+        """Test validation of ground truth masks with invalid type."""
+        with pytest.raises(TypeError, match="Masks must be a torch.Tensor"):
+            self.validator.validate_gt_mask([torch.zeros(10, 224, 224)])
+
+    def test_validate_gt_mask_invalid_shape(self) -> None:
+        """Test validation of ground truth masks with invalid shape."""
+        with pytest.raises(ValueError, match="Masks must have 1 channel, got 2."):
+            self.validator.validate_gt_mask(torch.zeros(2, 10, 2, 224, 224))
+
+    def test_validate_anomaly_map_valid(self) -> None:
+        """Test validation of a valid anomaly map batch."""
+        anomaly_map = torch.rand(2, 10, 224, 224)
+        validated_map = self.validator.validate_anomaly_map(anomaly_map)
+        assert isinstance(validated_map, Mask)
+        assert validated_map.shape == (2, 10, 224, 224)
+        assert validated_map.dtype == torch.float32
+
+    def test_validate_anomaly_map_none(self) -> None:
+        """Test validation of a None anomaly map batch."""
+        assert self.validator.validate_anomaly_map(None) is None
+
+    def test_validate_anomaly_map_invalid_shape(self) -> None:
+        """Test validation of an anomaly map batch with invalid shape."""
+        with pytest.raises(ValueError, match="Anomaly maps must have 1 channel, got 2."):
+            self.validator.validate_anomaly_map(torch.rand(2, 10, 2, 224, 224))
+
+    def test_validate_pred_score_valid(self) -> None:
+        """Test validation of valid prediction scores."""
+        scores = torch.tensor([0.1, 0.2])
+        validated_scores = self.validator.validate_pred_score(scores)
+        assert torch.equal(validated_scores, scores)
+
+    def test_validate_pred_score_none_with_anomaly_map(self) -> None:
+        """Test validation of None prediction scores with anomaly map."""
+        anomaly_map = torch.rand(2, 10, 224, 224)
+        computed_scores = self.validator.validate_pred_score(None, anomaly_map)
+        assert computed_scores.shape == (2,)
+
+    def test_validate_pred_label_valid(self) -> None:
+        """Test validation of valid prediction labels."""
+        labels = torch.tensor([1, 0])
+        validated_labels = self.validator.validate_pred_label(labels)
+        assert torch.equal(validated_labels, torch.tensor([True, False]))
+
+    def test_validate_pred_label_none(self) -> None:
+        """Test validation of None prediction labels."""
+        assert self.validator.validate_pred_label(None) is None
+
+    def test_validate_pred_label_invalid_shape(self) -> None:
+        """Test validation of prediction labels with invalid shape."""
+        with pytest.raises(ValueError, match="Predicted labels must be a 1D tensor"):
+            self.validator.validate_pred_label(torch.tensor([[1], [0]]))
diff --git a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
index f907e3f37c..b01c72cc56 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
@@ -54,6 +54,7 @@ def test_step(self, *_, **__) -> ImageBatch:
             image=torch.rand((1, 3, 100, 100)).to(self.device),
             gt_mask=torch.zeros((1, 100, 100)).to(self.device),
             anomaly_map=torch.ones((1, 100, 100)).to(self.device),
+            pred_score=torch.Tensor([1.0]),
             gt_label=torch.Tensor([0]).int().to(self.device),
             pred_label=torch.Tensor([0]).int().to(self.device),
             pred_mask=torch.zeros((1, 100, 100)).to(self.device),
diff --git a/tox.ini b/tox.ini
index c504b2552f..c6ddd8f753 100644
--- a/tox.ini
+++ b/tox.ini
@@ -35,14 +35,14 @@ commands =
     pip install .[full]
 
     ; 1. Run Coverage.
-    pytest -x -v --tb=auto tests/integration tests/unit \
+    pytest -v --tb=auto tests/integration tests/unit \
         --cov=anomalib \
         --cov-report=xml:{toxworkdir}/coverage.xml \
         --cov-fail-under=75 \
         {posargs}
 
     ; 2. Test Jupyter Notebooks.
-    pytest -x -v --tb=auto --nbmake notebooks \
+    pytest -v --tb=auto --nbmake notebooks \
         --ignore=notebooks/400_openvino \
         --ignore=notebooks/500_use_cases/501_dobot
 

From 06daad9a44b6f1de5188424569f91c423223cd40 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 9 Oct 2024 14:31:30 +0100
Subject: [PATCH 08/45] =?UTF-8?q?=F0=9F=9A=80=20Customisable=20Image=20Vis?=
 =?UTF-8?q?ualizer=20(#2334)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Add validators

* Add depth validators to depth classes

* Add image validators to depth classes

* Add video validators to depth classes

* Add numpy validators and update dataclasses

* Run all the tests on the ci

* Fix the tests

* Created validator tests and added numpy video tests

* Add numpy image tests

* Add numpy depth tests

* Add torch validator tests

* Fix numpy validation tests

* Convet private _validate methods to public validate method

* Revert "Convet private _validate methods to public validate method"

This reverts commit 47f183a8495b13085f2046ccd719eb4d3c4add48.

* Convert private _validate methods to public validate method

* Remove batch_size arg from validators

* Remove anomaly_map from validators

* Use validators as mixins

* convert abstractmethods to static abstractmethods

* Move pred-score computation to model implementations

* Add missing pred_score implemenations in models

* Fix the numpy validation tests

Signed-off-by: Samet Akcay 

* Fix visualization tests

Signed-off-by: Samet Akcay 

* Add numpy video validator mixin to numpy video item, and remove validation methods

Signed-off-by: Samet Akcay 

* Add np.bool_ to validate np label

Signed-off-by: Samet Akcay 

* add convert_to_title_case function to path utils

* Add ImageVisualizer

Signed-off-by: Samet Akcay 

* Create image visualization functionals

Signed-off-by: Samet Akcay 

* Create image visualization class

Signed-off-by: Samet Akcay 

* Add a comment in visualize-item

Signed-off-by: Samet Akcay 

* Update functional.py

* Add warning for invalid overlays

Signed-off-by: Samet Akcay 

* Add overlay_mask function with fill and contour modes

Signed-off-by: Samet Akcay 

* Moved `visualize_image_item` to a new module

Signed-off-by: Samet Akcay 

* Fix typo in visualizer

Signed-off-by: Samet Akcay 

* Pass mask color to visualize_mask

Signed-off-by: Samet Akcay 

* Fix tests

Signed-off-by: Samet Akcay 

* Modify item_visualizer

Signed-off-by: Samet Akcay 

* Update visualize item

Signed-off-by: Samet Akcay 

* Update the item visualization

Signed-off-by: Samet Akcay 

* Update the item visualization

Signed-off-by: Samet Akcay 

* Fix tests

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 
Signed-off-by: Samet Akcay 
Co-authored-by: Samet Akcay 
---
 src/anomalib/engine/engine.py                 |  13 +-
 src/anomalib/utils/path.py                    | 146 +++++
 src/anomalib/visualization/__init__.py        |  16 +
 src/anomalib/visualization/image/__init__.py  |  21 +
 .../visualization/image/functional.py         | 528 ++++++++++++++++++
 .../visualization/image/item_visualizer.py    | 296 ++++++++++
 .../visualization/image/visualizer.py         | 186 ++++++
 .../visualizer_callback/test_visualizer.py    |   2 +-
 8 files changed, 1198 insertions(+), 10 deletions(-)
 create mode 100644 src/anomalib/visualization/__init__.py
 create mode 100644 src/anomalib/visualization/image/__init__.py
 create mode 100644 src/anomalib/visualization/image/functional.py
 create mode 100644 src/anomalib/visualization/image/item_visualizer.py
 create mode 100644 src/anomalib/visualization/image/visualizer.py

diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index e7612e6e57..464be44d60 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -20,12 +20,11 @@
 from anomalib.callbacks.checkpoint import ModelCheckpoint
 from anomalib.callbacks.metrics import _MetricsCallback
 from anomalib.callbacks.timer import TimerCallback
-from anomalib.callbacks.visualizer import _VisualizationCallback
 from anomalib.data import AnomalibDataModule, AnomalibDataset, PredictDataset
 from anomalib.deploy import CompressionType, ExportType
 from anomalib.models import AnomalyModule
 from anomalib.utils.path import create_versioned_dir
-from anomalib.utils.visualization import ImageVisualizer
+from anomalib.visualization import ImageVisualizer
 
 logger = logging.getLogger(__name__)
 
@@ -378,13 +377,9 @@ def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None:
         # Add the metrics callback.
         _callbacks.append(_MetricsCallback(self.task, self.image_metric_names, self.pixel_metric_names))
 
-        _callbacks.append(
-            _VisualizationCallback(
-                visualizers=ImageVisualizer(task=self.task, normalize=False),
-                save=True,
-                root=self._cache.args["default_root_dir"] / "images",
-            ),
-        )
+        # Add the image visualizer callback if it is passed by the user.
+        if not any(isinstance(callback, ImageVisualizer) for callback in self._cache.args["callbacks"]):
+            _callbacks.append(ImageVisualizer())
 
         _callbacks.append(TimerCallback())
 
diff --git a/src/anomalib/utils/path.py b/src/anomalib/utils/path.py
index 47cc77652f..c9f92937d2 100644
--- a/src/anomalib/utils/path.py
+++ b/src/anomalib/utils/path.py
@@ -95,3 +95,149 @@ def convert_to_snake_case(s: str) -> str:
 
     # Replace multiple consecutive underscores with a single underscore
     return re.sub(r"__+", "_", s)
+
+
+def convert_to_title_case(text: str) -> str:
+    """Converts a given text to title case, handling regular text, snake_case, and camelCase.
+
+    Args:
+        text (str): The input text to be converted to title case.
+
+    Returns:
+        str: The input text converted to title case.
+
+    Raises:
+        TypeError: If the input is not a string.
+
+    Examples:
+        Regular text:
+        >>> convert_to_title_case("the quick brown fox")
+        'The Quick Brown Fox'
+
+        Snake case:
+        >>> convert_to_title_case("convert_snake_case_to_title_case")
+        'Convert Snake Case To Title Case'
+
+        Camel case:
+        >>> convert_to_title_case("convertCamelCaseToTitleCase")
+        'Convert Camel Case To Title Case'
+
+        Pascal case:
+        >>> convert_to_title_case("ConvertPascalCaseToTitleCase")
+        'Convert Pascal Case To Title Case'
+
+        Mixed cases:
+        >>> convert_to_title_case("mixed_snake_camelCase and PascalCase")
+        'Mixed Snake Camel Case And Pascal Case'
+
+        Handling punctuation and contractions:
+        >>> convert_to_title_case("what's the_weather_like? it'sSunnyToday.")
+        "What's The Weather Like? It's Sunny Today."
+
+        With numbers and special characters:
+        >>> convert_to_title_case("python3.9_features and camelCaseNames")
+        'Python 3.9 Features And Camel Case Names'
+    """
+    if not isinstance(text, str):
+        msg = "Input must be a string"
+        raise TypeError(msg)
+
+    # Handle snake_case
+    text = text.replace("_", " ")
+
+    # Handle camelCase and PascalCase
+    text = re.sub(r"([a-z])([A-Z])", r"\1 \2", text)
+    text = re.sub(r"([A-Z])([A-Z][a-z])", r"\1 \2", text)
+
+    # Split the text into words, preserving punctuation
+    words = re.findall(r"[\w']+|[.,!?;]", text)
+
+    # Capitalize each word
+    result = [word.capitalize() if word.isalpha() or "'" in word else word for word in words]
+
+    # Join the words back together
+    return " ".join(result)
+
+
+def generate_output_filename(
+    input_path: str | Path,
+    output_path: str | Path,
+    dataset_name: str,
+    category: str | None = None,
+    mkdir: bool = True,
+) -> Path:
+    """Generate an output filename based on the input path, preserving the directory structure.
+
+    This function takes an input path, an output base directory, a dataset name, and an optional
+    category. It generates an output path that preserves the directory structure after the dataset
+    name (and category, if provided) while placing the file in the specified output directory.
+
+    Args:
+        input_path (str | Path): The input file path.
+        output_path (str | Path): The base output directory.
+        dataset_name (str): The name of the dataset in the input path.
+        category (str | None, optional): The category name in the input path. Defaults to None.
+        mkdir (bool, optional): Whether to create the output directory. Defaults to True.
+
+    Returns:
+        Path: The generated output file path.
+
+    Raises:
+        ValueError: If the dataset name or category (if provided) is not found in the input path.
+
+    Examples:
+        >>> input_path = "/data/MVTec/bottle/test/broken_large/000.png"
+        >>> output_base = "/results"
+        >>> dataset = "MVTec"
+
+        # With category
+        >>> generate_output_filename(input_path, output_base, dataset, "bottle")
+        PosixPath('/results/test/broken_large/000.png')
+
+        # Without category
+        >>> generate_output_filename(input_path, output_base, dataset)
+        PosixPath('/results/bottle/test/broken_large/000.png')
+
+        # Different dataset structure
+        >>> input_path = "/datasets/MyDataset/train/class_A/image_001.jpg"
+        >>> generate_output_filename(input_path, "/output", "MyDataset", "class_A")
+        PosixPath('/output/image_001.jpg')
+
+        # Error case: Dataset not in path
+        >>> generate_output_filename("/wrong/path/image.png", "/out", "NonexistentDataset")
+        Traceback (most recent call last):
+            ...
+        ValueError: Dataset name 'NonexistentDataset' not found in the input path.
+    """
+    input_path = Path(input_path)
+    output_path = Path(output_path)
+
+    # Find the position of the dataset name in the path
+    try:
+        dataset_index = next(i for i, part in enumerate(input_path.parts) if part.lower() == dataset_name.lower())
+    except ValueError:
+        msg = f"Dataset name '{dataset_name}' not found in the input path."
+        raise ValueError(msg) from None
+
+    # Determine the start index for preserving subdirectories
+    start_index = dataset_index + 1
+    if category:
+        try:
+            category_index = input_path.parts.index(category, dataset_index)
+            start_index = category_index + 1
+        except ValueError:
+            msg = f"Category '{category}' not found in the input path after the dataset name."
+            raise ValueError(msg) from None
+
+    # Preserve all subdirectories after the category (or dataset if no category)
+    subdirs = input_path.parts[start_index:-1]  # Exclude the filename
+
+    # Construct the output path
+    output_path = output_path / Path(*subdirs)
+
+    # Create the output directory if it doesn't exist
+    if mkdir:
+        output_path.mkdir(parents=True, exist_ok=True)
+
+    # Create and return the output filename
+    return output_path / input_path.name
diff --git a/src/anomalib/visualization/__init__.py b/src/anomalib/visualization/__init__.py
new file mode 100644
index 0000000000..ca0b7bc138
--- /dev/null
+++ b/src/anomalib/visualization/__init__.py
@@ -0,0 +1,16 @@
+"""Visualization module."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .image import ImageVisualizer, visualize_anomaly_map, visualize_mask
+from .image.item_visualizer import visualize_image_item
+
+__all__ = [
+    # Image visualizer class
+    "ImageVisualizer",
+    # Image visualization functions
+    "visualize_anomaly_map",
+    "visualize_image_item",
+    "visualize_mask",
+]
diff --git a/src/anomalib/visualization/image/__init__.py b/src/anomalib/visualization/image/__init__.py
new file mode 100644
index 0000000000..9f60f1399a
--- /dev/null
+++ b/src/anomalib/visualization/image/__init__.py
@@ -0,0 +1,21 @@
+"""Image visualization module."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .functional import add_text_to_image, apply_colormap, overlay_images, visualize_anomaly_map, visualize_mask
+from .item_visualizer import visualize_image_item
+from .visualizer import ImageVisualizer
+
+__all__ = [
+    # Visualization functions
+    "add_text_to_image",
+    "apply_colormap",
+    "overlay_images",
+    "visualize_anomaly_map",
+    "visualize_mask",
+    # Visualize ImageItem
+    "visualize_image_item",
+    # Visualization class
+    "ImageVisualizer",
+]
diff --git a/src/anomalib/visualization/image/functional.py b/src/anomalib/visualization/image/functional.py
new file mode 100644
index 0000000000..940586c2d6
--- /dev/null
+++ b/src/anomalib/visualization/image/functional.py
@@ -0,0 +1,528 @@
+"""Visualizer for ImageItem fields using PIL and torchvision."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+import logging
+import sys
+from collections.abc import Callable
+from typing import Any, Literal
+
+import torch
+import torch.nn.functional as F  # noqa: N812
+from PIL import Image, ImageDraw, ImageEnhance, ImageFilter, ImageFont
+from torchvision.transforms.functional import to_pil_image
+
+logger = logging.getLogger(__name__)
+
+
+def dynamic_font_size(image_size: tuple[int, int], min_size: int = 20, max_size: int = 100, divisor: int = 10) -> int:
+    """Calculate a dynamic font size based on image dimensions.
+
+    Args:
+        image_size: Tuple of image dimensions (width, height).
+        min_size: Minimum font size (default: 20).
+        max_size: Maximum font size (default: 100).
+        divisor: Divisor for calculating font size (default: 10).
+
+    Returns:
+        Calculated font size within the specified range.
+    """
+    min_dimension = min(image_size)
+    return max(min_size, min(max_size, min_dimension // divisor))
+
+
+def add_text_to_image(
+    image: Image.Image,
+    text: str,
+    font: str | None = None,
+    size: int | None = None,
+    color: tuple[int, int, int] | str = "white",
+    background: tuple[int, ...] | str | None = (0, 0, 0, 128),  # Default to semi-transparent black
+    position: tuple[int, int] = (10, 10),
+    padding: int = 3,
+) -> Image.Image:
+    """Add text to an image with configurable parameters."""
+    # Create a new RGBA image as a transparent overlay
+    overlay = Image.new("RGBA", image.size, (0, 0, 0, 0))
+    draw = ImageDraw.Draw(overlay)
+
+    if size is None:
+        size = dynamic_font_size(image.size)
+
+    try:
+        image_font = ImageFont.truetype(font, size) if font else ImageFont.load_default()
+    except OSError:
+        logger.warning(f"Failed to load font '{font}'. Using default font.")
+        image_font = ImageFont.load_default()
+
+    # Calculate text size and position
+    text_bbox = draw.textbbox(position, text, font=image_font)
+    text_position = position
+    background_bbox = (text_bbox[0] - padding, text_bbox[1] - padding, text_bbox[2] + padding, text_bbox[3] + padding)
+
+    # Draw background if specified
+    if background is not None:
+        draw.rectangle(background_bbox, fill=background)
+
+    # Draw text
+    draw.text(text_position, text, font=image_font, fill=color)
+
+    # Composite the overlay onto the original image
+    return Image.alpha_composite(image.convert("RGBA"), overlay).convert("RGB")
+
+
+def apply_colormap(image: Image.Image) -> Image.Image:
+    """Apply a colormap to a single-channel PIL Image using torch and PIL.
+
+    This function converts a grayscale image to a colored image using the 'jet' colormap.
+
+    Args:
+        image (Image.Image): A single-channel PIL Image or an object that can be converted to PIL Image.
+
+    Returns:
+        Image.Image: A new PIL Image with the colormap applied.
+
+    Raises:
+        TypeError: If the input cannot be converted to a PIL Image.
+
+    Example:
+        >>> from PIL import Image
+        >>> import numpy as np
+        >>> # Create a sample grayscale image
+        >>> gray_image = Image.fromarray(np.random.randint(0, 256, (100, 100), dtype=np.uint8), mode='L')
+        >>> # Apply the jet colormap
+        >>> colored_image = apply_colormap(gray_image)
+        >>> colored_image.show()
+    """
+    # Try to convert the input to a PIL Image if it's not already
+    if not isinstance(image, Image.Image):
+        try:
+            image = Image.fromarray(image)
+        except TypeError:
+            msg = "Input must be a PIL Image object or an object that can be converted to PIL Image"
+            raise TypeError(msg) from None
+
+    # Ensure image is in 'L' mode (8-bit pixels, black and white)
+    if image.mode != "L":
+        image = image.convert("L")
+
+    # Define colormap values for the 'jet' colormap
+    colormap_values = [
+        (0, 0, 143),  # Dark blue
+        (0, 0, 255),  # Blue
+        (0, 127, 255),  # Light blue
+        (0, 255, 255),  # Cyan
+        (127, 255, 127),  # Light green
+        (255, 255, 0),  # Yellow
+        (255, 127, 0),  # Orange
+        (255, 0, 0),  # Red
+        (127, 0, 0),  # Dark red
+    ]
+
+    # Create a linear interpolation of the colormap
+    colormap_tensor = torch.tensor(colormap_values, dtype=torch.float32)
+    colormap_tensor = colormap_tensor.unsqueeze(0).unsqueeze(0)  # Add batch and channel dimensions
+
+    # Interpolate to create a smooth 256-color palette
+    interpolated = F.interpolate(colormap_tensor, size=(256, 3), mode="bilinear", align_corners=False)
+    interpolated = interpolated.squeeze().byte()
+
+    # Convert the interpolated tensor to a flat list for PIL
+    palette = interpolated.flatten().tolist()
+
+    # Apply the colormap to the image
+    colored_image = image.convert("P")  # Convert to 8-bit pixels, mapped to a palette
+    colored_image.putpalette(palette)  # Apply our custom palette
+    return colored_image.convert("RGB")  # Convert back to RGB for display
+
+
+def overlay_image(base: Image.Image, overlay: Image.Image, alpha: float = 0.5) -> Image.Image:
+    """Overlay an image on top of another image with a specified alpha value.
+
+    Args:
+        base (Image.Image): The base image.
+        overlay (Image.Image): The image to overlay.
+        alpha (float): The alpha value for blending (0.0 to 1.0). Defaults to 0.5.
+
+    Returns:
+        Image.Image: The image with the overlay applied.
+
+    Examples:
+        # Overlay a random mask on an image
+        >>> from PIL import Image, ImageDraw
+
+        >>> image = Image.new('RGB', (200, 200), color='green')
+        >>> draw = ImageDraw.Draw(image)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill='yellow')
+
+        >>> mask = Image.new('L', (200, 200), color=0)
+        >>> draw = ImageDraw.Draw(mask)
+        >>> draw.rectangle([75, 75, 125, 125], fill=255)
+
+        >>> result = overlay_image(image, mask, alpha=0.3)
+        >>> result.show()
+    """
+    base = base.convert("RGBA")
+    overlay = overlay.convert("RGBA")
+
+    # Resize mask to match input image size if necessary
+    if base.size != overlay.size:
+        overlay = overlay.resize(base.size)
+
+    # Adjust the alpha of the mask
+    alpha_mask = overlay.split()[3]
+    alpha_mask = ImageEnhance.Brightness(alpha_mask).enhance(alpha)
+    overlay.putalpha(alpha_mask)
+
+    # Composite the mask over the input image
+    return Image.alpha_composite(base, overlay)
+
+
+def overlay_images(
+    base: Image.Image,
+    overlays: Image.Image | list[Image.Image],
+    alpha: float | list[float] = 0.5,
+) -> Image.Image:
+    """Overlay multiple images on top of a base image with a specified alpha value.
+
+    If the overlay is a mask (L mode), draw its contours on the image instead.
+
+    Args:
+        base: The base PIL Image.
+        overlays: PIL Image or list of PIL Images to overlay on top of the base image.
+        alpha: The alpha value for blending (0.0 to 1.0). Defaults to 0.5.
+
+    Returns:
+        A new PIL Image with all overlays applied.
+
+    Examples:
+        # Overlay a single image
+        >>> from PIL import Image, ImageDraw
+        >>> image = Image.new('RGB', (200, 200), color='green')
+        >>> draw = ImageDraw.Draw(image)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill='yellow')
+
+        >>> mask = Image.new('L', (200, 200), color=0)
+        >>> draw = ImageDraw.Draw(mask)
+        >>> draw.rectangle([75, 75, 125, 125], fill=255)
+
+        >>> result = overlay_images(image, mask)
+
+        # Overlay multiple images
+        >>> image = Image.new('RGB', (200, 200), color='green')
+        >>> draw = ImageDraw.Draw(image)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill='yellow')
+
+        >>> mask1 = Image.new('L', (200, 200), color=0)
+        >>> draw = ImageDraw.Draw(mask1)
+        >>> draw.rectangle([25, 25, 75, 75], fill=255)
+
+        >>> mask2 = Image.new('L', (200, 200), color=0)
+        >>> draw = ImageDraw.Draw(mask2)
+        >>> draw.ellipse([50, 50, 150, 100], fill=255)
+
+        >>> result = overlay_images(image, [mask1, mask2])
+    """
+    if not isinstance(overlays, list):
+        overlays = [overlays]
+
+    alphas = [alpha] * len(overlays) if not isinstance(alpha, list) else alpha
+    for overlay, overlay_alpha in zip(overlays, alphas, strict=False):
+        base = overlay_image(base, overlay, alpha=overlay_alpha)
+
+    return base
+
+
+def visualize_anomaly_map(
+    anomaly_map: Image.Image | torch.Tensor,
+    colormap: bool = True,
+    normalize: bool = False,
+) -> Image.Image:
+    """Visualize the anomaly map.
+
+    This function takes an anomaly map as input and applies normalization and/or colormap
+    based on the provided parameters.
+
+    Args:
+        anomaly_map (Image.Image | torch.Tensor): The input anomaly map as a PIL Image or torch Tensor.
+        colormap (bool, optional): Whether to apply a colormap to the anomaly map. Defaults to True.
+        normalize (bool, optional): Whether to normalize the anomaly map. Defaults to False.
+
+    Returns:
+        Image.Image: The visualized anomaly map as a PIL Image in RGB mode.
+
+    Example:
+        >>> from PIL import Image
+        >>> import numpy as np
+        >>> import torch
+
+        >>> # Create a sample anomaly map as PIL Image
+        >>> anomaly_map_pil = Image.fromarray(np.random.rand(100, 100).astype(np.float32), mode='F')
+
+        >>> # Create a sample anomaly map as torch Tensor
+        >>> anomaly_map_tensor = torch.rand(100, 100)
+
+        >>> # Visualize the anomaly maps
+        >>> visualized_map_pil = visualize_anomaly_map(anomaly_map_pil, normalize=True, colormap=True)
+        >>> visualized_map_tensor = visualize_anomaly_map(anomaly_map_tensor, normalize=True, colormap=True)
+        >>> visualized_map_pil.show()
+        >>> visualized_map_tensor.show()
+    """
+    image = to_pil_image(anomaly_map) if isinstance(anomaly_map, torch.Tensor) else anomaly_map.copy()
+
+    if normalize:
+        # Get the min and max pixel values
+        min_value = image.getextrema()[0]
+        max_value = image.getextrema()[1]
+
+        # Create a normalized image
+        image = image.point(lambda x: (x - min_value) * 255 / (max_value - min_value))
+
+    return apply_colormap(image) if colormap else image.convert("RGB")
+
+
+def visualize_mask(
+    mask: Image.Image | torch.Tensor,
+    *,
+    mode: Literal["contour", "fill", "binary", "L", "1"] = "binary",
+    alpha: float = 0.5,
+    color: tuple[int, int, int] = (255, 0, 0),
+    background_color: tuple[int, int, int, int] = (0, 0, 0, 0),
+) -> Image.Image:
+    """Visualize a mask with different modes.
+
+    Args:
+        mask (Image.Image | torch.Tensor): The input mask. Can be a PIL Image or a PyTorch tensor.
+        mode (Literal["contour", "binary", "fill"]): The visualization mode.
+            - "contour": Draw contours of the mask.
+            - "fill": Fill the masked area with a color.
+            - "binary": Return the original binary mask.
+            - "L": Return the original grayscale mask.
+            - "1": Return the original binary mask.
+        alpha (float): The alpha value for blending (0.0 to 1.0). Only used in "fill" mode.
+            Defaults to 0.5.
+        color (tuple[int, int, int]): The color to apply to the mask.
+            Defaults to (255, 0, 0) (red).
+        background_color (tuple[int, int, int, int]): The background color (RGBA).
+            Defaults to (0, 0, 0, 0) (transparent).
+
+    Returns:
+        Image.Image: The visualized mask as a PIL Image.
+
+    Raises:
+        TypeError: If the mask is not a PIL Image or PyTorch tensor.
+        ValueError: If an invalid mode is provided.
+
+    Examples:
+        >>> mask_array = np.random.randint(0, 2, size=(100, 100), dtype=np.uint8) * 255
+        >>> mask_image = Image.fromarray(mask_array, mode='L')
+
+        >>> contour_mask = visualize_mask(mask_image, mode="contour", color=(255, 0, 0))
+        >>> contour_mask.show()
+
+        >>> binary_mask = visualize_mask(mask_image, mode="binary")
+        >>> binary_mask.show()
+
+        >>> fill_mask = visualize_mask(mask_image, mode="fill", color=(0, 255, 0), alpha=0.3)
+        >>> fill_mask.show()
+    """
+    # Convert torch.Tensor to PIL Image if necessary
+    if isinstance(mask, torch.Tensor):
+        if mask.dtype == torch.bool:
+            mask = mask.to(torch.uint8) * 255
+        mask = to_pil_image(mask)
+
+    if not isinstance(mask, Image.Image):
+        msg = "Mask must be a PIL Image or PyTorch tensor"
+        raise TypeError(msg)
+
+    # Ensure mask is in binary mode
+    mask = mask.convert("L")
+    if mode in {"binary", "L", "1"}:
+        return mask
+
+    # Create a background image
+    background = Image.new("RGBA", mask.size, background_color)
+
+    match mode:
+        case "contour":
+            # Find edges of the mask
+            edges = mask.filter(ImageFilter.FIND_EDGES)
+
+            # Create a colored version of the edges
+            colored_edges = Image.new("RGBA", mask.size, (*color, 255))
+            colored_edges.putalpha(edges)
+
+            # Composite the colored edges onto the background
+            return Image.alpha_composite(background, colored_edges)
+
+        case "fill":
+            # Create a solid color image for the overlay
+            overlay = Image.new("RGBA", mask.size, (*color, int(255 * alpha)))
+
+            # Use the mask to blend the overlay with the background
+            return Image.composite(overlay, background, mask)
+
+        case _:
+            msg = f"Invalid mode: {mode}. Allowed modes are 'contour', 'binary', or 'fill'."
+            raise ValueError(msg)
+
+
+def visualize_gt_mask(
+    mask: Image.Image | torch.Tensor,
+    *,
+    mode: Literal["contour", "fill", "binary", "L", "1"] = "binary",
+    alpha: float = 0.5,
+    color: tuple[int, int, int] = (255, 0, 0),
+    background_color: tuple[int, int, int, int] = (0, 0, 0, 0),
+) -> Image.Image:
+    """Visualize a ground truth mask."""
+    return visualize_mask(mask, mode=mode, alpha=alpha, color=color, background_color=background_color)
+
+
+def visualize_pred_mask(
+    mask: Image.Image | torch.Tensor,
+    *,
+    mode: Literal["contour", "fill", "binary", "L", "1"] = "binary",
+    color: tuple[int, int, int] = (255, 0, 0),
+    alpha: float = 0.5,
+    background_color: tuple[int, int, int, int] = (0, 0, 0, 0),
+) -> Image.Image:
+    """Visualize a prediction mask."""
+    return visualize_mask(mask, mode=mode, alpha=alpha, color=color, background_color=background_color)
+
+
+def create_image_grid(images: list[Image.Image], nrow: int) -> Image.Image:
+    """Create a grid of images using PIL.
+
+    Args:
+        images: List of PIL Images to arrange in a grid.
+        nrow: Number of images per row.
+
+    Returns:
+        A new PIL Image containing the grid of images.
+    """
+    if not images:
+        msg = "No images provided to create grid"
+        raise ValueError(msg)
+
+    # Assuming all images have the same size
+    img_width, img_height = images[0].size
+
+    # Calculate grid dimensions
+    ncol = (len(images) + nrow - 1) // nrow  # Ceiling division
+    grid_width = nrow * img_width
+    grid_height = ncol * img_height
+
+    # Create a new image with white background
+    grid_image = Image.new("RGB", (grid_width, grid_height), color="white")
+
+    # Paste images into grid
+    for idx, img in enumerate(images):
+        row = idx // nrow
+        col = idx % nrow
+        grid_image.paste(img, (col * img_width, row * img_height))
+
+    return grid_image
+
+
+def get_field_kwargs(field: str) -> dict[str, Any]:
+    """Get the keyword arguments for a visualization function.
+
+    This function retrieves the default keyword arguments for a given visualization function.
+
+    Args:
+        field (str): The name of the visualization field (e.g., 'mask', 'anomaly_map').
+
+    Returns:
+        dict[str, Any]: A dictionary containing the default keyword arguments for the visualization function.
+
+    Raises:
+        ValueError: If the specified field does not have a corresponding visualization function.
+
+    Examples:
+        >>> # Get keyword arguments for visualizing a mask
+        >>> mask_kwargs = get_field_kwargs('mask')
+        >>> print(mask_kwargs)
+        {'mode': 'binary', 'color': (255, 0, 0), 'alpha': 0.5, 'background_color': (0, 0, 0, 0)}
+
+        >>> # Get keyword arguments for visualizing an anomaly map
+        >>> anomaly_map_kwargs = get_field_kwargs('anomaly_map')
+        >>> print(anomaly_map_kwargs)
+        {'colormap': True, 'normalize': False}
+
+        >>> # Attempt to get keyword arguments for an invalid field
+        >>> get_field_kwargs('invalid_field')
+        Traceback (most recent call last):
+            ...
+        ValueError: 'invalid_field' is not a valid function in the current module.
+    """
+    # Get the current module
+    current_module = sys.modules[__name__]
+
+    # Try to get the function from the current module
+    func_name = f"visualize_{field}"
+    func = getattr(current_module, func_name, None)
+
+    if func is None or not callable(func):
+        msg = f"'{field}' is not a valid function in the current module."
+        raise ValueError(msg)
+
+    # Get the signature of the function
+    signature = inspect.signature(func)
+
+    # Initialize a dictionary to store keyword argument information
+    kwargs = {}
+
+    # Iterate through the parameters
+    for name, param in signature.parameters.items():
+        # Check if the parameter is a keyword argument
+        if param.kind in {inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}:
+            if param.default != inspect.Parameter.empty:
+                kwargs[name] = param.default
+        elif param.kind == inspect.Parameter.VAR_KEYWORD:
+            kwargs[name] = "Variable keyword arguments (**kwargs)"
+
+    return kwargs
+
+
+def get_visualize_function(field: str) -> Callable:
+    """Get the visualization function for a given field.
+
+    Args:
+        field (str): The name of the visualization field
+            (e.g., 'image', 'mask', 'anomaly_map').
+
+    Returns:
+        Callable: The visualization function corresponding to the given field.
+
+    Raises:
+        AttributeError: If the specified field does not have a corresponding
+            visualization function.
+
+    Examples:
+        >>> from PIL import Image
+
+        Get the visualize function for an anomaly map
+        >>> visualize_func = get_visualize_function('anomaly_map')
+        >>> anomaly_map = Image.new('F', (256, 256))
+        >>> visualized_map = visualize_func(anomaly_map, colormap=True, normalize=True)
+        >>> isinstance(visualized_map, Image.Image)
+        True
+
+        >>> visualize_func = get_visualize_function('mask')
+        >>> mask = Image.new('1', (256, 256))
+        >>> visualized_mask = visualize_func(mask, color=(255, 0, 0))
+        >>> isinstance(visualized_mask, Image.Image)
+        True
+
+        Attempt to get a function for an invalid field
+        >>> get_visualize_function('invalid_field')
+        Raises AttributeError: module 'anomalib.visualization.image.functional'
+        has no attribute 'visualize_invalid_field'
+    """
+    current_module = sys.modules[__name__]
+    func_name = f"visualize_{field}"
+    return getattr(current_module, func_name)
diff --git a/src/anomalib/visualization/image/item_visualizer.py b/src/anomalib/visualization/image/item_visualizer.py
new file mode 100644
index 0000000000..305230bb5a
--- /dev/null
+++ b/src/anomalib/visualization/image/item_visualizer.py
@@ -0,0 +1,296 @@
+"""ImageItem visualizer."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from typing import Any
+
+from PIL import Image
+
+from anomalib.data import ImageItem
+from anomalib.utils.path import convert_to_title_case
+from anomalib.visualization.image.functional import (
+    add_text_to_image,
+    create_image_grid,
+    get_visualize_function,
+    overlay_images,
+)
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_FIELDS_CONFIG = {
+    "image": {},
+    "gt_mask": {},
+    "pred_mask": {},
+    "anomaly_map": {"colormap": True, "normalize": False},
+}
+
+DEFAULT_OVERLAY_FIELDS_CONFIG = {
+    "gt_mask": {"color": (255, 255, 255), "alpha": 1.0, "mode": "contour"},
+    "pred_mask": {"color": (255, 0, 0), "alpha": 1.0, "mode": "contour"},
+}
+
+DEFAULT_TEXT_CONFIG = {
+    "enable": True,
+    "font": None,
+    "size": None,
+    "color": "white",
+    "background": (0, 0, 0, 128),
+}
+
+
+def visualize_image_item(
+    item: ImageItem,
+    fields: list[str] | None = None,
+    overlay_fields: list[tuple[str, list[str]]] | None = None,
+    field_size: tuple[int, int] = (256, 256),
+    fields_config: dict[str, dict[str, Any]] = DEFAULT_FIELDS_CONFIG,
+    overlay_fields_config: dict[str, dict[str, Any]] = DEFAULT_OVERLAY_FIELDS_CONFIG,
+    text_config: dict[str, Any] = DEFAULT_TEXT_CONFIG,
+) -> Image.Image | None:
+    """Visualizes specified fields of an ImageItem with configurable options.
+
+    This function creates visualizations for individual fields and overlays of an ImageItem.
+    It supports customization of field visualization, overlay composition, and text annotations.
+
+    Args:
+        item: An ImageItem instance containing the data to visualize.
+        fields: A list of field names to visualize individually. If None, no individual
+            fields are visualized.
+        overlay_fields: A list of tuples, each containing a base field and a list of
+            fields to overlay on it. If None, no overlays are created.
+        field_size: A tuple (width, height) specifying the size of each visualized field.
+        fields_config: A dictionary of field-specific visualization configurations.
+        overlay_fields_config: A dictionary of overlay-specific configurations.
+        text_config: A dictionary of text annotation configurations.
+
+    Returns:
+        A PIL Image containing the visualized fields and overlays, or None if no
+        valid fields to visualize.
+
+    Raises:
+        AttributeError: If a specified field doesn't exist in the ImageItem.
+        ValueError: If an invalid configuration is provided.
+
+    Examples:
+        Basic usage with default settings:
+        >>> item = ImageItem(image_path="image.jpg", gt_mask=mask, pred_mask=pred, anomaly_map=amap)
+        >>> result = visualize_image_item(item, fields=["image", "gt_mask", "pred_mask", "anomaly_map"])
+
+        Visualizing specific fields:
+        >>> result = visualize_image_item(item, fields=["image", "anomaly_map"])
+
+        Creating an overlay:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["image"],
+        ...     overlay_fields=[("image", ["anomaly_map"])]
+        ... )
+
+        Multiple overlays:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     overlay_fields=[
+        ...         ("image", ["gt_mask"]),
+        ...         ("image", ["pred_mask"]),
+        ...         ("image", ["anomaly_map"])
+        ...     ]
+        ... )
+
+        Customizing field visualization:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["image", "anomaly_map"],
+        ...     fields_config={
+        ...         "anomaly_map": {"colormap": True, "normalize": True}
+        ...     }
+        ... )
+
+        Adjusting overlay transparency:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     overlay_fields=[("image", ["gt_mask", "pred_mask"])],
+        ...     overlay_fields_config={
+        ...         "gt_mask": {"alpha": 0.3},
+        ...         "pred_mask": {"alpha": 0.7}
+        ...     }
+        ... )
+
+        Customizing text annotations:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["image", "gt_mask"],
+        ...     text_config={
+        ...         "font": "arial.ttf",
+        ...         "size": 20,
+        ...         "color": "yellow",
+        ...         "background": (0, 0, 0, 180)
+        ...     }
+        ... )
+
+        Disabling text annotations:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["image", "gt_mask"],
+        ...     text_config={"enable": False}
+        ... )
+
+        Combining multiple customizations:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["image", "gt_mask", "pred_mask"],
+        ...     overlay_fields=[("image", ["anomaly_map"])],
+        ...     field_size=(384, 384),
+        ...     fields_config={
+        ...         "anomaly_map": {"colormap": True, "normalize": True},
+        ...     },
+        ...     overlay_fields_config={
+        ...         "anomaly_map": {"colormap": True},
+        ...     },
+        ...     text_config={
+        ...         "font": "times.ttf",
+        ...         "size": 24,
+        ...         "color": "white",
+        ...         "background": (0, 0, 0, 200)
+        ...     }
+        ... )
+
+        Handling missing fields gracefully:
+        >>> item_no_pred = ImageItem(image_path="image.jpg", gt_mask=mask, anomaly_map=amap)
+        >>> result = visualize_image_item(
+        ...     item_no_pred,
+        ...     fields=["image", "gt_mask", "pred_mask", "anomaly_map"]
+        ... )
+        # This will visualize all available fields, skipping 'pred_mask'
+
+        Custom ordering of fields and overlays:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["anomaly_map", "image", "gt_mask"],
+        ...     overlay_fields=[
+        ...         ("image", ["pred_mask"]),
+        ...         ("image", ["gt_mask", "anomaly_map"]),
+        ...     ]
+        ... )
+        # This will maintain the specified order in the output
+
+        Different masking strategies:
+
+        1. Binary mask visualization:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["gt_mask", "pred_mask"],
+        ...     fields_config={
+        ...         "gt_mask": {"mode": "binary"},
+        ...         "pred_mask": {"mode": "binary"}
+        ...     }
+        ... )
+
+        2. Contour mask visualization:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["gt_mask", "pred_mask"],
+        ...     fields_config={
+        ...         "gt_mask": {"mode": "contour", "color": (0, 255, 0)},
+        ...         "pred_mask": {"mode": "contour", "color": (255, 0, 0)}
+        ...     }
+        ... )
+
+        3. Filled mask visualization:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["gt_mask", "pred_mask"],
+        ...     fields_config={
+        ...         "gt_mask": {"mode": "fill", "color": (0, 255, 0), "alpha": 0.5},
+        ...         "pred_mask": {"mode": "fill", "color": (255, 0, 0), "alpha": 0.5}
+        ...     }
+        ... )
+
+        4. Mixed masking strategies:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["image"],
+        ...     overlay_fields=[("image", ["gt_mask", "pred_mask"])],
+        ...     overlay_fields_config={
+        ...         "gt_mask": {"mode": "contour", "color": (0, 255, 0), "alpha": 0.7},
+        ...         "pred_mask": {"mode": "fill", "color": (255, 0, 0), "alpha": 0.3}
+        ...     }
+        ... )
+
+        5. Combining masking strategies with anomaly map:
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["image", "anomaly_map"],
+        ...     overlay_fields=[("image", ["gt_mask", "pred_mask"])],
+        ...     fields_config={
+        ...         "anomaly_map": {"colormap": True, "normalize": True}
+        ...     },
+        ...     overlay_fields_config={
+        ...         "gt_mask": {"mode": "contour", "color": (0, 255, 0), "alpha": 0.7},
+        ...         "pred_mask": {"mode": "fill", "color": (255, 0, 0), "alpha": 0.3}
+        ...     }
+        ... )
+
+    Note:
+        - The function preserves the order of fields as specified in the input.
+        - If a field is not available in the ImageItem, it will be skipped without raising an error.
+        - The function uses default configurations if not provided, which can be overridden
+          by passing custom configurations.
+        - For mask visualization, the 'mode' parameter in fields_config or overlay_fields_config
+          determines how the mask is displayed:
+            * 'binary': Shows the mask as a black and white image
+            * 'contour': Displays only the contours of the mask
+            * 'fill': Fills the mask area with a specified color and transparency
+    """
+    fields_config = {**DEFAULT_FIELDS_CONFIG, **(fields_config or {})}
+    overlay_fields_config = {**DEFAULT_OVERLAY_FIELDS_CONFIG, **(overlay_fields_config or {})}
+    text_config = {**DEFAULT_TEXT_CONFIG, **(text_config or {})}
+    add_text = text_config.pop("enable", True)
+
+    all_fields = set(fields or [])
+    all_fields.update(field for base, overlays in (overlay_fields or []) for field in [base, *overlays])
+
+    field_images = {}
+    output_images = []
+
+    for field in all_fields:
+        image: Image.Image | None = None
+        if field == "image":
+            # NOTE: use get_visualize_function(field) when input transforms are introduced in models.
+            image = Image.open(item.image_path).convert("RGB")
+        else:
+            field_value = getattr(item, field, None)
+            if field_value is not None:
+                image = get_visualize_function(field)(field_value, **fields_config.get(field, {}))
+            else:
+                logger.warning(f"Field '{field}' is None in ImageItem. Skipping visualization.")
+        if image:
+            field_images[field] = image.resize(field_size)
+
+    for field in fields or []:
+        if field in field_images:
+            output_image = field_images[field].copy()
+            if add_text:
+                output_image = add_text_to_image(output_image, convert_to_title_case(field), **text_config)
+            output_images.append(output_image)
+
+    for base, overlays in overlay_fields or []:
+        if base in field_images:
+            base_image = field_images[base].copy()
+            valid_overlays = [o for o in overlays if o in field_images]
+            for overlay in valid_overlays:
+                overlay_config = overlay_fields_config.get(overlay, {})
+                overlay_value = getattr(item, overlay, None)
+                if overlay_value is not None:
+                    overlay_image = get_visualize_function(overlay)(overlay_value, **overlay_config)
+                    base_image = overlay_images(base_image, overlay_image, alpha=overlay_config.get("alpha", 0.5))
+                else:
+                    logger.warning(f"Field '{overlay}' is None in ImageItem. Skipping visualization.")
+
+            if valid_overlays and add_text:
+                title = f"{convert_to_title_case(base)} + {'+'.join(convert_to_title_case(o) for o in valid_overlays)}"
+                base_image = add_text_to_image(base_image, title, **text_config)
+            output_images.append(base_image)
+
+    return create_image_grid(output_images, nrow=len(output_images)) if output_images else None
diff --git a/src/anomalib/visualization/image/visualizer.py b/src/anomalib/visualization/image/visualizer.py
new file mode 100644
index 0000000000..7c83446ae5
--- /dev/null
+++ b/src/anomalib/visualization/image/visualizer.py
@@ -0,0 +1,186 @@
+"""Image Visualizer."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+from typing import Any
+
+from lightning.pytorch import Callback, Trainer
+
+from anomalib.data import ImageBatch
+from anomalib.models import AnomalyModule
+from anomalib.utils.path import generate_output_filename
+
+from .item_visualizer import (
+    DEFAULT_FIELDS_CONFIG,
+    DEFAULT_OVERLAY_FIELDS_CONFIG,
+    DEFAULT_TEXT_CONFIG,
+    visualize_image_item,
+)
+
+
+class ImageVisualizer(Callback):
+    """Image Visualizer.
+
+    This class is responsible for visualizing images and their corresponding anomaly maps
+    during the testing and prediction phases of an anomaly detection model.
+
+    Args:
+        fields (list[str] | None): List of fields to visualize.
+            Defaults to ["image", "gt_mask"].
+        overlay_fields (list[tuple[str, list[str]]] | None): List of tuples specifying fields to overlay.
+            Defaults to [("image", ["anomaly_map"]), ("image", ["pred_mask"])].
+        field_size (tuple[int, int]): Size of each field in the visualization.
+            Defaults to (256, 256).
+        fields_config (dict[str, dict[str, Any]]): Custom configurations for field visualization.
+            Defaults to DEFAULT_FIELDS_CONFIG.
+        overlay_fields_config (dict[str, dict[str, Any]]): Custom configurations for field overlays.
+            Defaults to DEFAULT_OVERLAY_FIELDS_CONFIG.
+        text_config (dict[str, Any]): Configuration for text overlay.
+            Defaults to DEFAULT_TEXT_CONFIG.
+        output_dir (str | Path | None): Directory to save the visualizations.
+            Defaults to None.
+
+    Examples:
+        Basic usage with default settings:
+        >>> visualizer = ImageVisualizer()
+
+        Customizing fields to visualize:
+        >>> visualizer = ImageVisualizer(
+        ...     fields=["image", "gt_mask", "anomaly_map"],
+        ...     overlay_fields=[("image", ["anomaly_map"])]
+        ... )
+
+        Adjusting field size:
+        >>> visualizer = ImageVisualizer(field_size=(512, 512))
+
+        Customizing anomaly map visualization:
+        >>> visualizer = ImageVisualizer(
+        ...     fields_config={
+        ...         "anomaly_map": {"colormap": True, "normalize": True}
+        ...     }
+        ... )
+
+        Modifying overlay appearance:
+        >>> visualizer = ImageVisualizer(
+        ...     overlay_fields_config={
+        ...         "pred_mask": {"alpha": 0.7, "color": (255, 0, 0), "mode": "fill"},
+        ...         "anomaly_map": {"alpha": 0.5, "color": (0, 255, 0), "mode": "contour"}
+        ...     }
+        ... )
+
+        Customizing text overlay:
+        >>> visualizer = ImageVisualizer(
+        ...     text_config={
+        ...         "font": "arial.ttf",
+        ...         "size": 20,
+        ...         "color": "yellow",
+        ...         "background": (0, 0, 0, 200)
+        ...     }
+        ... )
+
+        Specifying output directory:
+        >>> visualizer = ImageVisualizer(output_dir="./output/visualizations")
+
+        Advanced configuration combining multiple customizations:
+        >>> visualizer = ImageVisualizer(
+        ...     fields=["image", "gt_mask", "anomaly_map", "pred_mask"],
+        ...     overlay_fields=[("image", ["anomaly_map"]), ("image", ["pred_mask"])],
+        ...     field_size=(384, 384),
+        ...     fields_config={
+        ...         "anomaly_map": {"colormap": True, "normalize": True},
+        ...         "pred_mask": {"color": (0, 0, 255)}
+        ...     },
+        ...     overlay_fields_config={
+        ...         "anomaly_map": {"alpha": 0.6, "mode": "fill"},
+        ...         "pred_mask": {"alpha": 0.7, "mode": "contour"}
+        ...     },
+        ...     text_config={
+        ...         "font": "times.ttf",
+        ...         "size": 24,
+        ...         "color": "white",
+        ...         "background": (0, 0, 0, 180)
+        ...     },
+        ...     output_dir="./custom_visualizations"
+        ... )
+
+    Note:
+        - The 'fields' parameter determines which individual fields are visualized.
+        - The 'overlay_fields' parameter specifies which fields should be overlaid on others.
+        - Field configurations in 'fields_config' affect how individual fields are visualized.
+        - Overlay configurations in 'overlay_fields_config' determine how fields are blended when overlaid.
+        - Text configurations in 'text_config' control the appearance of text labels on visualizations.
+        - If 'output_dir' is not specified, visualizations will be saved in a default location.
+
+    For more details on available options for each configuration, refer to the documentation
+    of the `visualize_image_item`, `visualize_field`, and related functions.
+    """
+
+    def __init__(
+        self,
+        fields: list[str] | None = None,
+        overlay_fields: list[tuple[str, list[str]]] | None = None,
+        field_size: tuple[int, int] = (256, 256),
+        fields_config: dict[str, dict[str, Any]] | None = None,
+        overlay_fields_config: dict[str, dict[str, Any]] | None = None,
+        text_config: dict[str, Any] | None = None,
+        output_dir: str | Path | None = None,
+    ) -> None:
+        self.fields = fields or ["image", "gt_mask"]
+        self.overlay_fields = overlay_fields or [("image", ["anomaly_map"]), ("image", ["pred_mask"])]
+        self.field_size = field_size
+        self.fields_config = {**DEFAULT_FIELDS_CONFIG, **(fields_config or {})}
+        self.overlay_fields_config = {**DEFAULT_OVERLAY_FIELDS_CONFIG, **(overlay_fields_config or {})}
+        self.text_config = {**DEFAULT_TEXT_CONFIG, **(text_config or {})}
+        self.output_dir = output_dir
+
+    def on_test_batch_end(
+        self,
+        trainer: Trainer,
+        pl_module: AnomalyModule,
+        outputs: ImageBatch,
+        batch: ImageBatch,
+        batch_idx: int,
+        dataloader_idx: int = 0,
+    ) -> None:
+        """Called when the test batch ends."""
+        del pl_module, outputs, batch_idx, dataloader_idx  # Unused arguments.
+
+        if self.output_dir is None:
+            self.output_dir = Path(trainer.default_root_dir) / "images"
+
+        for item in batch:
+            image = visualize_image_item(
+                item,
+                fields=self.fields,
+                overlay_fields=self.overlay_fields,
+                field_size=self.field_size,
+                fields_config=self.fields_config,
+                overlay_fields_config=self.overlay_fields_config,
+                text_config=self.text_config,
+            )
+
+            if image is not None:
+                # Get the dataset name and category to save the image
+                filename = generate_output_filename(
+                    input_path=item.image_path or "",
+                    output_path=self.output_dir,
+                    dataset_name=getattr(trainer.datamodule, "name", "") or "",
+                    category=getattr(trainer.datamodule, "category", "") or "",
+                )
+
+                # Save the image to the specified filename
+                image.save(filename)
+
+    def on_predict_batch_end(
+        self,
+        trainer: Trainer,
+        pl_module: AnomalyModule,
+        outputs: ImageBatch,
+        batch: ImageBatch,
+        batch_idx: int,
+        dataloader_idx: int = 0,
+    ) -> None:
+        """Called when the predict batch ends."""
+        return self.on_test_batch_end(trainer, pl_module, outputs, batch, batch_idx, dataloader_idx)
diff --git a/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py b/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
index a8d397c2f5..1cf0f90cba 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
@@ -31,7 +31,7 @@ def test_add_images(task: TaskType, dataset_path: Path) -> None:
         )
         engine.test(model=model, datamodule=MVTec(root=dataset_path / "mvtec", category="dummy"))
         # test if images are logged
-        assert len(list(Path(dir_loc).glob("**/*.png"))) == 1, "Failed to save to local path"
+        assert len(list(Path(dir_loc).glob("**/*.png"))) >= 1, "Failed to save to local path"
 
         # test if tensorboard logs are created
         assert len(list((Path(dir_loc) / "tensorboard_logs").glob("version_*"))) != 0, "Failed to save to tensorboard"

From 95115f9d81e7227576c421ee6843c730f38aad32 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 16 Oct 2024 13:51:09 +0100
Subject: [PATCH 09/45] Merge main the feature branch. (#2376)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Update timm requirement from <=1.0.7,>=1.0.7 to >=1.0.7,<=1.0.9 (#2274)

* Update timm requirement from <=1.0.7,>=1.0.7 to >=1.0.7,<=1.0.9

Updates the requirements on [timm](https://github.com/huggingface/pytorch-image-models) to permit the latest version.
- [Release notes](https://github.com/huggingface/pytorch-image-models/releases)
- [Commits](https://github.com/huggingface/pytorch-image-models/compare/v1.0.7...v1.0.9)

---
updated-dependencies:
- dependency-name: timm
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] 

* Update pyproject.toml

---------

Signed-off-by: dependabot[bot] 
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Samet Akcay 

* 🐞Update `setuptools` requirement for PEP 660 support (#2320)

Update setup tools

Signed-off-by: Samet Akcay 

* Fix transforms for draem, dsr and rkde (#2324)

Signed-off-by: Blaz Rolih 

* Add check before loading metrics data from checkpoint (#2323)

Add check before loading from checkpoint

Signed-off-by: Blaz Rolih 
Co-authored-by: Samet Akcay 

* Add PIMO (#2329)

* PIMO (#1726)

* update

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* test binclf curves numpy and numba and fixes

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct som docstrings

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* torch interface and tests

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* torch interface and tests

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* constants regrouped in dataclass as class vars

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* result class was unneccesary for per_image_binclf_curve

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* factorize function _get_threshs_minmax_linspace

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* small docs fixes

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add pimo numpy version and test

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* move validation

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add `shared_fpr_metric` option

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add pimo torch functional version and test

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add torchmetrics interface and test

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* renames and put things in init

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* validate inputs in result objects

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* result objects to from dict and tests

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add save and load methods to result objects and test

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor validations and minor changes

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* test result objects' properties

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minor refactors

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add missing docstrings

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minore vocabulary fix for consistency

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add per image scores statistics and test it

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor constants notation

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add stats tests and test it

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* change the meaning of AUPIMO.num_thresh

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* interface to format pairwise test results

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* improve doc

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add optional `paths` to result objects and some minor fixes and refactors

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* remove frozen from dataclasses and some done todos

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* review headers

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* doc modifs

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor `score_less_than_thresh` in `_binclf_one_curve_python`

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct license comments

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* fix doc

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* numba as extra requirement

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor copyrights from jpcbertoldo

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* remove from __future__ import annotations

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor validations names

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* dedupe file path validation

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* fix tests

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* Add todo

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor enums

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* only logger.warning

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor test imports

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor docs

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor some docs

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct pre commit errors

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* remove author tag

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add thrid party program

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* Update src/anomalib/metrics/per_image/pimo.py

* move HAS_NUMBA

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* remove PIMOSharedFPRMetric

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* make torchmetrics compute avg by dft

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* pre-commit hooks corrections

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct numpy.trapezoid

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Co-authored-by: Samet Akcay 

* 🗑️ Remove numba (#2313)

* remove numba

Signed-off-by: Ashwin Vaidya 

* fix pre-commit checks

Signed-off-by: Ashwin Vaidya 

* add third-party-programs.txt

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* 🗑️ Remove unused methods (#2315)

* remove numba

Signed-off-by: Ashwin Vaidya 

* fix pre-commit checks

Signed-off-by: Ashwin Vaidya 

* remove all unused methods

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* PIMO: Port Numpy → Torch (#2316)

* remove numba

Signed-off-by: Ashwin Vaidya 

* fix pre-commit checks

Signed-off-by: Ashwin Vaidya 

* remove all unused methods

Signed-off-by: Ashwin Vaidya 

* replace numpy with torch

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* 🔨Refactor methods across files (#2321)

* remove numba

Signed-off-by: Ashwin Vaidya 

* fix pre-commit checks

Signed-off-by: Ashwin Vaidya 

* remove all unused methods

Signed-off-by: Ashwin Vaidya 

* replace numpy with torch

Signed-off-by: Ashwin Vaidya 

* refactor code

Signed-off-by: Ashwin Vaidya 

* refactor
move functional inside update
remove path from the metric

* Add changes from comments

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* Remove model to model comparison (#2325)

* rename to pimo

Signed-off-by: Ashwin Vaidya 

* minor refactor

Signed-off-by: Ashwin Vaidya 

* remove model to model comparison

Signed-off-by: Ashwin Vaidya 

* fix test

Signed-off-by: Ashwin Vaidya 

* PR comments

Signed-off-by: Ashwin Vaidya 

* Minor refactor

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* PR comments

Signed-off-by: Ashwin Vaidya 

* Remove unused enums

Signed-off-by: Ashwin Vaidya 

* update doc strings

Signed-off-by: Ashwin Vaidya 

* update param names

Signed-off-by: Ashwin Vaidya 

* add aupimo basic usage tutorial notebook (#2330)

* add aupimo basic usage tutorial notebook

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* update scipy import

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add cite us

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minor

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* modify texts and add illustration

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* udpate working dir

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Signed-off-by: Ashwin Vaidya 
Co-authored-by: Joao P C Bertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Co-authored-by: Samet Akcay 

* Makes batch size dynamic (#2339)

Made batch dimension of ONNX export dynamic when specifying input shape.

* Add pimo tutorial advanced i (fixed) (#2336)

* uset all padim features to make it deterministic

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add aupimo notebook advanced i

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* update readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* modify changelog

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct again

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minor corrections

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* Pimo tutorials/02 advanced ii (#2347)

* uset all padim features to make it deterministic

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add aupimo notebook advanced i

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* update readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* modify changelog

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct again

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minor corrections

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add aupimo notebook advanced ii (pimo curve and integration bounds)

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* fix links

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct change log

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* Create epic.yaml

* 🔨 Update the issue templates (#2363)

* Update epic.yaml

* Update epic.yaml

* Update epic.yaml

* Update epic.yaml

* Update task.yaml

* Create user_story.yaml

* Update epic.yaml

* Pimo tutorials/03 advanced iii (#2348)

* add aupimo notebook advanced iii (aupimo score of a random model)

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add cite us

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* update notebooks readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Co-authored-by: Samet Akcay 

* 🔨 Deprecate try import and replace it with Lightning's package_available (#2373)

Replace try_import with lightnings package_available function

Signed-off-by: Samet Akcay 

* Refactor folder3d to avoid complex-structure (C901) issue (#2185)

* Refactored-make_folder3d_dataset-ruff-error-C901 (#1926)

Signed-off-by: sahusiddharth 

* Simplify folder 3d dataset (#2184)

---------

Signed-off-by: sahusiddharth 
Co-authored-by: Siddharth Sahu <112792547+sahusiddharth@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] 
Signed-off-by: Samet Akcay 
Signed-off-by: Blaz Rolih 
Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Signed-off-by: Ashwin Vaidya 
Signed-off-by: sahusiddharth 
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Blaž Rolih <61357777+blaz-r@users.noreply.github.com>
Co-authored-by: Ashwin Vaidya 
Co-authored-by: Joao P C Bertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Co-authored-by: Marcus Pertlwieser <116986601+Marcus1506@users.noreply.github.com>
Co-authored-by: Siddharth Sahu <112792547+sahusiddharth@users.noreply.github.com>
---
 .github/ISSUE_TEMPLATE/epic.yaml              |   39 +
 .github/ISSUE_TEMPLATE/task.yaml              |   74 +-
 .github/ISSUE_TEMPLATE/user_story.yaml        |   69 +
 CHANGELOG.md                                  |    3 +
 notebooks/700_metrics/701a_aupimo.ipynb       |  543 +++++++
 .../700_metrics/701b_aupimo_advanced_i.ipynb  | 1433 +++++++++++++++++
 .../700_metrics/701c_aupimo_advanced_ii.ipynb |  936 +++++++++++
 .../701d_aupimo_advanced_iii.ipynb            |  372 +++++
 notebooks/700_metrics/pimo_viz.svg            |  619 +++++++
 notebooks/700_metrics/roc_pro_pimo.svg        |  690 ++++++++
 notebooks/README.md                           |    9 +
 pyproject.toml                                |    4 +-
 src/anomalib/cli/pipelines.py                 |    4 +-
 src/anomalib/cli/utils/openvino.py            |    5 +-
 src/anomalib/data/datasets/depth/folder_3d.py |   60 +-
 src/anomalib/data/utils/path.py               |   14 +-
 src/anomalib/loggers/wandb.py                 |    5 +-
 src/anomalib/metrics/__init__.py              |    3 +
 src/anomalib/metrics/pimo/__init__.py         |   23 +
 src/anomalib/metrics/pimo/_validate.py        |  427 +++++
 .../pimo/binary_classification_curve.py       |  334 ++++
 src/anomalib/metrics/pimo/dataclasses.py      |  226 +++
 src/anomalib/metrics/pimo/functional.py       |  355 ++++
 src/anomalib/metrics/pimo/pimo.py             |  296 ++++
 src/anomalib/metrics/pimo/utils.py            |   19 +
 .../models/components/base/export_mixin.py    |   10 +-
 .../models/image/draem/lightning_model.py     |   11 +
 .../models/image/dsr/lightning_model.py       |    7 +
 .../models/image/rkde/lightning_model.py      |   11 +
 src/anomalib/utils/exceptions/imports.py      |    9 +
 tests/unit/data/utils/test_path.py            |    6 +
 tests/unit/metrics/pimo/__init__.py           |    8 +
 .../pimo/test_binary_classification_curve.py  |  423 +++++
 tests/unit/metrics/pimo/test_pimo.py          |  368 +++++
 third-party-programs.txt                      |    4 +
 35 files changed, 7349 insertions(+), 70 deletions(-)
 create mode 100644 .github/ISSUE_TEMPLATE/epic.yaml
 create mode 100644 .github/ISSUE_TEMPLATE/user_story.yaml
 create mode 100644 notebooks/700_metrics/701a_aupimo.ipynb
 create mode 100644 notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
 create mode 100644 notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
 create mode 100644 notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb
 create mode 100644 notebooks/700_metrics/pimo_viz.svg
 create mode 100644 notebooks/700_metrics/roc_pro_pimo.svg
 create mode 100644 src/anomalib/metrics/pimo/__init__.py
 create mode 100644 src/anomalib/metrics/pimo/_validate.py
 create mode 100644 src/anomalib/metrics/pimo/binary_classification_curve.py
 create mode 100644 src/anomalib/metrics/pimo/dataclasses.py
 create mode 100644 src/anomalib/metrics/pimo/functional.py
 create mode 100644 src/anomalib/metrics/pimo/pimo.py
 create mode 100644 src/anomalib/metrics/pimo/utils.py
 create mode 100644 tests/unit/metrics/pimo/__init__.py
 create mode 100644 tests/unit/metrics/pimo/test_binary_classification_curve.py
 create mode 100644 tests/unit/metrics/pimo/test_pimo.py

diff --git a/.github/ISSUE_TEMPLATE/epic.yaml b/.github/ISSUE_TEMPLATE/epic.yaml
new file mode 100644
index 0000000000..23c3bf51d3
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/epic.yaml
@@ -0,0 +1,39 @@
+name: 🎯 Epic
+description: A large body of work that can be broken down into smaller stories
+title: "🎯 [EPIC] "
+labels: ["epic"]
+assignees: []
+body:
+  - type: markdown
+    attributes:
+      value: "## 🎯 Epic Description"
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the epic
+      description: Provide a clear and concise description of what this epic encompasses
+    validations:
+      required: true
+  - type: textarea
+    id: goals
+    attributes:
+      label: Goals
+      description: What are the main goals of this epic?
+    validations:
+      required: true
+  - type: textarea
+    id: tasks
+    attributes:
+      label: Tasks
+      description: Break down the epic into smaller tasks. Add or remove tasks as needed.
+      value: |
+        - [ ] Task 1:
+        - [ ] Task 2:
+        - [ ] Task 3:
+        - [ ] Task 4:
+        - [ ] Task 5:
+    validations:
+      required: true
+  - type: markdown
+    attributes:
+      value: "Remember to create separate issues for each task and link them to this epic."
diff --git a/.github/ISSUE_TEMPLATE/task.yaml b/.github/ISSUE_TEMPLATE/task.yaml
index 9369e33c96..065712d1dc 100644
--- a/.github/ISSUE_TEMPLATE/task.yaml
+++ b/.github/ISSUE_TEMPLATE/task.yaml
@@ -1,35 +1,65 @@
-name: Tasks
-description: This is used to capture tasks being implemented/to implement such as features, maintenance, refactor, etc.
-title: "[Task]: "
-labels: ["Task"]
+name: 📋 Task
+description: A specific piece of work to be completed
+title: "📋 [TASK] "
+labels: ["task"]
+assignees: []
 body:
   - type: markdown
     attributes:
-      value: |
-        We encourage our users to submit feature requests in our [Discussion forum](https://github.com/openvinotoolkit/anomalib/discussions/categories/ideas-feature-requests). You can use this template for consistency.
-
+      value: "## 📋 Task Description"
   - type: textarea
-    id: motivation
+    id: description
     attributes:
-      label: What is the motivation for this task?
-      description: A clear and concise description of what the problem is.
-      placeholder: |
-        1. I'm always frustrated when [...]. It would be better if we could [...]
-        2. I would like to have [...] model/dataset to be supported in Anomalib.
+      label: Describe the task
+      description: Provide a clear and concise description of the task to be completed
     validations:
       required: true
   - type: textarea
-    id: solution
+    id: acceptance-criteria
     attributes:
-      label: Describe the solution you'd like
-      description: A clear and concise description of what you want to happen. Add screenshots or code-blocks if necessary.
-      placeholder: |
-        I would like to have [...] to do this we would need to [...]
-        Here is what I would like to see [...]
+      label: Acceptance Criteria
+      description: List the specific criteria that must be met for this task to be considered complete
+    validations:
+      required: true
+  - type: dropdown
+    id: priority
+    attributes:
+      label: Priority
+      options:
+        - Low
+        - Medium
+        - High
+    validations:
+      required: true
+  - type: input
+    id: epic-link
+    attributes:
+      label: Related Epic
+      description: If this task is part of an epic, provide the epic's issue number (e.g., #123)
+    validations:
+      required: false
+  - type: input
+    id: estimated-time
+    attributes:
+      label: Estimated Time
+      description: Provide an estimate of how long this task will take (e.g., 2h, 1d)
+    validations:
+      required: false
+  - type: dropdown
+    id: status
+    attributes:
+      label: Current Status
+      options:
+        - Not Started
+        - In Progress
+        - Blocked
+        - Ready for Review
     validations:
       required: true
   - type: textarea
-    id: additional-context
+    id: additional-info
     attributes:
-      label: Additional context
-      description: Add any other context or screenshots about the feature request here.
+      label: Additional Information
+      description: Any other relevant details or context for this task
+    validations:
+      required: false
diff --git a/.github/ISSUE_TEMPLATE/user_story.yaml b/.github/ISSUE_TEMPLATE/user_story.yaml
new file mode 100644
index 0000000000..c32d1e45ea
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/user_story.yaml
@@ -0,0 +1,69 @@
+name: 📖 User Story
+description: A small, self-contained unit of development work describing a feature from an end-user perspective
+title: "📖 [STORY] "
+labels: ["user-story"]
+assignees: []
+body:
+  - type: markdown
+    attributes:
+      value: "## 📖 User Story Description"
+  - type: textarea
+    id: user-story
+    attributes:
+      label: User Story
+      description: As a [type of user], I want [an action] so that [a benefit/a value]
+      placeholder: As a computer vision researcher, I want to implement a new anomaly detection algorithm so that I can improve detection accuracy for industrial defect scenarios.
+    validations:
+      required: true
+  - type: textarea
+    id: acceptance-criteria
+    attributes:
+      label: Acceptance Criteria
+      description: List the acceptance criteria for this user story
+      placeholder: |
+        1. The new algorithm is implemented and integrated into the anomalib framework
+        2. Unit tests are written and pass for the new implementation
+        3. Performance benchmarks show improvement over existing methods on specified datasets
+        4. Documentation is updated to include usage instructions and theory behind the new algorithm
+        5. An example notebook is provided demonstrating the algorithm's application
+    validations:
+      required: true
+  - type: input
+    id: story-points
+    attributes:
+      label: Story Points
+      description: Estimate the complexity of this story (e.g., 1, 2, 3, 5, 8, 13)
+    validations:
+      required: true
+  - type: input
+    id: epic-link
+    attributes:
+      label: Related Epic
+      description: If this story is part of an epic, provide the epic's issue number (e.g., #123)
+    validations:
+      required: false
+  - type: dropdown
+    id: model-category
+    attributes:
+      label: Category
+      description: Select the category this story primarily relates to
+      options:
+        - Data
+        - Anomaly Detection Algorithms
+        - Pre-processing
+        - Post-processing
+        - Evaluation Metrics
+        - Visualization
+        - Performance Optimization
+        - API/Interface
+        - Documentation
+        - Others
+    validations:
+      required: true
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add any other context, background, or relevant research papers about the user story here
+    validations:
+      required: false
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fc80fa3e7e..340641fb7c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 
+- Add `AUPIMO` tutorials notebooks in https://github.com/openvinotoolkit/anomalib/pull/2330 and https://github.com/openvinotoolkit/anomalib/pull/2336
+- Add `AUPIMO` metric by [jpcbertoldo](https://github.com/jpcbertoldo) in https://github.com/openvinotoolkit/anomalib/pull/1726 and refactored by [ashwinvaidya17](https://github.com/ashwinvaidya17) in https://github.com/openvinotoolkit/anomalib/pull/2329
+
 ### Changed
 
 ### Deprecated
diff --git a/notebooks/700_metrics/701a_aupimo.ipynb b/notebooks/700_metrics/701a_aupimo.ipynb
new file mode 100644
index 0000000000..5c5497b3b8
--- /dev/null
+++ b/notebooks/700_metrics/701a_aupimo.ipynb
@@ -0,0 +1,543 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AUPIMO\n",
+    "\n",
+    "Basic usage of the metric AUPIMO (pronounced \"a-u-pee-mo\")."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# What is AUPIMO?\n",
+    "\n",
+    "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n",
+    "\n",
+    "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n",
+    "\n",
+    "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n",
+    "\n",
+    "But:\n",
+    "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n",
+    "- the FPR (X-axis) considers the (average of) **normal** images only; \n",
+    "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n",
+    "\n",
+    "\\* The score (the area under the curve) is normalized to be in [0, 1].\n",
+    "\n",
+    "AUPIMO can be interpreted as\n",
+    "\n",
+    "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n",
+    "\n",
+    "References in the last cell.\n",
+    "\n",
+    "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Install `anomalib` using `pip`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released  # noqa: TD003\n",
+    "%pip install ../.."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Change the directory to have access to the datasets."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "# NOTE: Provide the path to the dataset root directory.\n",
+    "#   If the datasets is not downloaded, it will be downloaded\n",
+    "#   to this directory.\n",
+    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.ticker import MaxNLocator, PercentFormatter\n",
+    "from scipy import stats\n",
+    "\n",
+    "from anomalib import TaskType\n",
+    "from anomalib.data import MVTec\n",
+    "from anomalib.engine import Engine\n",
+    "from anomalib.metrics import AUPIMO\n",
+    "from anomalib.models import Padim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data Module\n",
+    "\n",
+    "We will use dataset Leather from MVTec AD. \n",
+    "\n",
+    "> See the notebooks below for more details on datamodules. \n",
+    "> [github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "task = TaskType.SEGMENTATION\n",
+    "datamodule = MVTec(\n",
+    "    root=dataset_root,\n",
+    "    category=\"leather\",\n",
+    "    image_size=256,\n",
+    "    train_batch_size=32,\n",
+    "    eval_batch_size=32,\n",
+    "    num_workers=8,\n",
+    "    task=task,\n",
+    ")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Model\n",
+    "\n",
+    "We will use `PaDiM` (performance is not the best, but it is fast to train).\n",
+    "\n",
+    "> See the notebooks below for more details on models. \n",
+    "> [github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Instantiate the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = Padim(\n",
+    "    # only use one layer to speed it up\n",
+    "    layers=[\"layer1\"],\n",
+    "    n_features=64,\n",
+    "    backbone=\"resnet18\",\n",
+    "    pre_trained=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Average AUPIMO (Basic)\n",
+    "\n",
+    "The easiest way to use AUPIMO is via the collection of pixel metrics in the engine.\n",
+    "\n",
+    "By default, the average AUPIMO is calculated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "engine = Engine(\n",
+    "    pixel_metrics=\"AUPIMO\",  # others can be added\n",
+    "    accelerator=\"auto\",  # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n",
+    "    devices=1,\n",
+    "    logger=False,\n",
+    ")\n",
+    "engine.fit(datamodule=datamodule, model=model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "F1Score class exists for backwards compatibility. It will be removed in v1.1. Please use BinaryF1Score from torchmetrics instead\n",
+      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "880e325e4e4842b2b679340ca8007849",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Testing: |          | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃        Test metric        ┃       DataLoader 0        ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│        image_AUROC        │    0.9887908697128296     │\n",
+       "│       image_F1Score       │    0.9726775884628296     │\n",
+       "│       pixel_AUPIMO        │    0.7428419829089654     │\n",
+       "└───────────────────────────┴───────────────────────────┘\n",
+       "\n"
+      ],
+      "text/plain": [
+       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+       "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+       "│\u001b[36m \u001b[0m\u001b[36m       image_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9887908697128296    \u001b[0m\u001b[35m \u001b[0m│\n",
+       "│\u001b[36m \u001b[0m\u001b[36m      image_F1Score      \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9726775884628296    \u001b[0m\u001b[35m \u001b[0m│\n",
+       "│\u001b[36m \u001b[0m\u001b[36m      pixel_AUPIMO       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.7428419829089654    \u001b[0m\u001b[35m \u001b[0m│\n",
+       "└───────────────────────────┴───────────────────────────┘\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[{'pixel_AUPIMO': 0.7428419829089654,\n",
+       "  'image_AUROC': 0.9887908697128296,\n",
+       "  'image_F1Score': 0.9726775884628296}]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# will output the AUPIMO score on the test set\n",
+    "engine.test(datamodule=datamodule, model=model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Individual AUPIMO Scores (Detailed)\n",
+    "\n",
+    "AUPIMO assigns one recall score per anomalous image in the dataset.\n",
+    "\n",
+    "It is possible to access each of the individual AUPIMO scores and look at the distribution."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Collect the predictions and the ground truth."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ckpt_path is not provided. Model weights will not be loaded.\n",
+      "F1Score class exists for backwards compatibility. It will be removed in v1.1. Please use BinaryF1Score from torchmetrics instead\n",
+      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e8116b80da39406e966c2099ecb2fdb1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Predicting: |          | 0/? [00:00"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "ax.hist(aupimo_result.aupimos.numpy(), bins=np.linspace(0, 1, 11), edgecolor=\"black\")\n",
+    "ax.set_ylabel(\"Count (number of images)\")\n",
+    "ax.yaxis.set_major_locator(MaxNLocator(5, integer=True))\n",
+    "ax.set_xlim(0, 1)\n",
+    "ax.set_xlabel(\"AUPIMO [%]\")\n",
+    "ax.xaxis.set_major_formatter(PercentFormatter(1))\n",
+    "ax.grid()\n",
+    "ax.set_title(\"AUPIMO distribution\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cite Us\n",
+    "\n",
+    "AUPIMO was developed during Google Summer of Code 2023 (GSoC 2023) with the `anomalib` team from OpenVINO Toolkit.\n",
+    "\n",
+    "Our work was accepted to the British Machine Vision Conference 2024 (BMVC 2024).\n",
+    "\n",
+    "```bibtex\n",
+    "@misc{bertoldo2024aupimo,\n",
+    "      title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n",
+    "      author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n",
+    "      year={2024},\n",
+    "      eprint={2401.01984},\n",
+    "      archivePrefix={arXiv},\n",
+    "      primaryClass={cs.CV},\n",
+    "      url={https://arxiv.org/abs/2401.01984}, \n",
+    "}\n",
+    "```\n",
+    "\n",
+    "Paper on arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n",
+    "\n",
+    "Medium post: [medium.com/p/c653ac30e802](https://medium.com/p/c653ac30e802)\n",
+    "\n",
+    "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n",
+    "\n",
+    "GSoC 2023 page: [summerofcode.withgoogle.com/archive/2023/projects/SPMopugd](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "anomalib-dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
new file mode 100644
index 0000000000..a785075060
--- /dev/null
+++ b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
@@ -0,0 +1,1433 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AUPIMO\n",
+    "\n",
+    "Advance use cases of the metric AUPIMO (pronounced \"a-u-pee-mo\").\n",
+    "\n",
+    "> For basic usage, please check the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb).\n",
+    "\n",
+    "Includes:\n",
+    "- selection of test representative samples for qualitative analysis\n",
+    "- visualization of the AUPIMO metric with heatmaps"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# What is AUPIMO?\n",
+    "\n",
+    "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n",
+    "\n",
+    "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n",
+    "\n",
+    "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n",
+    "\n",
+    "But:\n",
+    "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n",
+    "- the FPR (X-axis) considers the (average of) **normal** images only; \n",
+    "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n",
+    "\n",
+    "\\* The score (the area under the curve) is normalized to be in [0, 1].\n",
+    "\n",
+    "AUPIMO can be interpreted as\n",
+    "\n",
+    "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n",
+    "\n",
+    "References in the last cell.\n",
+    "\n",
+    "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Install `anomalib` using `pip`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released  # noqa: TD003\n",
+    "%pip install ../.."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Change the directory to have access to the datasets."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "# NOTE: Provide the path to the dataset root directory.\n",
+    "#   If the datasets is not downloaded, it will be downloaded\n",
+    "#   to this directory.\n",
+    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import matplotlib as mpl\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.ticker import PercentFormatter\n",
+    "from scipy import stats\n",
+    "\n",
+    "from anomalib import TaskType\n",
+    "from anomalib.data import MVTec\n",
+    "from anomalib.data.utils import read_image\n",
+    "from anomalib.engine import Engine\n",
+    "from anomalib.metrics import AUPIMO\n",
+    "from anomalib.models import Padim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pd.set_option(\"display.float_format\", \"{:.2f}\".format)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Basics\n",
+    "\n",
+    "This part was covered in the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb), so we'll not discuss it here.\n",
+    "\n",
+    "It will train a model and evaluate it using AUPIMO.\n",
+    "We will use dataset Leather from MVTec AD with `PaDiM` (performance is not the best, but it is fast to train).\n",
+    "\n",
+    "> See the notebooks below for more details on:\n",
+    "> - datamodules: [100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules);\n",
+    "> - models: [200_models](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# train the model\n",
+    "task = TaskType.SEGMENTATION\n",
+    "datamodule = MVTec(\n",
+    "    root=dataset_root,\n",
+    "    category=\"leather\",\n",
+    "    image_size=256,\n",
+    "    train_batch_size=32,\n",
+    "    eval_batch_size=32,\n",
+    "    num_workers=8,\n",
+    "    task=task,\n",
+    ")\n",
+    "model = Padim(\n",
+    "    # only use one layer to speed it up\n",
+    "    layers=[\"layer1\"],\n",
+    "    n_features=64,\n",
+    "    backbone=\"resnet18\",\n",
+    "    pre_trained=True,\n",
+    ")\n",
+    "engine = Engine(\n",
+    "    pixel_metrics=\"AUPIMO\",  # others can be added\n",
+    "    accelerator=\"auto\",  # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n",
+    "    devices=1,\n",
+    "    logger=False,\n",
+    ")\n",
+    "engine.fit(datamodule=datamodule, model=model)\n",
+    "# infer\n",
+    "predictions = engine.predict(dataloaders=datamodule.test_dataloader(), model=model, return_predictions=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Compute AUPIMO"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
+     ]
+    }
+   ],
+   "source": [
+    "aupimo = AUPIMO(\n",
+    "    # with `False` all the values are returned in a dataclass\n",
+    "    return_average=False,\n",
+    ")\n",
+    "\n",
+    "anomaly_maps = []\n",
+    "masks = []\n",
+    "labels = []\n",
+    "image_paths = []\n",
+    "for batch in predictions:\n",
+    "    anomaly_maps.append(batch_anomaly_maps := batch[\"anomaly_maps\"].squeeze(dim=1))\n",
+    "    masks.append(batch_masks := batch[\"mask\"])\n",
+    "    labels.append(batch[\"label\"])\n",
+    "    image_paths.append(batch[\"image_path\"])\n",
+    "    aupimo.update(anomaly_maps=batch_anomaly_maps, masks=batch_masks)\n",
+    "\n",
+    "# list[list[str]] -> list[str]\n",
+    "image_paths = [item for sublist in image_paths for item in sublist]\n",
+    "anomaly_maps = torch.cat(anomaly_maps, dim=0)\n",
+    "masks = torch.cat(masks, dim=0)\n",
+    "labels = torch.cat(labels, dim=0)\n",
+    "\n",
+    "# `pimo_result` has the PIMO curves of each image\n",
+    "# `aupimo_result` has the AUPIMO values\n",
+    "#     i.e. their Area Under the Curve (AUC)\n",
+    "pimo_result, aupimo_result = aupimo.compute()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Statistics and score distribution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MEAN\n",
+      "aupimo_result.aupimos[labels == 1].mean().item()=0.742841961578308\n",
+      "OTHER STATISTICS\n",
+      "DescribeResult(nobs=92, minmax=(0.0, 1.0), mean=0.742841961578308, variance=0.08757792704451817, skewness=-0.9285678601866055, kurtosis=-0.3299211772047075)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# the normal images have `nan` values because\n",
+    "# recall is not defined for them so we ignore them\n",
+    "print(f\"MEAN\\n{aupimo_result.aupimos[labels == 1].mean().item()=}\")\n",
+    "print(f\"OTHER STATISTICS\\n{stats.describe(aupimo_result.aupimos[labels == 1])}\")\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "ax.hist(aupimo_result.aupimos[labels == 1].numpy(), bins=np.linspace(0, 1, 11), edgecolor=\"black\")\n",
+    "ax.set_ylabel(\"Count (number of images)\")\n",
+    "ax.set_xlim(0, 1)\n",
+    "ax.set_xlabel(\"AUPIMO [%]\")\n",
+    "ax.xaxis.set_major_formatter(PercentFormatter(1))\n",
+    "ax.grid()\n",
+    "ax.set_title(\"AUPIMO distribution\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Until here we just reproduded the notebook with the basic usage of AUPIMO."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Selecting Representative Samples for Qualitative Analysis\n",
+    "\n",
+    "Instead of cherry picking or inspecting the 92 samples from above, we'll try to choose them smartly.\n",
+    "\n",
+    "Our goal here is to select a handful of samples in a meaningful way.\n",
+    "\n",
+    "> Notice that a random selection from the distribution above would probably miss the worst cases.\n",
+    "\n",
+    "We will summarize this distribution with a boxplot, then select the samples corresponding to the statistics in it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(7, 2))\n",
+    "boxplot_data = ax.boxplot(\n",
+    "    aupimo_result.aupimos[labels == 1].numpy(),\n",
+    "    vert=False,\n",
+    "    widths=0.4,\n",
+    ")\n",
+    "_ = ax.set_yticks([])\n",
+    "ax.set_xlim(0 - (eps := 2e-2), 1 + eps)\n",
+    "ax.xaxis.set_major_formatter(PercentFormatter(1))\n",
+    "ax.set_xlabel(\"AUPIMO [%]\")\n",
+    "ax.set_title(\"AUPIMO Scores Boxplot\")\n",
+    "num_images = (labels == 1).sum().item()\n",
+    "ax.annotate(\n",
+    "    text=f\"Number of images: {num_images}\",\n",
+    "    xy=(0.03, 0.95),\n",
+    "    xycoords=\"axes fraction\",\n",
+    "    xytext=(0, 0),\n",
+    "    textcoords=\"offset points\",\n",
+    "    annotation_clip=False,\n",
+    "    verticalalignment=\"top\",\n",
+    ")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To get the values in the boxplot (e.g., whiskers, quartiles, etc.), we're going to use `matplotlib`'s internal function `mpl.cbook.boxplot_stats()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys(['mean', 'iqr', 'cilo', 'cihi', 'whishi', 'whislo', 'fliers', 'q1', 'med', 'q3'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "boxplot_data = mpl.cbook.boxplot_stats(aupimo_result.aupimos[labels == 1].numpy())[0]\n",
+    "print(boxplot_data.keys())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We'll select 5 of those and find images in the dataset that match them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  statistic  value  image_index\n",
+      "0    whislo   0.00           65\n",
+      "1        q1   0.53           58\n",
+      "2       med   0.89           63\n",
+      "3        q3   1.00           22\n",
+      "4    whishi   1.00            0\n"
+     ]
+    }
+   ],
+   "source": [
+    "image_selection = []\n",
+    "\n",
+    "for key in [\"whislo\", \"q1\", \"med\", \"q3\", \"whishi\"]:\n",
+    "    value = boxplot_data[key]\n",
+    "    # find the image that is closest to the value of the statistic\n",
+    "    #     `[labels == 1]` is not used here so that the image's\n",
+    "    #         indexes are the same as the ones in the dataset\n",
+    "    #     we use `sort()` -- instead of `argmin()` -- so that\n",
+    "    #         the `nan`s are not considered (they are at the end)\n",
+    "    closest_image_index = (aupimo_result.aupimos - value).abs().argsort()[0]\n",
+    "    image_selection.append({\"statistic\": key, \"value\": value, \"image_index\": closest_image_index.item()})\n",
+    "\n",
+    "image_selection = pd.DataFrame(image_selection)\n",
+    "print(image_selection)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice that they are sorted from the worst to the best AUPIMO score."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Visualizing the Representative Samples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's visualize what the heatmaps of these samples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# will be used to normalize the anomaly maps to fit a colormap\n",
+    "global_vmin, global_vmax = torch.quantile(anomaly_maps, torch.tensor([0.02, 0.98]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, axes = plt.subplots(2, 5, figsize=(16, 7), layout=\"constrained\")\n",
+    "\n",
+    "for ax_column, (_, row) in zip(axes.T, image_selection.iterrows(), strict=False):\n",
+    "    ax_above, ax_below = ax_column\n",
+    "    image = cv2.resize(read_image(image_paths[row.image_index]), (256, 256))\n",
+    "    anomaly_map = anomaly_maps[row.image_index].numpy()\n",
+    "    mask = masks[row.image_index].squeeze().numpy()\n",
+    "    ax_above.imshow(image)\n",
+    "    ax_above.contour(mask, levels=[0.5], colors=\"magenta\", linewidths=1)\n",
+    "    ax_below.imshow(image)\n",
+    "    ax_below.imshow(anomaly_map, cmap=\"jet\", vmin=global_vmin, vmax=global_vmax, alpha=0.30)\n",
+    "    ax_below.contour(mask, levels=[0.5], colors=\"magenta\", linewidths=1)\n",
+    "    ax_above.set_title(f\"{row.statistic}: {row.value:.0%} AUPIMO  image {row.image_index}\")\n",
+    "\n",
+    "for ax in axes.flatten():\n",
+    "    ax.set_xticks([])\n",
+    "    ax.set_yticks([])\n",
+    "\n",
+    "axes[0, 0].set_ylabel(\"Image + GT Mask\")\n",
+    "axes[1, 0].set_ylabel(\"Image + GT Mask + Anomaly Map\")\n",
+    "fig.text(\n",
+    "    0.03,\n",
+    "    -0.01,\n",
+    "    \"Magenta: contours of the ground truth (GT) mask. \"\n",
+    "    \"Anomaly maps colored in JET colormap with global (across all images) min-max normalization.\",\n",
+    "    ha=\"left\",\n",
+    "    va=\"top\",\n",
+    "    fontsize=\"small\",\n",
+    "    color=\"dimgray\",\n",
+    ")\n",
+    "\n",
+    "fig.suptitle(\"Anomalous samples from AUPIMO boxplot's statistics\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The heatmaps give the impression that all samples are properly detected, right?\n",
+    "\n",
+    "Notice that the lowest AUPIMO (left) is 0, but the heatmap is (contradictorily) showing a good detection.\n",
+    "\n",
+    "Why is that?\n",
+    "\n",
+    "These heatmaps are colored with a gradient from the minimum to the maximum value in all the heatmaps from the test set.\n",
+    "\n",
+    "This is not taking into account the contraints (FPR restriction) in AUPIMO.\n",
+    "\n",
+    "Let's compare with the heatmaps from some normal images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, axes = plt.subplots(2, 5, figsize=(16, 7), layout=\"constrained\")\n",
+    "\n",
+    "# random selection of normal images\n",
+    "rng = np.random.default_rng(42)\n",
+    "normal_images_selection = rng.choice(np.where(labels == 0)[0], size=5, replace=False)\n",
+    "\n",
+    "for ax_column, index in zip(axes.T, normal_images_selection, strict=False):\n",
+    "    ax_above, ax_below = ax_column\n",
+    "    image = cv2.resize(read_image(image_paths[index]), (256, 256))\n",
+    "    anomaly_map = anomaly_maps[index].numpy()\n",
+    "    ax_above.imshow(image)\n",
+    "    ax_below.imshow(image)\n",
+    "    ax_below.imshow(anomaly_map, cmap=\"jet\", vmin=global_vmin, vmax=global_vmax, alpha=0.30)\n",
+    "    ax_above.set_title(f\"image {index}\")\n",
+    "\n",
+    "for ax in axes.flatten():\n",
+    "    ax.set_xticks([])\n",
+    "    ax.set_yticks([])\n",
+    "\n",
+    "axes[0, 0].set_ylabel(\"Image\")\n",
+    "axes[1, 0].set_ylabel(\"Image + Anomaly Map\")\n",
+    "fig.text(\n",
+    "    0.03,\n",
+    "    -0.01,\n",
+    "    \"Anomaly maps colored in JET colormap with global (across all images) min-max normalization.\",\n",
+    "    ha=\"left\",\n",
+    "    va=\"top\",\n",
+    "    fontsize=\"small\",\n",
+    "    color=\"dimgray\",\n",
+    ")\n",
+    "\n",
+    "fig.suptitle(\"Normal samples (test set)\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice how the normal images also have high anomaly scores (\"hot\" colors) although there is no anomaly.\n",
+    "\n",
+    "As a matter of fact, the heatmaps can barely differentiate between some normal and anomalous images.\n",
+    "\n",
+    "See the two heatmaps below for instance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, axes = plt.subplots(1, 2, figsize=(7, 4), layout=\"constrained\")\n",
+    "\n",
+    "for ax, index in zip(axes.flatten(), [87, 65], strict=False):\n",
+    "    image = cv2.resize(read_image(image_paths[index]), (256, 256))\n",
+    "    anomaly_map = anomaly_maps[index].numpy()\n",
+    "    mask = masks[index].squeeze().numpy()\n",
+    "    ax.imshow(image)\n",
+    "    ax.contour(mask, levels=[0.5], colors=\"magenta\", linewidths=1)\n",
+    "    ax.imshow(anomaly_map, cmap=\"jet\", vmin=global_vmin, vmax=global_vmax, alpha=0.30)\n",
+    "    ax.set_title(f\"image {index}\")\n",
+    "\n",
+    "for ax in axes.flatten():\n",
+    "    ax.set_xticks([])\n",
+    "    ax.set_yticks([])\n",
+    "\n",
+    "axes[0].set_title(f\"{axes[0].get_title()} (normal)\")\n",
+    "axes[1].set_title(f\"{axes[1].get_title()} (anomalous)\")\n",
+    "\n",
+    "fig.text(\n",
+    "    0.03,\n",
+    "    -0.01,\n",
+    "    \"Magenta: contours of the ground truth (GT) mask.\\n\"\n",
+    "    \"Anomaly maps colored in JET colormap with global (across all images) min-max normalization.\",\n",
+    "    ha=\"left\",\n",
+    "    va=\"top\",\n",
+    "    fontsize=\"small\",\n",
+    "    color=\"dimgray\",\n",
+    ")\n",
+    "\n",
+    "fig.suptitle(\"Normal vs. Anomalous Samples\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One would expect image 65 (anomalous) to a 'hotter' heatmap than image 87 (normal), but it is the opposite.\n",
+    "\n",
+    "This shows that the model is not doing a great job."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Visualizing the AUPIMO on the Heatmaps\n",
+    "\n",
+    "We will create another visualization to link the heatmaps to AUPIMO.\n",
+    "\n",
+    "Recall that AUPIMO computes this integral (simplified):\n",
+    "\n",
+    "$$\n",
+    "    \\int_{\\log(L)}^{\\log(U)} \n",
+    "    \\operatorname{TPR}^{i}\\left( \\operatorname{FRP^{-1}}( z ) \\right)\n",
+    "    \\, \n",
+    "    \\mathrm{d}\\log(z)   \n",
+    "$$\n",
+    "\n",
+    "The integration bounds -- $L$[ower] and $U$[pper] -- are FPR values.\n",
+    "\n",
+    "> More details about their meaning in the next notebook.\n",
+    "\n",
+    "We will leverage these two bounds to create a heatmap that shows them in a gradient like this:\n",
+    "\n",
+    "![Visualization of AUPIMO on the heatmaps](./pimo_viz.svg)\n",
+    "\n",
+    "If the anomaly score is\n",
+    "1. too low (below the lowest threshold of AUPIMO) $\\rightarrow$ not shown; \n",
+    "2. between the bounds $\\rightarrow$ shown in a JET gradient;\n",
+    "3. too high (above the highest threshold of AUPIMO) $\\rightarrow$ shown in a single color.\n",
+    "\n",
+    "> Technical detail: lower/upper bound of FPR correspond to the upper/lower bound of threshold.\n",
+    "\n",
+    "> **Why low values are not shown?**\n",
+    ">\n",
+    "> Because the values below the lower (threshold) bound would  _never_  be seen as \"anomalous\" by the metric.\n",
+    ">\n",
+    "> Analogously, high values are shown in red because they are  _always_  seen as \"anomalous\" by the metric."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "FPR bounds\n",
+      "Lower bound: 0.00001\n",
+      "Upper bound: 0.00010\n",
+      "Thresholds corresponding to the FPR bounds\n",
+      "Lower threshold: 0.504\n",
+      "Upper threshold: 0.553\n"
+     ]
+    }
+   ],
+   "source": [
+    "# the fpr bounds are fixed in advance in the metric object\n",
+    "print(f\"\"\"FPR bounds\n",
+    "Lower bound: {aupimo.fpr_bounds[0]:.5f}\n",
+    "Upper bound: {aupimo.fpr_bounds[1]:.5f}\"\"\")\n",
+    "\n",
+    "# their corresponding thresholds depend on the model's behavior\n",
+    "# so they only show in the result object\n",
+    "print(f\"\"\"Thresholds corresponding to the FPR bounds\n",
+    "Lower threshold: {aupimo_result.thresh_lower_bound:.3g}\n",
+    "Upper threshold: {aupimo_result.thresh_upper_bound:.3g}\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# we re-sample other normal images\n",
+    "#    the FPR bounds are so strict that the heatmaps in the normal images\n",
+    "#    become almost invisible with this colormap\n",
+    "max_anom_score_per_image = anomaly_maps.max(dim=2).values.max(dim=1).values  # noqa: PD011\n",
+    "normal_images_with_highest_max_score = sorted(\n",
+    "    zip(max_anom_score_per_image[labels == 0], torch.where(labels == 0)[0], strict=False),\n",
+    "    reverse=True,\n",
+    "    key=lambda x: x[0],\n",
+    ")\n",
+    "normal_images_with_highest_max_score = [idx.item() for _, idx in normal_images_with_highest_max_score[:5]]\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 5, figsize=(16, 7), layout=\"constrained\")\n",
+    "\n",
+    "for ax, (_, row) in zip(axes[0], image_selection.iterrows(), strict=False):\n",
+    "    image = cv2.resize(read_image(image_paths[row.image_index]), (256, 256))\n",
+    "    anomaly_map = anomaly_maps[row.image_index].numpy()\n",
+    "    mask = masks[row.image_index].squeeze().numpy()\n",
+    "    ax.imshow(image)\n",
+    "    #\n",
+    "    # where the magic happens!\n",
+    "    #\n",
+    "    ax.imshow(\n",
+    "        # anything below the lower threshold is set to `nan` so it's not shown\n",
+    "        #    because such values would never be detected as anomalies with AUPIMO's contraints\n",
+    "        np.where(anomaly_map < aupimo_result.thresh_lower_bound, np.nan, anomaly_map),\n",
+    "        cmap=\"jet\",\n",
+    "        alpha=0.50,\n",
+    "        # notice that vmin/vmax changed here to use the thresholds from the result object\n",
+    "        vmin=aupimo_result.thresh_lower_bound,\n",
+    "        vmax=aupimo_result.thresh_upper_bound,\n",
+    "    )\n",
+    "    ax.contour(anomaly_map, levels=[aupimo_result.thresh_lower_bound], colors=[\"blue\"], linewidths=1)\n",
+    "    ax.contour(mask, levels=[0.5], colors=\"magenta\", linewidths=1)\n",
+    "    ax.set_title(f\"{row.statistic}: {row.value:.0%}AUPIMO  image {row.image_index}\")\n",
+    "\n",
+    "for ax, index in zip(axes[1], normal_images_with_highest_max_score, strict=False):\n",
+    "    image = cv2.resize(read_image(image_paths[index]), (256, 256))\n",
+    "    anomaly_map = anomaly_maps[index].numpy()\n",
+    "    mask = masks[index].squeeze().numpy()\n",
+    "    ax.imshow(image)\n",
+    "    ax.imshow(\n",
+    "        np.where(anomaly_map < aupimo_result.thresh_lower_bound, np.nan, anomaly_map),\n",
+    "        cmap=\"jet\",\n",
+    "        alpha=0.30,\n",
+    "        vmin=aupimo_result.thresh_lower_bound,\n",
+    "        vmax=aupimo_result.thresh_upper_bound,\n",
+    "    )\n",
+    "    ax.contour(anomaly_map, levels=[aupimo_result.thresh_lower_bound], colors=[\"blue\"], linewidths=1)\n",
+    "    ax.set_title(f\"image {index}\")\n",
+    "\n",
+    "for ax in axes.flatten():\n",
+    "    ax.set_xticks([])\n",
+    "    ax.set_yticks([])\n",
+    "\n",
+    "axes[0, 0].set_ylabel(\"Anomalous\")\n",
+    "axes[1, 0].set_ylabel(\"Normal\")\n",
+    "fig.text(\n",
+    "    0.03,\n",
+    "    -0.01,\n",
+    "    \"Magenta: contours of the ground truth (GT) mask. \"\n",
+    "    \"Anomaly maps colored in JET colormap between the thresholds in AUPIMO's integral. \"\n",
+    "    \"Lower values are transparent, higher values are red.\",\n",
+    "    ha=\"left\",\n",
+    "    va=\"top\",\n",
+    "    fontsize=\"small\",\n",
+    "    color=\"dimgray\",\n",
+    ")\n",
+    "\n",
+    "fig.suptitle(\"Visualization linked to AUPIMO's bounds\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now the AUPIMO scores make sense with what you see in the heatmaps.\n",
+    "\n",
+    "The samples on the left and right are special cases: \n",
+    "- left (0% AUPIMO): nothing is seen because the model completely misses the anomaly\\*;\n",
+    "- right (100% AUPIMO): is practically red only because the detected the anomaly very well.  \n",
+    "\n",
+    "\\* Because the scores in image 65 are as low as those in normal images."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cite Us\n",
+    "\n",
+    "AUPIMO was developed during Google Summer of Code 2023 (GSoC 2023) with the `anomalib` team from OpenVINO Toolkit.\n",
+    "\n",
+    "Our work was accepted to the British Machine Vision Conference 2024 (BMVC 2024).\n",
+    "\n",
+    "```bibtex\n",
+    "@misc{bertoldo2024aupimo,\n",
+    "      title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n",
+    "      author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n",
+    "      year={2024},\n",
+    "      eprint={2401.01984},\n",
+    "      archivePrefix={arXiv},\n",
+    "      primaryClass={cs.CV},\n",
+    "      url={https://arxiv.org/abs/2401.01984}, \n",
+    "}\n",
+    "```\n",
+    "\n",
+    "Paper on arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n",
+    "\n",
+    "Medium post: [medium.com/p/c653ac30e802](https://medium.com/p/c653ac30e802)\n",
+    "\n",
+    "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n",
+    "\n",
+    "GSoC 2023 page: [summerofcode.withgoogle.com/archive/2023/projects/SPMopugd](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Utils\n",
+    "\n",
+    "Here we provide some utility functions to reproduce the techniques shown in this notebook.\n",
+    "\n",
+    "They are `numpy` compatible and cover edge cases not discussed here (check the examples)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Representative samples from the boxplot's statistics\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from numpy import ndarray\n",
+    "from torch import Tensor\n",
+    "\n",
+    "\n",
+    "def _validate_tensor_or_ndarray(x: Tensor | ndarray) -> ndarray:\n",
+    "    if not isinstance(x, Tensor | ndarray):\n",
+    "        msg = f\"Expected argument to be a tensor or ndarray, but got {type(x)}.\"\n",
+    "        raise TypeError(msg)\n",
+    "\n",
+    "    if isinstance(x, Tensor):\n",
+    "        x = x.cpu().numpy()\n",
+    "\n",
+    "    return x\n",
+    "\n",
+    "\n",
+    "def _validate_values(values: ndarray) -> None:\n",
+    "    if values.ndim != 1:\n",
+    "        msg = f\"Expected argument `values` to be a 1D, but got {values.ndim}D.\"\n",
+    "        raise ValueError(msg)\n",
+    "\n",
+    "\n",
+    "def _validate_labels(labels: ndarray) -> ndarray:\n",
+    "    if labels.ndim != 1:\n",
+    "        msg = f\"Expected argument `labels` to be a 1D, but got {labels.ndim}D.\"\n",
+    "        raise ValueError(msg)\n",
+    "\n",
+    "    # if torch.is_floating_point(labels):\n",
+    "    if np.issubdtype(labels.dtype, np.floating):\n",
+    "        msg = f\"Expected argument `labels` to be of int or binary types, but got float: {labels.dtype}.\"\n",
+    "        raise TypeError(msg)\n",
+    "\n",
+    "    # check if it is binary and convert to int\n",
+    "    if np.issubdtype(labels.dtype, np.bool_):\n",
+    "        labels = labels.astype(int)\n",
+    "\n",
+    "    unique_values = np.unique(labels)\n",
+    "    nor_0_nor_1 = (unique_values != 0) & (unique_values != 1)\n",
+    "    if nor_0_nor_1.any():\n",
+    "        msg = f\"Expected argument `labels` to have 0s and 1s as ground truth labels, but got values {unique_values}.\"\n",
+    "        raise ValueError(msg)\n",
+    "\n",
+    "    return labels\n",
+    "\n",
+    "\n",
+    "def boxplot_stats(\n",
+    "    values: Tensor | ndarray,\n",
+    "    labels: Tensor | ndarray,\n",
+    "    only_label: int | None = 1,\n",
+    "    flier_policy: str | None = None,\n",
+    "    repeated_policy: str | None = \"avoid\",\n",
+    ") -> list[dict[str, str | int | float | None]]:\n",
+    "    \"\"\"Compute boxplot statistics of `values` and find the samples that are closest to them.\n",
+    "\n",
+    "    This function uses `matplotlib.cbook.boxplot_stats`, which is the same function used by `matplotlib.pyplot.boxplot`.\n",
+    "\n",
+    "    Args:\n",
+    "        values (Tensor | ndarray): Values to compute boxplot statistics from.\n",
+    "        labels (Tensor | ndarray): Labels of the samples (0=normal, 1=anomalous). Must have the same shape as `values`.\n",
+    "        only_label (int | None): If 0 or 1, only use samples of that class. If None, use both. Defaults to 1.\n",
+    "        flier_policy (str | None): What happens with the fliers ('outliers')?\n",
+    "                                        - None: Do not include fliers.\n",
+    "                                        - 'high': Include only high fliers.\n",
+    "                                        - 'low': Include only low fliers.\n",
+    "                                        - 'both': Include both high and low fliers.\n",
+    "                                    Defaults to None.\n",
+    "        repeated_policy (str | None): What happens if a sample has already selected [for another statistic]?\n",
+    "                                        - None: Don't care, repeat the sample.\n",
+    "                                        - 'avoid': Avoid selecting the same one, go to the next closest.\n",
+    "                                        Defaults to 'avoid'.\n",
+    "\n",
+    "    Returns:\n",
+    "        list[dict[str, str | int | float | None]]: List of boxplot statistics.\n",
+    "            Keys:\n",
+    "                - 'statistic' (str): Name of the statistic.\n",
+    "                - 'value' (float): Value of the statistic (same units as `values`).\n",
+    "                - 'nearest' (float): Value of the sample in `values` that is closest to the statistic.\n",
+    "                            Some statistics (e.g. 'mean') are not guaranteed to be a value in `values`.\n",
+    "                            This value is the actual one when they that is the case.\n",
+    "                - 'index': Index in `values` that has the `nearest` value to the statistic.\n",
+    "    \"\"\"\n",
+    "    # operate on numpy arrays only for simplicity\n",
+    "    values = _validate_tensor_or_ndarray(values)  # (N,)\n",
+    "    labels = _validate_tensor_or_ndarray(labels)  # (N,)\n",
+    "\n",
+    "    # validate the arguments\n",
+    "    _validate_values(values)\n",
+    "    labels = _validate_labels(labels)\n",
+    "    if values.shape != labels.shape:\n",
+    "        msg = (\n",
+    "            \"Expected arguments `values` and `labels` to have the same shape, \"\n",
+    "            f\"but got {values.shape=} and {labels.shape=}.\"\n",
+    "        )\n",
+    "        raise ValueError(msg)\n",
+    "    assert only_label in {None, 0, 1}, f\"Invalid argument `only_label`: {only_label}\"\n",
+    "    assert flier_policy in {None, \"high\", \"low\", \"both\"}, f\"Invalid argument `flier_policy`: {flier_policy}\"\n",
+    "    assert repeated_policy in {None, \"avoid\"}, f\"Invalid argument `repeated_policy`: {repeated_policy}\"\n",
+    "\n",
+    "    if only_label is not None and only_label not in labels:\n",
+    "        msg = f\"Argument {only_label=} but `labels` does not contain this class.\"\n",
+    "        raise ValueError(msg)\n",
+    "\n",
+    "    # only consider samples of the given label\n",
+    "    # `values` and `labels` now have shape (n,) instead of (N,), where n <= N\n",
+    "    label_filter_mask = (labels == only_label) if only_label is not None else np.ones_like(labels, dtype=bool)\n",
+    "    values = values[label_filter_mask]  # (n,)\n",
+    "    labels = labels[label_filter_mask]  # (n,)\n",
+    "    indexes = np.nonzero(label_filter_mask)[0]  # (n,) values are indices in  {0, 1, ..., N-1}\n",
+    "\n",
+    "    indexes_selected = set()  # values in {0, 1, ..., N-1}\n",
+    "\n",
+    "    def append(records_: dict, statistic_: str, value_: float) -> None:\n",
+    "        indices_sorted_by_distance = np.abs(values - value_).argsort()  # (n,)\n",
+    "        candidate = indices_sorted_by_distance[0]  # idx that refers to {0, 1, ..., n-1}\n",
+    "\n",
+    "        nearest = values[candidate]\n",
+    "        index = indexes[candidate]  # index has value in {0, 1, ..., N-1}\n",
+    "        label = labels[candidate]\n",
+    "\n",
+    "        if index in indexes_selected and repeated_policy == \"avoid\":\n",
+    "            for candidate in indices_sorted_by_distance:\n",
+    "                index_of_candidate = indexes[candidate]\n",
+    "                if index_of_candidate in indexes_selected:\n",
+    "                    continue\n",
+    "                # if the code reaches here, it means that `index_of_candidate` is not repeated\n",
+    "                # if this is never reached, the first choice will be kept\n",
+    "                nearest = values[candidate]\n",
+    "                label = labels[candidate]\n",
+    "                index = index_of_candidate\n",
+    "                break\n",
+    "\n",
+    "        indexes_selected.add(index)\n",
+    "\n",
+    "        records_.append(\n",
+    "            {\n",
+    "                \"statistic\": statistic_,\n",
+    "                \"value\": float(value_),\n",
+    "                \"nearest\": float(nearest),\n",
+    "                \"index\": int(index),\n",
+    "                \"label\": int(label),\n",
+    "            },\n",
+    "        )\n",
+    "\n",
+    "    # function used in `matplotlib.boxplot`\n",
+    "    boxplot_stats = mpl.cbook.boxplot_stats(values)[0]  # [0] is for the only boxplot\n",
+    "\n",
+    "    records = []\n",
+    "    for stat, val in boxplot_stats.items():\n",
+    "        if stat in {\"iqr\", \"cilo\", \"cihi\"}:\n",
+    "            continue\n",
+    "\n",
+    "        if stat != \"fliers\":\n",
+    "            append(records, stat, val)\n",
+    "            continue\n",
+    "\n",
+    "        if flier_policy is None:\n",
+    "            continue\n",
+    "\n",
+    "        for val_ in val:\n",
+    "            stat_ = \"flierhi\" if val_ > boxplot_stats[\"med\"] else \"flierlo\"\n",
+    "            if flier_policy == \"high\" and stat_ == \"flierlo\":\n",
+    "                continue\n",
+    "            if flier_policy == \"low\" and stat_ == \"flierhi\":\n",
+    "                continue\n",
+    "            # else means that they match or `fliers == \"both\"`\n",
+    "            append(records, stat_, val_)\n",
+    "\n",
+    "    return sorted(records, key=lambda r: r[\"value\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Basic Usage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  statistic  value  nearest  index  label\n",
+      "0    whislo   0.00     0.00     65      1\n",
+      "1        q1   0.53     0.53     58      1\n",
+      "2      mean   0.74     0.75      7      1\n",
+      "3       med   0.89     0.89     63      1\n",
+      "4        q3   1.00     1.00     22      1\n",
+      "5    whishi   1.00     1.00      0      1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# basic usage\n",
+    "boxplot_statistics = boxplot_stats(aupimo_result.aupimos, labels)\n",
+    "boxplot_statistics = pd.DataFrame.from_records(boxplot_statistics)\n",
+    "print(boxplot_statistics)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Repeated Statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  statistic  value  nearest  index  label\n",
+      "0    whislo   0.00     0.00     67      1\n",
+      "1        q1   0.59     0.59     58      1\n",
+      "2      mean   0.78     0.79     43      1\n",
+      "3       med   0.98     0.99      9      1\n",
+      "4    whishi   1.00     1.00      0      1\n",
+      "5        q3   1.00     1.00     36      1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# repeated values\n",
+    "#   if the distribution is very skewed to one side,\n",
+    "#   some statistics may have the same value\n",
+    "#   e.g. the Q3 and the high whisker\n",
+    "#\n",
+    "#   let's simulate this situation\n",
+    "\n",
+    "# increase all values by 10% and clip to [0, 1]\n",
+    "mock = torch.clip(aupimo_result.aupimos.clone() * 1.10, 0, 1)\n",
+    "\n",
+    "# 'avoid' is the default policy\n",
+    "# notice how Q3 and the high whisker have the same value, but different indexes\n",
+    "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, repeated_policy=\"avoid\")))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  statistic  value  nearest  index  label\n",
+      "0    whislo   0.00     0.00     67      1\n",
+      "1        q1   0.59     0.59     58      1\n",
+      "2      mean   0.78     0.79     43      1\n",
+      "3       med   0.98     0.99      9      1\n",
+      "4    whishi   1.00     1.00      0      1\n",
+      "5        q3   1.00     1.00      0      1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# this behavior can be changed to allow repeated values\n",
+    "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, repeated_policy=None)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fliers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# fliers\n",
+    "#    if the distribution is very skewed to one side,\n",
+    "#    it is possible that some extreme values are considered\n",
+    "#    are considered as outliers, showing as fliers in the boxplot\n",
+    "#\n",
+    "#    there are two types of fliers: high and low\n",
+    "#    they are defined as:\n",
+    "#        - high: values > high whisker = Q3 + 1.5 * IQR\n",
+    "#        - low: values < low whisker = Q1 - 1.5 * IQR\n",
+    "#     where IQR = Q3 - Q1\n",
+    "\n",
+    "# let's artificially simulate this situation\n",
+    "#     we will create a distortion in the values so that\n",
+    "#     high values (close to 1) become even higher\n",
+    "#     and low values (close to 0) become even lower\n",
+    "\n",
+    "\n",
+    "def distortion(vals: Tensor) -> Tensor:\n",
+    "    \"\"\"Artificial distortion to simulate a skewed distribution.\n",
+    "\n",
+    "    To visualize it:\n",
+    "    ```\n",
+    "    fig, ax = plt.subplots()\n",
+    "    t = np.linspace(0, 1, 100)\n",
+    "    ax.plot(t, np.clip(distortion(t), 0, 1), label=\"distortion\")\n",
+    "    ax.plot(t, t, label=\"identity\", linestyle=\"--\")\n",
+    "    fig\n",
+    "    ```\n",
+    "    \"\"\"\n",
+    "    return vals + 0.12 * (vals * (1 - vals) * 4)\n",
+    "\n",
+    "\n",
+    "mock = torch.clip(distortion(aupimo_result.aupimos.clone()), 0, 1)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(7, 2))\n",
+    "ax.boxplot(\n",
+    "    mock[labels == 1].numpy(),\n",
+    "    vert=False,\n",
+    "    widths=0.4,\n",
+    ")\n",
+    "_ = ax.set_yticks([])\n",
+    "ax.set_xlim(0 - (eps := 2e-2), 1 + eps)\n",
+    "ax.xaxis.set_major_formatter(PercentFormatter(1))\n",
+    "ax.set_xlabel(\"AUPIMO [%]\")\n",
+    "ax.set_title(\"AUPIMO Scores Boxplot\")\n",
+    "num_images = (labels == 1).sum().item()\n",
+    "ax.annotate(\n",
+    "    text=f\"Number of images: {num_images}\",\n",
+    "    xy=(0.03, 0.95),\n",
+    "    xycoords=\"axes fraction\",\n",
+    "    xytext=(0, 0),\n",
+    "    textcoords=\"offset points\",\n",
+    "    annotation_clip=False,\n",
+    "    verticalalignment=\"top\",\n",
+    ")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  statistic  value  nearest  index  label\n",
+      "0    whislo   0.24     0.24     44      1\n",
+      "1        q1   0.65     0.65     58      1\n",
+      "2      mean   0.79     0.78     29      1\n",
+      "3       med   0.94     0.93     63      1\n",
+      "4        q3   1.00     1.00     22      1\n",
+      "5    whishi   1.00     1.00      0      1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# `None` is the default policy, so the fliers are not returned\n",
+    "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, flier_policy=None)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "with option 'low'\n",
+      "  statistic  value  nearest  index  label\n",
+      "0   flierlo   0.00     0.00     65      1\n",
+      "1   flierlo   0.00     0.00     67      1\n",
+      "2   flierlo   0.01     0.01     71      1\n",
+      "3   flierlo   0.09     0.09     64      1\n",
+      "4    whislo   0.24     0.24     44      1\n",
+      "5        q1   0.65     0.65     58      1\n",
+      "6      mean   0.79     0.78     29      1\n",
+      "7       med   0.94     0.93     63      1\n",
+      "8        q3   1.00     1.00     22      1\n",
+      "9    whishi   1.00     1.00      0      1\n",
+      "with option 'both'\n",
+      "  statistic  value  nearest  index  label\n",
+      "0   flierlo   0.00     0.00     65      1\n",
+      "1   flierlo   0.00     0.00     67      1\n",
+      "2   flierlo   0.01     0.01     71      1\n",
+      "3   flierlo   0.09     0.09     64      1\n",
+      "4    whislo   0.24     0.24     44      1\n",
+      "5        q1   0.65     0.65     58      1\n",
+      "6      mean   0.79     0.78     29      1\n",
+      "7       med   0.94     0.93     63      1\n",
+      "8        q3   1.00     1.00     22      1\n",
+      "9    whishi   1.00     1.00      0      1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# one can choose to include only high or low fliers, or both\n",
+    "# since there are only low fliers...\n",
+    "\n",
+    "# 'low' and 'both' will return the same result\n",
+    "print(\"with option 'low'\")\n",
+    "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, flier_policy=\"low\")))\n",
+    "\n",
+    "print(\"with option 'both'\")\n",
+    "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, flier_policy=\"both\")))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "with option 'high'\n",
+      "  statistic  value  nearest  index  label\n",
+      "0    whislo   0.24     0.24     44      1\n",
+      "1        q1   0.65     0.65     58      1\n",
+      "2      mean   0.79     0.78     29      1\n",
+      "3       med   0.94     0.93     63      1\n",
+      "4        q3   1.00     1.00     22      1\n",
+      "5    whishi   1.00     1.00      0      1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# and 'high' will return no fliers (same as `flier_policy=None` in this case)\n",
+    "print(\"with option 'high'\")\n",
+    "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, flier_policy=\"high\")))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Other applications and `only_label` argument"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "stats for the maximum anomaly score in the anomaly maps\n",
+      "  statistic  value  nearest  index  label\n",
+      "0    whislo   0.46     0.46     65      1\n",
+      "1        q1   0.63     0.63     48      1\n",
+      "2       med   0.70     0.71     10      1\n",
+      "3      mean   0.73     0.73    118      1\n",
+      "4        q3   0.81     0.81    115      1\n",
+      "5    whishi   1.00     1.00     22      1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# other applications\n",
+    "#    since the function is agnostic to the meaning of the values\n",
+    "#    we can also use it to find representative samples\n",
+    "#    with another metric or signal\n",
+    "#\n",
+    "#    in the last plot cell we used the maximum anomaly score per image\n",
+    "#    to select normal images, so let's reuse that criterion here\n",
+    "\n",
+    "# recompute it for didactic purposes\n",
+    "max_anom_score_per_image = anomaly_maps.max(dim=2).values.max(dim=1).values  # noqa: PD011\n",
+    "print(\"stats for the maximum anomaly score in the anomaly maps\")\n",
+    "print(pd.DataFrame.from_records(boxplot_stats(max_anom_score_per_image, labels)))\n",
+    "# notice that the indices are not the same as before"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  statistic  value  nearest  index  label\n",
+      "0    whislo   0.42     0.42     90      0\n",
+      "1        q1   0.43     0.43     80      0\n",
+      "2       med   0.45     0.45    105      0\n",
+      "3      mean   0.46     0.46     89      0\n",
+      "4        q3   0.48     0.48     75      0\n",
+      "5    whishi   0.52     0.52     95      0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# we can also use the `only_label` argument to select only the\n",
+    "# samples from the normal class\n",
+    "print(pd.DataFrame.from_records(boxplot_stats(max_anom_score_per_image, labels, only_label=0)))\n",
+    "# notice the labels are all 0 now"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  statistic  value  nearest  index  label\n",
+      "0    whislo   0.42     0.42     90      0\n",
+      "1        q1   0.52     0.52     95      0\n",
+      "2       med   0.65     0.65     17      1\n",
+      "3      mean   0.66     0.66     45      1\n",
+      "4        q3   0.77     0.77    108      1\n",
+      "5    whishi   1.00     1.00     22      1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# or we can consider data from both classes (`None` option)\n",
+    "print(pd.DataFrame.from_records(boxplot_stats(max_anom_score_per_image, labels, only_label=None)))\n",
+    "# notice that the labels are mixed"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cite Us\n",
+    "\n",
+    "AUPIMO was developed during Google Summer of Code 2023 (GSoC 2023) with the `anomalib` team from OpenVINO Toolkit.\n",
+    "\n",
+    "Our work was accepted to the British Machine Vision Conference 2024 (BMVC 2024).\n",
+    "\n",
+    "```bibtex\n",
+    "@misc{bertoldo2024aupimo,\n",
+    "      title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n",
+    "      author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n",
+    "      year={2024},\n",
+    "      eprint={2401.01984},\n",
+    "      archivePrefix={arXiv},\n",
+    "      primaryClass={cs.CV},\n",
+    "      url={https://arxiv.org/abs/2401.01984}, \n",
+    "}\n",
+    "```\n",
+    "\n",
+    "Paper on arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n",
+    "\n",
+    "Medium post: [medium.com/p/c653ac30e802](https://medium.com/p/c653ac30e802)\n",
+    "\n",
+    "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n",
+    "\n",
+    "GSoC 2023 page: [summerofcode.withgoogle.com/archive/2023/projects/SPMopugd](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "anomalib-dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
new file mode 100644
index 0000000000..ed647ef666
--- /dev/null
+++ b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
@@ -0,0 +1,936 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AUPIMO\n",
+    "\n",
+    "Advance use cases of the metric AUPIMO (pronounced \"a-u-pee-mo\").\n",
+    "\n",
+    "> For basic usage, please check the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb).\n",
+    "\n",
+    "Includes:\n",
+    "- visualization of the PIMO curve\n",
+    "- theoretical AUPIMO of a random classifier (\"baseline\")\n",
+    "- understanding the x-axis (FPR) bounds\n",
+    "- customizing the x-axis (FPR) bounds"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# What is AUPIMO?\n",
+    "\n",
+    "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n",
+    "\n",
+    "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n",
+    "\n",
+    "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n",
+    "\n",
+    "But:\n",
+    "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n",
+    "- the FPR (X-axis) considers the (average of) **normal** images only; \n",
+    "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n",
+    "\n",
+    "\\* The score (the area under the curve) is normalized to be in [0, 1].\n",
+    "\n",
+    "AUPIMO can be interpreted as\n",
+    "\n",
+    "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n",
+    "\n",
+    "References in the last cell.\n",
+    "\n",
+    "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Install `anomalib` using `pip`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released  # noqa: TD003\n",
+    "%pip install ../.."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Change the directory to have access to the datasets."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "# NOTE: Provide the path to the dataset root directory.\n",
+    "#   If the datasets is not downloaded, it will be downloaded\n",
+    "#   to this directory.\n",
+    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.axes import Axes\n",
+    "from matplotlib.ticker import FixedLocator, PercentFormatter\n",
+    "from numpy import ndarray\n",
+    "from scipy import stats\n",
+    "from torch import Tensor\n",
+    "\n",
+    "from anomalib import TaskType\n",
+    "from anomalib.data import MVTec\n",
+    "from anomalib.data.utils import read_image\n",
+    "from anomalib.engine import Engine\n",
+    "from anomalib.metrics import AUPIMO\n",
+    "from anomalib.models import Padim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Basics\n",
+    "\n",
+    "This part was covered in the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb), so we'll not discuss it here.\n",
+    "\n",
+    "It will train a model and evaluate it using AUPIMO.\n",
+    "We will use dataset Leather from MVTec AD with `PaDiM` (performance is not the best, but it is fast to train).\n",
+    "\n",
+    "> See the notebooks below for more details on:\n",
+    "> - datamodules: [100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules);\n",
+    "> - models: [200_models](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# train the model\n",
+    "task = TaskType.SEGMENTATION\n",
+    "datamodule = MVTec(\n",
+    "    root=dataset_root,\n",
+    "    category=\"leather\",\n",
+    "    image_size=256,\n",
+    "    train_batch_size=32,\n",
+    "    eval_batch_size=32,\n",
+    "    num_workers=8,\n",
+    "    task=task,\n",
+    ")\n",
+    "model = Padim(\n",
+    "    # only use one layer to speed it up\n",
+    "    layers=[\"layer1\"],\n",
+    "    n_features=64,\n",
+    "    backbone=\"resnet18\",\n",
+    "    pre_trained=True,\n",
+    ")\n",
+    "engine = Engine(\n",
+    "    pixel_metrics=\"AUPIMO\",  # others can be added\n",
+    "    accelerator=\"auto\",  # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n",
+    "    devices=1,\n",
+    "    logger=False,\n",
+    ")\n",
+    "engine.fit(datamodule=datamodule, model=model)\n",
+    "# infer\n",
+    "predictions = engine.predict(dataloaders=datamodule.test_dataloader(), model=model, return_predictions=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Compute AUPIMO"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
+     ]
+    }
+   ],
+   "source": [
+    "aupimo = AUPIMO(\n",
+    "    # with `False` all the values are returned in a dataclass\n",
+    "    return_average=False,\n",
+    ")\n",
+    "\n",
+    "anomaly_maps = []\n",
+    "masks = []\n",
+    "labels = []\n",
+    "image_paths = []\n",
+    "for batch in predictions:\n",
+    "    anomaly_maps.append(batch_anomaly_maps := batch[\"anomaly_maps\"].squeeze(dim=1))\n",
+    "    masks.append(batch_masks := batch[\"mask\"])\n",
+    "    labels.append(batch[\"label\"])\n",
+    "    image_paths.append(batch[\"image_path\"])\n",
+    "    aupimo.update(anomaly_maps=batch_anomaly_maps, masks=batch_masks)\n",
+    "\n",
+    "# list[list[str]] -> list[str]\n",
+    "image_paths = [item for sublist in image_paths for item in sublist]\n",
+    "anomaly_maps = torch.cat(anomaly_maps, dim=0)\n",
+    "masks = torch.cat(masks, dim=0)\n",
+    "labels = torch.cat(labels, dim=0)\n",
+    "\n",
+    "# `pimo_result` has the PIMO curves of each image\n",
+    "# `aupimo_result` has the AUPIMO values\n",
+    "#     i.e. their Area Under the Curve (AUC)\n",
+    "pimo_result, aupimo_result = aupimo.compute()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Statistics and score distribution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MEAN\n",
+      "aupimo_result.aupimos[labels == 1].mean().item()=0.742841961578308\n",
+      "OTHER STATISTICS\n",
+      "DescribeResult(nobs=92, minmax=(0.0, 1.0), mean=0.742841961578308, variance=0.08757792704451818, skewness=-0.9285678601866053, kurtosis=-0.3299211772047079)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# the normal images have `nan` values because\n",
+    "# recall is not defined for them so we ignore them\n",
+    "print(f\"MEAN\\n{aupimo_result.aupimos[labels == 1].mean().item()=}\")\n",
+    "print(f\"OTHER STATISTICS\\n{stats.describe(aupimo_result.aupimos[labels == 1])}\")\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "ax.hist(aupimo_result.aupimos[labels == 1].numpy(), bins=np.linspace(0, 1, 11), edgecolor=\"black\")\n",
+    "ax.set_ylabel(\"Count (number of images)\")\n",
+    "ax.set_xlim(0, 1)\n",
+    "ax.set_xlabel(\"AUPIMO [%]\")\n",
+    "ax.xaxis.set_major_formatter(PercentFormatter(1))\n",
+    "ax.grid()\n",
+    "ax.set_title(\"AUPIMO distribution\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Until here we just reproduded the notebook with the basic usage of AUPIMO."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# The PIMO curve \n",
+    "\n",
+    "We'll select a bunch of images to visualize the PIMO curves.\n",
+    "\n",
+    "To make sure we have best and worst detection examples, we'll use the representative samples selected in the previous notebook ([701b_aupimo_advanced_i.ipynb](./701b_aupimo_advanced_i.ipynb)).\n",
+    "\n",
+    "> Note the FPR (X-axis) is the average (in-image) FPR of the normal images in the test set. We'll note it as `FPRn`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# representative samples (in terms of the AUPIMO value)\n",
+    "# from lowest to highest AUPIMO score\n",
+    "samples = [65, 7, 58, 63, 22]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fmt_pow10(value: float) -> str:\n",
+    "    \"\"\"Format the power of 10.\"\"\"\n",
+    "    return \"1\" if value == 1 else f\"$10^{{{int(np.log10(value))}}}$\"\n",
+    "\n",
+    "\n",
+    "def plot_pimo_with_auc_zone(\n",
+    "    ax: Axes,\n",
+    "    tpr: ndarray,\n",
+    "    fpr: ndarray,\n",
+    "    lower_bound: float,\n",
+    "    upper_bound: float,\n",
+    "    fpr_in_auc: ndarray,\n",
+    "    tpr_in_auc: ndarray,\n",
+    ") -> None:\n",
+    "    \"\"\"Helper function to plot the PIMO curve with the AUC zone.\"\"\"\n",
+    "    # plot\n",
+    "    ax.plot(fpr, tpr, linewidth=3.5)\n",
+    "    ax.axvspan(lower_bound, upper_bound, color=\"magenta\", alpha=0.3, zorder=-1)\n",
+    "    ax.fill_between(fpr_in_auc, tpr_in_auc, alpha=1, color=\"tab:purple\", zorder=1)\n",
+    "\n",
+    "    # config plots\n",
+    "    ax.set_ylabel(\"TPR [%]\")\n",
+    "    ax.yaxis.set_major_locator(FixedLocator(np.linspace(0, 1, 6)))\n",
+    "    ax.yaxis.set_major_formatter(PercentFormatter(1, 0, symbol=\"\"))\n",
+    "    ax.set_ylim(0, 1 + 3e-2)\n",
+    "    ax.set_xlabel(\"FPRn\")\n",
+    "    ax.set_xscale(\"log\")\n",
+    "    ax.xaxis.set_major_locator(FixedLocator(np.logspace(-6, 0, 7)))\n",
+    "    ax.xaxis.set_major_formatter(lambda x, _: fmt_pow10(x))\n",
+    "    ax.set_xlim(1e-6 / (eps := (1 + 3e-1)), 1 * eps)\n",
+    "    ax.grid()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(2, 3, figsize=(10, 5), layout=\"tight\")\n",
+    "\n",
+    "for ax, index in zip(axes.flatten(), samples, strict=False):\n",
+    "    score = aupimo_result.aupimos[index].item()\n",
+    "    tpr = pimo_result.per_image_tprs[index]\n",
+    "    fpr = pimo_result.shared_fpr\n",
+    "    lower_bound, upper_bound = aupimo.fpr_bounds\n",
+    "    threshs_auc_mask = (pimo_result.thresholds > aupimo_result.thresh_lower_bound) & (\n",
+    "        pimo_result.thresholds < aupimo_result.thresh_upper_bound\n",
+    "    )\n",
+    "    fpr_in_auc = fpr[threshs_auc_mask]\n",
+    "    tpr_in_auc = tpr[threshs_auc_mask]\n",
+    "\n",
+    "    plot_pimo_with_auc_zone(ax, tpr, fpr, lower_bound, upper_bound, fpr_in_auc, tpr_in_auc)\n",
+    "    ax.set_title(f\"Image {index} ({score:.0%} AUPIMO)\")\n",
+    "\n",
+    "axes[-1, -1].axis(\"off\")\n",
+    "axes[-1, -1].text(\n",
+    "    -0.08,\n",
+    "    0,\n",
+    "    \"\"\"\n",
+    "FPRn: Avg. [in-image] False Positive Rate (FPR)\n",
+    "      on normal images only ('n').\n",
+    "\n",
+    "TPR: [in-image] True Positive Rate (TPR),\n",
+    "     or Recall.\n",
+    "\n",
+    "Integration zone in light pink, and area\n",
+    "under the curve (AUC) in purple.\n",
+    "\n",
+    "This area is normalized by the range size\n",
+    "so that AUPIMO is in [0, 1].\n",
+    "\"\"\",\n",
+    "    ha=\"left\",\n",
+    "    va=\"bottom\",\n",
+    "    fontsize=\"x-small\",\n",
+    "    color=\"dimgray\",\n",
+    "    font=\"monospace\",\n",
+    ")\n",
+    "\n",
+    "fig.suptitle(\"PIMO curves\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Meaning of the FPRn bounds\n",
+    "\n",
+    "AUPIMOo only uses _normal images_ in the X-axis -- i.e. the $\\operatorname{FPRn}$.\n",
+    "\n",
+    "**Why?** \n",
+    "\n",
+    "Because the integration range is a validation\\* of \"usable operating thresholds\", so using $\\operatorname{FPRn}$ makes it unbiased (to the anomalies).\n",
+    "\n",
+    "> Recall that, in practice, a threshold is set to decide if a pixel/image is anomalous.\n",
+    "> \n",
+    "> This strategy was inspired on [AUPRO](https://link.springer.com/article/10.1007/s11263-020-01400-4).\n",
+    "\n",
+    "---\n",
+    "\n",
+    "**Definition 1**: Average FPR on Normal Images ($\\operatorname{FPRn}$):\n",
+    "\n",
+    "$$\n",
+    "    \\operatorname{FPRn} : t \\mapsto \\frac{1}{N} \\sum_{i=1}^{N} \\; \\times \\; \\operatorname{FPR}^{i}(t)\n",
+    "$$\n",
+    "\n",
+    "where $i$ and $N$ are, respectively, the index and the number of normal images in the test set. Note that $\\operatorname{FPRn}$ is the empirical average of $\\operatorname{FPR}^{i}$, so \n",
+    "\n",
+    "$$\n",
+    "    \\operatorname{FPRn} \\approx \\mathbb{E} \\left[ \\operatorname{FPR}^{i} \\right]\n",
+    "$$\n",
+    "\n",
+    "**Defintion 2**: FPR of the $i$-th normal image ($\\operatorname{FPR}^{i}$): \n",
+    "\n",
+    "$$\n",
+    "    \\operatorname{FPR}^{i} : t \\mapsto \\frac{\\text{Area of } \\mathbb{a}^{i} \\text{ above } t}{\\text{Area of } \\mathbb{a}^{i}}\n",
+    "$$\n",
+    "\n",
+    "where $\\mathbb{a}^{i}$ is the anomaly score map of the $i$-th image.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "No further ado, let's visualize this $\\operatorname{FPRn}$!\n",
+    "\n",
+    "> For more details on this topic, check our paper in the last cell."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualizing the FPR of normal images ($\\operatorname{FPR}^{i}$)\n",
+    "\n",
+    "$\\operatorname{FPRn}$ is the average of $\\operatorname{FPR}^{i}$, so let's first visualize the latter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# visalization of $FPR^i$\n",
+    "#   since normal images do not have anomalous pixels\n",
+    "#   their FPR actually correspond to the ratio of pixels\n",
+    "#   (wrongly) classified as anomalous\n",
+    "\n",
+    "# we'll visualize 3 levels of FPR^(i) on some normal images\n",
+    "FRP_levels = [1e-2, 1e-3, 1e-4]\n",
+    "# technical detail: decreasing order of FPR --> increasing order of threshold\n",
+    "\n",
+    "\n",
+    "def threshold_from_fpr(anomaly_map: Tensor, fpr_level: float | Tensor) -> float:\n",
+    "    \"\"\"Find the threshold that corresponds to the given FPR level.\n",
+    "\n",
+    "    Args:\n",
+    "        anomaly_map (torch.Tensor): Anomaly map, assumed to be from a normal image.\n",
+    "        fpr_level (float): Desired FPR level.\n",
+    "\n",
+    "    Returns:\n",
+    "        float: Threshold such that `(anomaly_map > threshold).mean() == fpr_level`.\n",
+    "    \"\"\"\n",
+    "    # make a dicothomic search\n",
+    "    lower, upper = anomaly_map.min(), anomaly_map.max()  # initial bounds\n",
+    "    middle = (lower + upper) / 2\n",
+    "    fpr_level = torch.tensor(fpr_level)\n",
+    "\n",
+    "    def fpr(threshold: Tensor) -> Tensor:\n",
+    "        return (anomaly_map > threshold).float().mean()\n",
+    "\n",
+    "    while not torch.isclose(fpr(middle), fpr_level, rtol=1e-2):\n",
+    "        if torch.isclose(lower, upper, rtol=1e-3):\n",
+    "            break\n",
+    "        if fpr(middle) < fpr_level:\n",
+    "            upper = middle\n",
+    "        else:\n",
+    "            lower = middle\n",
+    "        middle = (lower + upper) / 2\n",
+    "    return middle.item()\n",
+    "\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 3, figsize=(13, 5), layout=\"constrained\")\n",
+    "\n",
+    "# select normal images with low and high mean anomaly scores\n",
+    "avg_anom_score_per_image = anomaly_maps.mean(dim=(1, 2))\n",
+    "# get the indices of the normal images sorted by their mean anomaly score\n",
+    "argsort = avg_anom_score_per_image.sort().indices\n",
+    "argsort = argsort[torch.isin(argsort, torch.where(labels == 0)[0])]\n",
+    "# select first, median and last\n",
+    "normal_images_selection = argsort[[0, len(argsort) // 2, -1]]\n",
+    "\n",
+    "# heatmaps will be normalized across *normal* images\n",
+    "# so the range of thresholds have an exact mapping to the range of [0, 1] in FPRn\n",
+    "# PS: it is not exactly true because we don't get a min-max, but a quantile-based normalization\n",
+    "global_normal_vmin, global_normal_vmax = torch.quantile(anomaly_maps[labels == 0], torch.tensor([0.02, 0.98]))\n",
+    "\n",
+    "for ax, index in zip(axes, normal_images_selection, strict=False):\n",
+    "    image = cv2.resize(read_image(image_paths[index]), (256, 256))\n",
+    "    anomaly_map = anomaly_maps[index]\n",
+    "    thresholds = [threshold_from_fpr(anomaly_map, fpr_level) for fpr_level in FRP_levels]\n",
+    "    anomaly_map = anomaly_map.numpy()\n",
+    "\n",
+    "    ax.imshow(image)\n",
+    "    ax.imshow(anomaly_map, cmap=\"jet\", alpha=0.10, vmin=global_normal_vmin, vmax=global_normal_vmax)\n",
+    "    c = ax.contour(anomaly_map, levels=thresholds, linewidths=1, colors=[\"blue\", \"yellow\", \"red\"])\n",
+    "    ax.set_title(f\"image {index}\")\n",
+    "\n",
+    "for ax in axes.flatten():\n",
+    "    ax.set_xticks([])\n",
+    "    ax.set_yticks([])\n",
+    "\n",
+    "fig.text(\n",
+    "    0.03,\n",
+    "    -0.01,\n",
+    "    \"Anomaly maps colored in JET colormap with min-max normalization across all normal images. \"\n",
+    "    \"     $\\\\operatorname{FPR}^{i}$ levels:   \"\n",
+    "    f\"Blue = {fmt_pow10(FRP_levels[0])}  Yellow = {fmt_pow10(FRP_levels[1])}  Red = {fmt_pow10(FRP_levels[2])}\",\n",
+    "    ha=\"left\",\n",
+    "    va=\"top\",\n",
+    "    color=\"dimgray\",\n",
+    ")\n",
+    "\n",
+    "fig.suptitle(\"Contours of $\\\\operatorname{FPR}^{i}$ levels on normal samples from the test set\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A few notes about the different FPR levels:\n",
+    "- $10^{-2}$ (blue): images have many and/or quite visible false positive regions;\n",
+    "- $10^{-3}$ (yellow): most regions disappear, but a few are still visible; \n",
+    "- $10^{-4}$ (red): usually one or two regions, barely visible."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualizing the Average FPR on Normal Images ($\\operatorname{FPRn}$)\n",
+    "\n",
+    "Let's now visualize the $\\operatorname{FPRn}$ and the variance of $\\operatorname{FPR}^{i}$ across the normal images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# visalization of $FPRn$\n",
+    "#    this one is an average behavior of the previous\n",
+    "#    so one should expect a similar behavior but with\n",
+    "#    some variations at each FPR level\n",
+    "\n",
+    "# we'll visualize the same FPR levels\n",
+    "FRP_levels = [1e-2, 1e-3, 1e-4]\n",
+    "# technical detail: decreasing order of FPR --> increasing order of threshold\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 3, figsize=(14, 5.2), layout=\"constrained\")\n",
+    "\n",
+    "# function `threshold_from_fpr()` is replaced by an equivalent function\n",
+    "# for FPRn is already implemented in `pimo_result.thresh_at`\n",
+    "thresholds = [pimo_result.thresh_at(fpr_level)[1] for fpr_level in FRP_levels]\n",
+    "# note that all images used the same (ie 'shared') thresholds now\n",
+    "\n",
+    "# `normal_images_selection` is the same from the previous cell\n",
+    "for ax, index in zip(axes, normal_images_selection, strict=False):\n",
+    "    image = cv2.resize(read_image(image_paths[index]), (256, 256))\n",
+    "    anomaly_map = anomaly_maps[index]\n",
+    "    fprs = [(anomaly_map > threshold).float().mean() for threshold in thresholds]\n",
+    "    anomaly_map = anomaly_map.numpy()\n",
+    "\n",
+    "    ax.imshow(image)\n",
+    "    # `global_normal_vmin` and `global_normal_vmax` are the same from the previous cell\n",
+    "    ax.imshow(anomaly_map, cmap=\"jet\", alpha=0.10, vmin=global_normal_vmin, vmax=global_normal_vmax)\n",
+    "    c = ax.contour(anomaly_map, levels=thresholds, linewidths=1, colors=[\"blue\", \"yellow\", \"red\"])\n",
+    "    ax.set_title(f\"image {index}\")\n",
+    "\n",
+    "    ax.annotate(\n",
+    "        \"$\\\\operatorname{FPR}^{i}$ levels: \"\n",
+    "        f\"Blue = {fprs[0] * 100:.1g}%    Yellow = {fprs[1] * 100:.1g}%    Red = {fprs[2] * 100:.1g}%\",\n",
+    "        xy=(0.01, 0.01),\n",
+    "        xycoords=\"axes fraction\",\n",
+    "        ha=\"left\",\n",
+    "        va=\"bottom\",\n",
+    "        color=\"white\",\n",
+    "    )\n",
+    "\n",
+    "for ax in axes.flatten():\n",
+    "    ax.set_xticks([])\n",
+    "    ax.set_yticks([])\n",
+    "\n",
+    "fig.text(\n",
+    "    0.03,\n",
+    "    -0.01,\n",
+    "    \"Anomaly maps colored in JET colormap with min-max normalization across all normal images. \"\n",
+    "    \"     $\\\\operatorname{FPRn}$ levels:   \"\n",
+    "    f\"Blue = {fmt_pow10(FRP_levels[0])}    Yellow = {fmt_pow10(FRP_levels[1])}    Red = {fmt_pow10(FRP_levels[2])}\",\n",
+    "    ha=\"left\",\n",
+    "    va=\"top\",\n",
+    "    color=\"dimgray\",\n",
+    ")\n",
+    "\n",
+    "fig.suptitle(\"Contours of $\\\\operatorname{FPRn}$ levels on normal samples from the test set\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Discussion\n",
+    "\n",
+    "#### Variance\n",
+    "\n",
+    "Note that each $\\operatorname{FPR}^{i}$ has a wide variance\\* of visual results across images.\n",
+    " \n",
+    "For instance, the blue level ranges from 0.2% to 3%, which visually is a huge difference, and the red level doesn't even show in most images.\n",
+    "\n",
+    "This variance is specific to each model-dataset, we observed many state-of-the-art models on the datasets from MVTec-AD and VisA, and we noticed that low levels tend to have a negligible visual variance.\n",
+    "\n",
+    "#### Default bounds (L and U)\n",
+    "\n",
+    "So how were the default bounds chosen?\n",
+    "\n",
+    "> Recall: \n",
+    "> \n",
+    "> $$\n",
+    ">     \\text{AUPIMO} \n",
+    ">     \\; = \\; \n",
+    ">     \\frac{1}{\\log(U/L)}\n",
+    ">     \\int_{\\log(L)}^{\\log(U)} \n",
+    ">     \\operatorname{TPR}^{i}\\left( \\operatorname{FRPn^{-1}}( z ) \\right)\n",
+    ">     \\, \n",
+    ">     \\mathrm{d}\\log(z)   \n",
+    "> $$\n",
+    "\n",
+    "##### Upper bound U = 10^{-4}\n",
+    "\n",
+    "The upper bound $U$ sets the requirement level of the detection task.\n",
+    "\n",
+    "The lower the $U$, the harder the task, and ideally we'd like it be zero (i.e. anomalies are detected with no false positives).\n",
+    "\n",
+    "Compared to the images' content, the regions at $\\operatorname{FPRn} = 10^{-4}$ are _visually negligible_\\*.\n",
+    " \n",
+    "##### Lower bound L = 10^{-5}\n",
+    "\n",
+    "The lower bound $L$ has two numerical motivations.\n",
+    "\n",
+    "First, AUPIMO's integral is in log scale, so necessarily $L > 0$ and more weight is given to lower FPR levels.\n",
+    "\n",
+    "Second, images/masks/anomaly maps have finite resolution ($\\approx 10^{6}$ pixels/image\\*) -- so $\\operatorname{FPR}^{i}$ and $\\operatorname{FPRn}$ have discrete ranges.\n",
+    "\n",
+    "At $\\operatorname{FPRn} = 10^{-5}$, the discretization effects are still reasonable.\n",
+    "\n",
+    "##### Be careful!\n",
+    "\n",
+    "\\* These observations are based on the datasets we analyzed (from MVTec-AD and VisA).\n",
+    "\n",
+    "For other datasets, the default bounds may not be the best choice.\n",
+    "\n",
+    "Fortunately, AUPIMO allows customizing the bounds!\n",
+    "\n",
+    "> More details on these topics in our paper (see the last cell)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Custom FPRn bounds\n",
+    "\n",
+    "It's very easy to customize the $\\operatorname{FPRn}$ bounds $L$ and $U$ in AUPIMO.\n",
+    "\n",
+    "You can guess from the signature:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[0;31mInit signature:\u001b[0m\n",
+      "\u001b[0mAUPIMO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
+      "\u001b[0;34m\u001b[0m    \u001b[0mnum_thresholds\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m300000\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+      "\u001b[0;34m\u001b[0m    \u001b[0mfpr_bounds\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1e-05\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.0001\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+      "\u001b[0;34m\u001b[0m    \u001b[0mreturn_average\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+      "\u001b[0;34m\u001b[0m    \u001b[0mforce\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+      "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mDocstring:\u001b[0m     \n",
+      "Area Under the Per-Image Overlap (PIMO) curve.\n",
+      "\n",
+      "This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code.\n",
+      "The tensors are converted to numpy arrays and then passed and validated in the numpy code.\n",
+      "The results are converted back to tensors and wrapped in an dataclass object.\n",
+      "\n",
+      "Scores are computed from the integration of the PIMO curves within the given FPR bounds, then normalized to [0, 1].\n",
+      "It can be thought of as the average TPR of the PIMO curves within the given FPR bounds.\n",
+      "\n",
+      "Details: `anomalib.metrics.per_image.pimo`.\n",
+      "\n",
+      "Notation:\n",
+      "    N: number of images\n",
+      "    H: image height\n",
+      "    W: image width\n",
+      "    K: number of thresholds\n",
+      "\n",
+      "Attributes:\n",
+      "    anomaly_maps: floating point anomaly score maps of shape (N, H, W)\n",
+      "    masks: binary (bool or int) ground truth masks of shape (N, H, W)\n",
+      "\n",
+      "Args:\n",
+      "    num_thresholds: number of thresholds to compute (K)\n",
+      "    fpr_bounds: lower and upper bounds of the FPR integration range\n",
+      "    force: whether to force the computation despite bad conditions\n",
+      "\n",
+      "Returns:\n",
+      "    tuple[PIMOResult, AUPIMOResult]: PIMO and AUPIMO results dataclass objects. See `PIMOResult` and `AUPIMOResult`.\n",
+      "\u001b[0;31mInit docstring:\u001b[0m\n",
+      "Area Under the Per-Image Overlap (PIMO) curve.\n",
+      "\n",
+      "Args:\n",
+      "    num_thresholds: [passed to parent `PIMO`] number of thresholds used to compute the PIMO curve\n",
+      "    fpr_bounds: lower and upper bounds of the FPR integration range\n",
+      "    return_average: if True, return the average AUPIMO score; if False, return all the individual AUPIMO scores\n",
+      "    force: if True, force the computation of the AUPIMO scores even in bad conditions (e.g. few points)\n",
+      "\u001b[0;31mFile:\u001b[0m           ~/miniconda3/envs/anomalib-dev/lib/python3.10/site-packages/anomalib/metrics/pimo/pimo.py\n",
+      "\u001b[0;31mType:\u001b[0m           ABCMeta\n",
+      "\u001b[0;31mSubclasses:\u001b[0m     "
+     ]
+    }
+   ],
+   "source": [
+    "AUPIMO?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's recompute the scores with the following situation: \n",
+    "- $U = 10^{-2}$ to make the detection task easier;\n",
+    "- $L = 10^{-4}$ assuming that \"small\" anomalies are not important for the application."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
+     ]
+    }
+   ],
+   "source": [
+    "aupimo_custom = AUPIMO(\n",
+    "    # with `False` all the values are returned in a dataclass\n",
+    "    return_average=False,\n",
+    "    # customized!\n",
+    "    fpr_bounds=(1e-4, 1e-2),\n",
+    ")\n",
+    "\n",
+    "# we already have all of them in concatenated tensors\n",
+    "# so we don't need to loop over the batches like before\n",
+    "aupimo_custom.update(anomaly_maps=anomaly_maps, masks=masks)\n",
+    "pimo_result_custom, aupimo_result_custom = aupimo_custom.compute()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(2, 3, figsize=(10, 5), layout=\"tight\")\n",
+    "\n",
+    "for ax, index in zip(axes.flatten(), samples, strict=False):\n",
+    "    score = aupimo_result_custom.aupimos[index].item()\n",
+    "    tpr = pimo_result_custom.per_image_tprs[index]\n",
+    "    fpr = pimo_result_custom.shared_fpr\n",
+    "    lower_bound, upper_bound = aupimo_custom.fpr_bounds\n",
+    "    threshs_auc_mask = (pimo_result_custom.thresholds > aupimo_result_custom.thresh_lower_bound) & (\n",
+    "        pimo_result_custom.thresholds < aupimo_result_custom.thresh_upper_bound\n",
+    "    )\n",
+    "    fpr_in_auc = fpr[threshs_auc_mask]\n",
+    "    tpr_in_auc = tpr[threshs_auc_mask]\n",
+    "\n",
+    "    plot_pimo_with_auc_zone(ax, tpr, fpr, lower_bound, upper_bound, fpr_in_auc, tpr_in_auc)\n",
+    "    ax.set_title(f\"Image {index} ({score:.0%} AUPIMO)\")\n",
+    "\n",
+    "axes[-1, -1].axis(\"off\")\n",
+    "axes[-1, -1].text(\n",
+    "    -0.08,\n",
+    "    0,\n",
+    "    \"\"\"\n",
+    "FPRn: Avg. [in-image] False Positive Rate (FPR)\n",
+    "      on normal images only ('n').\n",
+    "\n",
+    "TPR: [in-image] True Positive Rate (TPR),\n",
+    "     or Recall.\n",
+    "\n",
+    "Integration zone in light pink, and area\n",
+    "under the curve (AUC) in purple.\n",
+    "\n",
+    "This area is normalized by the range size\n",
+    "so that AUPIMO is in [0, 1].\n",
+    "\"\"\",\n",
+    "    ha=\"left\",\n",
+    "    va=\"bottom\",\n",
+    "    fontsize=\"x-small\",\n",
+    "    color=\"dimgray\",\n",
+    "    font=\"monospace\",\n",
+    ")\n",
+    "\n",
+    "fig.suptitle(\"PIMO curves\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice how the AUPIMO score increased with the easier task :) "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cite Us\n",
+    "\n",
+    "AUPIMO was developed during Google Summer of Code 2023 (GSoC 2023) with the `anomalib` team from OpenVINO Toolkit.\n",
+    "\n",
+    "Our work was accepted to the British Machine Vision Conference 2024 (BMVC 2024).\n",
+    "\n",
+    "```bibtex\n",
+    "@misc{bertoldo2024aupimo,\n",
+    "      title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n",
+    "      author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n",
+    "      year={2024},\n",
+    "      eprint={2401.01984},\n",
+    "      archivePrefix={arXiv},\n",
+    "      primaryClass={cs.CV},\n",
+    "      url={https://arxiv.org/abs/2401.01984}, \n",
+    "}\n",
+    "```\n",
+    "\n",
+    "Paper on arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n",
+    "\n",
+    "Medium post: [medium.com/p/c653ac30e802](https://medium.com/p/c653ac30e802)\n",
+    "\n",
+    "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n",
+    "\n",
+    "GSoC 2023 page: [summerofcode.withgoogle.com/archive/2023/projects/SPMopugd](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "anomalib-dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb b/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb
new file mode 100644
index 0000000000..6d446d171e
--- /dev/null
+++ b/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb
@@ -0,0 +1,372 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AUPIMO Score of a Random Model\n",
+    "\n",
+    "If model randomly assigns scores to the pixels -- i.e. no discrimination -- its AUROC score will be 50%. \n",
+    "\n",
+    "What would be its AUPIMO score?\n",
+    "\n",
+    "> AUPIMO is pronounced \"a-u-pee-mo\".\n",
+    "\n",
+    "> For basic usage, please check the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb).\n",
+    "\n",
+    "> For PIMO curve plots, please check the notebook [701c_aupimo_advanced_ii.ipynb](./701c_aupimo_advanced_ii.ipynb)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# What is AUPIMO?\n",
+    "\n",
+    "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n",
+    "\n",
+    "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n",
+    "\n",
+    "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n",
+    "\n",
+    "But:\n",
+    "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n",
+    "- the FPR (X-axis) considers the (average of) **normal** images only; \n",
+    "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n",
+    "\n",
+    "\\* The score (the area under the curve) is normalized to be in [0, 1].\n",
+    "\n",
+    "AUPIMO can be interpreted as\n",
+    "\n",
+    "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n",
+    "\n",
+    "References in the last cell.\n",
+    "\n",
+    "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Install `anomalib` using `pip`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released  # noqa: TD003\n",
+    "%pip install ../.."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.axes import Axes\n",
+    "from matplotlib.ticker import FixedLocator, PercentFormatter\n",
+    "from numpy import ndarray"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Random Model\n",
+    "\n",
+    "If a model cannot discriminate between normal and anomalous images, the survival fuctions\\* of the anomaly scores conditioned to each class would be the same.\n",
+    "\n",
+    "> \\* https://en.wikipedia.org/wiki/Survival_function\n",
+    "\n",
+    "In other words, FPR and TPR would be the same.\n",
+    "\n",
+    "Let's simulate this situation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "thresholds = torch.linspace(0, 1, 1001)\n",
+    "\n",
+    "# fpr and tpr as a function of the threshold (i.e. the survival functions)\n",
+    "# generaly look like logistic functions flipped horizontally\n",
+    "# their actual shapes don't matter much, but rather how they compare to each other\n",
+    "# in this case, since they're the same, this choice is arbitrary as long as\n",
+    "# they're monotonically decreasing with the threshold\n",
+    "fpr = 1 - 1e2 / (1e2 + torch.exp(-20 * (thresholds - 0.5)))\n",
+    "tpr = fpr.clone()\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(8, 2), constrained_layout=True, sharey=True)\n",
+    "\n",
+    "axes[0].plot(thresholds, fpr, label=\"FPR\")\n",
+    "axes[1].plot(thresholds, tpr, label=\"TPR\")\n",
+    "\n",
+    "for ax in axes:\n",
+    "    ax.set_xlabel(\"Threshold\")\n",
+    "    ax.legend(loc=\"upper right\")\n",
+    "    ax.set_yticks([0, 0.5, 1])\n",
+    "    ax.set_xticks([])\n",
+    "    ax.grid()\n",
+    "\n",
+    "fig.supylabel(\"FPR or TPR\", x=-0.03)\n",
+    "fig.suptitle(\"Simulated FPR and TPR curves\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PIMO curve\n",
+    "\n",
+    "In the ROC curve, the FPR = TPR looks like a straight line.\n",
+    "\n",
+    "What does it look like in the PIMO curve?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# utility plot functions (from the previous notebook)\n",
+    "\n",
+    "\n",
+    "def fmt_pow10(value: float) -> str:\n",
+    "    \"\"\"Format the power of 10.\"\"\"\n",
+    "    return \"1\" if value == 1 else f\"$10^{{{int(np.log10(value))}}}$\"\n",
+    "\n",
+    "\n",
+    "def plot_pimo_with_auc_zone(\n",
+    "    ax: Axes,\n",
+    "    tpr: ndarray,\n",
+    "    fpr: ndarray,\n",
+    "    lower_bound: float,\n",
+    "    upper_bound: float,\n",
+    "    fpr_in_auc: ndarray,\n",
+    "    tpr_in_auc: ndarray,\n",
+    ") -> None:\n",
+    "    \"\"\"Helper function to plot the PIMO curve with the AUC zone.\"\"\"\n",
+    "    # plot\n",
+    "    ax.plot(fpr, tpr, linewidth=3.5)\n",
+    "    ax.axvspan(lower_bound, upper_bound, color=\"magenta\", alpha=0.3, zorder=-1)\n",
+    "    ax.fill_between(fpr_in_auc, tpr_in_auc, alpha=1, color=\"tab:purple\", zorder=1)\n",
+    "\n",
+    "    # config plots\n",
+    "    ax.set_ylabel(\"TPR [%]\")\n",
+    "    ax.yaxis.set_major_locator(FixedLocator(np.linspace(0, 1, 6)))\n",
+    "    ax.yaxis.set_major_formatter(PercentFormatter(1, 0, symbol=\"\"))\n",
+    "    ax.set_ylim(0, 1 + 3e-2)\n",
+    "    ax.set_xlabel(\"FPR\")\n",
+    "    ax.set_xscale(\"log\")\n",
+    "    ax.xaxis.set_major_locator(FixedLocator(np.logspace(-6, 0, 7)))\n",
+    "    ax.xaxis.set_major_formatter(lambda x, _: fmt_pow10(x))\n",
+    "    ax.set_xlim(1e-6 / (eps := (1 + 3e-1)), 1 * eps)\n",
+    "    ax.grid()\n",
+    "\n",
+    "\n",
+    "# simulate a random model's curve\n",
+    "lower_bound, upper_bound = 1e-5, 1e-4\n",
+    "threshs_auc_mask = (fpr > lower_bound) & (fpr < upper_bound)\n",
+    "fpr_in_auc = fpr[threshs_auc_mask]\n",
+    "tpr_in_auc = tpr[threshs_auc_mask]\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(6, 4.5))\n",
+    "plot_pimo_with_auc_zone(ax, tpr, fpr, lower_bound, upper_bound, fpr_in_auc, tpr_in_auc)\n",
+    "\n",
+    "fig.text(\n",
+    "    0.15,\n",
+    "    -0.01,\n",
+    "    \"\"\"\n",
+    "FPR: Avg. [in-image] False Positive Rate (FPR) on normal images only.\n",
+    "\n",
+    "TPR: [in-image] True Positive Rate (TPR), or Recall.\n",
+    "\n",
+    "Integration zone in light pink, and area under the curve (AUC) in purple.\n",
+    "\n",
+    "This area is normalized by the range size so that AUPIMO is in [0, 1].\n",
+    "\"\"\",\n",
+    "    ha=\"left\",\n",
+    "    va=\"top\",\n",
+    "    fontsize=\"x-small\",\n",
+    "    color=\"dimgray\",\n",
+    "    font=\"monospace\",\n",
+    ")\n",
+    "\n",
+    "fig.suptitle(\"Random model's PIMO curve\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AUPIMO Score\n",
+    "\n",
+    "Recall that AUPIMO is computed from this integral:\n",
+    "\n",
+    "$$\n",
+    "    \\frac{1}{\\log(U/L)}\n",
+    "    \\int_{\\log(L)}^{\\log(U)} \n",
+    "    \\operatorname{TPR}^{i}\\left( \\operatorname{FRP^{-1}}( z ) \\right)\n",
+    "    \\, \n",
+    "    \\mathrm{d}\\log(z)   \n",
+    "$$\n",
+    "\n",
+    "where the integration bounds -- $L$[ower] and $U$[pper] -- are the FPR bounds.\n",
+    "\n",
+    "By assuming $\\operatorname{TPR}^{i} = \\operatorname{FPR}$, the AUPIMO score only depends on the FPR bounds:\n",
+    "\n",
+    "$$\n",
+    "    \\text{AUPIMO of a random model} = \\frac{U - L}{\\log(U/L)}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "random_model_aupimo(1e-4, 1e-5)=0.004%\n"
+     ]
+    }
+   ],
+   "source": [
+    "def random_model_aupimo(lower_bound: float, upper_bound: float) -> float:\n",
+    "    \"\"\"AUPIMO score obtained by a random model (no class discrimination).\"\"\"\n",
+    "    return (upper_bound - lower_bound) / np.log(upper_bound / lower_bound)\n",
+    "\n",
+    "\n",
+    "print(f\"{random_model_aupimo(1e-4, 1e-5)=:.3%}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice how a random model's AUPIMO score of $0.004%$ is numerically neglegible in the scale up to 100% -- while its AUROC is 50%.\n",
+    "\n",
+    "It's easier to interpret the meaning of AUPIMO scores: \n",
+    "- $0$%: random or worse, \n",
+    "- $100$%: perfect."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cite Us\n",
+    "\n",
+    "AUPIMO was developed during Google Summer of Code 2023 (GSoC 2023) with the `anomalib` team from OpenVINO Toolkit.\n",
+    "\n",
+    "Our work was accepted to the British Machine Vision Conference 2024 (BMVC 2024).\n",
+    "\n",
+    "```bibtex\n",
+    "@misc{bertoldo2024aupimo,\n",
+    "      title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n",
+    "      author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n",
+    "      year={2024},\n",
+    "      eprint={2401.01984},\n",
+    "      archivePrefix={arXiv},\n",
+    "      primaryClass={cs.CV},\n",
+    "      url={https://arxiv.org/abs/2401.01984}, \n",
+    "}\n",
+    "```\n",
+    "\n",
+    "Paper on arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n",
+    "\n",
+    "Medium post: [medium.com/p/c653ac30e802](https://medium.com/p/c653ac30e802)\n",
+    "\n",
+    "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n",
+    "\n",
+    "GSoC 2023 page: [summerofcode.withgoogle.com/archive/2023/projects/SPMopugd](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "anomalib-dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/700_metrics/pimo_viz.svg b/notebooks/700_metrics/pimo_viz.svg
new file mode 100644
index 0000000000..962c95f463
--- /dev/null
+++ b/notebooks/700_metrics/pimo_viz.svg
@@ -0,0 +1,619 @@
+
+
+
+image/svg+xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+PIMO
+
+
+
+
+
+i
+
+
+
+
+
+AUPIMO
+
+
+
+
+
+i
+
+
+Recall(t)
+
+
+Upper bound
+
+
+Lower bound
+
+
+FPR(t)
+
+
+⇒
+
+Recall(t)
+
+Upper bound
+
+Lower bound
+
+t [anomaly score threholds]
+
+Transparent(never detected as anomalous)
+
+RED(always detectedas anomalous)
+
+JET(AUPIMO range)
+
+
diff --git a/notebooks/700_metrics/roc_pro_pimo.svg b/notebooks/700_metrics/roc_pro_pimo.svg
new file mode 100644
index 0000000000..b580e89d17
--- /dev/null
+++ b/notebooks/700_metrics/roc_pro_pimo.svg
@@ -0,0 +1,690 @@
+
+
+
+image/svg+xmlEach curve summarizesthe test set with di
+
+
+ff
+
+
+erent aggregations.
+
+
+ROC
+
+
+PRO
+
+
+One per image!
+
+
+AUROC
+
+
+AUPRO
+
+
+AUPIMO
+
+
+PIMO
+
+
+i
+
+
+i
+
+
+Recall
+
+
diff --git a/notebooks/README.md b/notebooks/README.md
index 36976a6855..15935b93cf 100644
--- a/notebooks/README.md
+++ b/notebooks/README.md
@@ -51,3 +51,12 @@ To install Python, Git and other required tools, [OpenVINO Notebooks](https://gi
 | ---------------------- | ------------------------------------------------------------------------------------------------------------- | ----- |
 | Dobot Dataset Creation | [501a_training](/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb) |       |
 | Training               | [501b_training](/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb)                   |       |
+
+## 7. Metrics
+
+| Notebook                                        | GitHub                                                                            | Colab                                                                                                                                                                                                          |
+| ----------------------------------------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AUPIMO basics                                   | [701a_aupimo](/notebooks/700_metrics/701a_aupimo.ipynb)                           | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701a_aupimo.ipynb)              |
+| AUPIMO representative samples and visualization | [701b_aupimo_advanced_i](/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb)     | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb)   |
+| PIMO curve and integration bounds               | [701c_aupimo_advanced_ii](/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb)  |
+| (AU)PIMO of a random model                      | [701d_aupimo_advanced_iii](/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb) |
diff --git a/pyproject.toml b/pyproject.toml
index 9709c1a112..2893ad20c4 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,7 @@
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
 # SETUP CONFIGURATION.                                                        #
 [build-system]
-requires = ["setuptools>=42", "wheel"]
+requires = ["setuptools>=64.0.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -46,7 +46,7 @@ core = [
     "matplotlib>=3.4.3",
     "opencv-python>=4.5.3.56",
     "pandas>=1.1.0",
-    "timm<=1.0.7,>=1.0.7",
+    "timm",
     "lightning>=2.2",
     "torch>=2",
     "torchmetrics>=1.3.2",
diff --git a/src/anomalib/cli/pipelines.py b/src/anomalib/cli/pipelines.py
index a76e57c298..8cfb04fd2e 100644
--- a/src/anomalib/cli/pipelines.py
+++ b/src/anomalib/cli/pipelines.py
@@ -6,13 +6,13 @@
 import logging
 
 from jsonargparse import Namespace
+from lightning_utilities.core.imports import package_available
 
 from anomalib.cli.utils.help_formatter import get_short_docstring
-from anomalib.utils.exceptions import try_import
 
 logger = logging.getLogger(__name__)
 
-if try_import("anomalib.pipelines"):
+if package_available("anomalib.pipelines"):
     from anomalib.pipelines import Benchmark
     from anomalib.pipelines.components.base import Pipeline
 
diff --git a/src/anomalib/cli/utils/openvino.py b/src/anomalib/cli/utils/openvino.py
index 40046ac615..ee54bf09b2 100644
--- a/src/anomalib/cli/utils/openvino.py
+++ b/src/anomalib/cli/utils/openvino.py
@@ -6,13 +6,12 @@
 import logging
 
 from jsonargparse import ArgumentParser
-
-from anomalib.utils.exceptions import try_import
+from lightning_utilities.core.imports import package_available
 
 logger = logging.getLogger(__name__)
 
 
-if try_import("openvino"):
+if package_available("openvino"):
     from openvino.tools.ovc.cli_parser import get_common_cli_parser
 else:
     get_common_cli_parser = None
diff --git a/src/anomalib/data/datasets/depth/folder_3d.py b/src/anomalib/data/datasets/depth/folder_3d.py
index 9ec78487b3..a176674ff0 100644
--- a/src/anomalib/data/datasets/depth/folder_3d.py
+++ b/src/anomalib/data/datasets/depth/folder_3d.py
@@ -110,7 +110,7 @@ def name(self) -> str:
         return self._name
 
 
-def make_folder3d_dataset(  # noqa: C901
+def make_folder3d_dataset(
     normal_dir: str | Path,
     root: str | Path | None = None,
     abnormal_dir: str | Path | None = None,
@@ -164,37 +164,28 @@ def make_folder3d_dataset(  # noqa: C901
         msg = "A folder location must be provided in normal_dir."
         raise ValueError(msg)
 
-    filenames = []
-    labels = []
-    dirs = {DirType.NORMAL: normal_dir}
-
-    if abnormal_dir:
-        dirs[DirType.ABNORMAL] = abnormal_dir
-
-    if normal_test_dir:
-        dirs[DirType.NORMAL_TEST] = normal_test_dir
-
-    if normal_depth_dir:
-        dirs[DirType.NORMAL_DEPTH] = normal_depth_dir
-
-    if abnormal_depth_dir:
-        dirs[DirType.ABNORMAL_DEPTH] = abnormal_depth_dir
-
-    if normal_test_depth_dir:
-        dirs[DirType.NORMAL_TEST_DEPTH] = normal_test_depth_dir
-
-    if mask_dir:
-        dirs[DirType.MASK] = mask_dir
-
-    for dir_type, path in dirs.items():
-        filename, label = _prepare_files_labels(path, dir_type, extensions)
-        filenames += filename
-        labels += label
+    dirs = {
+        DirType.NORMAL: normal_dir,
+        DirType.ABNORMAL: abnormal_dir,
+        DirType.NORMAL_TEST: normal_test_dir,
+        DirType.NORMAL_DEPTH: normal_depth_dir,
+        DirType.ABNORMAL_DEPTH: abnormal_depth_dir,
+        DirType.NORMAL_TEST_DEPTH: normal_test_depth_dir,
+        DirType.MASK: mask_dir,
+    }
+
+    filenames: list[Path] = []
+    labels: list[str] = []
+
+    for dir_type, dir_path in dirs.items():
+        if dir_path is not None:
+            filename, label = _prepare_files_labels(dir_path, dir_type, extensions)
+            filenames += filename
+            labels += label
 
     samples = DataFrame({"image_path": filenames, "label": labels})
     samples = samples.sort_values(by="image_path", ignore_index=True)
 
-    # Create label index for normal (0) and abnormal (1) images.
     samples.loc[
         (samples.label == DirType.NORMAL) | (samples.label == DirType.NORMAL_TEST),
         "label_index",
@@ -223,9 +214,12 @@ def make_folder3d_dataset(  # noqa: C901
             .all()
         )
         if not mismatch:
-            msg = """Mismatch between anomalous images and depth images. Make sure the mask files
-            in 'xyz' folder follow the same naming convention as the anomalous images in the dataset
-            (e.g. image: '000.png', depth: '000.tiff')."""
+            msg = (
+                "Mismatch between anomalous images and depth images. "
+                "Make sure the mask files in 'xyz' folder follow the same naming "
+                "convention as the anomalous images in the dataset"
+                "(e.g. image: '000.png', depth: '000.tiff')."
+            )
             raise MisMatchError(msg)
 
         missing_depth_files = samples.depth_path.apply(
@@ -245,7 +239,7 @@ def make_folder3d_dataset(  # noqa: C901
         samples["mask_path"] = samples["mask_path"].fillna("")
         samples = samples.astype({"mask_path": "str"})
 
-        # make sure all the files exist
+        # Make sure all the files exist
         if not samples.mask_path.apply(
             lambda x: Path(x).exists() if x != "" else True,
         ).all():
@@ -254,7 +248,7 @@ def make_folder3d_dataset(  # noqa: C901
     else:
         samples["mask_path"] = ""
 
-    # remove all the rows with temporal image samples that have already been assigned
+    # Remove all the rows with temporal image samples that have already been assigned
     samples = samples.loc[
         (samples.label == DirType.NORMAL) | (samples.label == DirType.ABNORMAL) | (samples.label == DirType.NORMAL_TEST)
     ]
diff --git a/src/anomalib/data/utils/path.py b/src/anomalib/data/utils/path.py
index 9c3f56273b..7bc61b27fe 100644
--- a/src/anomalib/data/utils/path.py
+++ b/src/anomalib/data/utils/path.py
@@ -142,13 +142,20 @@ def contains_non_printable_characters(path: str | Path) -> bool:
     return not printable_pattern.match(str(path))
 
 
-def validate_path(path: str | Path, base_dir: str | Path | None = None, should_exist: bool = True) -> Path:
+def validate_path(
+    path: str | Path,
+    base_dir: str | Path | None = None,
+    should_exist: bool = True,
+    extensions: tuple[str, ...] | None = None,
+) -> Path:
     """Validate the path.
 
     Args:
         path (str | Path): Path to validate.
         base_dir (str | Path): Base directory to restrict file access.
         should_exist (bool): If True, do not raise an exception if the path does not exist.
+        extensions (tuple[str, ...] | None): Accepted extensions for the path. An exception is raised if the
+            path does not have one of the accepted extensions. If None, no check is performed. Defaults to None.
 
     Returns:
         Path: Validated path.
@@ -213,6 +220,11 @@ def validate_path(path: str | Path, base_dir: str | Path | None = None, should_e
             msg = f"Read or execute permissions denied for the path: {path}"
             raise PermissionError(msg)
 
+    # Check if the path has one of the accepted extensions
+    if extensions is not None and path.suffix not in extensions:
+        msg = f"Path extension is not accepted. Accepted extensions: {extensions}. Path: {path}"
+        raise ValueError(msg)
+
     return path
 
 
diff --git a/src/anomalib/loggers/wandb.py b/src/anomalib/loggers/wandb.py
index 0a23c25192..55e65e6d54 100644
--- a/src/anomalib/loggers/wandb.py
+++ b/src/anomalib/loggers/wandb.py
@@ -9,13 +9,12 @@
 from lightning.fabric.utilities.types import _PATH
 from lightning.pytorch.loggers.wandb import WandbLogger
 from lightning.pytorch.utilities import rank_zero_only
+from lightning_utilities.core.imports import package_available
 from matplotlib.figure import Figure
 
-from anomalib.utils.exceptions import try_import
-
 from .base import ImageLoggerBase
 
-if try_import("wandb"):
+if package_available("wandb"):
     import wandb
 
 if TYPE_CHECKING:
diff --git a/src/anomalib/metrics/__init__.py b/src/anomalib/metrics/__init__.py
index 4c3eafa811..81bab3c93f 100644
--- a/src/anomalib/metrics/__init__.py
+++ b/src/anomalib/metrics/__init__.py
@@ -19,6 +19,7 @@
 from .f1_max import F1Max
 from .f1_score import F1Score
 from .min_max import MinMax
+from .pimo import AUPIMO, PIMO
 from .precision_recall_curve import BinaryPrecisionRecallCurve
 from .pro import PRO
 from .threshold import F1AdaptiveThreshold, ManualThreshold
@@ -35,6 +36,8 @@
     "ManualThreshold",
     "MinMax",
     "PRO",
+    "PIMO",
+    "AUPIMO",
 ]
 
 logger = logging.getLogger(__name__)
diff --git a/src/anomalib/metrics/pimo/__init__.py b/src/anomalib/metrics/pimo/__init__.py
new file mode 100644
index 0000000000..174f546e4d
--- /dev/null
+++ b/src/anomalib/metrics/pimo/__init__.py
@@ -0,0 +1,23 @@
+"""Per-Image Metrics."""
+
+# Original Code
+# https://github.com/jpcbertoldo/aupimo
+#
+# Modified
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .binary_classification_curve import ThresholdMethod
+from .pimo import AUPIMO, PIMO, AUPIMOResult, PIMOResult
+
+__all__ = [
+    # constants
+    "ThresholdMethod",
+    # result classes
+    "PIMOResult",
+    "AUPIMOResult",
+    # torchmetrics interfaces
+    "PIMO",
+    "AUPIMO",
+    "StatsOutliersPolicy",
+]
diff --git a/src/anomalib/metrics/pimo/_validate.py b/src/anomalib/metrics/pimo/_validate.py
new file mode 100644
index 0000000000..f0ba7af4bf
--- /dev/null
+++ b/src/anomalib/metrics/pimo/_validate.py
@@ -0,0 +1,427 @@
+"""Utils for validating arguments and results.
+
+TODO(jpcbertoldo): Move validations to a common place and reuse them across the codebase.
+https://github.com/openvinotoolkit/anomalib/issues/2093
+"""
+
+# Original Code
+# https://github.com/jpcbertoldo/aupimo
+#
+# Modified
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+import torch
+from torch import Tensor
+
+from .utils import images_classes_from_masks
+
+logger = logging.getLogger(__name__)
+
+
+def is_num_thresholds_gte2(num_thresholds: int) -> None:
+    """Validate the number of thresholds is a positive integer >= 2."""
+    if not isinstance(num_thresholds, int):
+        msg = f"Expected the number of thresholds to be an integer, but got {type(num_thresholds)}"
+        raise TypeError(msg)
+
+    if num_thresholds < 2:
+        msg = f"Expected the number of thresholds to be larger than 1, but got {num_thresholds}"
+        raise ValueError(msg)
+
+
+def is_same_shape(*args) -> None:
+    """Works both for tensors and ndarrays."""
+    assert len(args) > 0
+    shapes = sorted({tuple(arg.shape) for arg in args})
+    if len(shapes) > 1:
+        msg = f"Expected arguments to have the same shape, but got {shapes}"
+        raise ValueError(msg)
+
+
+def is_rate(rate: float | int, zero_ok: bool, one_ok: bool) -> None:
+    """Validates a rate parameter.
+
+    Args:
+        rate (float | int): The rate to be validated.
+        zero_ok (bool): Flag indicating if rate can be 0.
+        one_ok (bool): Flag indicating if rate can be 1.
+    """
+    if not isinstance(rate, float | int):
+        msg = f"Expected rate to be a float or int, but got {type(rate)}."
+        raise TypeError(msg)
+
+    if rate < 0.0 or rate > 1.0:
+        msg = f"Expected rate to be in [0, 1], but got {rate}."
+        raise ValueError(msg)
+
+    if not zero_ok and rate == 0.0:
+        msg = "Rate cannot be 0."
+        raise ValueError(msg)
+
+    if not one_ok and rate == 1.0:
+        msg = "Rate cannot be 1."
+        raise ValueError(msg)
+
+
+def is_rate_range(bounds: tuple[float, float]) -> None:
+    """Validates the range of rates within the bounds.
+
+    Args:
+        bounds (tuple[float, float]): The lower and upper bounds of the rates.
+    """
+    if not isinstance(bounds, tuple):
+        msg = f"Expected the bounds to be a tuple, but got {type(bounds)}"
+        raise TypeError(msg)
+
+    if len(bounds) != 2:
+        msg = f"Expected the bounds to be a tuple of length 2, but got {len(bounds)}"
+        raise ValueError(msg)
+
+    lower, upper = bounds
+    is_rate(lower, zero_ok=False, one_ok=False)
+    is_rate(upper, zero_ok=False, one_ok=True)
+
+    if lower >= upper:
+        msg = f"Expected the upper bound to be larger than the lower bound, but got {upper=} <= {lower=}"
+        raise ValueError(msg)
+
+
+def is_valid_threshold(thresholds: Tensor) -> None:
+    """Validate that the thresholds are valid and monotonically increasing."""
+    if not isinstance(thresholds, Tensor):
+        msg = f"Expected thresholds to be an Tensor, but got {type(thresholds)}"
+        raise TypeError(msg)
+
+    if thresholds.ndim != 1:
+        msg = f"Expected thresholds to be 1D, but got {thresholds.ndim}"
+        raise ValueError(msg)
+
+    if not thresholds.dtype.is_floating_point:
+        msg = f"Expected thresholds to be of float type, but got Tensor with dtype {thresholds.dtype}"
+        raise TypeError(msg)
+
+    # make sure they are strictly increasing
+    if not torch.all(torch.diff(thresholds) > 0):
+        msg = "Expected thresholds to be strictly increasing, but it is not."
+        raise ValueError(msg)
+
+
+def validate_threshold_bounds(threshold_bounds: tuple[float, float]) -> None:
+    if not isinstance(threshold_bounds, tuple):
+        msg = f"Expected threshold bounds to be a tuple, but got {type(threshold_bounds)}."
+        raise TypeError(msg)
+
+    if len(threshold_bounds) != 2:
+        msg = f"Expected threshold bounds to be a tuple of length 2, but got {len(threshold_bounds)}."
+        raise ValueError(msg)
+
+    lower, upper = threshold_bounds
+
+    if not isinstance(lower, float):
+        msg = f"Expected lower threshold bound to be a float, but got {type(lower)}."
+        raise TypeError(msg)
+
+    if not isinstance(upper, float):
+        msg = f"Expected upper threshold bound to be a float, but got {type(upper)}."
+        raise TypeError(msg)
+
+    if upper <= lower:
+        msg = f"Expected the upper bound to be greater than the lower bound, but got {upper} <= {lower}."
+        raise ValueError(msg)
+
+
+def is_anomaly_maps(anomaly_maps: Tensor) -> None:
+    if anomaly_maps.ndim != 3:
+        msg = f"Expected anomaly maps have 3 dimensions (N, H, W), but got {anomaly_maps.ndim} dimensions"
+        raise ValueError(msg)
+
+    if not anomaly_maps.dtype.is_floating_point:
+        msg = (
+            "Expected anomaly maps to be an floating Tensor with anomaly scores,"
+            f" but got Tensor with dtype {anomaly_maps.dtype}"
+        )
+        raise TypeError(msg)
+
+
+def is_masks(masks: Tensor) -> None:
+    if masks.ndim != 3:
+        msg = f"Expected masks have 3 dimensions (N, H, W), but got {masks.ndim} dimensions"
+        raise ValueError(msg)
+
+    if masks.dtype == torch.bool:
+        pass
+    elif masks.dtype.is_floating_point:
+        msg = (
+            "Expected masks to be an integer or boolean Tensor with ground truth labels, "
+            f"but got Tensor with dtype {masks.dtype}"
+        )
+        raise TypeError(msg)
+    else:
+        # assumes the type to be (signed or unsigned) integer
+        # this will change with the dataclass refactor
+        masks_unique_vals = torch.unique(masks)
+        if torch.any((masks_unique_vals != 0) & (masks_unique_vals != 1)):
+            msg = (
+                "Expected masks to be a *binary* Tensor with ground truth labels, "
+                f"but got Tensor with unique values {sorted(masks_unique_vals)}"
+            )
+            raise ValueError(msg)
+
+
+def is_binclf_curves(binclf_curves: Tensor, valid_thresholds: Tensor | None) -> None:
+    if binclf_curves.ndim != 4:
+        msg = f"Expected binclf curves to be 4D, but got {binclf_curves.ndim}D"
+        raise ValueError(msg)
+
+    if binclf_curves.shape[-2:] != (2, 2):
+        msg = f"Expected binclf curves to have shape (..., 2, 2), but got {binclf_curves.shape}"
+        raise ValueError(msg)
+
+    if binclf_curves.dtype != torch.int64:
+        msg = f"Expected binclf curves to have dtype int64, but got {binclf_curves.dtype}."
+        raise TypeError(msg)
+
+    if (binclf_curves < 0).any():
+        msg = "Expected binclf curves to have non-negative values, but got negative values."
+        raise ValueError(msg)
+
+    neg = binclf_curves[:, :, 0, :].sum(axis=-1)  # (num_images, num_thresholds)
+
+    if (neg != neg[:, :1]).any():
+        msg = "Expected binclf curves to have the same number of negatives per image for every thresh."
+        raise ValueError(msg)
+
+    pos = binclf_curves[:, :, 1, :].sum(axis=-1)  # (num_images, num_thresholds)
+
+    if (pos != pos[:, :1]).any():
+        msg = "Expected binclf curves to have the same number of positives per image for every thresh."
+        raise ValueError(msg)
+
+    if valid_thresholds is None:
+        return
+
+    if binclf_curves.shape[1] != valid_thresholds.shape[0]:
+        msg = (
+            "Expected the binclf curves to have as many confusion matrices as the thresholds sequence, "
+            f"but got {binclf_curves.shape[1]} and {valid_thresholds.shape[0]}"
+        )
+        raise RuntimeError(msg)
+
+
+def is_images_classes(images_classes: Tensor) -> None:
+    if images_classes.ndim != 1:
+        msg = f"Expected image classes to be 1D, but got {images_classes.ndim}D."
+        raise ValueError(msg)
+
+    if images_classes.dtype == torch.bool:
+        pass
+    elif images_classes.dtype.is_floating_point:
+        msg = (
+            "Expected image classes to be an integer or boolean Tensor with ground truth labels, "
+            f"but got Tensor with dtype {images_classes.dtype}"
+        )
+        raise TypeError(msg)
+    else:
+        # assumes the type to be (signed or unsigned) integer
+        # this will change with the dataclass refactor
+        unique_vals = torch.unique(images_classes)
+        if torch.any((unique_vals != 0) & (unique_vals != 1)):
+            msg = (
+                "Expected image classes to be a *binary* Tensor with ground truth labels, "
+                f"but got Tensor with unique values {sorted(unique_vals)}"
+            )
+            raise ValueError(msg)
+
+
+def is_rates(rates: Tensor, nan_allowed: bool) -> None:
+    if rates.ndim != 1:
+        msg = f"Expected rates to be 1D, but got {rates.ndim}D."
+        raise ValueError(msg)
+
+    if not rates.dtype.is_floating_point:
+        msg = f"Expected rates to have dtype of float type, but got {rates.dtype}."
+        raise ValueError(msg)
+
+    isnan_mask = torch.isnan(rates)
+    if nan_allowed:
+        # if they are all nan, then there is nothing to validate
+        if isnan_mask.all():
+            return
+        valid_values = rates[~isnan_mask]
+    elif isnan_mask.any():
+        msg = "Expected rates to not contain NaN values, but got NaN values."
+        raise ValueError(msg)
+    else:
+        valid_values = rates
+
+    if (valid_values < 0).any():
+        msg = "Expected rates to have values in the interval [0, 1], but got values < 0."
+        raise ValueError(msg)
+
+    if (valid_values > 1).any():
+        msg = "Expected rates to have values in the interval [0, 1], but got values > 1."
+        raise ValueError(msg)
+
+
+def is_rate_curve(rate_curve: Tensor, nan_allowed: bool, decreasing: bool) -> None:
+    is_rates(rate_curve, nan_allowed=nan_allowed)
+
+    diffs = torch.diff(rate_curve)
+    diffs_valid = diffs[~torch.isnan(diffs)] if nan_allowed else diffs
+
+    if decreasing and (diffs_valid > 0).any():
+        msg = "Expected rate curve to be monotonically decreasing, but got non-monotonically decreasing values."
+        raise ValueError(msg)
+
+    if not decreasing and (diffs_valid < 0).any():
+        msg = "Expected rate curve to be monotonically increasing, but got non-monotonically increasing values."
+        raise ValueError(msg)
+
+
+def is_per_image_rate_curves(rate_curves: Tensor, nan_allowed: bool, decreasing: bool | None) -> None:
+    if rate_curves.ndim != 2:
+        msg = f"Expected per-image rate curves to be 2D, but got {rate_curves.ndim}D."
+        raise ValueError(msg)
+
+    if not rate_curves.dtype.is_floating_point:
+        msg = f"Expected per-image rate curves to have dtype of float type, but got {rate_curves.dtype}."
+        raise ValueError(msg)
+
+    isnan_mask = torch.isnan(rate_curves)
+    if nan_allowed:
+        # if they are all nan, then there is nothing to validate
+        if isnan_mask.all():
+            return
+        valid_values = rate_curves[~isnan_mask]
+    elif isnan_mask.any():
+        msg = "Expected per-image rate curves to not contain NaN values, but got NaN values."
+        raise ValueError(msg)
+    else:
+        valid_values = rate_curves
+
+    if (valid_values < 0).any():
+        msg = "Expected per-image rate curves to have values in the interval [0, 1], but got values < 0."
+        raise ValueError(msg)
+
+    if (valid_values > 1).any():
+        msg = "Expected per-image rate curves to have values in the interval [0, 1], but got values > 1."
+        raise ValueError(msg)
+
+    if decreasing is None:
+        return
+
+    diffs = torch.diff(rate_curves, axis=1)
+    diffs_valid = diffs[~torch.isnan(diffs)] if nan_allowed else diffs
+
+    if decreasing and (diffs_valid > 0).any():
+        msg = (
+            "Expected per-image rate curves to be monotonically decreasing, "
+            "but got non-monotonically decreasing values."
+        )
+        raise ValueError(msg)
+
+    if not decreasing and (diffs_valid < 0).any():
+        msg = (
+            "Expected per-image rate curves to be monotonically increasing, "
+            "but got non-monotonically increasing values."
+        )
+        raise ValueError(msg)
+
+
+def is_scores_batch(scores_batch: torch.Tensor) -> None:
+    """scores_batch (torch.Tensor): floating (N, D)."""
+    if not isinstance(scores_batch, torch.Tensor):
+        msg = f"Expected `scores_batch` to be an torch.Tensor, but got {type(scores_batch)}"
+        raise TypeError(msg)
+
+    if not scores_batch.dtype.is_floating_point:
+        msg = (
+            "Expected `scores_batch` to be an floating torch.Tensor with anomaly scores_batch,"
+            f" but got torch.Tensor with dtype {scores_batch.dtype}"
+        )
+        raise TypeError(msg)
+
+    if scores_batch.ndim != 2:
+        msg = f"Expected `scores_batch` to be 2D, but got {scores_batch.ndim}"
+        raise ValueError(msg)
+
+
+def is_gts_batch(gts_batch: torch.Tensor) -> None:
+    """gts_batch (torch.Tensor): boolean (N, D)."""
+    if not isinstance(gts_batch, torch.Tensor):
+        msg = f"Expected `gts_batch` to be an torch.Tensor, but got {type(gts_batch)}"
+        raise TypeError(msg)
+
+    if gts_batch.dtype != torch.bool:
+        msg = (
+            "Expected `gts_batch` to be an boolean torch.Tensor with anomaly scores_batch,"
+            f" but got torch.Tensor with dtype {gts_batch.dtype}"
+        )
+        raise TypeError(msg)
+
+    if gts_batch.ndim != 2:
+        msg = f"Expected `gts_batch` to be 2D, but got {gts_batch.ndim}"
+        raise ValueError(msg)
+
+
+def has_at_least_one_anomalous_image(masks: torch.Tensor) -> None:
+    is_masks(masks)
+    image_classes = images_classes_from_masks(masks)
+    if (image_classes == 1).sum() == 0:
+        msg = "Expected at least one ANOMALOUS image, but found none."
+        raise ValueError(msg)
+
+
+def has_at_least_one_normal_image(masks: torch.Tensor) -> None:
+    is_masks(masks)
+    image_classes = images_classes_from_masks(masks)
+    if (image_classes == 0).sum() == 0:
+        msg = "Expected at least one NORMAL image, but found none."
+        raise ValueError(msg)
+
+
+def joint_validate_thresholds_shared_fpr(thresholds: torch.Tensor, shared_fpr: torch.Tensor) -> None:
+    if thresholds.shape[0] != shared_fpr.shape[0]:
+        msg = (
+            "Expected `thresholds` and `shared_fpr` to have the same number of elements, "
+            f"but got {thresholds.shape[0]} != {shared_fpr.shape[0]}"
+        )
+        raise ValueError(msg)
+
+
+def is_per_image_tprs(per_image_tprs: torch.Tensor, image_classes: torch.Tensor) -> None:
+    is_images_classes(image_classes)
+    # general validations
+    is_per_image_rate_curves(
+        per_image_tprs,
+        nan_allowed=True,  # normal images have NaN TPRs
+        decreasing=None,  # not checked here
+    )
+
+    # specific to anomalous images
+    is_per_image_rate_curves(
+        per_image_tprs[image_classes == 1],
+        nan_allowed=False,
+        decreasing=True,
+    )
+
+    # specific to normal images
+    normal_images_tprs = per_image_tprs[image_classes == 0]
+    if not normal_images_tprs.isnan().all():
+        msg = "Expected all normal images to have NaN TPRs, but some have non-NaN values."
+        raise ValueError(msg)
+
+
+def is_per_image_scores(per_image_scores: torch.Tensor) -> None:
+    if per_image_scores.ndim != 1:
+        msg = f"Expected per-image scores to be 1D, but got {per_image_scores.ndim}D."
+        raise ValueError(msg)
+
+
+def is_image_class(image_class: int) -> None:
+    if image_class not in {0, 1}:
+        msg = f"Expected image class to be either 0 for 'normal' or 1 for 'anomalous', but got {image_class}."
+        raise ValueError(msg)
diff --git a/src/anomalib/metrics/pimo/binary_classification_curve.py b/src/anomalib/metrics/pimo/binary_classification_curve.py
new file mode 100644
index 0000000000..1a80944041
--- /dev/null
+++ b/src/anomalib/metrics/pimo/binary_classification_curve.py
@@ -0,0 +1,334 @@
+"""Binary classification curve (numpy-only implementation).
+
+A binary classification (binclf) matrix (TP, FP, FN, TN) is evaluated at multiple thresholds.
+
+The thresholds are shared by all instances/images, but their binclf are computed independently for each instance/image.
+"""
+
+# Original Code
+# https://github.com/jpcbertoldo/aupimo
+#
+# Modified
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import itertools
+import logging
+from enum import Enum
+from functools import partial
+
+import numpy as np
+import torch
+
+from . import _validate
+
+logger = logging.getLogger(__name__)
+
+
+class ThresholdMethod(Enum):
+    """Sequence of thresholds to use."""
+
+    GIVEN: str = "given"
+    MINMAX_LINSPACE: str = "minmax-linspace"
+    MEAN_FPR_OPTIMIZED: str = "mean-fpr-optimized"
+
+
+def _binary_classification_curve(scores: np.ndarray, gts: np.ndarray, thresholds: np.ndarray) -> np.ndarray:
+    """One binary classification matrix at each threshold.
+
+    In the case where the thresholds are given (i.e. not considering all possible thresholds based on the scores),
+    this weird-looking function is faster than the two options in `torchmetrics` on the CPU:
+        - `_binary_precision_recall_curve_update_vectorized`
+        - `_binary_precision_recall_curve_update_loop`
+    (both in module `torchmetrics.functional.classification.precision_recall_curve` in `torchmetrics==1.1.0`).
+    Note: VALIDATION IS NOT DONE HERE. Make sure to validate the arguments before calling this function.
+
+    Args:
+        scores (np.ndarray): Anomaly scores (D,).
+        gts (np.ndarray): Binary (bool) ground truth of shape (D,).
+        thresholds (np.ndarray): Sequence of thresholds in ascending order (K,).
+
+    Returns:
+        np.ndarray: Binary classification matrix curve (K, 2, 2)
+        Details: `anomalib.metrics.per_image.binclf_curve_numpy.binclf_multiple_curves`.
+    """
+    num_th = len(thresholds)
+
+    # POSITIVES
+    scores_positives = scores[gts]
+    # the sorting is very important for the algorithm to work and the speedup
+    scores_positives = np.sort(scores_positives)
+    # variable updated in the loop; start counting with lowest thresh ==> everything is predicted as positive
+    num_pos = current_count_tp = scores_positives.size
+    tps = np.empty((num_th,), dtype=np.int64)
+
+    # NEGATIVES
+    # same thing but for the negative samples
+    scores_negatives = scores[~gts]
+    scores_negatives = np.sort(scores_negatives)
+    num_neg = current_count_fp = scores_negatives.size
+    fps = np.empty((num_th,), dtype=np.int64)
+
+    def score_less_than_thresh(score: float, thresh: float) -> bool:
+        return score < thresh
+
+    # it will progressively drop the scores that are below the current thresh
+    for thresh_idx, thresh in enumerate(thresholds):
+        # UPDATE POSITIVES
+        # < becasue it is the same as ~(>=)
+        num_drop = sum(1 for _ in itertools.takewhile(partial(score_less_than_thresh, thresh=thresh), scores_positives))
+        scores_positives = scores_positives[num_drop:]
+        current_count_tp -= num_drop
+        tps[thresh_idx] = current_count_tp
+
+        # UPDATE NEGATIVES
+        # same with the negatives
+        num_drop = sum(1 for _ in itertools.takewhile(partial(score_less_than_thresh, thresh=thresh), scores_negatives))
+        scores_negatives = scores_negatives[num_drop:]
+        current_count_fp -= num_drop
+        fps[thresh_idx] = current_count_fp
+
+    # deduce the rest of the matrix counts
+    fns = num_pos * np.ones((num_th,), dtype=np.int64) - tps
+    tns = num_neg * np.ones((num_th,), dtype=np.int64) - fps
+
+    # sequence of dimensions is (thresholds, true class, predicted class) (see docstring)
+    return np.stack(
+        [
+            np.stack([tns, fps], axis=-1),
+            np.stack([fns, tps], axis=-1),
+        ],
+        axis=-1,
+    ).transpose(0, 2, 1)
+
+
+def binary_classification_curve(
+    scores_batch: torch.Tensor,
+    gts_batch: torch.Tensor,
+    thresholds: torch.Tensor,
+) -> torch.Tensor:
+    """Returns a binary classification matrix at each threshold for each image in the batch.
+
+    This is a wrapper around `_binary_classification_curve`.
+    Validation of the arguments is done here (not in the actual implementation functions).
+
+    Note: predicted as positive condition is `score >= thresh`.
+
+    Args:
+        scores_batch (torch.Tensor): Anomaly scores (N, D,).
+        gts_batch (torch.Tensor): Binary (bool) ground truth of shape (N, D,).
+        thresholds (torch.Tensor): Sequence of thresholds in ascending order (K,).
+
+    Returns:
+        torch.Tensor: Binary classification matrix curves (N, K, 2, 2)
+
+        The last two dimensions are the confusion matrix (ground truth, predictions)
+        So for each thresh it gives:
+            - `tp`: `[... , 1, 1]`
+            - `fp`: `[... , 0, 1]`
+            - `fn`: `[... , 1, 0]`
+            - `tn`: `[... , 0, 0]`
+
+        `t` is for `true` and `f` is for `false`, `p` is for `positive` and `n` is for `negative`, so:
+            - `tp` stands for `true positive`
+            - `fp` stands for `false positive`
+            - `fn` stands for `false negative`
+            - `tn` stands for `true negative`
+
+        The numbers in each confusion matrix are the counts (not the ratios).
+
+        Counts are relative to each instance (i.e. from 0 to D, e.g. the total is the number of pixels in the image).
+
+        Thresholds are shared across all instances, so all confusion matrices, for instance,
+        at position [:, 0, :, :] are relative to the 1st threshold in `thresholds`.
+
+        Thresholds are sorted in ascending order.
+    """
+    _validate.is_scores_batch(scores_batch)
+    _validate.is_gts_batch(gts_batch)
+    _validate.is_same_shape(scores_batch, gts_batch)
+    _validate.is_valid_threshold(thresholds)
+    # TODO(ashwinvaidya17): this is kept as numpy for now because it is much faster.
+    # TEMP-0
+    result = np.vectorize(_binary_classification_curve, signature="(n),(n),(k)->(k,2,2)")(
+        scores_batch.detach().cpu().numpy(),
+        gts_batch.detach().cpu().numpy(),
+        thresholds.detach().cpu().numpy(),
+    )
+    return torch.from_numpy(result).to(scores_batch.device)
+
+
+def _get_linspaced_thresholds(anomaly_maps: torch.Tensor, num_thresholds: int) -> torch.Tensor:
+    """Get thresholds linearly spaced between the min and max of the anomaly maps."""
+    _validate.is_num_thresholds_gte2(num_thresholds)
+    # this operation can be a bit expensive
+    thresh_low, thresh_high = thresh_bounds = (anomaly_maps.min().item(), anomaly_maps.max().item())
+    try:
+        _validate.validate_threshold_bounds(thresh_bounds)
+    except ValueError as ex:
+        msg = f"Invalid threshold bounds computed from the given anomaly maps. Cause: {ex}"
+        raise ValueError(msg) from ex
+    return torch.linspace(thresh_low, thresh_high, num_thresholds, dtype=anomaly_maps.dtype)
+
+
+def threshold_and_binary_classification_curve(
+    anomaly_maps: torch.Tensor,
+    masks: torch.Tensor,
+    threshold_choice: ThresholdMethod | str = ThresholdMethod.MINMAX_LINSPACE,
+    thresholds: torch.Tensor | None = None,
+    num_thresholds: int | None = None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Return thresholds and binary classification matrix at each threshold for each image in the batch.
+
+    Args:
+        anomaly_maps (torch.Tensor): Anomaly score maps of shape (N, H, W)
+        masks (torch.Tensor): Binary ground truth masks of shape (N, H, W)
+        threshold_choice (str, optional): Sequence of thresholds to use. Defaults to THRESH_SEQUENCE_MINMAX_LINSPACE.
+        thresholds (torch.Tensor, optional): Sequence of thresholds to use.
+            Only applicable when threshold_choice is THRESH_SEQUENCE_GIVEN.
+        num_thresholds (int, optional): Number of thresholds between the min and max of the anomaly maps.
+            Only applicable when threshold_choice is THRESH_SEQUENCE_MINMAX_LINSPACE.
+
+    Returns:
+        tuple[torch.Tensor, torch.Tensor]:
+            [0] Thresholds of shape (K,) and dtype is the same as `anomaly_maps.dtype`.
+
+            [1] Binary classification matrices of shape (N, K, 2, 2)
+
+                N: number of images/instances
+                K: number of thresholds
+
+            The last two dimensions are the confusion matrix (ground truth, predictions)
+            So for each thresh it gives:
+                - `tp`: `[... , 1, 1]`
+                - `fp`: `[... , 0, 1]`
+                - `fn`: `[... , 1, 0]`
+                - `tn`: `[... , 0, 0]`
+
+            `t` is for `true` and `f` is for `false`, `p` is for `positive` and `n` is for `negative`, so:
+                - `tp` stands for `true positive`
+                - `fp` stands for `false positive`
+                - `fn` stands for `false negative`
+                - `tn` stands for `true negative`
+
+            The numbers in each confusion matrix are the counts of pixels in the image (not the ratios).
+
+            Thresholds are shared across all images, so all confusion matrices, for instance,
+            at position [:, 0, :, :] are relative to the 1st threshold in `thresholds`.
+
+            Thresholds are sorted in ascending order.
+    """
+    threshold_choice = ThresholdMethod(threshold_choice)
+    _validate.is_anomaly_maps(anomaly_maps)
+    _validate.is_masks(masks)
+    _validate.is_same_shape(anomaly_maps, masks)
+
+    if threshold_choice == ThresholdMethod.GIVEN:
+        assert thresholds is not None
+        _validate.is_valid_threshold(thresholds)
+        if num_thresholds is not None:
+            logger.warning(
+                "Argument `num_thresholds` was given, "
+                f"but it is ignored because `thresholds_choice` is '{threshold_choice.value}'.",
+            )
+        thresholds = thresholds.to(anomaly_maps.dtype)
+
+    elif threshold_choice == ThresholdMethod.MINMAX_LINSPACE:
+        assert num_thresholds is not None
+        if thresholds is not None:
+            logger.warning(
+                "Argument `thresholds_given` was given, "
+                f"but it is ignored because `thresholds_choice` is '{threshold_choice.value}'.",
+            )
+        # `num_thresholds` is validated in the function below
+        thresholds = _get_linspaced_thresholds(anomaly_maps, num_thresholds)
+
+    elif threshold_choice == ThresholdMethod.MEAN_FPR_OPTIMIZED:
+        raise NotImplementedError(f"TODO implement {threshold_choice.value}")  # noqa: EM102
+
+    else:
+        msg = (
+            f"Expected `threshs_choice` to be from {list(ThresholdMethod.__members__)},"
+            f" but got '{threshold_choice.value}'"
+        )
+        raise NotImplementedError(msg)
+
+    # keep the batch dimension and flatten the rest
+    scores_batch = anomaly_maps.reshape(anomaly_maps.shape[0], -1)
+    gts_batch = masks.reshape(masks.shape[0], -1).to(bool)  # make sure it is boolean
+
+    binclf_curves = binary_classification_curve(scores_batch, gts_batch, thresholds)
+
+    num_images = anomaly_maps.shape[0]
+
+    try:
+        _validate.is_binclf_curves(binclf_curves, valid_thresholds=thresholds)
+
+        # these two validations cannot be done in `_validate.binclf_curves` because it does not have access to the
+        # original shapes of `anomaly_maps`
+        if binclf_curves.shape[0] != num_images:
+            msg = (
+                "Expected `binclf_curves` to have the same number of images as `anomaly_maps`, "
+                f"but got {binclf_curves.shape[0]} and {anomaly_maps.shape[0]}"
+            )
+            raise RuntimeError(msg)
+
+    except (TypeError, ValueError) as ex:
+        msg = f"Invalid `binclf_curves` was computed. Cause: {ex}"
+        raise RuntimeError(msg) from ex
+
+    return thresholds, binclf_curves
+
+
+def per_image_tpr(binclf_curves: torch.Tensor) -> torch.Tensor:
+    """True positive rates (TPR) for image for each thresh.
+
+    TPR = TP / P = TP / (TP + FN)
+
+    TP: true positives
+    FM: false negatives
+    P: positives (TP + FN)
+
+    Args:
+        binclf_curves (torch.Tensor): Binary classification matrix curves (N, K, 2, 2). See `per_image_binclf_curve`.
+
+    Returns:
+        torch.Tensor: shape (N, K), dtype float64
+        N: number of images
+        K: number of thresholds
+
+        Thresholds are sorted in ascending order, so TPR is in descending order.
+    """
+    # shape: (num images, num thresholds)
+    tps = binclf_curves[..., 1, 1]
+    pos = binclf_curves[..., 1, :].sum(axis=2)  # 2 was the 3 originally
+
+    # tprs will be nan if pos == 0 (normal image), which is expected
+    return tps.to(torch.float64) / pos.to(torch.float64)
+
+
+def per_image_fpr(binclf_curves: torch.Tensor) -> torch.Tensor:
+    """False positive rates (TPR) for image for each thresh.
+
+    FPR = FP / N = FP / (FP + TN)
+
+    FP: false positives
+    TN: true negatives
+    N: negatives (FP + TN)
+
+    Args:
+        binclf_curves (torch.Tensor): Binary classification matrix curves (N, K, 2, 2). See `per_image_binclf_curve`.
+
+    Returns:
+        torch.Tensor: shape (N, K), dtype float64
+        N: number of images
+        K: number of thresholds
+
+        Thresholds are sorted in ascending order, so FPR is in descending order.
+    """
+    # shape: (num images, num thresholds)
+    fps = binclf_curves[..., 0, 1]
+    neg = binclf_curves[..., 0, :].sum(axis=2)  # 2 was the 3 originally
+
+    # it can be `nan` if an anomalous image is fully covered by the mask
+    return fps.to(torch.float64) / neg.to(torch.float64)
diff --git a/src/anomalib/metrics/pimo/dataclasses.py b/src/anomalib/metrics/pimo/dataclasses.py
new file mode 100644
index 0000000000..0c5aeb025d
--- /dev/null
+++ b/src/anomalib/metrics/pimo/dataclasses.py
@@ -0,0 +1,226 @@
+"""Dataclasses for PIMO metrics."""
+
+# Based on the code: https://github.com/jpcbertoldo/aupimo
+#
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass, field
+
+import torch
+
+from . import _validate, functional
+
+
+@dataclass
+class PIMOResult:
+    """Per-Image Overlap (PIMO, pronounced pee-mo) curve.
+
+    This interface gathers the PIMO curve data and metadata and provides several utility methods.
+
+    Notation:
+        - N: number of images
+        - K: number of thresholds
+        - FPR: False Positive Rate
+        - TPR: True Positive Rate
+
+    Attributes:
+        thresholds (torch.Tensor): sequence of K (monotonically increasing) thresholds used to compute the PIMO curve
+        shared_fpr (torch.Tensor): K values of the shared FPR metric at the corresponding thresholds
+        per_image_tprs (torch.Tensor): for each of the N images, the K values of in-image TPR at the corresponding
+            thresholds
+    """
+
+    # data
+    thresholds: torch.Tensor = field(repr=False)  # shape => (K,)
+    shared_fpr: torch.Tensor = field(repr=False)  # shape => (K,)
+    per_image_tprs: torch.Tensor = field(repr=False)  # shape => (N, K)
+
+    @property
+    def num_threshsholds(self) -> int:
+        """Number of thresholds."""
+        return self.thresholds.shape[0]
+
+    @property
+    def num_images(self) -> int:
+        """Number of images."""
+        return self.per_image_tprs.shape[0]
+
+    @property
+    def image_classes(self) -> torch.Tensor:
+        """Image classes (0: normal, 1: anomalous).
+
+        Deduced from the per-image TPRs.
+        If any TPR value is not NaN, the image is considered anomalous.
+        """
+        return (~torch.isnan(self.per_image_tprs)).any(dim=1).to(torch.int32)
+
+    def __post_init__(self) -> None:
+        """Validate the inputs for the result object are consistent."""
+        try:
+            _validate.is_valid_threshold(self.thresholds)
+            _validate.is_rate_curve(self.shared_fpr, nan_allowed=False, decreasing=True)  # is_shared_apr
+            _validate.is_per_image_tprs(self.per_image_tprs, self.image_classes)
+
+        except (TypeError, ValueError) as ex:
+            msg = f"Invalid inputs for {self.__class__.__name__} object. Cause: {ex}."
+            raise TypeError(msg) from ex
+
+        if self.thresholds.shape != self.shared_fpr.shape:
+            msg = (
+                f"Invalid {self.__class__.__name__} object. Attributes have inconsistent shapes: "
+                f"{self.thresholds.shape=} != {self.shared_fpr.shape=}."
+            )
+            raise TypeError(msg)
+
+        if self.thresholds.shape[0] != self.per_image_tprs.shape[1]:
+            msg = (
+                f"Invalid {self.__class__.__name__} object. Attributes have inconsistent shapes: "
+                f"{self.thresholds.shape[0]=} != {self.per_image_tprs.shape[1]=}."
+            )
+            raise TypeError(msg)
+
+    def thresh_at(self, fpr_level: float) -> tuple[int, float, float]:
+        """Return the threshold at the given shared FPR.
+
+        See `anomalib.metrics.per_image.pimo_numpy.thresh_at_shared_fpr_level` for details.
+
+        Args:
+            fpr_level (float): shared FPR level
+
+        Returns:
+            tuple[int, float, float]:
+                [0] index of the threshold
+                [1] threshold
+                [2] the actual shared FPR value at the returned threshold
+        """
+        return functional.thresh_at_shared_fpr_level(
+            self.thresholds,
+            self.shared_fpr,
+            fpr_level,
+        )
+
+
+@dataclass
+class AUPIMOResult:
+    """Area Under the Per-Image Overlap (AUPIMO, pronounced a-u-pee-mo) curve.
+
+    This interface gathers the AUPIMO data and metadata and provides several utility methods.
+
+    Attributes:
+        fpr_lower_bound (float): [metadata] LOWER bound of the FPR integration range
+        fpr_upper_bound (float): [metadata] UPPER bound of the FPR integration range
+        num_thresholds (int): [metadata] number of thresholds used to effectively compute AUPIMO;
+                            should not be confused with the number of thresholds used to compute the PIMO curve
+        thresh_lower_bound (float): LOWER threshold bound --> corresponds to the UPPER FPR bound
+        thresh_upper_bound (float): UPPER threshold bound --> corresponds to the LOWER FPR bound
+        aupimos (torch.Tensor): values of AUPIMO scores (1 per image)
+    """
+
+    # metadata
+    fpr_lower_bound: float
+    fpr_upper_bound: float
+    num_thresholds: int
+
+    # data
+    thresh_lower_bound: float = field(repr=False)
+    thresh_upper_bound: float = field(repr=False)
+    aupimos: torch.Tensor = field(repr=False)  # shape => (N,)
+
+    @property
+    def num_images(self) -> int:
+        """Number of images."""
+        return self.aupimos.shape[0]
+
+    @property
+    def num_normal_images(self) -> int:
+        """Number of normal images."""
+        return int((self.image_classes == 0).sum())
+
+    @property
+    def num_anomalous_images(self) -> int:
+        """Number of anomalous images."""
+        return int((self.image_classes == 1).sum())
+
+    @property
+    def image_classes(self) -> torch.Tensor:
+        """Image classes (0: normal, 1: anomalous)."""
+        # if an instance has `nan` aupimo it's because it's a normal image
+        return self.aupimos.isnan().to(torch.int32)
+
+    @property
+    def fpr_bounds(self) -> tuple[float, float]:
+        """Lower and upper bounds of the FPR integration range."""
+        return self.fpr_lower_bound, self.fpr_upper_bound
+
+    @property
+    def thresh_bounds(self) -> tuple[float, float]:
+        """Lower and upper bounds of the threshold integration range.
+
+        Recall: they correspond to the FPR bounds in reverse order.
+        I.e.:
+            fpr_lower_bound --> thresh_upper_bound
+            fpr_upper_bound --> thresh_lower_bound
+        """
+        return self.thresh_lower_bound, self.thresh_upper_bound
+
+    def __post_init__(self) -> None:
+        """Validate the inputs for the result object are consistent."""
+        try:
+            _validate.is_rate_range((self.fpr_lower_bound, self.fpr_upper_bound))
+            # TODO(jpcbertoldo): warn when it's too low (use parameters from the numpy code)  # noqa: TD003
+            _validate.is_num_thresholds_gte2(self.num_thresholds)
+            _validate.is_rates(self.aupimos, nan_allowed=True)  # validate is_aupimos
+
+            _validate.validate_threshold_bounds((self.thresh_lower_bound, self.thresh_upper_bound))
+
+        except (TypeError, ValueError) as ex:
+            msg = f"Invalid inputs for {self.__class__.__name__} object. Cause: {ex}."
+            raise TypeError(msg) from ex
+
+    @classmethod
+    def from_pimo_result(
+        cls: type["AUPIMOResult"],
+        pimo_result: PIMOResult,
+        fpr_bounds: tuple[float, float],
+        num_thresholds_auc: int,
+        aupimos: torch.Tensor,
+    ) -> "AUPIMOResult":
+        """Return an AUPIMO result object from a PIMO result object.
+
+        Args:
+            pimo_result: PIMO result object
+            fpr_bounds: lower and upper bounds of the FPR integration range
+            num_thresholds_auc: number of thresholds used to effectively compute AUPIMO;
+                         NOT the number of thresholds used to compute the PIMO curve!
+            aupimos: AUPIMO scores
+            paths: paths to the source images to which the AUPIMO scores correspond.
+        """
+        if pimo_result.per_image_tprs.shape[0] != aupimos.shape[0]:
+            msg = (
+                f"Invalid {cls.__name__} object. Attributes have inconsistent shapes: "
+                f"there are {pimo_result.per_image_tprs.shape[0]} PIMO curves but {aupimos.shape[0]} AUPIMO scores."
+            )
+            raise TypeError(msg)
+
+        if not torch.isnan(aupimos[pimo_result.image_classes == 0]).all():
+            msg = "Expected all normal images to have NaN AUPIMOs, but some have non-NaN values."
+            raise TypeError(msg)
+
+        if torch.isnan(aupimos[pimo_result.image_classes == 1]).any():
+            msg = "Expected all anomalous images to have valid AUPIMOs (not nan), but some have NaN values."
+            raise TypeError(msg)
+
+        fpr_lower_bound, fpr_upper_bound = fpr_bounds
+        # recall: fpr upper/lower bounds are the same as the thresh lower/upper bounds
+        _, thresh_lower_bound, __ = pimo_result.thresh_at(fpr_upper_bound)
+        _, thresh_upper_bound, __ = pimo_result.thresh_at(fpr_lower_bound)
+        # `_` is the threshold's index, `__` is the actual fpr value
+        return cls(
+            fpr_lower_bound=fpr_lower_bound,
+            fpr_upper_bound=fpr_upper_bound,
+            num_thresholds=num_thresholds_auc,
+            thresh_lower_bound=float(thresh_lower_bound),
+            thresh_upper_bound=float(thresh_upper_bound),
+            aupimos=aupimos,
+        )
diff --git a/src/anomalib/metrics/pimo/functional.py b/src/anomalib/metrics/pimo/functional.py
new file mode 100644
index 0000000000..7eac07b1bd
--- /dev/null
+++ b/src/anomalib/metrics/pimo/functional.py
@@ -0,0 +1,355 @@
+"""Per-Image Overlap curve (PIMO, pronounced pee-mo) and its area under the curve (AUPIMO).
+
+Details: `anomalib.metrics.per_image.pimo`.
+"""
+
+# Original Code
+# https://github.com/jpcbertoldo/aupimo
+#
+# Modified
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+import numpy as np
+import torch
+
+from . import _validate
+from .binary_classification_curve import (
+    ThresholdMethod,
+    _get_linspaced_thresholds,
+    per_image_fpr,
+    per_image_tpr,
+    threshold_and_binary_classification_curve,
+)
+from .utils import images_classes_from_masks
+
+logger = logging.getLogger(__name__)
+
+
+def pimo_curves(
+    anomaly_maps: torch.Tensor,
+    masks: torch.Tensor,
+    num_thresholds: int,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Compute the Per-IMage Overlap (PIMO, pronounced pee-mo) curves.
+
+    PIMO is a curve of True Positive Rate (TPR) values on each image across multiple anomaly score thresholds.
+    The anomaly score thresholds are indexed by a (cross-image shared) value of False Positive Rate (FPR) measure on
+    the normal images.
+
+    Details: `anomalib.metrics.per_image.pimo`.
+
+    Args' notation:
+        N: number of images
+        H: image height
+        W: image width
+        K: number of thresholds
+
+    Args:
+        anomaly_maps: floating point anomaly score maps of shape (N, H, W)
+        masks: binary (bool or int) ground truth masks of shape (N, H, W)
+        num_thresholds: number of thresholds to compute (K)
+
+    Returns:
+        tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+            [0] thresholds of shape (K,) in ascending order
+            [1] shared FPR values of shape (K,) in descending order (indices correspond to the thresholds)
+            [2] per-image TPR curves of shape (N, K), axis 1 in descending order (indices correspond to the thresholds)
+            [3] image classes of shape (N,) with values 0 (normal) or 1 (anomalous)
+    """
+    # validate the strings are valid
+    _validate.is_num_thresholds_gte2(num_thresholds)
+    _validate.is_anomaly_maps(anomaly_maps)
+    _validate.is_masks(masks)
+    _validate.is_same_shape(anomaly_maps, masks)
+    _validate.has_at_least_one_anomalous_image(masks)
+    _validate.has_at_least_one_normal_image(masks)
+
+    image_classes = images_classes_from_masks(masks)
+
+    # the thresholds are computed here so that they can be restrained to the normal images
+    # therefore getting a better resolution in terms of FPR quantization
+    # otherwise the function `binclf_curve_numpy.per_image_binclf_curve` would have the range of thresholds
+    # computed from all the images (normal + anomalous)
+    thresholds = _get_linspaced_thresholds(
+        anomaly_maps[image_classes == 0],
+        num_thresholds,
+    )
+
+    # N: number of images, K: number of thresholds
+    # shapes are (K,) and (N, K, 2, 2)
+    thresholds, binclf_curves = threshold_and_binary_classification_curve(
+        anomaly_maps=anomaly_maps,
+        masks=masks,
+        threshold_choice=ThresholdMethod.GIVEN.value,
+        thresholds=thresholds,
+        num_thresholds=None,
+    )
+
+    shared_fpr: torch.Tensor
+    # mean-per-image-fpr on normal images
+    # shape -> (N, K)
+    per_image_fprs_normals = per_image_fpr(binclf_curves[image_classes == 0])
+    try:
+        _validate.is_per_image_rate_curves(per_image_fprs_normals, nan_allowed=False, decreasing=True)
+    except ValueError as ex:
+        msg = f"Cannot compute PIMO because the per-image FPR curves from normal images are invalid. Cause: {ex}"
+        raise RuntimeError(msg) from ex
+
+    # shape -> (K,)
+    # this is the only shared FPR metric implemented so far,
+    # see note about shared FPR in Details: `anomalib.metrics.per_image.pimo`.
+    shared_fpr = per_image_fprs_normals.mean(axis=0)
+
+    # shape -> (N, K)
+    per_image_tprs = per_image_tpr(binclf_curves)
+
+    return thresholds, shared_fpr, per_image_tprs, image_classes
+
+
+# =========================================== AUPIMO ===========================================
+
+
+def aupimo_scores(
+    anomaly_maps: torch.Tensor,
+    masks: torch.Tensor,
+    num_thresholds: int = 300_000,
+    fpr_bounds: tuple[float, float] = (1e-5, 1e-4),
+    force: bool = False,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, int]:
+    """Compute the PIMO curves and their Area Under the Curve (i.e. AUPIMO) scores.
+
+    Scores are computed from the integration of the PIMO curves within the given FPR bounds, then normalized to [0, 1].
+    It can be thought of as the average TPR of the PIMO curves within the given FPR bounds.
+
+    Details: `anomalib.metrics.per_image.pimo`.
+
+    Args' notation:
+        N: number of images
+        H: image height
+        W: image width
+        K: number of thresholds
+
+    Args:
+        anomaly_maps: floating point anomaly score maps of shape (N, H, W)
+        masks: binary (bool or int) ground truth masks of shape (N, H, W)
+        num_thresholds: number of thresholds to compute (K)
+        fpr_bounds: lower and upper bounds of the FPR integration range
+        force: whether to force the computation despite bad conditions
+
+    Returns:
+        tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+            [0] thresholds of shape (K,) in ascending order
+            [1] shared FPR values of shape (K,) in descending order (indices correspond to the thresholds)
+            [2] per-image TPR curves of shape (N, K), axis 1 in descending order (indices correspond to the thresholds)
+            [3] image classes of shape (N,) with values 0 (normal) or 1 (anomalous)
+            [4] AUPIMO scores of shape (N,) in [0, 1]
+            [5] number of points used in the AUC integration
+    """
+    _validate.is_rate_range(fpr_bounds)
+
+    # other validations are done in the `pimo` function
+    thresholds, shared_fpr, per_image_tprs, image_classes = pimo_curves(
+        anomaly_maps=anomaly_maps,
+        masks=masks,
+        num_thresholds=num_thresholds,
+    )
+    try:
+        _validate.is_valid_threshold(thresholds)
+        _validate.is_rate_curve(shared_fpr, nan_allowed=False, decreasing=True)
+        _validate.is_images_classes(image_classes)
+        _validate.is_per_image_rate_curves(per_image_tprs[image_classes == 1], nan_allowed=False, decreasing=True)
+
+    except ValueError as ex:
+        msg = f"Cannot compute AUPIMO because the PIMO curves are invalid. Cause: {ex}"
+        raise RuntimeError(msg) from ex
+
+    fpr_lower_bound, fpr_upper_bound = fpr_bounds
+
+    # get the threshold indices where the fpr bounds are achieved
+    fpr_lower_bound_thresh_idx, _, fpr_lower_bound_defacto = thresh_at_shared_fpr_level(
+        thresholds,
+        shared_fpr,
+        fpr_lower_bound,
+    )
+    fpr_upper_bound_thresh_idx, _, fpr_upper_bound_defacto = thresh_at_shared_fpr_level(
+        thresholds,
+        shared_fpr,
+        fpr_upper_bound,
+    )
+
+    if not torch.isclose(
+        fpr_lower_bound_defacto,
+        torch.tensor(fpr_lower_bound, dtype=fpr_lower_bound_defacto.dtype, device=fpr_lower_bound_defacto.device),
+        rtol=(rtol := 1e-2),
+    ):
+        logger.warning(
+            "The lower bound of the shared FPR integration range is not exactly achieved. "
+            f"Expected {fpr_lower_bound} but got {fpr_lower_bound_defacto}, which is not within {rtol=}.",
+        )
+
+    if not torch.isclose(
+        fpr_upper_bound_defacto,
+        torch.tensor(fpr_upper_bound, dtype=fpr_upper_bound_defacto.dtype, device=fpr_upper_bound_defacto.device),
+        rtol=rtol,
+    ):
+        logger.warning(
+            "The upper bound of the shared FPR integration range is not exactly achieved. "
+            f"Expected {fpr_upper_bound} but got {fpr_upper_bound_defacto}, which is not within {rtol=}.",
+        )
+
+    # reminder: fpr lower/upper bound is threshold upper/lower bound (reversed)
+    thresh_lower_bound_idx = fpr_upper_bound_thresh_idx
+    thresh_upper_bound_idx = fpr_lower_bound_thresh_idx
+
+    # deal with edge cases
+    if thresh_lower_bound_idx >= thresh_upper_bound_idx:
+        msg = (
+            "The thresholds corresponding to the given `fpr_bounds` are not valid because "
+            "they matched the same threshold or the are in the wrong order. "
+            f"FPR upper/lower = threshold lower/upper = {thresh_lower_bound_idx} and {thresh_upper_bound_idx}."
+        )
+        raise RuntimeError(msg)
+
+    # limit the curves to the integration range [lbound, ubound]
+    shared_fpr_bounded: torch.Tensor = shared_fpr[thresh_lower_bound_idx : (thresh_upper_bound_idx + 1)]
+    per_image_tprs_bounded: torch.Tensor = per_image_tprs[:, thresh_lower_bound_idx : (thresh_upper_bound_idx + 1)]
+
+    # `shared_fpr` and `tprs` are in descending order; `flip()` reverts to ascending order
+    shared_fpr_bounded = torch.flip(shared_fpr_bounded, dims=[0])
+    per_image_tprs_bounded = torch.flip(per_image_tprs_bounded, dims=[1])
+
+    # the log's base does not matter because it's a constant factor canceled by normalization factor
+    shared_fpr_bounded_log = torch.log(shared_fpr_bounded)
+
+    # deal with edge cases
+    invalid_shared_fpr = ~torch.isfinite(shared_fpr_bounded_log)
+
+    if invalid_shared_fpr.all():
+        msg = (
+            "Cannot compute AUPIMO because the shared fpr integration range is invalid). "
+            "Try increasing the number of thresholds."
+        )
+        raise RuntimeError(msg)
+
+    if invalid_shared_fpr.any():
+        logger.warning(
+            "Some values in the shared fpr integration range are nan. "
+            "The AUPIMO will be computed without these values.",
+        )
+
+        # get rid of nan values by removing them from the integration range
+        shared_fpr_bounded_log = shared_fpr_bounded_log[~invalid_shared_fpr]
+        per_image_tprs_bounded = per_image_tprs_bounded[:, ~invalid_shared_fpr]
+
+    num_points_integral = int(shared_fpr_bounded_log.shape[0])
+
+    if num_points_integral <= 30:
+        msg = (
+            "Cannot compute AUPIMO because the shared fpr integration range doesn't have enough points. "
+            f"Found {num_points_integral} points in the integration range. "
+            "Try increasing `num_thresholds`."
+        )
+        if not force:
+            raise RuntimeError(msg)
+        msg += " Computation was forced!"
+        logger.warning(msg)
+
+    if num_points_integral < 300:
+        logger.warning(
+            "The AUPIMO may be inaccurate because the shared fpr integration range doesn't have enough points. "
+            f"Found {num_points_integral} points in the integration range. "
+            "Try increasing `num_thresholds`.",
+        )
+
+    aucs: torch.Tensor = torch.trapezoid(per_image_tprs_bounded, x=shared_fpr_bounded_log, axis=1)
+
+    # normalize, then clip(0, 1) makes sure that the values are in [0, 1] in case of numerical errors
+    normalization_factor = aupimo_normalizing_factor(fpr_bounds)
+    aucs = (aucs / normalization_factor).clip(0, 1)
+
+    return thresholds, shared_fpr, per_image_tprs, image_classes, aucs, num_points_integral
+
+
+# =========================================== AUX ===========================================
+
+
+def thresh_at_shared_fpr_level(
+    thresholds: torch.Tensor,
+    shared_fpr: torch.Tensor,
+    fpr_level: float,
+) -> tuple[int, float, torch.Tensor]:
+    """Return the threshold and its index at the given shared FPR level.
+
+    Three cases are possible:
+    - fpr_level == 0: the lowest threshold that achieves 0 FPR is returned
+    - fpr_level == 1: the highest threshold that achieves 1 FPR is returned
+    - 0 < fpr_level < 1: the threshold that achieves the closest (higher or lower) FPR to `fpr_level` is returned
+
+    Args:
+        thresholds: thresholds at which the shared FPR was computed.
+        shared_fpr: shared FPR values.
+        fpr_level: shared FPR value at which to get the threshold.
+
+    Returns:
+        tuple[int, float, float]:
+            [0] index of the threshold
+            [1] threshold
+            [2] the actual shared FPR value at the returned threshold
+    """
+    _validate.is_valid_threshold(thresholds)
+    _validate.is_rate_curve(shared_fpr, nan_allowed=False, decreasing=True)
+    _validate.joint_validate_thresholds_shared_fpr(thresholds, shared_fpr)
+    _validate.is_rate(fpr_level, zero_ok=True, one_ok=True)
+
+    shared_fpr_min, shared_fpr_max = shared_fpr.min(), shared_fpr.max()
+
+    if fpr_level < shared_fpr_min:
+        msg = (
+            "Invalid `fpr_level` because it's out of the range of `shared_fpr` = "
+            f"[{shared_fpr_min}, {shared_fpr_max}], and got {fpr_level}."
+        )
+        raise ValueError(msg)
+
+    if fpr_level > shared_fpr_max:
+        msg = (
+            "Invalid `fpr_level` because it's out of the range of `shared_fpr` = "
+            f"[{shared_fpr_min}, {shared_fpr_max}], and got {fpr_level}."
+        )
+        raise ValueError(msg)
+
+    # fpr_level == 0 or 1 are special case
+    # because there may be multiple solutions, and the chosen should their MINIMUM/MAXIMUM respectively
+    if fpr_level == 0.0:
+        index = torch.min(torch.where(shared_fpr == fpr_level)[0])
+
+    elif fpr_level == 1.0:
+        index = torch.max(torch.where(shared_fpr == fpr_level)[0])
+
+    else:
+        index = torch.argmin(torch.abs(shared_fpr - fpr_level))
+
+    index = int(index)
+    fpr_level_defacto = shared_fpr[index]
+    thresh = thresholds[index]
+    return index, thresh, fpr_level_defacto
+
+
+def aupimo_normalizing_factor(fpr_bounds: tuple[float, float]) -> float:
+    """Constant that normalizes the AUPIMO integral to 0-1 range.
+
+    It is the maximum possible value from the integral in AUPIMO's definition.
+    It corresponds to assuming a constant function T_i: thresh --> 1.
+
+    Args:
+        fpr_bounds: lower and upper bounds of the FPR integration range.
+
+    Returns:
+        float: the normalization factor (>0).
+    """
+    _validate.is_rate_range(fpr_bounds)
+    fpr_lower_bound, fpr_upper_bound = fpr_bounds
+    # the log's base must be the same as the one used in the integration!
+    return float(np.log(fpr_upper_bound / fpr_lower_bound))
diff --git a/src/anomalib/metrics/pimo/pimo.py b/src/anomalib/metrics/pimo/pimo.py
new file mode 100644
index 0000000000..9703b60b59
--- /dev/null
+++ b/src/anomalib/metrics/pimo/pimo.py
@@ -0,0 +1,296 @@
+"""Per-Image Overlap curve (PIMO, pronounced pee-mo) and its area under the curve (AUPIMO).
+
+# PIMO
+
+PIMO is a curve of True Positive Rate (TPR) values on each image across multiple anomaly score thresholds.
+The anomaly score thresholds are indexed by a (shared) valued of False Positive Rate (FPR) measure on the normal images.
+
+Each *anomalous* image has its own curve such that the X-axis is shared by all of them.
+
+At a given threshold:
+    X-axis: Shared FPR (may vary)
+        1. Log of the Average of per-image FPR on normal images.
+        SEE NOTE BELOW.
+    Y-axis: per-image TP Rate (TPR), or "Overlap" between the ground truth and the predicted masks.
+
+*** Note about other shared FPR alternatives ***
+The shared FPR metric can be made harder by using the cross-image max (or high-percentile) FPRs instead of the mean.
+Rationale: this will further punish models that have exceptional FPs in normal images.
+So far there is only one shared FPR metric implemented but others will be added in the future.
+
+# AUPIMO
+
+`AUPIMO` is the area under each `PIMO` curve with bounded integration range in terms of shared FPR.
+
+# Disclaimer
+
+This module implements torch interfaces to access the numpy code in `pimo_numpy.py`.
+Tensors are converted to numpy arrays and then passed and validated in the numpy code.
+The results are converted back to tensors and eventually wrapped in an dataclass object.
+
+Validations will preferably happen in ndarray so the numpy code can be reused without torch,
+so often times the Tensor arguments will be converted to ndarray and then validated.
+"""
+
+# Original Code
+# https://github.com/jpcbertoldo/aupimo
+#
+# Modified
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+import torch
+from torchmetrics import Metric
+
+from . import _validate, functional
+from .dataclasses import AUPIMOResult, PIMOResult
+
+logger = logging.getLogger(__name__)
+
+
+class PIMO(Metric):
+    """Per-IMage Overlap (PIMO, pronounced pee-mo) curves.
+
+    This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code.
+    The tensors are converted to numpy arrays and then passed and validated in the numpy code.
+    The results are converted back to tensors and wrapped in an dataclass object.
+
+    PIMO is a curve of True Positive Rate (TPR) values on each image across multiple anomaly score thresholds.
+    The anomaly score thresholds are indexed by a (cross-image shared) value of False Positive Rate (FPR) measure on
+    the normal images.
+
+    Details: `anomalib.metrics.per_image.pimo`.
+
+    Notation:
+        N: number of images
+        H: image height
+        W: image width
+        K: number of thresholds
+
+    Attributes:
+        anomaly_maps: floating point anomaly score maps of shape (N, H, W)
+        masks: binary (bool or int) ground truth masks of shape (N, H, W)
+
+    Args:
+        num_thresholds: number of thresholds to compute (K)
+        binclf_algorithm: algorithm to compute the binary classifier curve (see `binclf_curve_numpy.Algorithm`)
+
+    Returns:
+        PIMOResult: PIMO curves dataclass object. See `PIMOResult` for details.
+    """
+
+    is_differentiable: bool = False
+    higher_is_better: bool | None = None
+    full_state_update: bool = False
+
+    num_thresholds: int
+    binclf_algorithm: str
+
+    anomaly_maps: list[torch.Tensor]
+    masks: list[torch.Tensor]
+
+    @property
+    def _is_empty(self) -> bool:
+        """Return True if the metric has not been updated yet."""
+        return len(self.anomaly_maps) == 0
+
+    @property
+    def num_images(self) -> int:
+        """Number of images."""
+        return sum(am.shape[0] for am in self.anomaly_maps)
+
+    @property
+    def image_classes(self) -> torch.Tensor:
+        """Image classes (0: normal, 1: anomalous)."""
+        return functional.images_classes_from_masks(self.masks)
+
+    def __init__(self, num_thresholds: int) -> None:
+        """Per-Image Overlap (PIMO) curve.
+
+        Args:
+            num_thresholds: number of thresholds used to compute the PIMO curve (K)
+        """
+        super().__init__()
+
+        logger.warning(
+            f"Metric `{self.__class__.__name__}` will save all targets and predictions in buffer."
+            " For large datasets this may lead to large memory footprint.",
+        )
+
+        # the options below are, redundantly, validated here to avoid reaching
+        # an error later in the execution
+
+        _validate.is_num_thresholds_gte2(num_thresholds)
+        self.num_thresholds = num_thresholds
+
+        self.add_state("anomaly_maps", default=[], dist_reduce_fx="cat")
+        self.add_state("masks", default=[], dist_reduce_fx="cat")
+
+    def update(self, anomaly_maps: torch.Tensor, masks: torch.Tensor) -> None:
+        """Update lists of anomaly maps and masks.
+
+        Args:
+            anomaly_maps (torch.Tensor): predictions of the model (ndim == 2, float)
+            masks (torch.Tensor): ground truth masks (ndim == 2, binary)
+        """
+        _validate.is_anomaly_maps(anomaly_maps)
+        _validate.is_masks(masks)
+        _validate.is_same_shape(anomaly_maps, masks)
+        self.anomaly_maps.append(anomaly_maps)
+        self.masks.append(masks)
+
+    def compute(self) -> PIMOResult:
+        """Compute the PIMO curves.
+
+        Call the functional interface `pimo_curves()`, which is a wrapper around the numpy code.
+
+        Returns:
+            PIMOResult: PIMO curves dataclass object. See `PIMOResult` for details.
+        """
+        if self._is_empty:
+            msg = "No anomaly maps and masks have been added yet. Please call `update()` first."
+            raise RuntimeError(msg)
+        anomaly_maps = torch.concat(self.anomaly_maps, dim=0)
+        masks = torch.concat(self.masks, dim=0)
+
+        thresholds, shared_fpr, per_image_tprs, _ = functional.pimo_curves(
+            anomaly_maps,
+            masks,
+            self.num_thresholds,
+        )
+        return PIMOResult(
+            thresholds=thresholds,
+            shared_fpr=shared_fpr,
+            per_image_tprs=per_image_tprs,
+        )
+
+
+class AUPIMO(PIMO):
+    """Area Under the Per-Image Overlap (PIMO) curve.
+
+    This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code.
+    The tensors are converted to numpy arrays and then passed and validated in the numpy code.
+    The results are converted back to tensors and wrapped in an dataclass object.
+
+    Scores are computed from the integration of the PIMO curves within the given FPR bounds, then normalized to [0, 1].
+    It can be thought of as the average TPR of the PIMO curves within the given FPR bounds.
+
+    Details: `anomalib.metrics.per_image.pimo`.
+
+    Notation:
+        N: number of images
+        H: image height
+        W: image width
+        K: number of thresholds
+
+    Attributes:
+        anomaly_maps: floating point anomaly score maps of shape (N, H, W)
+        masks: binary (bool or int) ground truth masks of shape (N, H, W)
+
+    Args:
+        num_thresholds: number of thresholds to compute (K)
+        fpr_bounds: lower and upper bounds of the FPR integration range
+        force: whether to force the computation despite bad conditions
+
+    Returns:
+        tuple[PIMOResult, AUPIMOResult]: PIMO and AUPIMO results dataclass objects. See `PIMOResult` and `AUPIMOResult`.
+    """
+
+    fpr_bounds: tuple[float, float]
+    return_average: bool
+    force: bool
+
+    @staticmethod
+    def normalizing_factor(fpr_bounds: tuple[float, float]) -> float:
+        """Constant that normalizes the AUPIMO integral to 0-1 range.
+
+        It is the maximum possible value from the integral in AUPIMO's definition.
+        It corresponds to assuming a constant function T_i: thresh --> 1.
+
+        Args:
+            fpr_bounds: lower and upper bounds of the FPR integration range.
+
+        Returns:
+            float: the normalization factor (>0).
+        """
+        return functional.aupimo_normalizing_factor(fpr_bounds)
+
+    def __repr__(self) -> str:
+        """Show the metric name and its integration bounds."""
+        lower, upper = self.fpr_bounds
+        return f"{self.__class__.__name__}([{lower:.2g}, {upper:.2g}])"
+
+    def __init__(
+        self,
+        num_thresholds: int = 300_000,
+        fpr_bounds: tuple[float, float] = (1e-5, 1e-4),
+        return_average: bool = True,
+        force: bool = False,
+    ) -> None:
+        """Area Under the Per-Image Overlap (PIMO) curve.
+
+        Args:
+            num_thresholds: [passed to parent `PIMO`] number of thresholds used to compute the PIMO curve
+            fpr_bounds: lower and upper bounds of the FPR integration range
+            return_average: if True, return the average AUPIMO score; if False, return all the individual AUPIMO scores
+            force: if True, force the computation of the AUPIMO scores even in bad conditions (e.g. few points)
+        """
+        super().__init__(num_thresholds=num_thresholds)
+
+        # other validations are done in PIMO.__init__()
+
+        _validate.is_rate_range(fpr_bounds)
+        self.fpr_bounds = fpr_bounds
+        self.return_average = return_average
+        self.force = force
+
+    def compute(self, force: bool | None = None) -> tuple[PIMOResult, AUPIMOResult]:  # type: ignore[override]
+        """Compute the PIMO curves and their Area Under the curve (AUPIMO) scores.
+
+        Call the functional interface `aupimo_scores()`, which is a wrapper around the numpy code.
+
+        Args:
+            force: if given (not None), override the `force` attribute.
+
+        Returns:
+            tuple[PIMOResult, AUPIMOResult]: PIMO curves and AUPIMO scores dataclass objects.
+                See `PIMOResult` and `AUPIMOResult` for details.
+        """
+        if self._is_empty:
+            msg = "No anomaly maps and masks have been added yet. Please call `update()` first."
+            raise RuntimeError(msg)
+        anomaly_maps = torch.concat(self.anomaly_maps, dim=0)
+        masks = torch.concat(self.masks, dim=0)
+        force = force if force is not None else self.force
+
+        # other validations are done in the numpy code
+
+        thresholds, shared_fpr, per_image_tprs, _, aupimos, num_thresholds_auc = functional.aupimo_scores(
+            anomaly_maps,
+            masks,
+            self.num_thresholds,
+            fpr_bounds=self.fpr_bounds,
+            force=force,
+        )
+
+        pimo_result = PIMOResult(
+            thresholds=thresholds,
+            shared_fpr=shared_fpr,
+            per_image_tprs=per_image_tprs,
+        )
+        aupimo_result = AUPIMOResult.from_pimo_result(
+            pimo_result,
+            fpr_bounds=self.fpr_bounds,
+            # not `num_thresholds`!
+            # `num_thresholds` is the number of thresholds used to compute the PIMO curve
+            # this is the number of thresholds used to compute the AUPIMO integral
+            num_thresholds_auc=num_thresholds_auc,
+            aupimos=aupimos,
+        )
+        if self.return_average:
+            # normal images have NaN AUPIMO scores
+            is_nan = torch.isnan(aupimo_result.aupimos)
+            return aupimo_result.aupimos[~is_nan].mean()
+        return pimo_result, aupimo_result
diff --git a/src/anomalib/metrics/pimo/utils.py b/src/anomalib/metrics/pimo/utils.py
new file mode 100644
index 0000000000..f0cac45657
--- /dev/null
+++ b/src/anomalib/metrics/pimo/utils.py
@@ -0,0 +1,19 @@
+"""Torch-oriented interfaces for `utils.py`."""
+
+# Original Code
+# https://github.com/jpcbertoldo/aupimo
+#
+# Modified
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+import torch
+
+logger = logging.getLogger(__name__)
+
+
+def images_classes_from_masks(masks: torch.Tensor) -> torch.Tensor:
+    """Deduce the image classes from the masks."""
+    return (masks == 1).any(axis=(1, 2)).to(torch.int32)
diff --git a/src/anomalib/models/components/base/export_mixin.py b/src/anomalib/models/components/base/export_mixin.py
index bd44fb2a61..210a314d22 100644
--- a/src/anomalib/models/components/base/export_mixin.py
+++ b/src/anomalib/models/components/base/export_mixin.py
@@ -13,6 +13,7 @@
 import numpy as np
 import torch
 from lightning.pytorch import LightningModule
+from lightning_utilities.core.imports import package_available
 from torch import nn
 from torchmetrics import Metric
 from torchvision.transforms.v2 import Transform
@@ -22,7 +23,6 @@
 from anomalib.deploy.export import CompressionType, ExportType
 from anomalib.deploy.utils import make_transform_exportable
 from anomalib.metrics import create_metric_collection
-from anomalib.utils.exceptions import try_import
 
 if TYPE_CHECKING:
     from importlib.util import find_spec
@@ -139,7 +139,9 @@ def to_onnx(
         input_shape = torch.zeros((1, 3, *input_size)) if input_size else torch.zeros((1, 3, 1, 1))
         input_shape = input_shape.to(self.device)
         dynamic_axes = (
-            None if input_size else {"input": {0: "batch_size", 2: "height", 3: "weight"}, "output": {0: "batch_size"}}
+            {"input": {0: "batch_size"}, "output": {0: "batch_size"}}
+            if input_size
+            else {"input": {0: "batch_size", 2: "height", 3: "weight"}, "output": {0: "batch_size"}}
         )
         onnx_path = export_root / "model.onnx"
         # apply pass through the model to get the output names
@@ -241,7 +243,7 @@ def to_openvino(
             ...     task="segmentation",
             ... )
         """
-        if not try_import("openvino"):
+        if not package_available("openvino"):
             logger.exception("Could not find OpenVINO. Please check OpenVINO installation.")
             raise ModuleNotFoundError
 
@@ -289,7 +291,7 @@ def _compress_ov_model(
         Returns:
             model (CompiledModel): Model in the OpenVINO format compressed with NNCF quantization.
         """
-        if not try_import("nncf"):
+        if not package_available("nncf"):
             logger.exception("Could not find NCCF. Please check NNCF installation.")
             raise ModuleNotFoundError
 
diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py
index 1ee025d117..ba63ad4d46 100644
--- a/src/anomalib/models/image/draem/lightning_model.py
+++ b/src/anomalib/models/image/draem/lightning_model.py
@@ -12,6 +12,7 @@
 import torch
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 from torch import nn
+from torchvision.transforms.v2 import Compose, Resize, Transform
 
 from anomalib import LearningType
 from anomalib.data import Batch
@@ -150,3 +151,13 @@ def learning_type(self) -> LearningType:
             LearningType: Learning type of the model.
         """
         return LearningType.ONE_CLASS
+
+    @staticmethod
+    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
+        """Default transform for DRAEM. Normalization is not needed as the images are scaled to [0, 1] in Dataset."""
+        image_size = image_size or (256, 256)
+        return Compose(
+            [
+                Resize(image_size, antialias=True),
+            ],
+        )
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index a0c41bfc66..e96a4fdb8b 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -12,6 +12,7 @@
 
 import torch
 from lightning.pytorch.utilities.types import STEP_OUTPUT, OptimizerLRScheduler
+from torchvision.transforms.v2 import Compose, Resize, Transform
 
 from anomalib import LearningType
 from anomalib.data import Batch
@@ -189,3 +190,9 @@ def learning_type(self) -> LearningType:
             LearningType: Learning type of the model.
         """
         return LearningType.ONE_CLASS
+
+    @staticmethod
+    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
+        """Default transform for DSR. Normalization is not needed as the images are scaled to [0, 1] in Dataset."""
+        image_size = image_size or (256, 256)
+        return Compose([Resize(image_size, antialias=True)])
diff --git a/src/anomalib/models/image/rkde/lightning_model.py b/src/anomalib/models/image/rkde/lightning_model.py
index 02ad6c2564..f8b6af6d7a 100644
--- a/src/anomalib/models/image/rkde/lightning_model.py
+++ b/src/anomalib/models/image/rkde/lightning_model.py
@@ -11,6 +11,7 @@
 
 import torch
 from lightning.pytorch.utilities.types import STEP_OUTPUT
+from torchvision.transforms.v2 import Compose, Resize, Transform
 
 from anomalib import LearningType
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
@@ -143,3 +144,13 @@ def learning_type(self) -> LearningType:
             LearningType: Learning type of the model.
         """
         return LearningType.ONE_CLASS
+
+    @staticmethod
+    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
+        """Default transform for RKDE."""
+        image_size = image_size or (240, 360)
+        return Compose(
+            [
+                Resize(image_size, antialias=True),
+            ],
+        )
diff --git a/src/anomalib/utils/exceptions/imports.py b/src/anomalib/utils/exceptions/imports.py
index ebf6f11c61..dac22ba056 100644
--- a/src/anomalib/utils/exceptions/imports.py
+++ b/src/anomalib/utils/exceptions/imports.py
@@ -18,6 +18,15 @@ def try_import(import_path: str) -> bool:
     Returns:
         bool: True if import succeeds, False otherwise.
     """
+    import warnings
+
+    warnings.warn(
+        "The 'try_import' function is deprecated and will be removed in v2.0.0. "
+        "Use 'package_available' from lightning-utilities instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
     try:
         import_module(import_path)
     except ImportError:
diff --git a/tests/unit/data/utils/test_path.py b/tests/unit/data/utils/test_path.py
index c3f134b021..09f88496ad 100644
--- a/tests/unit/data/utils/test_path.py
+++ b/tests/unit/data/utils/test_path.py
@@ -76,3 +76,9 @@ def test_no_read_execute_permission() -> None:
             Path(tmp_dir).chmod(0o222)  # Remove read and execute permission
             with pytest.raises(PermissionError, match=r"Read or execute permissions denied for the path:*"):
                 validate_path(tmp_dir, base_dir=Path(tmp_dir))
+
+    @staticmethod
+    def test_file_wrongsuffix() -> None:
+        """Test ``validate_path`` raises ValueError for a file with wrong suffix."""
+        with pytest.raises(ValueError, match="Path extension is not accepted."):
+            validate_path("file.png", should_exist=False, extensions=(".json", ".txt"))
diff --git a/tests/unit/metrics/pimo/__init__.py b/tests/unit/metrics/pimo/__init__.py
new file mode 100644
index 0000000000..555d67a102
--- /dev/null
+++ b/tests/unit/metrics/pimo/__init__.py
@@ -0,0 +1,8 @@
+"""Per-Image Metrics Tests."""
+
+# Original Code
+# https://github.com/jpcbertoldo/aupimo
+#
+# Modified
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/metrics/pimo/test_binary_classification_curve.py b/tests/unit/metrics/pimo/test_binary_classification_curve.py
new file mode 100644
index 0000000000..5459d08a14
--- /dev/null
+++ b/tests/unit/metrics/pimo/test_binary_classification_curve.py
@@ -0,0 +1,423 @@
+"""Tests for per-image binary classification curves using numpy version."""
+
+# Original Code
+# https://github.com/jpcbertoldo/aupimo
+#
+# Modified
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# ruff: noqa: SLF001, PT011
+
+import pytest
+import torch
+
+from anomalib.metrics.pimo.binary_classification_curve import (
+    _binary_classification_curve,
+    binary_classification_curve,
+    per_image_fpr,
+    per_image_tpr,
+    threshold_and_binary_classification_curve,
+)
+
+
+def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
+    """Generate test cases."""
+    pred = torch.arange(1, 5, dtype=torch.float32)
+    thresholds = torch.arange(1, 5, dtype=torch.float32)
+
+    gt_norm = torch.zeros(4).to(bool)
+    gt_anom = torch.concatenate([torch.zeros(2), torch.ones(2)]).to(bool)
+
+    # in the case where thresholds are all unique values in the predictions
+    expected_norm = torch.stack(
+        [
+            torch.tensor([[0, 4], [0, 0]]),
+            torch.tensor([[1, 3], [0, 0]]),
+            torch.tensor([[2, 2], [0, 0]]),
+            torch.tensor([[3, 1], [0, 0]]),
+        ],
+        axis=0,
+    ).to(int)
+    expected_anom = torch.stack(
+        [
+            torch.tensor([[0, 2], [0, 2]]),
+            torch.tensor([[1, 1], [0, 2]]),
+            torch.tensor([[2, 0], [0, 2]]),
+            torch.tensor([[2, 0], [1, 1]]),
+        ],
+        axis=0,
+    ).to(int)
+
+    expected_tprs_norm = torch.tensor([torch.nan, torch.nan, torch.nan, torch.nan])
+    expected_tprs_anom = torch.tensor([1.0, 1.0, 1.0, 0.5])
+    expected_tprs = torch.stack([expected_tprs_anom, expected_tprs_norm], axis=0).to(torch.float64)
+
+    expected_fprs_norm = torch.tensor([1.0, 0.75, 0.5, 0.25])
+    expected_fprs_anom = torch.tensor([1.0, 0.5, 0.0, 0.0])
+    expected_fprs = torch.stack([expected_fprs_anom, expected_fprs_norm], axis=0).to(torch.float64)
+
+    # in the case where all thresholds are higher than the highest prediction
+    expected_norm_thresholds_too_high = torch.stack(
+        [
+            torch.tensor([[4, 0], [0, 0]]),
+            torch.tensor([[4, 0], [0, 0]]),
+            torch.tensor([[4, 0], [0, 0]]),
+            torch.tensor([[4, 0], [0, 0]]),
+        ],
+        axis=0,
+    ).to(int)
+    expected_anom_thresholds_too_high = torch.stack(
+        [
+            torch.tensor([[2, 0], [2, 0]]),
+            torch.tensor([[2, 0], [2, 0]]),
+            torch.tensor([[2, 0], [2, 0]]),
+            torch.tensor([[2, 0], [2, 0]]),
+        ],
+        axis=0,
+    ).to(int)
+
+    # in the case where all thresholds are lower than the lowest prediction
+    expected_norm_thresholds_too_low = torch.stack(
+        [
+            torch.tensor([[0, 4], [0, 0]]),
+            torch.tensor([[0, 4], [0, 0]]),
+            torch.tensor([[0, 4], [0, 0]]),
+            torch.tensor([[0, 4], [0, 0]]),
+        ],
+        axis=0,
+    ).to(int)
+    expected_anom_thresholds_too_low = torch.stack(
+        [
+            torch.tensor([[0, 2], [0, 2]]),
+            torch.tensor([[0, 2], [0, 2]]),
+            torch.tensor([[0, 2], [0, 2]]),
+            torch.tensor([[0, 2], [0, 2]]),
+        ],
+        axis=0,
+    ).to(int)
+
+    if metafunc.function is test__binclf_one_curve:
+        metafunc.parametrize(
+            argnames=("pred", "gt", "thresholds", "expected"),
+            argvalues=[
+                (pred, gt_anom, thresholds[:3], expected_anom[:3]),
+                (pred, gt_anom, thresholds, expected_anom),
+                (pred, gt_norm, thresholds, expected_norm),
+                (pred, gt_norm, 10 * thresholds, expected_norm_thresholds_too_high),
+                (pred, gt_anom, 10 * thresholds, expected_anom_thresholds_too_high),
+                (pred, gt_norm, 0.001 * thresholds, expected_norm_thresholds_too_low),
+                (pred, gt_anom, 0.001 * thresholds, expected_anom_thresholds_too_low),
+            ],
+        )
+
+    preds = torch.stack([pred, pred], axis=0)
+    gts = torch.stack([gt_anom, gt_norm], axis=0)
+    binclf_curves = torch.stack([expected_anom, expected_norm], axis=0)
+    binclf_curves_thresholds_too_high = torch.stack(
+        [expected_anom_thresholds_too_high, expected_norm_thresholds_too_high],
+        axis=0,
+    )
+    binclf_curves_thresholds_too_low = torch.stack(
+        [expected_anom_thresholds_too_low, expected_norm_thresholds_too_low],
+        axis=0,
+    )
+
+    if metafunc.function is test__binclf_multiple_curves:
+        metafunc.parametrize(
+            argnames=("preds", "gts", "thresholds", "expecteds"),
+            argvalues=[
+                (preds, gts, thresholds[:3], binclf_curves[:, :3]),
+                (preds, gts, thresholds, binclf_curves),
+            ],
+        )
+
+    if metafunc.function is test_binclf_multiple_curves:
+        metafunc.parametrize(
+            argnames=(
+                "preds",
+                "gts",
+                "thresholds",
+                "expected_binclf_curves",
+            ),
+            argvalues=[
+                (preds[:1], gts[:1], thresholds, binclf_curves[:1]),
+                (preds, gts, thresholds, binclf_curves),
+                (10 * preds, gts, 10 * thresholds, binclf_curves),
+            ],
+        )
+
+    if metafunc.function is test_binclf_multiple_curves_validations:
+        metafunc.parametrize(
+            argnames=("args", "kwargs", "exception"),
+            argvalues=[
+                # `scores` and `gts` must be 2D
+                ([preds.reshape(2, 2, 2), gts, thresholds], {}, ValueError),
+                ([preds, gts.flatten(), thresholds], {}, ValueError),
+                # `thresholds` must be 1D
+                ([preds, gts, thresholds.reshape(2, 2)], {}, ValueError),
+                # `scores` and `gts` must have the same shape
+                ([preds, gts[:1], thresholds], {}, ValueError),
+                ([preds[:, :2], gts, thresholds], {}, ValueError),
+                # `scores` be of type float
+                ([preds.to(int), gts, thresholds], {}, TypeError),
+                # `gts` be of type bool
+                ([preds, gts.to(int), thresholds], {}, TypeError),
+                # `thresholds` be of type float
+                ([preds, gts, thresholds.to(int)], {}, TypeError),
+                # `thresholds` must be sorted in ascending order
+                ([preds, gts, torch.flip(thresholds, dims=[0])], {}, ValueError),
+                ([preds, gts, torch.concatenate([thresholds[-2:], thresholds[:2]])], {}, ValueError),
+                # `thresholds` must be unique
+                ([preds, gts, torch.sort(torch.concatenate([thresholds, thresholds]))[0]], {}, ValueError),
+            ],
+        )
+
+    # the following tests are for `per_image_binclf_curve()`, which expects
+    # inputs in image spatial format, i.e. (height, width)
+    preds = preds.reshape(2, 2, 2)
+    gts = gts.reshape(2, 2, 2)
+
+    per_image_binclf_curves_argvalues = [
+        # `thresholds_choice` = "given"
+        (
+            preds,
+            gts,
+            "given",
+            thresholds,
+            None,
+            thresholds,
+            binclf_curves,
+        ),
+        (
+            preds,
+            gts,
+            "given",
+            10 * thresholds,
+            2,
+            10 * thresholds,
+            binclf_curves_thresholds_too_high,
+        ),
+        (
+            preds,
+            gts,
+            "given",
+            0.01 * thresholds,
+            None,
+            0.01 * thresholds,
+            binclf_curves_thresholds_too_low,
+        ),
+        # `thresholds_choice` = 'minmax-linspace'"
+        (
+            preds,
+            gts,
+            "minmax-linspace",
+            None,
+            len(thresholds),
+            thresholds,
+            binclf_curves,
+        ),
+        (
+            2 * preds,
+            gts.to(int),  # this is ok
+            "minmax-linspace",
+            None,
+            len(thresholds),
+            2 * thresholds,
+            binclf_curves,
+        ),
+    ]
+
+    if metafunc.function is test_per_image_binclf_curve:
+        metafunc.parametrize(
+            argnames=(
+                "anomaly_maps",
+                "masks",
+                "threshold_choice",
+                "thresholds",
+                "num_thresholds",
+                "expected_thresholds",
+                "expected_binclf_curves",
+            ),
+            argvalues=per_image_binclf_curves_argvalues,
+        )
+
+    if metafunc.function is test_per_image_binclf_curve_validations:
+        metafunc.parametrize(
+            argnames=("args", "exception"),
+            argvalues=[
+                # `scores` and `gts` must be 3D
+                ([preds.reshape(2, 2, 2, 1), gts], ValueError),
+                ([preds, gts.flatten()], ValueError),
+                # `scores` and `gts` must have the same shape
+                ([preds, gts[:1]], ValueError),
+                ([preds[:, :1], gts], ValueError),
+                # `scores` be of type float
+                ([preds.to(int), gts], TypeError),
+                # `gts` be of type bool or int
+                ([preds, gts.to(float)], TypeError),
+                # `thresholds` be of type float
+                ([preds, gts, thresholds.to(int)], TypeError),
+            ],
+        )
+        metafunc.parametrize(
+            argnames=("kwargs",),
+            argvalues=[
+                (
+                    {
+                        "threshold_choice": "minmax-linspace",
+                        "thresholds": None,
+                        "num_thresholds": len(thresholds),
+                    },
+                ),
+            ],
+        )
+
+    # same as above but testing other validations
+    if metafunc.function is test_per_image_binclf_curve_validations_alt:
+        metafunc.parametrize(
+            argnames=("args", "kwargs", "exception"),
+            argvalues=[
+                # invalid `thresholds_choice`
+                (
+                    [preds, gts],
+                    {"threshold_choice": "glfrb", "thresholds": thresholds, "num_thresholds": None},
+                    ValueError,
+                ),
+            ],
+        )
+
+    if metafunc.function is test_rate_metrics:
+        metafunc.parametrize(
+            argnames=("binclf_curves", "expected_fprs", "expected_tprs"),
+            argvalues=[
+                (binclf_curves, expected_fprs, expected_tprs),
+                (10 * binclf_curves, expected_fprs, expected_tprs),
+            ],
+        )
+
+
+# ==================================================================================================
+# LOW-LEVEL FUNCTIONS (PYTHON)
+
+
+def test__binclf_one_curve(
+    pred: torch.Tensor,
+    gt: torch.Tensor,
+    thresholds: torch.Tensor,
+    expected: torch.Tensor,
+) -> None:
+    """Test if `_binclf_one_curve()` returns the expected values."""
+    computed = _binary_classification_curve(pred, gt, thresholds)
+    assert computed.shape == (thresholds.numel(), 2, 2)
+    assert (computed == expected.numpy()).all()
+
+
+def test__binclf_multiple_curves(
+    preds: torch.Tensor,
+    gts: torch.Tensor,
+    thresholds: torch.Tensor,
+    expecteds: torch.Tensor,
+) -> None:
+    """Test if `_binclf_multiple_curves()` returns the expected values."""
+    computed = binary_classification_curve(preds, gts, thresholds)
+    assert computed.shape == (preds.shape[0], thresholds.numel(), 2, 2)
+    assert (computed == expecteds).all()
+
+
+# ==================================================================================================
+# API FUNCTIONS (NUMPY)
+
+
+def test_binclf_multiple_curves(
+    preds: torch.Tensor,
+    gts: torch.Tensor,
+    thresholds: torch.Tensor,
+    expected_binclf_curves: torch.Tensor,
+) -> None:
+    """Test if `binclf_multiple_curves()` returns the expected values."""
+    computed = binary_classification_curve(
+        preds,
+        gts,
+        thresholds,
+    )
+    assert computed.shape == expected_binclf_curves.shape
+    assert (computed == expected_binclf_curves).all()
+
+    # it's ok to have the threhsholds beyond the range of the preds
+    binary_classification_curve(preds, gts, 2 * thresholds)
+
+    # or inside the bounds without reaching them
+    binary_classification_curve(preds, gts, 0.5 * thresholds)
+
+    # it's also ok to have more thresholds than unique values in the preds
+    # add the values in between the thresholds
+    thresholds_unncessary = 0.5 * (thresholds[:-1] + thresholds[1:])
+    thresholds_unncessary = torch.concatenate([thresholds_unncessary, thresholds])
+    thresholds_unncessary = torch.sort(thresholds_unncessary)[0]
+    binary_classification_curve(preds, gts, thresholds_unncessary)
+
+    # or less
+    binary_classification_curve(preds, gts, thresholds[1:3])
+
+
+def test_binclf_multiple_curves_validations(args: list, kwargs: dict, exception: Exception) -> None:
+    """Test if `_binclf_multiple_curves_python()` raises the expected errors."""
+    with pytest.raises(exception):
+        binary_classification_curve(*args, **kwargs)
+
+
+def test_per_image_binclf_curve(
+    anomaly_maps: torch.Tensor,
+    masks: torch.Tensor,
+    threshold_choice: str,
+    thresholds: torch.Tensor | None,
+    num_thresholds: int | None,
+    expected_thresholds: torch.Tensor,
+    expected_binclf_curves: torch.Tensor,
+) -> None:
+    """Test if `per_image_binclf_curve()` returns the expected values."""
+    computed_thresholds, computed_binclf_curves = threshold_and_binary_classification_curve(
+        anomaly_maps,
+        masks,
+        threshold_choice=threshold_choice,
+        thresholds=thresholds,
+        num_thresholds=num_thresholds,
+    )
+
+    # thresholds
+    assert computed_thresholds.shape == expected_thresholds.shape
+    assert computed_thresholds.dtype == computed_thresholds.dtype
+    assert (computed_thresholds == expected_thresholds).all()
+
+    # binclf_curves
+    assert computed_binclf_curves.shape == expected_binclf_curves.shape
+    assert computed_binclf_curves.dtype == expected_binclf_curves.dtype
+    assert (computed_binclf_curves == expected_binclf_curves).all()
+
+
+def test_per_image_binclf_curve_validations(args: list, kwargs: dict, exception: Exception) -> None:
+    """Test if `per_image_binclf_curve()` raises the expected errors."""
+    with pytest.raises(exception):
+        threshold_and_binary_classification_curve(*args, **kwargs)
+
+
+def test_per_image_binclf_curve_validations_alt(args: list, kwargs: dict, exception: Exception) -> None:
+    """Test if `per_image_binclf_curve()` raises the expected errors."""
+    test_per_image_binclf_curve_validations(args, kwargs, exception)
+
+
+def test_rate_metrics(
+    binclf_curves: torch.Tensor,
+    expected_fprs: torch.Tensor,
+    expected_tprs: torch.Tensor,
+) -> None:
+    """Test if rate metrics are computed correctly."""
+    tprs = per_image_tpr(binclf_curves)
+    fprs = per_image_fpr(binclf_curves)
+
+    assert tprs.shape == expected_tprs.shape
+    assert fprs.shape == expected_fprs.shape
+
+    assert torch.allclose(tprs, expected_tprs, equal_nan=True)
+    assert torch.allclose(fprs, expected_fprs, equal_nan=True)
diff --git a/tests/unit/metrics/pimo/test_pimo.py b/tests/unit/metrics/pimo/test_pimo.py
new file mode 100644
index 0000000000..81bafe4c8e
--- /dev/null
+++ b/tests/unit/metrics/pimo/test_pimo.py
@@ -0,0 +1,368 @@
+"""Test `anomalib.metrics.per_image.functional`."""
+
+# Original Code
+# https://github.com/jpcbertoldo/aupimo
+#
+# Modified
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+import pytest
+import torch
+from torch import Tensor
+
+from anomalib.metrics.pimo import AUPIMOResult, PIMOResult, functional, pimo
+
+
+def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
+    """Generate tests for all functions in this module.
+
+    All functions are parametrized with the same setting: 1 normal and 2 anomalous images.
+    The anomaly maps are the same for all functions, but the masks are different.
+    """
+    expected_thresholds = torch.arange(1, 7 + 1, dtype=torch.float32)
+    shape = (1000, 1000)  # (H, W), 1 million pixels
+
+    # --- normal ---
+    # histogram of scores:
+    # value:   7   6    5    4    3    2     1
+    # count:   1   9   90  900   9k   90k  900k
+    # cumsum:  1  10  100   1k  10k  100k    1M
+    pred_norm = torch.ones(1_000_000, dtype=torch.float32)
+    pred_norm[:100_000] += 1
+    pred_norm[:10_000] += 1
+    pred_norm[:1_000] += 1
+    pred_norm[:100] += 1
+    pred_norm[:10] += 1
+    pred_norm[:1] += 1
+    pred_norm = pred_norm.reshape(shape)
+    mask_norm = torch.zeros_like(pred_norm, dtype=torch.int32)
+
+    expected_fpr_norm = torch.tensor([1.0, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6], dtype=torch.float64)
+    expected_tpr_norm = torch.full((7,), torch.nan, dtype=torch.float64)
+
+    # --- anomalous ---
+    pred_anom1 = pred_norm.clone()
+    mask_anom1 = torch.ones_like(pred_anom1, dtype=torch.int32)
+    expected_tpr_anom1 = expected_fpr_norm.clone()
+
+    # only the first 100_000 pixels are anomalous
+    # which corresponds to the first 100_000 highest scores (2 to 7)
+    pred_anom2 = pred_norm.clone()
+    mask_anom2 = torch.concatenate([torch.ones(100_000), torch.zeros(900_000)]).reshape(shape).to(torch.int32)
+    expected_tpr_anom2 = (10 * expected_fpr_norm).clip(0, 1)
+
+    anomaly_maps = torch.stack([pred_norm, pred_anom1, pred_anom2], axis=0)
+    masks = torch.stack([mask_norm, mask_anom1, mask_anom2], axis=0)
+
+    expected_shared_fpr = expected_fpr_norm
+    expected_per_image_tprs = torch.stack([expected_tpr_norm, expected_tpr_anom1, expected_tpr_anom2], axis=0)
+    expected_image_classes = torch.tensor([0, 1, 1], dtype=torch.int32)
+
+    if metafunc.function is test_pimo or metafunc.function is test_aupimo_values:
+        argvalues_tensors = [
+            (
+                anomaly_maps,
+                masks,
+                expected_thresholds,
+                expected_shared_fpr,
+                expected_per_image_tprs,
+                expected_image_classes,
+            ),
+            (
+                10 * anomaly_maps,
+                masks,
+                10 * expected_thresholds,
+                expected_shared_fpr,
+                expected_per_image_tprs,
+                expected_image_classes,
+            ),
+        ]
+        metafunc.parametrize(
+            argnames=(
+                "anomaly_maps",
+                "masks",
+                "expected_thresholds",
+                "expected_shared_fpr",
+                "expected_per_image_tprs",
+                "expected_image_classes",
+            ),
+            argvalues=argvalues_tensors,
+        )
+
+    if metafunc.function is test_aupimo_values:
+        argvalues_tensors = [
+            (
+                (1e-1, 1.0),
+                torch.tensor(
+                    [
+                        torch.nan,
+                        # recall: trapezium area = (a + b) * h / 2
+                        (0.10 + 1.0) * 1 / 2,
+                        (1.0 + 1.0) * 1 / 2,
+                    ],
+                    dtype=torch.float64,
+                ),
+            ),
+            (
+                (1e-3, 1e-1),
+                torch.tensor(
+                    [
+                        torch.nan,
+                        # average of two trapezium areas / 2 (normalizing factor)
+                        (((1e-3 + 1e-2) * 1 / 2) + ((1e-2 + 1e-1) * 1 / 2)) / 2,
+                        (((1e-2 + 1e-1) * 1 / 2) + ((1e-1 + 1.0) * 1 / 2)) / 2,
+                    ],
+                    dtype=torch.float64,
+                ),
+            ),
+            (
+                (1e-5, 1e-4),
+                torch.tensor(
+                    [
+                        torch.nan,
+                        (1e-5 + 1e-4) * 1 / 2,
+                        (1e-4 + 1e-3) * 1 / 2,
+                    ],
+                    dtype=torch.float64,
+                ),
+            ),
+        ]
+        metafunc.parametrize(
+            argnames=(
+                "fpr_bounds",
+                "expected_aupimos",  # trapezoid surfaces
+            ),
+            argvalues=argvalues_tensors,
+        )
+
+    if metafunc.function is test_aupimo_edge:
+        metafunc.parametrize(
+            argnames=(
+                "anomaly_maps",
+                "masks",
+            ),
+            argvalues=[
+                (
+                    anomaly_maps,
+                    masks,
+                ),
+                (
+                    10 * anomaly_maps,
+                    masks,
+                ),
+            ],
+        )
+        metafunc.parametrize(
+            argnames=("fpr_bounds",),
+            argvalues=[
+                ((1e-1, 1.0),),
+                ((1e-3, 1e-2),),
+                ((1e-5, 1e-4),),
+                (None,),
+            ],
+        )
+
+
+def _do_test_pimo_outputs(
+    thresholds: Tensor,
+    shared_fpr: Tensor,
+    per_image_tprs: Tensor,
+    image_classes: Tensor,
+    expected_thresholds: Tensor,
+    expected_shared_fpr: Tensor,
+    expected_per_image_tprs: Tensor,
+    expected_image_classes: Tensor,
+) -> None:
+    """Test if the outputs of any of the PIMO interfaces are correct."""
+    assert isinstance(shared_fpr, Tensor)
+    assert isinstance(per_image_tprs, Tensor)
+    assert isinstance(image_classes, Tensor)
+    assert isinstance(expected_thresholds, Tensor)
+    assert isinstance(expected_shared_fpr, Tensor)
+    assert isinstance(expected_per_image_tprs, Tensor)
+    assert isinstance(expected_image_classes, Tensor)
+    allclose = torch.allclose
+
+    assert thresholds.ndim == 1
+    assert shared_fpr.ndim == 1
+    assert per_image_tprs.ndim == 2
+    assert tuple(image_classes.shape) == (3,)
+
+    assert allclose(thresholds, expected_thresholds)
+    assert allclose(shared_fpr, expected_shared_fpr)
+    assert allclose(per_image_tprs, expected_per_image_tprs, equal_nan=True)
+    assert (image_classes == expected_image_classes).all()
+
+
+def test_pimo(
+    anomaly_maps: Tensor,
+    masks: Tensor,
+    expected_thresholds: Tensor,
+    expected_shared_fpr: Tensor,
+    expected_per_image_tprs: Tensor,
+    expected_image_classes: Tensor,
+) -> None:
+    """Test if `pimo()` returns the expected values."""
+
+    def do_assertions(pimo_result: PIMOResult) -> None:
+        thresholds = pimo_result.thresholds
+        shared_fpr = pimo_result.shared_fpr
+        per_image_tprs = pimo_result.per_image_tprs
+        image_classes = pimo_result.image_classes
+        _do_test_pimo_outputs(
+            thresholds,
+            shared_fpr,
+            per_image_tprs,
+            image_classes,
+            expected_thresholds,
+            expected_shared_fpr,
+            expected_per_image_tprs,
+            expected_image_classes,
+        )
+
+    # metric interface
+    metric = pimo.PIMO(
+        num_thresholds=7,
+    )
+    metric.update(anomaly_maps, masks)
+    pimo_result = metric.compute()
+    do_assertions(pimo_result)
+
+
+def _do_test_aupimo_outputs(
+    thresholds: Tensor,
+    shared_fpr: Tensor,
+    per_image_tprs: Tensor,
+    image_classes: Tensor,
+    aupimos: Tensor,
+    expected_thresholds: Tensor,
+    expected_shared_fpr: Tensor,
+    expected_per_image_tprs: Tensor,
+    expected_image_classes: Tensor,
+    expected_aupimos: Tensor,
+) -> None:
+    _do_test_pimo_outputs(
+        thresholds,
+        shared_fpr,
+        per_image_tprs,
+        image_classes,
+        expected_thresholds,
+        expected_shared_fpr,
+        expected_per_image_tprs,
+        expected_image_classes,
+    )
+    assert isinstance(aupimos, Tensor)
+    assert isinstance(expected_aupimos, Tensor)
+    allclose = torch.allclose
+    assert tuple(aupimos.shape) == (3,)
+    assert allclose(aupimos, expected_aupimos, equal_nan=True)
+
+
+def test_aupimo_values(
+    anomaly_maps: torch.Tensor,
+    masks: torch.Tensor,
+    fpr_bounds: tuple[float, float],
+    expected_thresholds: torch.Tensor,
+    expected_shared_fpr: torch.Tensor,
+    expected_per_image_tprs: torch.Tensor,
+    expected_image_classes: torch.Tensor,
+    expected_aupimos: torch.Tensor,
+) -> None:
+    """Test if `aupimo()` returns the expected values."""
+
+    def do_assertions(pimo_result: PIMOResult, aupimo_result: AUPIMOResult) -> None:
+        # test metadata
+        assert aupimo_result.fpr_bounds == fpr_bounds
+        # recall: this one is not the same as the number of thresholds in the curve
+        # this is the number of thresholds used to compute the integral in `aupimo()`
+        # always less because of the integration bounds
+        assert aupimo_result.num_thresholds < 7
+
+        # test data
+        # from pimo result
+        thresholds = pimo_result.thresholds
+        shared_fpr = pimo_result.shared_fpr
+        per_image_tprs = pimo_result.per_image_tprs
+        image_classes = pimo_result.image_classes
+        # from aupimo result
+        aupimos = aupimo_result.aupimos
+        _do_test_aupimo_outputs(
+            thresholds,
+            shared_fpr,
+            per_image_tprs,
+            image_classes,
+            aupimos,
+            expected_thresholds,
+            expected_shared_fpr,
+            expected_per_image_tprs,
+            expected_image_classes,
+            expected_aupimos,
+        )
+        thresh_lower_bound = aupimo_result.thresh_lower_bound
+        thresh_upper_bound = aupimo_result.thresh_upper_bound
+        assert anomaly_maps.min() <= thresh_lower_bound < thresh_upper_bound <= anomaly_maps.max()
+
+    # metric interface
+    metric = pimo.AUPIMO(
+        num_thresholds=7,
+        fpr_bounds=fpr_bounds,
+        return_average=False,
+        force=True,
+    )
+    metric.update(anomaly_maps, masks)
+    pimo_result_from_metric, aupimo_result_from_metric = metric.compute()
+    do_assertions(pimo_result_from_metric, aupimo_result_from_metric)
+
+    # metric interface
+    metric = pimo.AUPIMO(
+        num_thresholds=7,
+        fpr_bounds=fpr_bounds,
+        return_average=True,  # only return the average AUPIMO
+        force=True,
+    )
+    metric.update(anomaly_maps, masks)
+    metric.compute()
+
+
+def test_aupimo_edge(
+    anomaly_maps: torch.Tensor,
+    masks: torch.Tensor,
+    fpr_bounds: tuple[float, float],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test some edge cases."""
+    # None is the case of testing the default bounds
+    fpr_bounds = {"fpr_bounds": fpr_bounds} if fpr_bounds is not None else {}
+
+    # not enough points on the curve
+    # 10 thresholds / 6 decades = 1.6 thresholds per decade < 3
+    with pytest.raises(RuntimeError):  # force=False --> raise error
+        functional.aupimo_scores(
+            anomaly_maps,
+            masks,
+            num_thresholds=10,
+            force=False,
+            **fpr_bounds,
+        )
+
+    with caplog.at_level(logging.WARNING):  # force=True --> warn
+        functional.aupimo_scores(
+            anomaly_maps,
+            masks,
+            num_thresholds=10,
+            force=True,
+            **fpr_bounds,
+        )
+    assert "Computation was forced!" in caplog.text
+
+    # default number of points on the curve (300k thresholds) should be enough
+    torch.manual_seed(42)
+    functional.aupimo_scores(
+        anomaly_maps * torch.FloatTensor(anomaly_maps.shape).uniform_(1.0, 1.1),
+        masks,
+        force=False,
+        **fpr_bounds,
+    )
diff --git a/third-party-programs.txt b/third-party-programs.txt
index 3155b2a930..5eeaca8ea9 100644
--- a/third-party-programs.txt
+++ b/third-party-programs.txt
@@ -42,3 +42,7 @@ terms are listed below.
 7. CLIP neural network used for deep feature extraction in AI-VAD model
    Copyright (c) 2022 @openai, https://github.com/openai/CLIP.
    SPDX-License-Identifier: MIT
+
+8. AUPIMO metric implementation is based on the original code
+   Copyright (c) 2023 @jpcbertoldo, https://github.com/jpcbertoldo/aupimo
+   SPDX-License-Identifier: MIT

From 6e1d8706d6318daf3713fdc332cf360ebe87cb0b Mon Sep 17 00:00:00 2001
From: Dick Ameln 
Date: Thu, 7 Nov 2024 17:02:34 +0100
Subject: [PATCH 10/45] Metrics redesign (#2326)

* refactor metrics callback

* add Evaluator class

* remove unused import

* add AnomalibMetric base class

* cleanup

* add create_anomalib_metric function

* use new AnomalibMetric class

* verify keys when updating metric

* use anomalib PR curve for f1max

* replace evaluator with metrics arg

* revert removing exportable transform method

* fix unit tests

* add kwargs to lightning models

* fix pre-commit issues

* remove kwargs key from update config

* add Evaluator to metrics init

* set default evaluator for image-only models

* fix cfa tests

* fix model tests

* update changelog

* remove tests of deprecated callback modules

* fix engine tests

* fix 201 notebook

* fix 600 notebook

* add default evaluator to fastflow

* revert cfa changes and fix pred score computation

* simplify evaluator argument

* validate metrics in evaluator

* remove unused import

* fix pred_label shape validation

* fix method name

* fix pred_label validator

* update validator tests

* fix method name in fastflow

* add AnomalibMetric functionality to PIMO

* add optional default fields and implement for pimo

* update aupimo notebooks

* use explicit args in lightning model signature

* remove kwargs from evaluator

* add _resolve_evaluator method

* fix config upgrade test

* do not force pypi install in mlflow notebook

* do not force pypi install in mlflow notebook
---
 CHANGELOG.md                                  |   1 +
 notebooks/200_models/201_fastflow.ipynb       |   1 -
 .../600_loggers/601_mlflow_logging.ipynb      |   5 +-
 notebooks/700_metrics/701a_aupimo.ipynb       | 223 +++---------
 .../700_metrics/701b_aupimo_advanced_i.ipynb  | 326 +++---------------
 .../700_metrics/701c_aupimo_advanced_ii.ipynb | 174 ++--------
 src/anomalib/callbacks/metrics.py             | 185 ----------
 src/anomalib/cli/cli.py                       |   4 -
 src/anomalib/data/validators/torch/image.py   |  14 +-
 src/anomalib/engine/engine.py                 |  12 +-
 src/anomalib/metrics/__init__.py              | 177 +---------
 src/anomalib/metrics/aupr.py                  |   7 +-
 src/anomalib/metrics/aupro.py                 |   7 +-
 src/anomalib/metrics/auroc.py                 |   8 +-
 src/anomalib/metrics/base.py                  | 127 +++++++
 src/anomalib/metrics/collection.py            |  37 --
 src/anomalib/metrics/evaluator.py             | 130 +++++++
 src/anomalib/metrics/f1_max.py                | 100 ------
 src/anomalib/metrics/f1_score.py              | 121 +++++--
 src/anomalib/metrics/pimo/pimo.py             |  18 +-
 src/anomalib/metrics/pro.py                   |   8 +-
 .../models/components/base/anomaly_module.py  |  66 ++--
 .../models/components/base/export_mixin.py    |  62 +---
 .../models/image/cfa/lightning_model.py       |   6 +-
 src/anomalib/models/image/cfa/torch_model.py  |   2 +-
 .../models/image/cflow/lightning_model.py     |   6 +-
 .../models/image/csflow/lightning_model.py    |   6 +-
 .../models/image/dfkde/lightning_model.py     |  14 +-
 .../models/image/dfm/lightning_model.py       |   6 +-
 .../models/image/draem/lightning_model.py     |   6 +-
 .../models/image/dsr/lightning_model.py       |  12 +-
 .../image/efficient_ad/lightning_model.py     |   6 +-
 .../models/image/fastflow/lightning_model.py  |  25 +-
 .../models/image/fre/lightning_model.py       |   6 +-
 .../models/image/ganomaly/lightning_model.py  |  14 +-
 .../models/image/padim/lightning_model.py     |   6 +-
 .../models/image/patchcore/lightning_model.py |   6 +-
 .../reverse_distillation/lightning_model.py   |   6 +-
 .../models/image/rkde/lightning_model.py      |   6 +-
 .../models/image/stfpm/lightning_model.py     |   6 +-
 .../models/image/uflow/lightning_model.py     |  25 +-
 .../models/image/winclip/lightning_model.py   |   7 +-
 .../models/video/ai_vad/lightning_model.py    |   3 +-
 tests/integration/model/test_models.py        |   1 -
 .../tools/upgrade/expected_draem_v1.yaml      |   2 +
 tests/unit/callbacks/__init__.py              |   4 -
 .../__init__.py                               |   4 -
 .../data/config-good-00.yaml                  |  13 -
 .../data/config-good-01.yaml                  |  13 -
 .../data/config-good-02-serialized.yaml       |  19 -
 .../data/config-good-02.yaml                  |  19 -
 .../test_metrics_configuration_callback.py    | 107 ------
 .../callbacks/test_normalization_callback.py  |  56 ---
 .../unit/data/validators/torch/test_depth.py  |   2 +-
 .../unit/data/validators/torch/test_image.py  |   2 +-
 tests/unit/engine/test_engine.py              |   5 -
 tests/unit/metrics/aupro/test_aupro.py        |   2 +-
 tests/unit/metrics/pimo/test_pimo.py          |   6 +-
 tests/unit/metrics/test_f1_max.py             |   2 +-
 tests/unit/metrics/test_pro.py                |   3 +-
 .../dummy_lightning_model.py                  |   4 +-
 .../visualizer_callback/test_visualizer.py    |   2 +-
 tests/unit/utils/test_visualizer.py           |   4 +-
 63 files changed, 737 insertions(+), 1520 deletions(-)
 delete mode 100644 src/anomalib/callbacks/metrics.py
 create mode 100644 src/anomalib/metrics/base.py
 delete mode 100644 src/anomalib/metrics/collection.py
 create mode 100644 src/anomalib/metrics/evaluator.py
 delete mode 100644 src/anomalib/metrics/f1_max.py
 delete mode 100644 tests/unit/callbacks/__init__.py
 delete mode 100644 tests/unit/callbacks/metrics_configuration_callback/__init__.py
 delete mode 100644 tests/unit/callbacks/metrics_configuration_callback/data/config-good-00.yaml
 delete mode 100644 tests/unit/callbacks/metrics_configuration_callback/data/config-good-01.yaml
 delete mode 100644 tests/unit/callbacks/metrics_configuration_callback/data/config-good-02-serialized.yaml
 delete mode 100644 tests/unit/callbacks/metrics_configuration_callback/data/config-good-02.yaml
 delete mode 100644 tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
 delete mode 100644 tests/unit/callbacks/test_normalization_callback.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 340641fb7c..24f95c932c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,6 +29,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Changed
 
+- Implement new design for metrics by @djdameln https://github.com/openvinotoolkit/anomalib/pull/2326
 - Set permissions for github workflows by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/2127
 - Update timm requirement from <=1.0.3,>=0.5.4 to >=0.5.4,<=1.0.7 by @dependabot in https://github.com/openvinotoolkit/anomalib/pull/2151
 - 🚀 Use gh actions runners for pre-commit checks by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2160
diff --git a/notebooks/200_models/201_fastflow.ipynb b/notebooks/200_models/201_fastflow.ipynb
index 4cf8853fb3..ad93049ac0 100644
--- a/notebooks/200_models/201_fastflow.ipynb
+++ b/notebooks/200_models/201_fastflow.ipynb
@@ -233,7 +233,6 @@
    "source": [
     "engine = Engine(\n",
     "    callbacks=callbacks,\n",
-    "    pixel_metrics=\"AUROC\",\n",
     "    accelerator=\"auto\",  # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n",
     "    devices=1,\n",
     "    logger=False,\n",
diff --git a/notebooks/600_loggers/601_mlflow_logging.ipynb b/notebooks/600_loggers/601_mlflow_logging.ipynb
index f45a7a0e74..b6b3c424cc 100644
--- a/notebooks/600_loggers/601_mlflow_logging.ipynb
+++ b/notebooks/600_loggers/601_mlflow_logging.ipynb
@@ -38,7 +38,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install -qU anomalib"
+    "%pip install anomalib"
    ]
   },
   {
@@ -56,7 +56,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install -qU anomalib[loggers]"
+    "%pip install anomalib[loggers]"
    ]
   },
   {
@@ -307,7 +307,6 @@
     "\n",
     "engine = Engine(\n",
     "    callbacks=callbacks,\n",
-    "    pixel_metrics=\"AUROC\",\n",
     "    accelerator=\"auto\",\n",
     "    devices=1,\n",
     "    logger=mlflow_logger,  # Logger is set here\n",
diff --git a/notebooks/700_metrics/701a_aupimo.ipynb b/notebooks/700_metrics/701a_aupimo.ipynb
index 5c5497b3b8..ecafbbb7ba 100644
--- a/notebooks/700_metrics/701a_aupimo.ipynb
+++ b/notebooks/700_metrics/701a_aupimo.ipynb
@@ -71,7 +71,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -105,7 +105,7 @@
     "from anomalib import TaskType\n",
     "from anomalib.data import MVTec\n",
     "from anomalib.engine import Engine\n",
-    "from anomalib.metrics import AUPIMO\n",
+    "from anomalib.metrics import AUPIMO, Evaluator\n",
     "from anomalib.models import Padim"
    ]
   },
@@ -132,7 +132,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -148,6 +148,27 @@
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Average AUPIMO (Basic)\n",
+    "\n",
+    "The easiest way to use AUPIMO is by creating the metric and setting it as the test metric in a new Evaluator. The evaluator will be attached to the model in the next step.\n",
+    "\n",
+    "By default, the average AUPIMO is calculated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "aupimo = AUPIMO()\n",
+    "evaluator = Evaluator(test_metrics=aupimo)"
+   ]
+  },
   {
    "attachments": {},
    "cell_type": "markdown",
@@ -165,12 +186,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Instantiate the model."
+    "Instantiate the model and add the `Evaluator` instance which we created in the previous step."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -180,20 +201,10 @@
     "    n_features=64,\n",
     "    backbone=\"resnet18\",\n",
     "    pre_trained=True,\n",
+    "    evaluator=evaluator,\n",
     ")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Average AUPIMO (Basic)\n",
-    "\n",
-    "The easiest way to use AUPIMO is via the collection of pixel metrics in the engine.\n",
-    "\n",
-    "By default, the average AUPIMO is calculated."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -201,7 +212,6 @@
    "outputs": [],
    "source": [
     "engine = Engine(\n",
-    "    pixel_metrics=\"AUPIMO\",  # others can be added\n",
     "    accelerator=\"auto\",  # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n",
     "    devices=1,\n",
     "    logger=False,\n",
@@ -211,69 +221,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "F1Score class exists for backwards compatibility. It will be removed in v1.1. Please use BinaryF1Score from torchmetrics instead\n",
-      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "880e325e4e4842b2b679340ca8007849",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Testing: |          | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃        Test metric        ┃       DataLoader 0        ┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│        image_AUROC        │    0.9887908697128296     │\n",
-       "│       image_F1Score       │    0.9726775884628296     │\n",
-       "│       pixel_AUPIMO        │    0.7428419829089654     │\n",
-       "└───────────────────────────┴───────────────────────────┘\n",
-       "\n"
-      ],
-      "text/plain": [
-       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       image_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9887908697128296    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m      image_F1Score      \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9726775884628296    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m      pixel_AUPIMO       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.7428419829089654    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "└───────────────────────────┴───────────────────────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[{'pixel_AUPIMO': 0.7428419829089654,\n",
-       "  'image_AUROC': 0.9887908697128296,\n",
-       "  'image_F1Score': 0.9726775884628296}]"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# will output the AUPIMO score on the test set\n",
     "engine.test(datamodule=datamodule, model=model)"
@@ -299,33 +249,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "ckpt_path is not provided. Model weights will not be loaded.\n",
-      "F1Score class exists for backwards compatibility. It will be removed in v1.1. Please use BinaryF1Score from torchmetrics instead\n",
-      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "e8116b80da39406e966c2099ecb2fdb1",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Predicting: |          | 0/? [00:00"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "fig, ax = plt.subplots()\n",
     "ax.hist(aupimo_result.aupimos.numpy(), bins=np.linspace(0, 1, 11), edgecolor=\"black\")\n",
@@ -520,7 +391,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "anomalib-dev",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
diff --git a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
index a785075060..42c45e60aa 100644
--- a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
+++ b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -98,7 +98,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -115,13 +115,13 @@
     "from anomalib.data import MVTec\n",
     "from anomalib.data.utils import read_image\n",
     "from anomalib.engine import Engine\n",
-    "from anomalib.metrics import AUPIMO\n",
+    "from anomalib.metrics import AUPIMO, Evaluator\n",
     "from anomalib.models import Padim"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -130,7 +130,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -170,15 +170,16 @@
     "    num_workers=8,\n",
     "    task=task,\n",
     ")\n",
+    "evaluator = Evaluator(test_metrics=AUPIMO())\n",
     "model = Padim(\n",
     "    # only use one layer to speed it up\n",
     "    layers=[\"layer1\"],\n",
     "    n_features=64,\n",
     "    backbone=\"resnet18\",\n",
     "    pre_trained=True,\n",
+    "    evaluator=evaluator,\n",
     ")\n",
     "engine = Engine(\n",
-    "    pixel_metrics=\"AUPIMO\",  # others can be added\n",
     "    accelerator=\"auto\",  # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n",
     "    devices=1,\n",
     "    logger=False,\n",
@@ -197,17 +198,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "aupimo = AUPIMO(\n",
     "    # with `False` all the values are returned in a dataclass\n",
@@ -219,11 +212,11 @@
     "labels = []\n",
     "image_paths = []\n",
     "for batch in predictions:\n",
-    "    anomaly_maps.append(batch_anomaly_maps := batch[\"anomaly_maps\"].squeeze(dim=1))\n",
-    "    masks.append(batch_masks := batch[\"mask\"])\n",
-    "    labels.append(batch[\"label\"])\n",
-    "    image_paths.append(batch[\"image_path\"])\n",
-    "    aupimo.update(anomaly_maps=batch_anomaly_maps, masks=batch_masks)\n",
+    "    anomaly_maps.append(batch.anomaly_map.squeeze(dim=1))\n",
+    "    masks.append(batch.gt_mask)\n",
+    "    labels.append(batch.gt_label)\n",
+    "    image_paths.append(batch.image_path)\n",
+    "    aupimo.update(batch)\n",
     "\n",
     "# list[list[str]] -> list[str]\n",
     "image_paths = [item for sublist in image_paths for item in sublist]\n",
@@ -246,31 +239,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "MEAN\n",
-      "aupimo_result.aupimos[labels == 1].mean().item()=0.742841961578308\n",
-      "OTHER STATISTICS\n",
-      "DescribeResult(nobs=92, minmax=(0.0, 1.0), mean=0.742841961578308, variance=0.08757792704451817, skewness=-0.9285678601866055, kurtosis=-0.3299211772047075)\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# the normal images have `nan` values because\n",
     "# recall is not defined for them so we ignore them\n",
@@ -312,21 +283,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "fig, ax = plt.subplots(figsize=(7, 2))\n",
     "boxplot_data = ax.boxplot(\n",
@@ -361,17 +320,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['mean', 'iqr', 'cilo', 'cihi', 'whishi', 'whislo', 'fliers', 'q1', 'med', 'q3'])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "boxplot_data = mpl.cbook.boxplot_stats(aupimo_result.aupimos[labels == 1].numpy())[0]\n",
     "print(boxplot_data.keys())"
@@ -386,22 +337,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  statistic  value  image_index\n",
-      "0    whislo   0.00           65\n",
-      "1        q1   0.53           58\n",
-      "2       med   0.89           63\n",
-      "3        q3   1.00           22\n",
-      "4    whishi   1.00            0\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "image_selection = []\n",
     "\n",
@@ -442,7 +380,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -649,22 +587,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "FPR bounds\n",
-      "Lower bound: 0.00001\n",
-      "Upper bound: 0.00010\n",
-      "Thresholds corresponding to the FPR bounds\n",
-      "Lower threshold: 0.504\n",
-      "Upper threshold: 0.553\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# the fpr bounds are fixed in advance in the metric object\n",
     "print(f\"\"\"FPR bounds\n",
@@ -828,7 +753,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1011,23 +936,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  statistic  value  nearest  index  label\n",
-      "0    whislo   0.00     0.00     65      1\n",
-      "1        q1   0.53     0.53     58      1\n",
-      "2      mean   0.74     0.75      7      1\n",
-      "3       med   0.89     0.89     63      1\n",
-      "4        q3   1.00     1.00     22      1\n",
-      "5    whishi   1.00     1.00      0      1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# basic usage\n",
     "boxplot_statistics = boxplot_stats(aupimo_result.aupimos, labels)\n",
@@ -1044,23 +955,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  statistic  value  nearest  index  label\n",
-      "0    whislo   0.00     0.00     67      1\n",
-      "1        q1   0.59     0.59     58      1\n",
-      "2      mean   0.78     0.79     43      1\n",
-      "3       med   0.98     0.99      9      1\n",
-      "4    whishi   1.00     1.00      0      1\n",
-      "5        q3   1.00     1.00     36      1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# repeated values\n",
     "#   if the distribution is very skewed to one side,\n",
@@ -1079,23 +976,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  statistic  value  nearest  index  label\n",
-      "0    whislo   0.00     0.00     67      1\n",
-      "1        q1   0.59     0.59     58      1\n",
-      "2      mean   0.78     0.79     43      1\n",
-      "3       med   0.98     0.99      9      1\n",
-      "4    whishi   1.00     1.00      0      1\n",
-      "5        q3   1.00     1.00      0      1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# this behavior can be changed to allow repeated values\n",
     "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, repeated_policy=None)))"
@@ -1110,21 +993,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# fliers\n",
     "#    if the distribution is very skewed to one side,\n",
@@ -1186,23 +1057,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  statistic  value  nearest  index  label\n",
-      "0    whislo   0.24     0.24     44      1\n",
-      "1        q1   0.65     0.65     58      1\n",
-      "2      mean   0.79     0.78     29      1\n",
-      "3       med   0.94     0.93     63      1\n",
-      "4        q3   1.00     1.00     22      1\n",
-      "5    whishi   1.00     1.00      0      1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# `None` is the default policy, so the fliers are not returned\n",
     "print(pd.DataFrame.from_records(boxplot_stats(mock, labels, flier_policy=None)))"
@@ -1210,40 +1067,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "with option 'low'\n",
-      "  statistic  value  nearest  index  label\n",
-      "0   flierlo   0.00     0.00     65      1\n",
-      "1   flierlo   0.00     0.00     67      1\n",
-      "2   flierlo   0.01     0.01     71      1\n",
-      "3   flierlo   0.09     0.09     64      1\n",
-      "4    whislo   0.24     0.24     44      1\n",
-      "5        q1   0.65     0.65     58      1\n",
-      "6      mean   0.79     0.78     29      1\n",
-      "7       med   0.94     0.93     63      1\n",
-      "8        q3   1.00     1.00     22      1\n",
-      "9    whishi   1.00     1.00      0      1\n",
-      "with option 'both'\n",
-      "  statistic  value  nearest  index  label\n",
-      "0   flierlo   0.00     0.00     65      1\n",
-      "1   flierlo   0.00     0.00     67      1\n",
-      "2   flierlo   0.01     0.01     71      1\n",
-      "3   flierlo   0.09     0.09     64      1\n",
-      "4    whislo   0.24     0.24     44      1\n",
-      "5        q1   0.65     0.65     58      1\n",
-      "6      mean   0.79     0.78     29      1\n",
-      "7       med   0.94     0.93     63      1\n",
-      "8        q3   1.00     1.00     22      1\n",
-      "9    whishi   1.00     1.00      0      1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# one can choose to include only high or low fliers, or both\n",
     "# since there are only low fliers...\n",
@@ -1258,24 +1084,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "with option 'high'\n",
-      "  statistic  value  nearest  index  label\n",
-      "0    whislo   0.24     0.24     44      1\n",
-      "1        q1   0.65     0.65     58      1\n",
-      "2      mean   0.79     0.78     29      1\n",
-      "3       med   0.94     0.93     63      1\n",
-      "4        q3   1.00     1.00     22      1\n",
-      "5    whishi   1.00     1.00      0      1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# and 'high' will return no fliers (same as `flier_policy=None` in this case)\n",
     "print(\"with option 'high'\")\n",
@@ -1291,24 +1102,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "stats for the maximum anomaly score in the anomaly maps\n",
-      "  statistic  value  nearest  index  label\n",
-      "0    whislo   0.46     0.46     65      1\n",
-      "1        q1   0.63     0.63     48      1\n",
-      "2       med   0.70     0.71     10      1\n",
-      "3      mean   0.73     0.73    118      1\n",
-      "4        q3   0.81     0.81    115      1\n",
-      "5    whishi   1.00     1.00     22      1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# other applications\n",
     "#    since the function is agnostic to the meaning of the values\n",
@@ -1327,23 +1123,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  statistic  value  nearest  index  label\n",
-      "0    whislo   0.42     0.42     90      0\n",
-      "1        q1   0.43     0.43     80      0\n",
-      "2       med   0.45     0.45    105      0\n",
-      "3      mean   0.46     0.46     89      0\n",
-      "4        q3   0.48     0.48     75      0\n",
-      "5    whishi   0.52     0.52     95      0\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# we can also use the `only_label` argument to select only the\n",
     "# samples from the normal class\n",
@@ -1353,23 +1135,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  statistic  value  nearest  index  label\n",
-      "0    whislo   0.42     0.42     90      0\n",
-      "1        q1   0.52     0.52     95      0\n",
-      "2       med   0.65     0.65     17      1\n",
-      "3      mean   0.66     0.66     45      1\n",
-      "4        q3   0.77     0.77    108      1\n",
-      "5    whishi   1.00     1.00     22      1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# or we can consider data from both classes (`None` option)\n",
     "print(pd.DataFrame.from_records(boxplot_stats(max_anom_score_per_image, labels, only_label=None)))\n",
@@ -1410,7 +1178,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "anomalib-dev",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
diff --git a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
index ed647ef666..a83abd5ee2 100644
--- a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
+++ b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
@@ -118,7 +118,7 @@
     "from anomalib.data import MVTec\n",
     "from anomalib.data.utils import read_image\n",
     "from anomalib.engine import Engine\n",
-    "from anomalib.metrics import AUPIMO\n",
+    "from anomalib.metrics import AUPIMO, Evaluator\n",
     "from anomalib.models import Padim"
    ]
   },
@@ -164,15 +164,16 @@
     "    num_workers=8,\n",
     "    task=task,\n",
     ")\n",
+    "evaluator = Evaluator(test_metrics=AUPIMO())\n",
     "model = Padim(\n",
     "    # only use one layer to speed it up\n",
     "    layers=[\"layer1\"],\n",
     "    n_features=64,\n",
     "    backbone=\"resnet18\",\n",
     "    pre_trained=True,\n",
+    "    evaluator=evaluator,\n",
     ")\n",
     "engine = Engine(\n",
-    "    pixel_metrics=\"AUPIMO\",  # others can be added\n",
     "    accelerator=\"auto\",  # \\<\"cpu\", \"gpu\", \"tpu\", \"ipu\", \"hpu\", \"auto\">,\n",
     "    devices=1,\n",
     "    logger=False,\n",
@@ -191,17 +192,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "aupimo = AUPIMO(\n",
     "    # with `False` all the values are returned in a dataclass\n",
@@ -213,11 +206,11 @@
     "labels = []\n",
     "image_paths = []\n",
     "for batch in predictions:\n",
-    "    anomaly_maps.append(batch_anomaly_maps := batch[\"anomaly_maps\"].squeeze(dim=1))\n",
-    "    masks.append(batch_masks := batch[\"mask\"])\n",
-    "    labels.append(batch[\"label\"])\n",
-    "    image_paths.append(batch[\"image_path\"])\n",
-    "    aupimo.update(anomaly_maps=batch_anomaly_maps, masks=batch_masks)\n",
+    "    anomaly_maps.append(batch.anomaly_map.squeeze(dim=1))\n",
+    "    masks.append(batch.gt_mask)\n",
+    "    labels.append(batch.gt_label)\n",
+    "    image_paths.append(batch.image_path)\n",
+    "    aupimo.update(batch)\n",
     "\n",
     "# list[list[str]] -> list[str]\n",
     "image_paths = [item for sublist in image_paths for item in sublist]\n",
@@ -240,31 +233,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "MEAN\n",
-      "aupimo_result.aupimos[labels == 1].mean().item()=0.742841961578308\n",
-      "OTHER STATISTICS\n",
-      "DescribeResult(nobs=92, minmax=(0.0, 1.0), mean=0.742841961578308, variance=0.08757792704451818, skewness=-0.9285678601866053, kurtosis=-0.3299211772047079)\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# the normal images have `nan` values because\n",
     "# recall is not defined for them so we ignore them\n",
@@ -354,21 +325,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "fig, axes = plt.subplots(2, 3, figsize=(10, 5), layout=\"tight\")\n",
     "\n",
@@ -713,63 +672,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[0;31mInit signature:\u001b[0m\n",
-      "\u001b[0mAUPIMO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mnum_thresholds\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m300000\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mfpr_bounds\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1e-05\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.0001\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mreturn_average\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mforce\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mDocstring:\u001b[0m     \n",
-      "Area Under the Per-Image Overlap (PIMO) curve.\n",
-      "\n",
-      "This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code.\n",
-      "The tensors are converted to numpy arrays and then passed and validated in the numpy code.\n",
-      "The results are converted back to tensors and wrapped in an dataclass object.\n",
-      "\n",
-      "Scores are computed from the integration of the PIMO curves within the given FPR bounds, then normalized to [0, 1].\n",
-      "It can be thought of as the average TPR of the PIMO curves within the given FPR bounds.\n",
-      "\n",
-      "Details: `anomalib.metrics.per_image.pimo`.\n",
-      "\n",
-      "Notation:\n",
-      "    N: number of images\n",
-      "    H: image height\n",
-      "    W: image width\n",
-      "    K: number of thresholds\n",
-      "\n",
-      "Attributes:\n",
-      "    anomaly_maps: floating point anomaly score maps of shape (N, H, W)\n",
-      "    masks: binary (bool or int) ground truth masks of shape (N, H, W)\n",
-      "\n",
-      "Args:\n",
-      "    num_thresholds: number of thresholds to compute (K)\n",
-      "    fpr_bounds: lower and upper bounds of the FPR integration range\n",
-      "    force: whether to force the computation despite bad conditions\n",
-      "\n",
-      "Returns:\n",
-      "    tuple[PIMOResult, AUPIMOResult]: PIMO and AUPIMO results dataclass objects. See `PIMOResult` and `AUPIMOResult`.\n",
-      "\u001b[0;31mInit docstring:\u001b[0m\n",
-      "Area Under the Per-Image Overlap (PIMO) curve.\n",
-      "\n",
-      "Args:\n",
-      "    num_thresholds: [passed to parent `PIMO`] number of thresholds used to compute the PIMO curve\n",
-      "    fpr_bounds: lower and upper bounds of the FPR integration range\n",
-      "    return_average: if True, return the average AUPIMO score; if False, return all the individual AUPIMO scores\n",
-      "    force: if True, force the computation of the AUPIMO scores even in bad conditions (e.g. few points)\n",
-      "\u001b[0;31mFile:\u001b[0m           ~/miniconda3/envs/anomalib-dev/lib/python3.10/site-packages/anomalib/metrics/pimo/pimo.py\n",
-      "\u001b[0;31mType:\u001b[0m           ABCMeta\n",
-      "\u001b[0;31mSubclasses:\u001b[0m     "
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "AUPIMO?"
    ]
@@ -785,17 +690,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Metric `AUPIMO` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "aupimo_custom = AUPIMO(\n",
     "    # with `False` all the values are returned in a dataclass\n",
@@ -804,29 +701,16 @@
     "    fpr_bounds=(1e-4, 1e-2),\n",
     ")\n",
     "\n",
-    "# we already have all of them in concatenated tensors\n",
-    "# so we don't need to loop over the batches like before\n",
-    "aupimo_custom.update(anomaly_maps=anomaly_maps, masks=masks)\n",
+    "for batch in predictions:\n",
+    "    aupimo_custom.update(batch)\n",
     "pimo_result_custom, aupimo_result_custom = aupimo_custom.compute()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "fig, axes = plt.subplots(2, 3, figsize=(10, 5), layout=\"tight\")\n",
     "\n",
@@ -913,7 +797,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "anomalib-dev",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
diff --git a/src/anomalib/callbacks/metrics.py b/src/anomalib/callbacks/metrics.py
deleted file mode 100644
index 3546310294..0000000000
--- a/src/anomalib/callbacks/metrics.py
+++ /dev/null
@@ -1,185 +0,0 @@
-"""MetricsManager callback."""
-
-# Copyright (C) 2023 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from dataclasses import asdict
-from enum import Enum
-from typing import Any
-
-import torch
-from lightning.pytorch import Callback, Trainer
-from lightning.pytorch.utilities.types import STEP_OUTPUT
-
-from anomalib import TaskType
-from anomalib.data import Batch
-from anomalib.metrics import AnomalibMetricCollection, create_metric_collection
-from anomalib.models import AnomalyModule
-
-logger = logging.getLogger(__name__)
-
-
-class Device(str, Enum):
-    """Device on which to compute metrics."""
-
-    CPU = "cpu"
-    GPU = "gpu"
-
-
-class _MetricsCallback(Callback):
-    """Create image and pixel-level AnomalibMetricsCollection.
-
-    This callback creates AnomalibMetricsCollection based on the
-        list of strings provided for image and pixel-level metrics.
-    After these MetricCollections are created, the callback assigns
-    these to the lightning module.
-
-    Args:
-        task (TaskType | str): Task type of the current run.
-        image_metrics (list[str] | str | dict[str, dict[str, Any]] | None): List of image-level metrics.
-        pixel_metrics (list[str] | str | dict[str, dict[str, Any]] | None): List of pixel-level metrics.
-        device (str): Whether to compute metrics on cpu or gpu. Defaults to cpu.
-    """
-
-    def __init__(
-        self,
-        task: TaskType | str = TaskType.SEGMENTATION,
-        image_metrics: list[str] | str | dict[str, dict[str, Any]] | None = None,
-        pixel_metrics: list[str] | str | dict[str, dict[str, Any]] | None = None,
-        device: Device = Device.CPU,
-    ) -> None:
-        super().__init__()
-        self.task = TaskType(task)
-        self.image_metric_names = image_metrics
-        self.pixel_metric_names = pixel_metrics
-        self.device = device
-
-    def setup(
-        self,
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        stage: str | None = None,
-    ) -> None:
-        """Set image and pixel-level AnomalibMetricsCollection within Anomalib Model.
-
-        Args:
-            trainer (pl.Trainer): PyTorch Lightning Trainer
-            pl_module (AnomalyModule): Anomalib Model that inherits pl LightningModule.
-            stage (str | None, optional): fit, validate, test or predict. Defaults to None.
-        """
-        del trainer, stage  # These variables are not used.
-
-        image_metric_names = [] if self.image_metric_names is None else self.image_metric_names
-        if isinstance(image_metric_names, str):
-            image_metric_names = [image_metric_names]
-
-        pixel_metric_names: list[str] | dict[str, dict[str, Any]]
-        if self.pixel_metric_names is None:
-            pixel_metric_names = []
-        elif self.task == TaskType.CLASSIFICATION:
-            pixel_metric_names = []
-            logger.warning(
-                "Cannot perform pixel-level evaluation when task type is classification. "
-                "Ignoring the following pixel-level metrics: %s",
-                self.pixel_metric_names,
-            )
-        else:
-            pixel_metric_names = (
-                self.pixel_metric_names if not isinstance(self.pixel_metric_names, str) else [self.pixel_metric_names]
-            )
-
-        if isinstance(pl_module, AnomalyModule):
-            pl_module.image_metrics = create_metric_collection(image_metric_names, "image_")
-            if hasattr(pl_module, "pixel_metrics"):  # incase metrics are loaded from model checkpoint
-                new_metrics = create_metric_collection(pixel_metric_names)
-                for name in new_metrics:
-                    if name not in pl_module.pixel_metrics:
-                        pl_module.pixel_metrics.add_metrics(new_metrics[name])
-            else:
-                pl_module.pixel_metrics = create_metric_collection(pixel_metric_names, "pixel_")
-
-    @staticmethod
-    def on_validation_epoch_start(trainer: Trainer, pl_module: AnomalyModule) -> None:
-        del trainer  # Unused argument.
-
-        pl_module.image_metrics.reset()
-        pl_module.pixel_metrics.reset()
-
-    def on_validation_batch_end(
-        self,
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        outputs: STEP_OUTPUT | None,
-        batch: Any,  # noqa: ANN401
-        batch_idx: int,
-        dataloader_idx: int = 0,
-    ) -> None:
-        del trainer, batch, batch_idx, dataloader_idx  # Unused arguments.
-
-        if outputs is not None:
-            outputs = self._outputs_to_device(outputs)
-            self._update_metrics(pl_module.image_metrics, pl_module.pixel_metrics, outputs)
-
-    def on_validation_epoch_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
-        del trainer  # Unused argument.
-
-        self._log_metrics(pl_module)
-
-    @staticmethod
-    def on_test_epoch_start(trainer: Trainer, pl_module: AnomalyModule) -> None:
-        del trainer  # Unused argument.
-
-        pl_module.image_metrics.reset()
-        pl_module.pixel_metrics.reset()
-
-    def on_test_batch_end(
-        self,
-        trainer: Trainer,
-        pl_module: AnomalyModule,
-        outputs: STEP_OUTPUT | None,
-        batch: Any,  # noqa: ANN401
-        batch_idx: int,
-        dataloader_idx: int = 0,
-    ) -> None:
-        del trainer, batch, batch_idx, dataloader_idx  # Unused arguments.
-
-        if outputs is not None:
-            outputs = self._outputs_to_device(outputs)
-            self._update_metrics(pl_module.image_metrics, pl_module.pixel_metrics, outputs)
-
-    def on_test_epoch_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
-        del trainer  # Unused argument.
-
-        self._log_metrics(pl_module)
-
-    def _update_metrics(
-        self,
-        image_metric: AnomalibMetricCollection,
-        pixel_metric: AnomalibMetricCollection,
-        output: STEP_OUTPUT,
-    ) -> None:
-        image_metric.to(self.device)
-        image_metric.update(output.pred_score, output.gt_label.int())
-        if output.gt_mask is not None and output.anomaly_map is not None:
-            pixel_metric.to(self.device)
-            pixel_metric.update(torch.squeeze(output.anomaly_map), torch.squeeze(output.gt_mask.int()))
-
-    def _outputs_to_device(self, output: STEP_OUTPUT) -> STEP_OUTPUT | dict[str, Any]:
-        if isinstance(output, dict):
-            for key, value in output.items():
-                output[key] = self._outputs_to_device(value)
-        elif isinstance(output, Batch):
-            output = output.__class__(**self._outputs_to_device(asdict(output)))
-        elif isinstance(output, torch.Tensor):
-            output = output.to(self.device)
-        return output
-
-    @staticmethod
-    def _log_metrics(pl_module: AnomalyModule) -> None:
-        """Log computed performance metrics."""
-        if pl_module.pixel_metrics._update_called:  # noqa: SLF001
-            pl_module.log_dict(pl_module.pixel_metrics, prog_bar=True)
-            pl_module.log_dict(pl_module.image_metrics, prog_bar=False)
-        else:
-            pl_module.log_dict(pl_module.image_metrics, prog_bar=True)
diff --git a/src/anomalib/cli/cli.py b/src/anomalib/cli/cli.py
index 048c948d89..b272fdc81b 100644
--- a/src/anomalib/cli/cli.py
+++ b/src/anomalib/cli/cli.py
@@ -148,8 +148,6 @@ def add_arguments_to_parser(parser: ArgumentParser) -> None:
             ``Engine`` class should be reflected manually.
         """
         parser.add_argument("--task", type=TaskType | str, default=TaskType.SEGMENTATION)
-        parser.add_argument("--metrics.image", type=list[str] | str | None, default=None)
-        parser.add_argument("--metrics.pixel", type=list[str] | str | None, default=None, required=False)
         parser.add_argument("--logging.log_graph", type=bool, help="Log the model to the logger", default=False)
         if hasattr(parser, "subcommand") and parser.subcommand not in {"export", "predict"}:
             parser.link_arguments("task", "data.init_args.task")
@@ -323,8 +321,6 @@ def instantiate_engine(self) -> None:
 
         engine_args = {
             "task": self._get(self.config_init, "task"),
-            "image_metrics": self._get(self.config_init, "metrics.image"),
-            "pixel_metrics": self._get(self.config_init, "metrics.pixel"),
         }
         trainer_config = {**self._get(self.config_init, "trainer", default={}), **engine_args}
         key = "callbacks"
diff --git a/src/anomalib/data/validators/torch/image.py b/src/anomalib/data/validators/torch/image.py
index a9c7cafe06..f001180a1d 100644
--- a/src/anomalib/data/validators/torch/image.py
+++ b/src/anomalib/data/validators/torch/image.py
@@ -585,10 +585,16 @@ def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
         if pred_label.ndim > 2:
             msg = f"Predicted label must be 1-dimensional or 2-dimensional, got shape {pred_label.shape}."
             raise ValueError(msg)
-        if pred_label.ndim == 2 and pred_label.shape[1] != 1:
-            msg = f"Predicted label with 2 dimensions must have shape [N, 1], got shape {pred_label.shape}."
-            raise ValueError(msg)
-
+        if pred_label.ndim == 2:
+            if pred_label.shape[0] == 1:
+                pred_label = pred_label.squeeze(0)
+            elif pred_label.shape[1] == 1:
+                pred_label = pred_label.squeeze(1)
+            else:
+                msg = (
+                    f"Predicted label with 2 dimensions must have shape [N, 1] or [1, N], got shape {pred_label.shape}."
+                )
+                raise ValueError(msg)
         return pred_label.to(torch.bool)
 
     @staticmethod
diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index 464be44d60..13eef8a63c 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -18,7 +18,6 @@
 
 from anomalib import LearningType, TaskType
 from anomalib.callbacks.checkpoint import ModelCheckpoint
-from anomalib.callbacks.metrics import _MetricsCallback
 from anomalib.callbacks.timer import TimerCallback
 from anomalib.data import AnomalibDataModule, AnomalibDataset, PredictDataset
 from anomalib.deploy import CompressionType, ExportType
@@ -116,8 +115,6 @@ def __init__(
         self,
         callbacks: list[Callback] | None = None,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_metrics: list[str] | str | dict[str, dict[str, Any]] | None = None,
-        pixel_metrics: list[str] | str | dict[str, dict[str, Any]] | None = None,
         logger: Logger | Iterable[Logger] | bool | None = None,
         default_root_dir: str | Path = "results",
         **kwargs,
@@ -137,12 +134,6 @@ def __init__(
         )
 
         self.task = TaskType(task)
-        self.image_metric_names = image_metrics if image_metrics else ["AUROC", "F1Max"]
-
-        # pixel metrics are only used for segmentation tasks.
-        self.pixel_metric_names = None
-        if self.task == TaskType.SEGMENTATION:
-            self.pixel_metric_names = pixel_metrics if pixel_metrics is not None else ["AUROC", "F1Max"]
 
         self._trainer: Trainer | None = None
 
@@ -375,7 +366,8 @@ def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None:
             _callbacks.append(model.post_processor)
 
         # Add the metrics callback.
-        _callbacks.append(_MetricsCallback(self.task, self.image_metric_names, self.pixel_metric_names))
+        if isinstance(model.evaluator, Callback):
+            _callbacks.append(model.evaluator)
 
         # Add the image visualizer callback if it is passed by the user.
         if not any(isinstance(callback, ImageVisualizer) for callback in self._cache.args["callbacks"]):
diff --git a/src/anomalib/metrics/__init__.py b/src/anomalib/metrics/__init__.py
index 81bab3c93f..6f606bc826 100644
--- a/src/anomalib/metrics/__init__.py
+++ b/src/anomalib/metrics/__init__.py
@@ -3,21 +3,13 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import importlib
-import logging
-from collections.abc import Callable
-from typing import Any
-
-import torchmetrics
-from omegaconf import DictConfig, ListConfig
-
 from .anomaly_score_distribution import AnomalyScoreDistribution
 from .aupr import AUPR
 from .aupro import AUPRO
 from .auroc import AUROC
-from .collection import AnomalibMetricCollection
-from .f1_max import F1Max
-from .f1_score import F1Score
+from .base import AnomalibMetric
+from .evaluator import Evaluator
+from .f1_score import F1Max, F1Score
 from .min_max import MinMax
 from .pimo import AUPIMO, PIMO
 from .precision_recall_curve import BinaryPrecisionRecallCurve
@@ -28,8 +20,10 @@
     "AUROC",
     "AUPR",
     "AUPRO",
+    "AnomalibMetric",
     "AnomalyScoreDistribution",
     "BinaryPrecisionRecallCurve",
+    "Evaluator",
     "F1AdaptiveThreshold",
     "F1Max",
     "F1Score",
@@ -39,164 +33,3 @@
     "PIMO",
     "AUPIMO",
 ]
-
-logger = logging.getLogger(__name__)
-
-
-def metric_collection_from_names(metric_names: list[str], prefix: str | None) -> AnomalibMetricCollection:
-    """Create a metric collection from a list of metric names.
-
-    The function will first try to retrieve the metric from the metrics defined in Anomalib metrics module,
-    then in TorchMetrics package.
-
-    Args:
-        metric_names (list[str]): List of metric names to be included in the collection.
-        prefix (str | None): prefix to assign to the metrics in the collection.
-
-    Returns:
-        AnomalibMetricCollection: Collection of metrics.
-    """
-    metrics_module = importlib.import_module("anomalib.metrics")
-    metrics = AnomalibMetricCollection([], prefix=prefix)
-    for metric_name in metric_names:
-        if hasattr(metrics_module, metric_name):
-            metric_cls = getattr(metrics_module, metric_name)
-            metrics.add_metrics(metric_cls())
-        elif hasattr(torchmetrics, metric_name):
-            try:
-                metric_cls = getattr(torchmetrics, metric_name)
-                metrics.add_metrics(metric_cls())
-            except TypeError:
-                msg = f"Incorrect constructor arguments for {metric_name} metric from TorchMetrics package."
-                logger.warning(msg)
-        else:
-            msg = f"No metric with name {metric_name} found in Anomalib metrics or TorchMetrics."
-            logger.warning(msg)
-    return metrics
-
-
-def _validate_metrics_dict(metrics: dict[str, dict[str, Any]]) -> None:
-    """Check the assumptions about metrics config dict.
-
-    - Keys are metric names
-    - Values are dictionaries.
-    - Internal dictionaries:
-        - have key "class_path" and its value is of type str
-        - have key init_args" and its value is of type dict).
-
-    """
-    if not all(isinstance(metric, str) for metric in metrics):
-        msg = f"All keys (metric names) must be strings, found {sorted(metrics.keys())}"
-        raise TypeError(msg)
-
-    if not all(isinstance(metric, DictConfig | dict) for metric in metrics.values()):
-        msg = f"All values must be dictionaries, found {list(metrics.values())}"
-        raise TypeError(msg)
-
-    if not all("class_path" in metric and isinstance(metric["class_path"], str) for metric in metrics.values()):
-        msg = "All internal dictionaries must have a 'class_path' key whose value is of type str."
-        raise ValueError(msg)
-
-    if not all(
-        "init_args" in metric and isinstance(metric["init_args"], dict) or isinstance(metric["init_args"], DictConfig)
-        for metric in metrics.values()
-    ):
-        msg = "All internal dictionaries must have a 'init_args' key whose value is of type dict."
-        raise ValueError(msg)
-
-
-def _get_class_from_path(class_path: str) -> Callable:
-    """Get a class from a module assuming the string format is `package.subpackage.module.ClassName`."""
-    module_name, class_name = class_path.rsplit(".", 1)
-    module = importlib.import_module(module_name)
-    if not hasattr(module, class_name):
-        msg = f"Class {class_name} not found in module {module_name}"
-        raise AttributeError(msg)
-    return getattr(module, class_name)
-
-
-def metric_collection_from_dicts(metrics: dict[str, dict[str, Any]], prefix: str | None) -> AnomalibMetricCollection:
-    """Create a metric collection from a dict of "metric name" -> "metric specifications".
-
-    Example:
-        metrics = {
-            "PixelWiseF1Score": {
-                "class_path": "torchmetrics.F1Score",
-                "init_args": {},
-            },
-            "PixelWiseAUROC": {
-                "class_path": "anomalib.metrics.AUROC",
-                "init_args": {
-                },
-            },
-        }
-
-    In the config file, the same specifications (for pixel-wise metrics) look like:
-
-        ```yaml
-        metrics:
-            pixel:
-                PixelWiseF1Score:
-                    class_path: torchmetrics.F1Score
-                    init_args: {}
-                PixelWiseAUROC:
-                    class_path: anomalib.metrics.AUROC
-
-        ```
-
-    Args:
-        metrics (dict[str, dict[str, Any]]): keys are metric names, values are dictionaries.
-            Internal dict[str, Any] keys are "class_path" (value is string) and "init_args" (value is dict),
-            following the convention in Pytorch Lightning CLI.
-
-        prefix (str | None): prefix to assign to the metrics in the collection.
-
-    Returns:
-        AnomalibMetricCollection: Collection of metrics.
-    """
-    _validate_metrics_dict(metrics)
-    metrics_collection = {}
-    for name, dict_ in metrics.items():
-        class_path = dict_["class_path"]
-        kwargs = dict_["init_args"]
-        cls = _get_class_from_path(class_path)
-        metrics_collection[name] = cls(**kwargs)
-    return AnomalibMetricCollection(metrics_collection, prefix=prefix)
-
-
-def create_metric_collection(
-    metrics: list[str] | dict[str, dict[str, Any]],
-    prefix: str | None = None,
-) -> AnomalibMetricCollection:
-    """Create a metric collection from a list of metric names or dictionaries.
-
-    This function will dispatch the actual creation to the appropriate function depending on the input type:
-
-        - if list[str] (names of metrics): see `metric_collection_from_names`
-        - if dict[str, dict[str, Any]] (path and init args of a class): see `metric_collection_from_dicts`
-
-    The function will first try to retrieve the metric from the metrics defined in Anomalib metrics module,
-    then in TorchMetrics package.
-
-    Args:
-        metrics (list[str] | dict[str, dict[str, Any]]): List of metrics or dictionaries to create metric collection.
-        prefix (str | None): Prefix to assign to the metrics in the collection.
-
-    Returns:
-        AnomalibMetricCollection: Collection of metrics.
-    """
-    # fallback is using the names
-
-    if isinstance(metrics, ListConfig | list):
-        if not all(isinstance(metric, str) for metric in metrics):
-            msg = f"All metrics must be strings, found {metrics}"
-            raise TypeError(msg)
-
-        return metric_collection_from_names(metrics, prefix)
-
-    if isinstance(metrics, DictConfig | dict):
-        _validate_metrics_dict(metrics)
-        return metric_collection_from_dicts(metrics, prefix)
-
-    msg = f"metrics must be a list or a dict, found {type(metrics)}"
-    raise ValueError(msg)
diff --git a/src/anomalib/metrics/aupr.py b/src/anomalib/metrics/aupr.py
index fb78a89564..5856a1ae5f 100644
--- a/src/anomalib/metrics/aupr.py
+++ b/src/anomalib/metrics/aupr.py
@@ -9,10 +9,11 @@
 from torchmetrics.utilities.compute import auc
 from torchmetrics.utilities.data import dim_zero_cat
 
+from .base import AnomalibMetric
 from .plotting_utils import plot_figure
 
 
-class AUPR(BinaryPrecisionRecallCurve):
+class _AUPR(BinaryPrecisionRecallCurve):
     """Area under the PR curve.
 
     This metric computes the area under the precision-recall curve.
@@ -106,3 +107,7 @@ def generate_figure(self) -> tuple[Figure, str]:
         )
 
         return fig, title
+
+
+class AUPR(AnomalibMetric, _AUPR):  # type: ignore[misc]
+    """Wrapper to add AnomalibMetric functionality to AUPR metric."""
diff --git a/src/anomalib/metrics/aupro.py b/src/anomalib/metrics/aupro.py
index 755f8e2833..0b5ac69d58 100644
--- a/src/anomalib/metrics/aupro.py
+++ b/src/anomalib/metrics/aupro.py
@@ -15,11 +15,12 @@
 
 from anomalib.metrics.pro import connected_components_cpu, connected_components_gpu
 
+from .base import AnomalibMetric
 from .binning import thresholds_between_0_and_1, thresholds_between_min_and_max
 from .plotting_utils import plot_figure
 
 
-class AUPRO(Metric):
+class _AUPRO(Metric):
     """Area under per region overlap (AUPRO) Metric.
 
     Args:
@@ -291,3 +292,7 @@ def interp1d(old_x: torch.Tensor, old_y: torch.Tensor, new_x: torch.Tensor) -> t
 
         # perform actual linear interpolation
         return old_y[idx] + slope[idx] * (new_x - old_x[idx])
+
+
+class AUPRO(AnomalibMetric, _AUPRO):  # type: ignore[misc]
+    """Wrapper to add AnomalibMetric functionality to AUPRO metric."""
diff --git a/src/anomalib/metrics/auroc.py b/src/anomalib/metrics/auroc.py
index 78f3d6cc77..183da7a4f0 100644
--- a/src/anomalib/metrics/auroc.py
+++ b/src/anomalib/metrics/auroc.py
@@ -8,10 +8,12 @@
 from torchmetrics.classification.roc import BinaryROC
 from torchmetrics.utilities.compute import auc
 
+from anomalib.metrics.base import AnomalibMetric
+
 from .plotting_utils import plot_figure
 
 
-class AUROC(BinaryROC):
+class _AUROC(BinaryROC):
     """Area under the ROC curve.
 
     Examples:
@@ -99,3 +101,7 @@ def generate_figure(self) -> tuple[Figure, str]:
         )
 
         return fig, title
+
+
+class AUROC(AnomalibMetric, _AUROC):  # type: ignore[misc]
+    """Wrapper to add AnomalibMetric functionality to AUROC metric."""
diff --git a/src/anomalib/metrics/base.py b/src/anomalib/metrics/base.py
new file mode 100644
index 0000000000..041e45a334
--- /dev/null
+++ b/src/anomalib/metrics/base.py
@@ -0,0 +1,127 @@
+"""Base classes for metrics in Anomalib."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+
+from torchmetrics import Metric, MetricCollection
+
+from anomalib.data import Batch
+
+
+class AnomalibMetric:
+    """Base class for metrics in Anomalib.
+
+    This class is designed to make any torchmetrics metric compatible with the
+    Anomalib framework. An Anomalib version of any torchmetrics metric can be created
+    by inheriting from this class and the desired torchmetrics metric. For example, to
+    create an Anomalib version of the BinaryF1Score metric, the user can create a new
+    class that inherits from AnomalibMetric and BinaryF1Score.
+
+    The AnomalibMetric class adds the ability to update the metric with a Batch
+    object instead of individual prediction and target tensors. To use this feature,
+    the user must provide a list of fields as constructor arguments when instantiating
+    the metric. When the metric is updated with a Batch object, it will extract the
+    values of these fields from the Batch object and pass them to the `update` method
+    of the metric.
+
+    Args:
+        fields (Sequence[str]): List of field names to extract from the Batch object.
+        prefix (str): Prefix to add to the metric name. Defaults to an empty string.
+        **kwargs: Variable keyword arguments that can be passed to the parent class.
+
+    Examples:
+        >>> from torchmetrics.classification import BinaryF1Score
+        >>> from anomalib.metrics import AnomalibMetric
+        >>> from anomalib.data import ImageBatch
+        >>> import torch
+        >>>
+        >>> class F1Score(AnomalibMetric, BinaryF1Score):
+        ...     pass
+        ...
+        >>> f1_score = F1Score(fields=["pred_label", "gt_label"])
+        >>>
+        >>> batch = ImageBatch(
+        ...     image=torch.rand(4, 3, 256, 256),
+        ...     pred_label=torch.tensor([0, 0, 0, 1]),
+        ...     gt_label=torch.tensor([0, 0, 1, 1])),
+        ... )
+        >>>
+        >>> # The AnomalibMetric class allows us to update the metric by passing a Batch
+        >>> # object directly.
+        >>> f1_score.update(batch)
+        >>> f1_score.compute()
+        tensor(0.6667)
+        >>>
+        >>> # specifying the field names allows us to distinguish between image and
+        >>> # pixel metrics.
+        >>> image_f1_score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
+        >>> pixel_f1_score = F1Score(fields=[pred_mask", "gt_mask"], prefix="pixel_")
+    """
+
+    default_fields: Sequence[str]
+
+    def __init__(self, fields: Sequence[str] | None = None, prefix: str = "", **kwargs) -> None:
+        fields = fields or getattr(self, "default_fields", None)
+        if fields is None:
+            msg = (
+                f"Batch fields must be provided for metric {self.__class__}. "
+                "Use the `fields` argument to specify which fields from the "
+                "batch object should be used to update the metric."
+            )
+            raise ValueError(msg)
+        self.fields = fields
+        self.name = prefix + self.__class__.__name__
+        super().__init__(**kwargs)
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        """Check that the subclass implements the torchmetrics.Metric interface."""
+        del kwargs
+        assert issubclass(
+            cls,
+            (Metric | MetricCollection),
+        ), "AnomalibMetric must be a subclass of torchmetrics.Metric or torchmetrics.MetricCollection"
+
+    def update(self, batch: Batch, *args, **kwargs) -> None:
+        """Update the metric with the specified fields from the Batch object."""
+        for key in self.fields:
+            if getattr(batch, key, None) is None:
+                msg = f"Batch object is missing required field: {key}"
+                raise ValueError(msg)
+        values = [getattr(batch, key) for key in self.fields]
+        super().update(*values, *args, **kwargs)  # type: ignore[misc]
+
+
+def create_anomalib_metric(metric_cls: type) -> type:
+    """Create an Anomalib version of a torchmetrics metric.
+
+    This function creates an Anomalib version of a torchmetrics metric by inheriting
+    from the AnomalibMetric class and the specified torchmetrics metric class. The
+    resulting class will have the same name as the input metric class and will inherit
+    from both AnomalibMetric and the input metric class.
+
+    Args:
+        metric_cls (Callable): The torchmetrics metric class to wrap.
+
+    Returns:
+        AnomalibMetric: An Anomalib version of the input metric class.
+
+    Examples:
+        >>> from torchmetrics.classification import BinaryF1Score
+        >>> from anomalib.metrics import create_anomalib_metric
+        >>>
+        >>> F1Score = create_anomalib_metric(BinaryF1Score)
+        >>> # This is equivalent to the following class definition:
+        >>> # class F1Score(AnomalibMetric, BinaryF1Score): ...
+        >>>
+        >>> f1_score = F1Score(fields=["pred_label", "gt_label"])
+        >>>
+        >>> # The AnomalibMetric class allows us to update the metric by passing a Batch
+        >>> # object directly.
+        >>> f1_score.update(batch)
+        >>> f1_score.compute()
+        tensor(0.6667)
+    """
+    assert issubclass(metric_cls, Metric), "The wrapped metric must be a subclass of torchmetrics.Metric."
+    return type(metric_cls.__name__, (AnomalibMetric, metric_cls), {})
diff --git a/src/anomalib/metrics/collection.py b/src/anomalib/metrics/collection.py
deleted file mode 100644
index 020aebd9e9..0000000000
--- a/src/anomalib/metrics/collection.py
+++ /dev/null
@@ -1,37 +0,0 @@
-"""Anomalib Metric Collection."""
-
-# Copyright (C) 2022-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from torchmetrics import MetricCollection
-
-
-class AnomalibMetricCollection(MetricCollection):
-    """Extends the MetricCollection class for use in the Anomalib pipeline."""
-
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self._update_called = False
-        self._threshold = 0.5
-
-    def set_threshold(self, threshold_value: float) -> None:
-        """Update the threshold value for all metrics that have the threshold attribute."""
-        self._threshold = threshold_value
-        for metric in self.values():
-            if hasattr(metric, "threshold"):
-                metric.threshold = threshold_value
-
-    def update(self, *args, **kwargs) -> None:
-        """Add data to the metrics."""
-        super().update(*args, **kwargs)
-        self._update_called = True
-
-    @property
-    def update_called(self) -> bool:
-        """Returns a boolean indicating if the update method has been called at least once."""
-        return self._update_called
-
-    @property
-    def threshold(self) -> float:
-        """Return the value of the anomaly threshold."""
-        return self._threshold
diff --git a/src/anomalib/metrics/evaluator.py b/src/anomalib/metrics/evaluator.py
new file mode 100644
index 0000000000..91ef47aa6d
--- /dev/null
+++ b/src/anomalib/metrics/evaluator.py
@@ -0,0 +1,130 @@
+"""Evaluator module for LightningModule."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+from typing import Any
+
+from lightning.pytorch import Callback, LightningModule, Trainer
+from lightning.pytorch.utilities.types import STEP_OUTPUT
+from torch import nn
+from torch.nn import ModuleList
+from torchmetrics import Metric
+
+from anomalib.metrics import AnomalibMetric
+
+
+class Evaluator(nn.Module, Callback):
+    """Evaluator module for LightningModule.
+
+    The Evaluator module is a PyTorch module that computes and logs metrics during
+    validation and test steps. Each AnomalyModule should have an Evaluator module as
+    a submodule to compute and log metrics during validation and test steps. An Evaluation
+    module can be passed to the AnomalyModule as a parameter during initialization. When
+    no Evaluator module is provided, the AnomalyModule will use a default Evaluator module
+    that logs a default set of metrics.
+
+    Args:
+        val_metrics (Sequence[AnomalibMetric], optional): Validation metrics.
+            Defaults to ``[]``.
+        test_metrics (Sequence[AnomalibMetric], optional): Test metrics.
+            Defaults to ``[]``.
+        compute_on_cpu (bool, optional): Whether to compute metrics on CPU.
+            Defaults to ``True``.
+
+    Examples:
+        >>> from anomalib.metrics import F1Score, AUROC
+        >>> from anomalib.data import ImageBatch
+        >>> import torch
+        >>>
+        >>> f1_score = F1Score(fields=["pred_label", "gt_label"])
+        >>> auroc = AUROC(fields=["pred_score", "gt_label"])
+        >>>
+        >>> evaluator = Evaluator(test_metrics=[f1_score])
+    """
+
+    def __init__(
+        self,
+        val_metrics: AnomalibMetric | Sequence[AnomalibMetric] | None = None,
+        test_metrics: AnomalibMetric | Sequence[AnomalibMetric] | None = None,
+        compute_on_cpu: bool = True,
+    ) -> None:
+        super().__init__()
+        self.val_metrics = ModuleList(self.validate_metrics(val_metrics))
+        self.test_metrics = ModuleList(self.validate_metrics(test_metrics))
+
+        if compute_on_cpu:
+            self.metrics_to_cpu(self.val_metrics)
+            self.metrics_to_cpu(self.test_metrics)
+
+    @staticmethod
+    def validate_metrics(metrics: AnomalibMetric | Sequence[AnomalibMetric] | None) -> Sequence[AnomalibMetric]:
+        """Validate metrics."""
+        if metrics is None:
+            return []
+        if isinstance(metrics, AnomalibMetric):
+            return [metrics]
+        if not isinstance(metrics, Sequence):
+            msg = f"metrics must be an AnomalibMetric or a list of AnomalibMetrics, got {type(metrics)}"
+            raise TypeError(msg)
+        return metrics
+
+    def on_validation_batch_end(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+        outputs: STEP_OUTPUT | None,
+        batch: Any,  # noqa: ANN401
+        batch_idx: int,
+        dataloader_idx: int = 0,
+    ) -> None:
+        """Update validation metrics with the batch output."""
+        del trainer, outputs, batch_idx, dataloader_idx, pl_module  # Unused arguments.
+        for metric in self.val_metrics:
+            metric.update(batch)
+
+    def on_validation_epoch_end(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+    ) -> None:
+        """Compute and log validation metrics."""
+        del trainer, pl_module  # Unused argument.
+        for metric in self.val_metrics:
+            self.log(metric.name, metric)
+
+    def on_test_batch_end(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+        outputs: STEP_OUTPUT | None,
+        batch: Any,  # noqa: ANN401
+        batch_idx: int,
+        dataloader_idx: int = 0,
+    ) -> None:
+        """Update test metrics with the batch output."""
+        del trainer, outputs, batch_idx, dataloader_idx, pl_module  # Unused arguments.
+        for metric in self.test_metrics:
+            metric.update(batch)
+
+    def on_test_epoch_end(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+    ) -> None:
+        """Compute and log test metrics."""
+        del trainer, pl_module  # Unused argument.
+        for metric in self.test_metrics:
+            self.log(metric.name, metric)
+
+    def metrics_to_cpu(self, metrics: Metric | list[Metric] | ModuleList) -> None:
+        """Set the compute_on_cpu attribute of the metrics to True."""
+        if isinstance(metrics, Metric):
+            metrics.compute_on_cpu = True
+        elif isinstance(metrics, (list | ModuleList)):
+            for metric in metrics:
+                self.metrics_to_cpu(metric)
+        else:
+            msg = f"metrics must be a Metric or a list of metrics, got {type(metrics)}"
+            raise TypeError(msg)
diff --git a/src/anomalib/metrics/f1_max.py b/src/anomalib/metrics/f1_max.py
deleted file mode 100644
index 8159945c77..0000000000
--- a/src/anomalib/metrics/f1_max.py
+++ /dev/null
@@ -1,100 +0,0 @@
-"""Implementation of F1Max score based on TorchMetrics."""
-
-# Copyright (C) 2022-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-
-import torch
-from torchmetrics import Metric
-
-from anomalib.metrics.precision_recall_curve import BinaryPrecisionRecallCurve
-
-logger = logging.getLogger(__name__)
-
-
-class F1Max(Metric):
-    """F1Max Metric for Computing the Maximum F1 Score.
-
-    This class is designed to calculate the maximum F1 score from the precision-
-    recall curve for binary classification tasks. The F1 score is a harmonic
-    mean of precision and recall, offering a balance between these two metrics.
-    The maximum F1 score (F1-Max) is particularly useful in scenarios where an
-    optimal balance between precision and recall is desired, such as in
-    imbalanced datasets or when both false positives and false negatives carry
-    significant costs.
-
-    After computing the F1Max score, the class also identifies and stores the
-    threshold that yields this maximum F1 score, which providing insight into
-    the optimal point for the classification decision.
-
-    Args:
-        **kwargs: Variable keyword arguments that can be passed to the parent class.
-
-    Attributes:
-        full_state_update (bool): Indicates whether the metric requires updating
-            the entire state. Set to False for this metric as it calculates the
-            F1 score based on the current state without needing historical data.
-        precision_recall_curve (BinaryPrecisionRecallCurve): Utility to compute
-            precision and recall values across different thresholds.
-        threshold (torch.Tensor): Stores the threshold value that results in the
-            maximum F1 score.
-
-    Examples:
-        >>> from anomalib.metrics import F1Max
-        >>> import torch
-
-        >>> preds = torch.tensor([0.1, 0.4, 0.35, 0.8])
-        >>> target = torch.tensor([0, 0, 1, 1])
-
-        >>> f1_max = F1Max()
-        >>> f1_max.update(preds, target)
-
-        >>> optimal_f1_score = f1_max.compute()
-        >>> print(f"Optimal F1 Score: {f1_max_score}")
-        >>> print(f"Optimal Threshold: {f1_max.threshold}")
-
-    Note:
-        - Use `update` method to input predictions and target labels.
-        - Use `compute` method to calculate the maximum F1 score after all
-          updates.
-        - Use `reset` method to clear the current state and prepare for a new
-          set of calculations.
-    """
-
-    full_state_update: bool = False
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-
-        self.precision_recall_curve = BinaryPrecisionRecallCurve()
-
-        self.threshold: torch.Tensor
-
-    def update(self, preds: torch.Tensor, target: torch.Tensor, *args, **kwargs) -> None:
-        """Update the precision-recall curve metric."""
-        del args, kwargs  # These variables are not used.
-
-        self.precision_recall_curve.update(preds, target)
-
-    def compute(self) -> torch.Tensor:
-        """Compute the value of the optimal F1 score.
-
-        Compute the F1 scores while varying the threshold. Store the optimal
-        threshold as attribute and return the maximum value of the F1 score.
-
-        Returns:
-            Value of the F1 score at the optimal threshold.
-        """
-        precision: torch.Tensor
-        recall: torch.Tensor
-        thresholds: torch.Tensor
-
-        precision, recall, thresholds = self.precision_recall_curve.compute()
-        f1_score = (2 * precision * recall) / (precision + recall + 1e-10)
-        self.threshold = thresholds.item() if thresholds.ndim == 0 else thresholds[torch.argmax(f1_score)]
-        return torch.max(f1_score)
-
-    def reset(self) -> None:
-        """Reset the metric."""
-        self.precision_recall_curve.reset()
diff --git a/src/anomalib/metrics/f1_score.py b/src/anomalib/metrics/f1_score.py
index f666542d32..ab85c0cc03 100644
--- a/src/anomalib/metrics/f1_score.py
+++ b/src/anomalib/metrics/f1_score.py
@@ -1,36 +1,107 @@
-"""F1 Score metric.
-
-This is added for convenience.
-"""
+"""F1 Score and F1Max Metrics for Binary Classification Tasks."""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import logging
-from typing import Any, Literal
-
+import torch
+from torchmetrics import Metric
 from torchmetrics.classification import BinaryF1Score
 
-logger = logging.getLogger(__name__)
+from anomalib.metrics.base import AnomalibMetric
+
+from .precision_recall_curve import BinaryPrecisionRecallCurve
+
+
+class F1Score(AnomalibMetric, BinaryF1Score):
+    """Wrapper to add AnomalibMetric functionality to F1Score metric."""
+
+
+class _F1Max(Metric):
+    """F1Max Metric for Computing the Maximum F1 Score.
+
+    This class is designed to calculate the maximum F1 score from the precision-
+    recall curve for binary classification tasks. The F1 score is a harmonic
+    mean of precision and recall, offering a balance between these two metrics.
+    The maximum F1 score (F1-Max) is particularly useful in scenarios where an
+    optimal balance between precision and recall is desired, such as in
+    imbalanced datasets or when both false positives and false negatives carry
+    significant costs.
+
+    After computing the F1Max score, the class also identifies and stores the
+    threshold that yields this maximum F1 score, which providing insight into
+    the optimal point for the classification decision.
+
+    Args:
+        **kwargs: Variable keyword arguments that can be passed to the parent class.
+
+    Attributes:
+        full_state_update (bool): Indicates whether the metric requires updating
+            the entire state. Set to False for this metric as it calculates the
+            F1 score based on the current state without needing historical data.
+        precision_recall_curve (BinaryPrecisionRecallCurve): Utility to compute
+            precision and recall values across different thresholds.
+        threshold (torch.Tensor): Stores the threshold value that results in the
+            maximum F1 score.
+
+    Examples:
+        >>> from anomalib.metrics import F1Max
+        >>> import torch
+
+        >>> preds = torch.tensor([0.1, 0.4, 0.35, 0.8])
+        >>> target = torch.tensor([0, 0, 1, 1])
 
+        >>> f1_max = F1Max()
+        >>> f1_max.update(preds, target)
 
-class F1Score(BinaryF1Score):
-    """This is a wrapper around torchmetrics' BinaryF1Score.
+        >>> optimal_f1_score = f1_max.compute()
+        >>> print(f"Optimal F1 Score: {f1_max_score}")
+        >>> print(f"Optimal Threshold: {f1_max.threshold}")
 
-    The idea behind this is to retain the current configuration otherwise the one from
-    torchmetrics requires ``task`` as a parameter.
+    Note:
+        - Use `update` method to input predictions and target labels.
+        - Use `compute` method to calculate the maximum F1 score after all
+          updates.
+        - Use `reset` method to clear the current state and prepare for a new
+          set of calculations.
     """
 
-    def __init__(
-        self,
-        threshold: float = 0.5,
-        multidim_average: Literal["global"] | Literal["samplewise"] = "global",
-        ignore_index: int | None = None,
-        validate_args: bool = True,
-        **kwargs: Any,  # noqa: ANN401
-    ) -> None:
-        super().__init__(threshold, multidim_average, ignore_index, validate_args, **kwargs)
-        logger.warning(
-            "F1Score class exists for backwards compatibility. It will be removed in v1.1."
-            " Please use BinaryF1Score from torchmetrics instead",
-        )
+    full_state_update: bool = False
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        self.precision_recall_curve = BinaryPrecisionRecallCurve()
+
+        self.threshold: torch.Tensor
+
+    def update(self, preds: torch.Tensor, target: torch.Tensor, *args, **kwargs) -> None:
+        """Update the precision-recall curve metric."""
+        del args, kwargs  # These variables are not used.
+
+        self.precision_recall_curve.update(preds, target)
+
+    def compute(self) -> torch.Tensor:
+        """Compute the value of the optimal F1 score.
+
+        Compute the F1 scores while varying the threshold. Store the optimal
+        threshold as attribute and return the maximum value of the F1 score.
+
+        Returns:
+            Value of the F1 score at the optimal threshold.
+        """
+        precision: torch.Tensor
+        recall: torch.Tensor
+        thresholds: torch.Tensor
+
+        precision, recall, thresholds = self.precision_recall_curve.compute()
+        f1_score = (2 * precision * recall) / (precision + recall + 1e-10)
+        self.threshold = thresholds.item() if thresholds.ndim == 0 else thresholds[torch.argmax(f1_score)]
+        return torch.max(f1_score)
+
+    def reset(self) -> None:
+        """Reset the metric."""
+        self.precision_recall_curve.reset()
+
+
+class F1Max(AnomalibMetric, _F1Max):  # type: ignore[misc]
+    """Wrapper to add AnomalibMetric functionality to F1Max metric."""
diff --git a/src/anomalib/metrics/pimo/pimo.py b/src/anomalib/metrics/pimo/pimo.py
index 9703b60b59..ef3e22ed3c 100644
--- a/src/anomalib/metrics/pimo/pimo.py
+++ b/src/anomalib/metrics/pimo/pimo.py
@@ -44,13 +44,15 @@
 import torch
 from torchmetrics import Metric
 
+from anomalib.metrics.base import AnomalibMetric
+
 from . import _validate, functional
 from .dataclasses import AUPIMOResult, PIMOResult
 
 logger = logging.getLogger(__name__)
 
 
-class PIMO(Metric):
+class _PIMO(Metric):
     """Per-IMage Overlap (PIMO, pronounced pee-mo) curves.
 
     This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code.
@@ -167,7 +169,13 @@ def compute(self) -> PIMOResult:
         )
 
 
-class AUPIMO(PIMO):
+class PIMO(AnomalibMetric, _PIMO):  # type: ignore[misc]
+    """Wrapper to add AnomalibMetric functionality to PIMO metric."""
+
+    default_fields = ("anomaly_map", "gt_mask")
+
+
+class _AUPIMO(_PIMO):
     """Area Under the Per-Image Overlap (PIMO) curve.
 
     This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code.
@@ -294,3 +302,9 @@ def compute(self, force: bool | None = None) -> tuple[PIMOResult, AUPIMOResult]:
             is_nan = torch.isnan(aupimo_result.aupimos)
             return aupimo_result.aupimos[~is_nan].mean()
         return pimo_result, aupimo_result
+
+
+class AUPIMO(AnomalibMetric, _AUPIMO):  # type: ignore[misc]
+    """Wrapper to add AnomalibMetric functionality to AUPIMO metric."""
+
+    default_fields = ("anomaly_map", "gt_mask")
diff --git a/src/anomalib/metrics/pro.py b/src/anomalib/metrics/pro.py
index 8bd39b69aa..d05d8def0d 100644
--- a/src/anomalib/metrics/pro.py
+++ b/src/anomalib/metrics/pro.py
@@ -10,8 +10,10 @@
 
 from anomalib.utils.cv import connected_components_cpu, connected_components_gpu
 
+from .base import AnomalibMetric
 
-class PRO(Metric):
+
+class _PRO(Metric):
     """Per-Region Overlap (PRO) Score.
 
     This metric computes the macro average of the per-region overlap between the
@@ -123,3 +125,7 @@ def pro_score(predictions: torch.Tensor, comps: torch.Tensor, threshold: float =
         ignore_index=0,
     )
     return recall_tensor.sum() / (n_comps - 1)
+
+
+class PRO(AnomalibMetric, _PRO):  # type: ignore[misc]
+    """Wrapper to add AnomalibMetric functionality to PRO metric."""
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py
index a27b77baf2..b22ee6981b 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomaly_module.py
@@ -3,10 +3,8 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import importlib
 import logging
 from abc import ABC, abstractmethod
-from collections import OrderedDict
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -20,6 +18,8 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch, InferenceBatch
+from anomalib.metrics import AUROC, F1Score
+from anomalib.metrics.evaluator import Evaluator
 from anomalib.metrics.threshold import Threshold
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 
@@ -28,7 +28,6 @@
 if TYPE_CHECKING:
     from lightning.pytorch.callbacks import Callback
 
-    from anomalib.metrics import AnomalibMetricCollection
 
 logger = logging.getLogger(__name__)
 
@@ -39,7 +38,11 @@ class AnomalyModule(ExportMixin, pl.LightningModule, ABC):
     Acts as a base class for all the Anomaly Modules in the library.
     """
 
-    def __init__(self, post_processor: PostProcessor | None = None) -> None:
+    def __init__(
+        self,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
+    ) -> None:
         super().__init__()
         logger.info("Initializing %s model.", self.__class__.__name__)
 
@@ -48,11 +51,11 @@ def __init__(self, post_processor: PostProcessor | None = None) -> None:
         self.loss: nn.Module
         self.callbacks: list[Callback]
 
-        self.image_metrics: AnomalibMetricCollection
-        self.pixel_metrics: AnomalibMetricCollection
-
+        # set the post-processor
         self.post_processor = post_processor or self.default_post_processor()
 
+        self.evaluator = self._resolve_evaluator(evaluator)
+
         self._transform: Transform | None = None
         self._input_size: tuple[int, int] | None = None
 
@@ -141,29 +144,6 @@ def trainer_arguments(self) -> dict[str, Any]:
         """Arguments used to override the trainer parameters so as to train the model correctly."""
         raise NotImplementedError
 
-    def _save_to_state_dict(self, destination: OrderedDict, prefix: str, keep_vars: bool) -> None:
-        if hasattr(self, "image_threshold"):
-            destination["image_threshold_class"] = (
-                f"{self.image_threshold.__class__.__module__}.{self.image_threshold.__class__.__name__}"
-            )
-        if hasattr(self, "pixel_threshold"):
-            destination["pixel_threshold_class"] = (
-                f"{self.pixel_threshold.__class__.__module__}.{self.pixel_threshold.__class__.__name__}"
-            )
-        if hasattr(self, "normalization_metrics"):
-            for metric in self.normalization_metrics:
-                metric_class = self.normalization_metrics[metric].__class__
-                destination[f"{metric}_normalization_class"] = f"{metric_class.__module__}.{metric_class.__name__}"
-
-        return super()._save_to_state_dict(destination, prefix, keep_vars)
-
-    @staticmethod
-    def _get_instance(state_dict: OrderedDict[str, Any], dict_key: str) -> Threshold:
-        """Get the threshold class from the ``state_dict``."""
-        class_path = state_dict.pop(dict_key)
-        module = importlib.import_module(".".join(class_path.split(".")[:-1]))
-        return getattr(module, class_path.split(".")[-1])()
-
     @property
     @abstractmethod
     def learning_type(self) -> LearningType:
@@ -213,6 +193,32 @@ def default_post_processor(self) -> PostProcessor:
               Please override the default_post_processor method in the model implementation."
         raise NotImplementedError(msg)
 
+    def _resolve_evaluator(self, evaluator: Evaluator | bool) -> Evaluator | None:
+        """Resolve the evaluator to be used in the model.
+
+        If the evaluator is set to True, the default evaluator will be used. If the evaluator is set to False, no
+        evaluator will be used. If the evaluator is an instance of Evaluator, it will be used as the evaluator.
+        """
+        if isinstance(evaluator, Evaluator):
+            return evaluator
+        if isinstance(evaluator, bool):
+            return self.configure_evaluator() if evaluator else None
+        msg = f"evaluator must be of type Evaluator or bool, got {type(evaluator)}"
+        raise TypeError(msg)
+
+    @staticmethod
+    def configure_evaluator() -> Evaluator:
+        """Default evaluator.
+
+        Override in subclass for model-specific evaluator behaviour.
+        """
+        image_auroc = AUROC(fields=["pred_score", "gt_label"], prefix="image_")
+        image_f1score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
+        pixel_auroc = AUROC(fields=["anomaly_map", "gt_mask"], prefix="pixel_")
+        pixel_f1score = F1Score(fields=["pred_mask", "gt_mask"], prefix="pixel_")
+        test_metrics = [image_auroc, image_f1score, pixel_auroc, pixel_f1score]
+        return Evaluator(test_metrics=test_metrics)
+
     @property
     def input_size(self) -> tuple[int, int] | None:
         """Return the effective input size of the model.
diff --git a/src/anomalib/models/components/base/export_mixin.py b/src/anomalib/models/components/base/export_mixin.py
index 210a314d22..b696ad2567 100644
--- a/src/anomalib/models/components/base/export_mixin.py
+++ b/src/anomalib/models/components/base/export_mixin.py
@@ -3,14 +3,12 @@
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import json
 import logging
 from collections.abc import Callable, Iterable
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import TYPE_CHECKING, Any
 
-import numpy as np
 import torch
 from lightning.pytorch import LightningModule
 from lightning_utilities.core.imports import package_available
@@ -22,13 +20,10 @@
 from anomalib.data import AnomalibDataModule
 from anomalib.deploy.export import CompressionType, ExportType
 from anomalib.deploy.utils import make_transform_exportable
-from anomalib.metrics import create_metric_collection
 
 if TYPE_CHECKING:
     from importlib.util import find_spec
 
-    from torch.types import Number
-
     if find_spec("openvino") is not None:
         from openvino import CompiledModel
 
@@ -165,7 +160,7 @@ def to_openvino(
         input_size: tuple[int, int] | None = None,
         compression_type: CompressionType | None = None,
         datamodule: AnomalibDataModule | None = None,
-        metric: Metric | str | None = None,
+        metric: Metric | None = None,
         ov_args: dict[str, Any] | None = None,
         task: TaskType | None = None,
     ) -> Path:
@@ -183,7 +178,7 @@ def to_openvino(
             datamodule (AnomalibDataModule | None, optional): Lightning datamodule.
                 Must be provided if ``CompressionType.INT8_PTQ`` or ``CompressionType.INT8_ACQ`` is selected.
                 Defaults to ``None``.
-            metric (Metric | str | None, optional): Metric to measure quality loss when quantizing.
+            metric (Metric | None, optional): Metric to measure quality loss when quantizing.
                 Must be provided if ``CompressionType.INT8_ACQ`` is selected and must return higher value for better
                 performance of the model.
                 Defaults to ``None``.
@@ -270,7 +265,7 @@ def _compress_ov_model(
         model: "CompiledModel",
         compression_type: CompressionType | None = None,
         datamodule: AnomalibDataModule | None = None,
-        metric: Metric | str | None = None,
+        metric: Metric | None = None,
         task: TaskType | None = None,
     ) -> "CompiledModel":
         """Compress OpenVINO model with NNCF.
@@ -350,7 +345,7 @@ def _post_training_quantization_ov(
     def _accuracy_control_quantization_ov(
         model: "CompiledModel",
         datamodule: AnomalibDataModule | None = None,
-        metric: Metric | str | None = None,
+        metric: Metric | None = None,
         task: TaskType | None = None,
     ) -> "CompiledModel":
         """Accuracy-Control Quantization with NNCF.
@@ -359,7 +354,7 @@ def _accuracy_control_quantization_ov(
             datamodule (AnomalibDataModule | None, optional): Lightning datamodule.
                 Must be provided if ``CompressionType.INT8_PTQ`` or ``CompressionType.INT8_ACQ`` is selected.
                 Defaults to ``None``.
-            metric (Metric | str | None, optional): Metric to measure quality loss when quantizing.
+            metric (Metric | None, optional): Metric to measure quality loss when quantizing.
                 Must be provided if ``CompressionType.INT8_ACQ`` is selected and must return higher value for better
                 performance of the model.
                 Defaults to ``None``.
@@ -395,9 +390,6 @@ def _accuracy_control_quantization_ov(
         calibration_dataset = nncf.Dataset(dataloader, lambda x: x["image"])
         validation_dataset = nncf.Dataset(datamodule.test_dataloader())
 
-        if isinstance(metric, str):
-            metric = create_metric_collection([metric])[metric]
-
         # validation function to evaluate the quality loss after quantization
         def val_fn(nncf_model: "CompiledModel", validation_data: Iterable) -> float:
             for batch in validation_data:
@@ -408,56 +400,12 @@ def val_fn(nncf_model: "CompiledModel", validation_data: Iterable) -> float:
 
         return nncf.quantize_with_accuracy_control(model, calibration_dataset, validation_dataset, val_fn)
 
-    def _get_metadata(
-        self,
-        task: TaskType | None = None,
-    ) -> dict[str, Any]:
-        """Get metadata for the exported model.
-
-        Args:
-            task (TaskType | None): Task type.
-                Defaults to None.
-
-        Returns:
-            dict[str, Any]: Metadata for the exported model.
-        """
-        model_metadata = {}
-        cached_metadata: dict[str, Number | torch.Tensor] = {}
-        for threshold_name in ("image_threshold", "pixel_threshold"):
-            if hasattr(self, threshold_name):
-                cached_metadata[threshold_name] = getattr(self, threshold_name).cpu().value.item()
-        if hasattr(self, "normalization_metrics") and self.normalization_metrics.state_dict() is not None:
-            for key, value in self.normalization_metrics.state_dict().items():
-                cached_metadata[key] = value.cpu()
-        # Remove undefined values by copying in a new dict
-        model_metadata = {key: val for key, val in cached_metadata.items() if not np.isinf(val).all()}
-        del cached_metadata
-        metadata = {"task": task, **model_metadata}
-
-        # Convert torch tensors to python lists or values for json serialization.
-        for key, value in metadata.items():
-            if isinstance(value, torch.Tensor):
-                metadata[key] = value.numpy().tolist()
-
-        return metadata
-
     @property
     def exportable_transform(self) -> Transform:
         """Return the exportable transform."""
         return make_transform_exportable(self.transform)
 
 
-def _write_metadata_to_json(metadata: dict[str, Any], export_root: Path) -> None:
-    """Write metadata to json file.
-
-    Args:
-        metadata (dict[str, Any]): Metadata to export.
-        export_root (Path): Path to the exported model.
-    """
-    with (export_root / "metadata.json").open("w", encoding="utf-8") as metadata_file:
-        json.dump(metadata, metadata_file, ensure_ascii=False, indent=4)
-
-
 def _create_export_root(export_root: str | Path, export_type: ExportType) -> Path:
     """Create export directory.
 
diff --git a/src/anomalib/models/image/cfa/lightning_model.py b/src/anomalib/models/image/cfa/lightning_model.py
index e367762484..363bd2eae7 100644
--- a/src/anomalib/models/image/cfa/lightning_model.py
+++ b/src/anomalib/models/image/cfa/lightning_model.py
@@ -16,7 +16,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .loss import CfaLoss
 from .torch_model import CfaModel
@@ -52,8 +54,10 @@ def __init__(
         num_nearest_neighbors: int = 3,
         num_hard_negative_features: int = 3,
         radius: float = 1e-5,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
         self.model: CfaModel = CfaModel(
             backbone=backbone,
             gamma_c=gamma_c,
diff --git a/src/anomalib/models/image/cfa/torch_model.py b/src/anomalib/models/image/cfa/torch_model.py
index 2fecfa4948..e36d53050e 100644
--- a/src/anomalib/models/image/cfa/torch_model.py
+++ b/src/anomalib/models/image/cfa/torch_model.py
@@ -227,7 +227,7 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
             distance=distance,
             scale=target_features.shape[-2:],
             image_size=input_tensor.shape[-2:],
-        )
+        ).squeeze()
         pred_score = torch.amax(anomaly_map, dim=(-2, -1))
         return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
diff --git a/src/anomalib/models/image/cflow/lightning_model.py b/src/anomalib/models/image/cflow/lightning_model.py
index edb4788111..3b4cb731e2 100644
--- a/src/anomalib/models/image/cflow/lightning_model.py
+++ b/src/anomalib/models/image/cflow/lightning_model.py
@@ -23,7 +23,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .torch_model import CflowModel
 from .utils import get_logp, positional_encoding_2d
@@ -67,8 +69,10 @@ def __init__(
         clamp_alpha: float = 1.9,
         permute_soft: bool = False,
         lr: float = 0.0001,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.model: CflowModel = CflowModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/csflow/lightning_model.py b/src/anomalib/models/image/csflow/lightning_model.py
index 3244ef7da7..e3762da180 100644
--- a/src/anomalib/models/image/csflow/lightning_model.py
+++ b/src/anomalib/models/image/csflow/lightning_model.py
@@ -14,7 +14,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .loss import CsFlowLoss
 from .torch_model import CsFlowModel
@@ -44,8 +46,10 @@ def __init__(
         n_coupling_blocks: int = 4,
         clamp: int = 3,
         num_channels: int = 3,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.cross_conv_hidden_channels = cross_conv_hidden_channels
         self.n_coupling_blocks = n_coupling_blocks
diff --git a/src/anomalib/models/image/dfkde/lightning_model.py b/src/anomalib/models/image/dfkde/lightning_model.py
index 210242ec5f..8b67e56907 100644
--- a/src/anomalib/models/image/dfkde/lightning_model.py
+++ b/src/anomalib/models/image/dfkde/lightning_model.py
@@ -12,8 +12,10 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import AUROC, Evaluator, F1Score
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.models.components.classification import FeatureScalingMethod
+from anomalib.post_processing import PostProcessor
 
 from .torch_model import DfkdeModel
 
@@ -46,8 +48,10 @@ def __init__(
         n_pca_components: int = 16,
         feature_scaling_method: FeatureScalingMethod = FeatureScalingMethod.SCALE,
         max_training_points: int = 40000,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.model = DfkdeModel(
             layers=layers,
@@ -119,3 +123,11 @@ def learning_type(self) -> LearningType:
             LearningType: Learning type of the model.
         """
         return LearningType.ONE_CLASS
+
+    @staticmethod
+    def configure_evaluator() -> Evaluator:
+        """Default evaluator for DFKE."""
+        image_auroc = AUROC(fields=["pred_score", "gt_label"], prefix="image_")
+        image_f1score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
+        test_metrics = [image_auroc, image_f1score]
+        return Evaluator(test_metrics=test_metrics)
diff --git a/src/anomalib/models/image/dfm/lightning_model.py b/src/anomalib/models/image/dfm/lightning_model.py
index 64777fda87..9b6f52979c 100644
--- a/src/anomalib/models/image/dfm/lightning_model.py
+++ b/src/anomalib/models/image/dfm/lightning_model.py
@@ -14,7 +14,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.post_processing import PostProcessor
 
 from .torch_model import DFMModel
 
@@ -47,8 +49,10 @@ def __init__(
         pooling_kernel_size: int = 4,
         pca_level: float = 0.97,
         score_type: str = "fre",
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.model: DFMModel = DFMModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py
index ba63ad4d46..ccfb52cbbd 100644
--- a/src/anomalib/models/image/draem/lightning_model.py
+++ b/src/anomalib/models/image/draem/lightning_model.py
@@ -17,7 +17,9 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.data.utils import Augmenter
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .loss import DraemLoss
 from .torch_model import DraemModel
@@ -44,8 +46,10 @@ def __init__(
         sspcab_lambda: float = 0.1,
         anomaly_source_path: str | None = None,
         beta: float | tuple[float, float] = (0.1, 1.0),
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.augmenter = Augmenter(anomaly_source_path, beta=beta)
         self.model = DraemModel(sspcab=enable_sspcab)
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index e96a4fdb8b..8ae8633c9c 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -18,10 +18,12 @@
 from anomalib.data import Batch
 from anomalib.data.utils import DownloadInfo, download_and_extract
 from anomalib.data.utils.augmenter import Augmenter
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.models.image.dsr.anomaly_generator import DsrAnomalyGenerator
 from anomalib.models.image.dsr.loss import DsrSecondStageLoss, DsrThirdStageLoss
 from anomalib.models.image.dsr.torch_model import DsrModel
+from anomalib.post_processing import PostProcessor
 
 __all__ = ["Dsr"]
 
@@ -42,8 +44,14 @@ class Dsr(AnomalyModule):
         upsampling_train_ratio (float): Ratio of training steps for the upsampling module. Defaults to 0.7
     """
 
-    def __init__(self, latent_anomaly_strength: float = 0.2, upsampling_train_ratio: float = 0.7) -> None:
-        super().__init__()
+    def __init__(
+        self,
+        latent_anomaly_strength: float = 0.2,
+        upsampling_train_ratio: float = 0.7,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
+    ) -> None:
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.automatic_optimization = False
         self.upsampling_train_ratio = upsampling_train_ratio
diff --git a/src/anomalib/models/image/efficient_ad/lightning_model.py b/src/anomalib/models/image/efficient_ad/lightning_model.py
index 1fe6753438..152f50c36a 100644
--- a/src/anomalib/models/image/efficient_ad/lightning_model.py
+++ b/src/anomalib/models/image/efficient_ad/lightning_model.py
@@ -20,7 +20,9 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.data.utils import DownloadInfo, download_and_extract
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .torch_model import EfficientAdModel, EfficientAdModelSize, reduce_tensor_elems
 
@@ -69,8 +71,10 @@ def __init__(
         weight_decay: float = 0.00001,
         padding: bool = False,
         pad_maps: bool = True,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.imagenet_dir = Path(imagenet_dir)
         if not isinstance(model_size, EfficientAdModelSize):
diff --git a/src/anomalib/models/image/fastflow/lightning_model.py b/src/anomalib/models/image/fastflow/lightning_model.py
index 577daaeb5f..75aff99584 100644
--- a/src/anomalib/models/image/fastflow/lightning_model.py
+++ b/src/anomalib/models/image/fastflow/lightning_model.py
@@ -14,7 +14,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import AUROC, Evaluator, F1Score
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .loss import FastflowLoss
 from .torch_model import FastflowModel
@@ -43,8 +45,10 @@ def __init__(
         flow_steps: int = 8,
         conv3x3_only: bool = False,
         hidden_ratio: float = 1.0,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.backbone = backbone
         self.pre_trained = pre_trained
@@ -128,3 +132,22 @@ def learning_type(self) -> LearningType:
             LearningType: Learning type of the model.
         """
         return LearningType.ONE_CLASS
+
+    @staticmethod
+    def configure_evaluator() -> Evaluator:
+        """Default evaluator.
+
+        Override in subclass for model-specific evaluator behaviour.
+        """
+        # val metrics (needed for early stopping)
+        image_auroc = AUROC(fields=["pred_score", "gt_label"], prefix="image_")
+        pixel_auroc = AUROC(fields=["anomaly_map", "gt_mask"], prefix="pixel_")
+        val_metrics = [image_auroc, pixel_auroc]
+
+        # test_metrics
+        image_auroc = AUROC(fields=["pred_score", "gt_label"], prefix="image_")
+        image_f1score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
+        pixel_auroc = AUROC(fields=["anomaly_map", "gt_mask"], prefix="pixel_")
+        pixel_f1score = F1Score(fields=["pred_mask", "gt_mask"], prefix="pixel_")
+        test_metrics = [image_auroc, image_f1score, pixel_auroc, pixel_f1score]
+        return Evaluator(val_metrics=val_metrics, test_metrics=test_metrics)
diff --git a/src/anomalib/models/image/fre/lightning_model.py b/src/anomalib/models/image/fre/lightning_model.py
index 20c383b128..b4628e6446 100755
--- a/src/anomalib/models/image/fre/lightning_model.py
+++ b/src/anomalib/models/image/fre/lightning_model.py
@@ -15,7 +15,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .torch_model import FREModel
 
@@ -49,8 +51,10 @@ def __init__(
         pooling_kernel_size: int = 2,
         input_dim: int = 65536,
         latent_dim: int = 220,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.model: FREModel = FREModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/ganomaly/lightning_model.py b/src/anomalib/models/image/ganomaly/lightning_model.py
index 5633c003ac..362a713050 100644
--- a/src/anomalib/models/image/ganomaly/lightning_model.py
+++ b/src/anomalib/models/image/ganomaly/lightning_model.py
@@ -15,7 +15,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import AUROC, Evaluator, F1Score
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .loss import DiscriminatorLoss, GeneratorLoss
 from .torch_model import GanomalyModel
@@ -64,8 +66,10 @@ def __init__(
         lr: float = 0.0002,
         beta1: float = 0.5,
         beta2: float = 0.999,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.n_features = n_features
         self.latent_vec_size = latent_vec_size
@@ -258,3 +262,11 @@ def learning_type(self) -> LearningType:
             LearningType: Learning type of the model.
         """
         return LearningType.ONE_CLASS
+
+    @staticmethod
+    def configure_evaluator() -> Evaluator:
+        """Default evaluator for GANomaly."""
+        image_auroc = AUROC(fields=["pred_score", "gt_label"], prefix="image_")
+        image_f1score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
+        test_metrics = [image_auroc, image_f1score]
+        return Evaluator(test_metrics=test_metrics)
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index 9cd326cf83..2a80171931 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -14,7 +14,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.post_processing import PostProcessor
 from anomalib.post_processing.one_class import OneClassPostProcessor
 
 from .torch_model import PadimModel
@@ -45,8 +47,10 @@ def __init__(
         layers: list[str] = ["layer1", "layer2", "layer3"],  # noqa: B006
         pre_trained: bool = True,
         n_features: int | None = None,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.model: PadimModel = PadimModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index 6b3b76e920..d633141af3 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -16,7 +16,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.post_processing import PostProcessor
 from anomalib.post_processing.one_class import OneClassPostProcessor
 
 from .torch_model import PatchcoreModel
@@ -47,8 +49,10 @@ def __init__(
         pre_trained: bool = True,
         coreset_sampling_ratio: float = 0.1,
         num_neighbors: int = 9,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.model: PatchcoreModel = PatchcoreModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/reverse_distillation/lightning_model.py b/src/anomalib/models/image/reverse_distillation/lightning_model.py
index c1ba797a03..916541ebda 100644
--- a/src/anomalib/models/image/reverse_distillation/lightning_model.py
+++ b/src/anomalib/models/image/reverse_distillation/lightning_model.py
@@ -14,7 +14,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .anomaly_map import AnomalyMapGenerationMode
 from .loss import ReverseDistillationLoss
@@ -41,8 +43,10 @@ def __init__(
         layers: Sequence[str] = ("layer1", "layer2", "layer3"),
         anomaly_map_mode: AnomalyMapGenerationMode = AnomalyMapGenerationMode.ADD,
         pre_trained: bool = True,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.backbone = backbone
         self.pre_trained = pre_trained
diff --git a/src/anomalib/models/image/rkde/lightning_model.py b/src/anomalib/models/image/rkde/lightning_model.py
index f8b6af6d7a..2d48da35c4 100644
--- a/src/anomalib/models/image/rkde/lightning_model.py
+++ b/src/anomalib/models/image/rkde/lightning_model.py
@@ -14,8 +14,10 @@
 from torchvision.transforms.v2 import Compose, Resize, Transform
 
 from anomalib import LearningType
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.models.components.classification import FeatureScalingMethod
+from anomalib.post_processing import PostProcessor
 
 from .region_extractor import RoiStage
 from .torch_model import RkdeModel
@@ -57,8 +59,10 @@ def __init__(
         n_pca_components: int = 16,
         feature_scaling_method: FeatureScalingMethod = FeatureScalingMethod.SCALE,
         max_training_points: int = 40000,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.model: RkdeModel = RkdeModel(
             roi_stage=roi_stage,
diff --git a/src/anomalib/models/image/stfpm/lightning_model.py b/src/anomalib/models/image/stfpm/lightning_model.py
index 42fc3c0c3d..eca57f6850 100644
--- a/src/anomalib/models/image/stfpm/lightning_model.py
+++ b/src/anomalib/models/image/stfpm/lightning_model.py
@@ -15,7 +15,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .loss import STFPMLoss
 from .torch_model import STFPMModel
@@ -37,8 +39,10 @@ def __init__(
         self,
         backbone: str = "resnet18",
         layers: Sequence[str] = ("layer1", "layer2", "layer3"),
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.model = STFPMModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/uflow/lightning_model.py b/src/anomalib/models/image/uflow/lightning_model.py
index b7368b1e4d..03ef56a2b0 100644
--- a/src/anomalib/models/image/uflow/lightning_model.py
+++ b/src/anomalib/models/image/uflow/lightning_model.py
@@ -17,7 +17,9 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
+from anomalib.post_processing import PostProcessor
 
 from .loss import UFlowLoss
 from .torch_model import UflowModel
@@ -28,7 +30,15 @@
 
 
 class Uflow(AnomalyModule):
-    """PL Lightning Module for the UFLOW algorithm."""
+    """Uflow model.
+
+    Args:
+        backbone (str): Backbone name.
+        flow_steps (int): Number of flow steps.
+        affine_clamp (float): Affine clamp.
+        affine_subnet_channels_ratio (float): Affine subnet channels ratio.
+        permute_soft (bool): Whether to use soft permutation.
+    """
 
     def __init__(
         self,
@@ -37,17 +47,10 @@ def __init__(
         affine_clamp: float = 2.0,
         affine_subnet_channels_ratio: float = 1.0,
         permute_soft: bool = False,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        """Uflow model.
-
-        Args:
-            backbone (str): Backbone name.
-            flow_steps (int): Number of flow steps.
-            affine_clamp (float): Affine clamp.
-            affine_subnet_channels_ratio (float): Affine subnet channels ratio.
-            permute_soft (bool): Whether to use soft permutation.
-        """
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
 
         self.backbone = backbone
         self.flow_steps = flow_steps
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index 222d887017..2651c588e3 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -18,8 +18,9 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.data.predict import PredictDataset
+from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
-from anomalib.post_processing import OneClassPostProcessor
+from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 
 from .torch_model import WinClipModel
 
@@ -50,8 +51,10 @@ def __init__(
         k_shot: int = 0,
         scales: tuple = (2, 3),
         few_shot_source: Path | str | None = None,
+        post_processor: PostProcessor | None = None,
+        evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__()
+        super().__init__(post_processor=post_processor, evaluator=evaluator)
         self.model = WinClipModel(scales=scales, apply_transform=False)
         self.class_name = class_name
         self.k_shot = k_shot
diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py
index 6b4ea8785e..8c36a689c7 100644
--- a/src/anomalib/models/video/ai_vad/lightning_model.py
+++ b/src/anomalib/models/video/ai_vad/lightning_model.py
@@ -77,8 +77,9 @@ def __init__(
         n_components_velocity: int = 2,
         n_neighbors_pose: int = 1,
         n_neighbors_deep: int = 1,
+        **kwargs,
     ) -> None:
-        super().__init__()
+        super().__init__(**kwargs)
 
         self.model = AiVadModel(
             box_score_thresh=box_score_thresh,
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index 9c344976f0..4fc266d190 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -210,7 +210,6 @@ def _get_objects(
             default_root_dir=project_path,
             max_epochs=1,
             devices=1,
-            pixel_metrics=["F1Max", "AUROC"],
             task=task_type,
             # TODO(ashwinvaidya17): Fix these Edge cases
             # https://github.com/openvinotoolkit/anomalib/issues/1478
diff --git a/tests/integration/tools/upgrade/expected_draem_v1.yaml b/tests/integration/tools/upgrade/expected_draem_v1.yaml
index a965186c90..f59a21d5e9 100644
--- a/tests/integration/tools/upgrade/expected_draem_v1.yaml
+++ b/tests/integration/tools/upgrade/expected_draem_v1.yaml
@@ -27,6 +27,8 @@ model:
     beta:
       - 0.1
       - 1.0
+    post_processor: null
+    evaluator: true
 normalization:
   normalization_method: min_max
 metrics:
diff --git a/tests/unit/callbacks/__init__.py b/tests/unit/callbacks/__init__.py
deleted file mode 100644
index b58dccf550..0000000000
--- a/tests/unit/callbacks/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-"""Test callbacks."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/callbacks/metrics_configuration_callback/__init__.py b/tests/unit/callbacks/metrics_configuration_callback/__init__.py
deleted file mode 100644
index cf1e0b50b9..0000000000
--- a/tests/unit/callbacks/metrics_configuration_callback/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-"""Test metrics configuration callback."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/callbacks/metrics_configuration_callback/data/config-good-00.yaml b/tests/unit/callbacks/metrics_configuration_callback/data/config-good-00.yaml
deleted file mode 100644
index 56ee957906..0000000000
--- a/tests/unit/callbacks/metrics_configuration_callback/data/config-good-00.yaml
+++ /dev/null
@@ -1,13 +0,0 @@
-metrics:
-  pixel:
-    F1Score:
-      class_path: anomalib.metrics.F1Score
-      init_args:
-        threshold: 0.5
-    AUROC:
-      class_path: anomalib.metrics.AUROC
-      init_args:
-        compute_on_cpu: true
-  image:
-    - F1Score
-    - AUROC
diff --git a/tests/unit/callbacks/metrics_configuration_callback/data/config-good-01.yaml b/tests/unit/callbacks/metrics_configuration_callback/data/config-good-01.yaml
deleted file mode 100644
index 5c724730e7..0000000000
--- a/tests/unit/callbacks/metrics_configuration_callback/data/config-good-01.yaml
+++ /dev/null
@@ -1,13 +0,0 @@
-metrics:
-  pixel:
-    - F1Score
-    - AUROC
-  image:
-    F1Score:
-      class_path: anomalib.metrics.F1Score
-      init_args:
-        threshold: 0.5
-    AUROC:
-      class_path: anomalib.metrics.AUROC
-      init_args:
-        compute_on_cpu: true
diff --git a/tests/unit/callbacks/metrics_configuration_callback/data/config-good-02-serialized.yaml b/tests/unit/callbacks/metrics_configuration_callback/data/config-good-02-serialized.yaml
deleted file mode 100644
index 1b6c352ae5..0000000000
--- a/tests/unit/callbacks/metrics_configuration_callback/data/config-good-02-serialized.yaml
+++ /dev/null
@@ -1,19 +0,0 @@
-metrics:
-  pixel:
-    F1Score:
-      class_path: anomalib.metrics.F1Score
-      init_args:
-        threshold: 0.5
-    AUROC:
-      class_path: anomalib.metrics.AUROC
-      init_args:
-        compute_on_cpu: true
-  image:
-    F1Score:
-      class_path: anomalib.metrics.F1Score
-      init_args:
-        threshold: 0.5
-    AUROC:
-      class_path: anomalib.metrics.AUROC
-      init_args:
-        compute_on_cpu: true
diff --git a/tests/unit/callbacks/metrics_configuration_callback/data/config-good-02.yaml b/tests/unit/callbacks/metrics_configuration_callback/data/config-good-02.yaml
deleted file mode 100644
index 1b6c352ae5..0000000000
--- a/tests/unit/callbacks/metrics_configuration_callback/data/config-good-02.yaml
+++ /dev/null
@@ -1,19 +0,0 @@
-metrics:
-  pixel:
-    F1Score:
-      class_path: anomalib.metrics.F1Score
-      init_args:
-        threshold: 0.5
-    AUROC:
-      class_path: anomalib.metrics.AUROC
-      init_args:
-        compute_on_cpu: true
-  image:
-    F1Score:
-      class_path: anomalib.metrics.F1Score
-      init_args:
-        threshold: 0.5
-    AUROC:
-      class_path: anomalib.metrics.AUROC
-      init_args:
-        compute_on_cpu: true
diff --git a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py b/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
deleted file mode 100644
index 7ed1feca95..0000000000
--- a/tests/unit/callbacks/metrics_configuration_callback/test_metrics_configuration_callback.py
+++ /dev/null
@@ -1,107 +0,0 @@
-"""Test metrics callback."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from pathlib import Path
-
-import lightning.pytorch as pl
-import pytest
-from omegaconf import DictConfig, OmegaConf
-from torchvision.transforms.v2 import Resize
-
-from anomalib import LearningType
-from anomalib.callbacks.metrics import _MetricsCallback
-from anomalib.data import InferenceBatch
-from anomalib.metrics import AnomalibMetricCollection
-from anomalib.metrics.threshold import F1AdaptiveThreshold
-from anomalib.models.components import AnomalyModule
-from anomalib.post_processing import PostProcessor
-
-
-class DummyPostProcessor(PostProcessor):
-    """Dummy post-processor for testing."""
-
-    @staticmethod
-    def forward(batch: InferenceBatch) -> InferenceBatch:
-        """Dummy forward method."""
-        return batch
-
-
-class _DummyAnomalyModule(AnomalyModule):
-    def __init__(self) -> None:
-        super().__init__()
-        self.task = "segmentation"
-        self.mode = "full"
-        self.callbacks = []
-        self.image_threshold = F1AdaptiveThreshold()
-        self.pixel_threshold = F1AdaptiveThreshold()
-
-    @staticmethod
-    def test_step(**_kwdargs) -> None:
-        return None
-
-    @staticmethod
-    def validation_epoch_end(**_kwdargs) -> None:
-        return None
-
-    @staticmethod
-    def test_epoch_end(**_kwdargs) -> None:
-        return None
-
-    @staticmethod
-    def configure_optimizers() -> None:
-        return None
-
-    @property
-    def learning_type(self) -> LearningType:
-        """Learning type of the model."""
-        return LearningType.ONE_CLASS
-
-    @property
-    def trainer_arguments(self) -> dict:
-        return {}
-
-    @property
-    def configure_transforms(self) -> None:
-        return Resize((256, 256))
-
-    def default_post_processor(self) -> PostProcessor:
-        return super().default_post_processor()
-
-
-@pytest.fixture()
-def config_from_yaml(request: "pytest.FixtureRequest") -> DictConfig:
-    """Loads config from path."""
-    return OmegaConf.load(Path(__file__).parent / request.param)
-
-
-@pytest.mark.parametrize(
-    "config_from_yaml",
-    ["data/config-good-00.yaml", "data/config-good-01.yaml"],
-    indirect=["config_from_yaml"],
-)
-def test_metric_collection_configuration_callback(config_from_yaml: str, tmpdir: str) -> None:
-    """Test if metrics are properly instantiated."""
-    callback = _MetricsCallback(
-        task="segmentation",
-        image_metrics=config_from_yaml.metrics.image,
-        pixel_metrics=config_from_yaml.metrics.pixel,
-    )
-
-    dummy_anomaly_module = _DummyAnomalyModule()
-    trainer = pl.Trainer(
-        callbacks=[callback],
-        enable_checkpointing=False,
-        default_root_dir=tmpdir,
-    )
-    callback.setup(trainer, dummy_anomaly_module)
-
-    assert isinstance(
-        dummy_anomaly_module.image_metrics,
-        AnomalibMetricCollection,
-    ), f"{dummy_anomaly_module.image_metrics}"
-    assert isinstance(
-        dummy_anomaly_module.pixel_metrics,
-        AnomalibMetricCollection,
-    ), f"{dummy_anomaly_module.pixel_metrics}"
diff --git a/tests/unit/callbacks/test_normalization_callback.py b/tests/unit/callbacks/test_normalization_callback.py
deleted file mode 100644
index c9fad49d09..0000000000
--- a/tests/unit/callbacks/test_normalization_callback.py
+++ /dev/null
@@ -1,56 +0,0 @@
-"""Test normalization callback."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from pathlib import Path
-
-import pytest
-from lightning.pytorch import seed_everything
-from lightning.pytorch.utilities.types import _EVALUATE_OUTPUT
-
-from anomalib.data import MVTec
-from anomalib.engine import Engine
-from anomalib.models import Padim
-
-
-def run_train_test(normalization_method: str, dataset_path: Path) -> _EVALUATE_OUTPUT:
-    """Run training and testing with a given normalization method.
-
-    Args:
-        normalization_method (str): Normalization method used to run the test.
-        dataset_path (Path): Path to the dummy dataset.
-
-    Returns:
-        _EVALUATE_OUTPUT: Results of the test.
-    """
-    model = Padim()
-    datamodule = MVTec(root=dataset_path / "mvtec", category="dummy", seed=42)
-
-    engine = Engine(
-        normalization=normalization_method,
-        threshold="F1AdaptiveThreshold",
-        image_metrics=["F1Score", "AUROC"],
-        devices=1,
-    )
-    engine.fit(model=model, datamodule=datamodule)
-    return engine.test(model=model, datamodule=datamodule)
-
-
-@pytest.mark.skip(reason="This test is flaky and needs to be revisited.")
-def test_normalizer(dataset_path: Path) -> None:
-    """Test if all normalization methods give the same performance."""
-    # run without normalization
-    seed_everything(42)
-    results_without_normalization = run_train_test(normalization_method="none", dataset_path=dataset_path)
-
-    # run without normalization
-    seed_everything(42)
-    results_with_minmax_normalization = run_train_test(normalization_method="min_max", dataset_path=dataset_path)
-
-    # performance should be the same
-    for metric in ["image_AUROC", "image_F1Score"]:
-        assert round(results_without_normalization[0][metric], 3) == round(
-            results_with_minmax_normalization[0][metric],
-            3,
-        )
diff --git a/tests/unit/data/validators/torch/test_depth.py b/tests/unit/data/validators/torch/test_depth.py
index e9f372b277..360c8f6424 100644
--- a/tests/unit/data/validators/torch/test_depth.py
+++ b/tests/unit/data/validators/torch/test_depth.py
@@ -221,7 +221,7 @@ def test_validate_pred_label_valid(self) -> None:
         """Test validation of valid prediction labels."""
         labels = torch.tensor([[1], [0], [1], [1]])
         validated_labels = self.validator.validate_pred_label(labels)
-        assert torch.equal(validated_labels, torch.tensor([[True], [False], [True], [True]]))
+        assert torch.equal(validated_labels, torch.tensor([True, False, True, True]))
 
     def test_validate_pred_label_none(self) -> None:
         """Test validation of None prediction labels."""
diff --git a/tests/unit/data/validators/torch/test_image.py b/tests/unit/data/validators/torch/test_image.py
index e1f6c0ec9a..3e459630a6 100644
--- a/tests/unit/data/validators/torch/test_image.py
+++ b/tests/unit/data/validators/torch/test_image.py
@@ -226,7 +226,7 @@ def test_validate_pred_label_valid(self) -> None:
         """Test validation of valid prediction labels."""
         labels = torch.tensor([[1], [0], [1], [1]])
         validated_labels = self.validator.validate_pred_label(labels)
-        assert torch.equal(validated_labels, torch.tensor([[True], [False], [True], [True]]))
+        assert torch.equal(validated_labels, torch.tensor([True, False, True, True]))
 
     def test_validate_pred_label_none(self) -> None:
         """Test validation of None prediction labels."""
diff --git a/tests/unit/engine/test_engine.py b/tests/unit/engine/test_engine.py
index 1c2e157a05..1fdb7532a4 100644
--- a/tests/unit/engine/test_engine.py
+++ b/tests/unit/engine/test_engine.py
@@ -63,11 +63,6 @@ def fxt_full_config_path(tmp_path: Path) -> Path:
             sync_batchnorm: false
             reload_dataloaders_every_n_epochs: 0
         task: SEGMENTATION
-        metrics:
-            image:
-            - F1Score
-            - AUROC
-            pixel: null
         logging:
             log_graph: false
         default_root_dir: results
diff --git a/tests/unit/metrics/aupro/test_aupro.py b/tests/unit/metrics/aupro/test_aupro.py
index d91970c135..a9ba5a6cad 100644
--- a/tests/unit/metrics/aupro/test_aupro.py
+++ b/tests/unit/metrics/aupro/test_aupro.py
@@ -7,7 +7,7 @@
 import pytest
 import torch
 
-from anomalib.metrics import AUPRO
+from anomalib.metrics.aupro import _AUPRO as AUPRO
 
 from .aupro_reference import calculate_au_pro
 
diff --git a/tests/unit/metrics/pimo/test_pimo.py b/tests/unit/metrics/pimo/test_pimo.py
index 81bafe4c8e..8765f55de3 100644
--- a/tests/unit/metrics/pimo/test_pimo.py
+++ b/tests/unit/metrics/pimo/test_pimo.py
@@ -224,7 +224,7 @@ def do_assertions(pimo_result: PIMOResult) -> None:
         )
 
     # metric interface
-    metric = pimo.PIMO(
+    metric = pimo._PIMO(  # noqa: SLF001
         num_thresholds=7,
     )
     metric.update(anomaly_maps, masks)
@@ -306,7 +306,7 @@ def do_assertions(pimo_result: PIMOResult, aupimo_result: AUPIMOResult) -> None:
         assert anomaly_maps.min() <= thresh_lower_bound < thresh_upper_bound <= anomaly_maps.max()
 
     # metric interface
-    metric = pimo.AUPIMO(
+    metric = pimo._AUPIMO(  # noqa: SLF001
         num_thresholds=7,
         fpr_bounds=fpr_bounds,
         return_average=False,
@@ -317,7 +317,7 @@ def do_assertions(pimo_result: PIMOResult, aupimo_result: AUPIMOResult) -> None:
     do_assertions(pimo_result_from_metric, aupimo_result_from_metric)
 
     # metric interface
-    metric = pimo.AUPIMO(
+    metric = pimo._AUPIMO(  # noqa: SLF001
         num_thresholds=7,
         fpr_bounds=fpr_bounds,
         return_average=True,  # only return the average AUPIMO
diff --git a/tests/unit/metrics/test_f1_max.py b/tests/unit/metrics/test_f1_max.py
index 7ce60e9996..c8328638e5 100644
--- a/tests/unit/metrics/test_f1_max.py
+++ b/tests/unit/metrics/test_f1_max.py
@@ -5,7 +5,7 @@
 
 import torch
 
-from anomalib.metrics.f1_max import F1Max
+from anomalib.metrics.f1_score import _F1Max as F1Max
 
 
 def test_f1_max_logits() -> None:
diff --git a/tests/unit/metrics/test_pro.py b/tests/unit/metrics/test_pro.py
index bd02473700..21f26c3349 100644
--- a/tests/unit/metrics/test_pro.py
+++ b/tests/unit/metrics/test_pro.py
@@ -7,7 +7,8 @@
 from torchvision.transforms import RandomAffine
 
 from anomalib.data.utils import random_2d_perlin
-from anomalib.metrics.pro import PRO, connected_components_cpu, connected_components_gpu
+from anomalib.metrics.pro import _PRO as PRO
+from anomalib.metrics.pro import connected_components_cpu, connected_components_gpu
 
 
 def test_pro() -> None:
diff --git a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
index b01c72cc56..33a215f56f 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
@@ -33,9 +33,9 @@ class DummyModule(AnomalyModule):
     TODO(ashwinvaidya17): Remove this when the DummyModels have been refactored.
     """
 
-    def __init__(self, dataset_path: Path) -> None:
+    def __init__(self, dataset_path: Path, **kwargs) -> None:
         """Initializes the dummy model."""
-        super().__init__()
+        super().__init__(**kwargs)
         self.model = _DummyModel()
         self.task = "segmentation"
         self.mode = "full"
diff --git a/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py b/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
index 1cf0f90cba..964e62415b 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
@@ -21,7 +21,7 @@ def test_add_images(task: TaskType, dataset_path: Path) -> None:
     """Tests if tensorboard logs are generated."""
     with tempfile.TemporaryDirectory() as dir_loc:
         logger = AnomalibTensorBoardLogger(name="tensorboard_logs", save_dir=dir_loc)
-        model = DummyModule(dataset_path)
+        model = DummyModule(dataset_path, evaluator=False)
         engine = Engine(
             logger=logger,
             default_root_dir=dir_loc,
diff --git a/tests/unit/utils/test_visualizer.py b/tests/unit/utils/test_visualizer.py
index 977598e0e4..be8993debb 100644
--- a/tests/unit/utils/test_visualizer.py
+++ b/tests/unit/utils/test_visualizer.py
@@ -14,7 +14,7 @@
 from anomalib import TaskType
 from anomalib.data import ImageBatch, MVTec, PredictDataset
 from anomalib.engine import Engine
-from anomalib.models import get_model
+from anomalib.models import Padim
 from anomalib.utils.visualization.image import _ImageGrid
 
 
@@ -48,7 +48,7 @@ def test_model_visualizer_mode(
     ) -> None:
         """Test combination of model/visualizer/mode on only 1 epoch as a sanity check before merge."""
         _ckpt_path: Path = ckpt_path("Padim")
-        model = get_model("padim")
+        model = Padim(evaluator=False)
         engine = Engine(
             default_root_dir=project_path,
             fast_dev_run=True,

From dddf7076443382dda9cc1f673e844400005303a6 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Fri, 8 Nov 2024 07:10:29 +0000
Subject: [PATCH 11/45] =?UTF-8?q?=F0=9F=9A=80=20Add=20`PreProcessor`=20to?=
 =?UTF-8?q?=20`AnomalyModule`=20(#2358)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Created pre-processor

Signed-off-by: Samet Akcay 

* Rename transforms to transform in pre-processor

Signed-off-by: Samet Akcay 

* Remove transforms from datamodules

Signed-off-by: Samet Akcay 

* Remove transforms from datasets

Signed-off-by: Samet Akcay 

* Remove setup_transforms from Engine

Signed-off-by: Samet Akcay 

* Add preprocessor to AnomalyModule and models

Signed-off-by: Samet Akcay 

* Fix tests

Signed-off-by: Samet Akcay 

* Remove self._transform from AnomalyModule

Signed-off-by: Samet Akcay 

* revert transforms in datasets

Signed-off-by: Samet Akcay 

* fix efficient_ad and engine.config tests

Signed-off-by: Samet Akcay 

* Update the upgrade tests

Signed-off-by: Samet Akcay 

* Revert on_load_checkpoint hook to AnomalyModule

Signed-off-by: Samet Akcay 

* Remove exportable transform from anomaly module and move to pre-processor

Signed-off-by: Samet Akcay 

* Add pre-processor to the model graph

Signed-off-by: Samet Akcay 

* Add docstring to pre-processor class

Signed-off-by: Samet Akcay 

* Fix win-clip tests

Signed-off-by: Samet Akcay 

* Update notebooks

Signed-off-by: Samet Akcay 

* Split the forward logic and move the training to model hooks

Signed-off-by: Samet Akcay 

* Set data transforms from preprocessor

Signed-off-by: Samet Akcay 

* Update the docstrings

Signed-off-by: Samet Akcay 

* Get stage transforms in setup of pre-processor

Signed-off-by: Samet Akcay 

* Revert data config yaml files

Signed-off-by: Samet Akcay 

* Revert datamodules

Signed-off-by: Samet Akcay 

* Revert datasets

Signed-off-by: Samet Akcay 

* Revert notebooks

Signed-off-by: Samet Akcay 

* remove padim preprocessor

Signed-off-by: Samet Akcay 

* Update the setup logic in pre-processor

Signed-off-by: Samet Akcay 

* Revert datamodules

Signed-off-by: Samet Akcay 

* Set datamodule transforms property from preprocessor

Signed-off-by: Samet Akcay 

* Revert v1 upgrade tool

Signed-off-by: Samet Akcay 

* Fix aupimo notebooks

Signed-off-by: Samet Akcay 

* Add pre-processor unit tests

Signed-off-by: Samet Akcay 

* Increase the test coverage for PreProcessor

Signed-off-by: Samet Akcay 

* Add option to disable pre-processor

Signed-off-by: Samet Akcay 

* Split setup_transforms to setup_datamodule_transforms and setup_dataloader_transforms

Signed-off-by: Samet Akcay 

* Replace batch.update with in-place batch transforms

Signed-off-by: Samet Akcay 

* Remove logger.warning when the default pre-processor is used

Signed-off-by: Samet Akcay 

* Use predict-transforms explicitly

Signed-off-by: Samet Akcay 

* remove pre-processor and configure_transforms from export mixin

Signed-off-by: Samet Akcay 

* Rename set_datamodule_transform to set_datamodule_stage_transform

Signed-off-by: Samet Akcay 

* Remove transforms from datamodules

Signed-off-by: Samet Akcay 

* Remove transforms from datamodules

Signed-off-by: Samet Akcay 

* Remove transforms from datamodules

Signed-off-by: Samet Akcay 

* Remove transforms from datamodules

Signed-off-by: Samet Akcay 

* Remove transforms from datamodules

Signed-off-by: Samet Akcay 

* Remove transform related keys from data configs

Signed-off-by: Samet Akcay 

* update preprocessor tests

Signed-off-by: Samet Akcay 

* Remove setup method from the model implementations

Signed-off-by: Samet Akcay 

* Remove image size from datamodules in jupyter notebooks

Signed-off-by: Samet Akcay 

* Modify folder notebook to acccess the batch from dataset not dataloader

Signed-off-by: Samet Akcay 

* Create resolve preprocessor method

Signed-off-by: Samet Akcay 

* Return  if  is

Signed-off-by: Samet Akcay 

* Rename self.exportable_transform to self.export_transform

Signed-off-by: Samet Akcay 

* Remove set_datamodule_transforms

Signed-off-by: Samet Akcay 

* remove hooks as they are not needed anymore

Signed-off-by: Samet Akcay 

* Fix pre-processor tests

Signed-off-by: Samet Akcay 

* remove transform getter util function

Signed-off-by: Samet Akcay 

* Fix transform dict to setup datamodule transforms

Signed-off-by: Samet Akcay 

* Fix Fastflow notebook

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 
---
 configs/data/avenue.yaml                      |   3 -
 configs/data/btech.yaml                       |   3 -
 configs/data/folder.yaml                      |   3 -
 configs/data/kolektor.yaml                    |   3 -
 configs/data/mvtec.yaml                       |   3 -
 configs/data/mvtec_3d.yaml                    |   3 -
 configs/data/shanghaitech.yaml                |   3 -
 configs/data/ucsd_ped.yaml                    |   3 -
 configs/data/visa.yaml                        |   3 -
 notebooks/100_datamodules/101_btech.ipynb     |   5 +-
 notebooks/100_datamodules/102_mvtec.ipynb     |   5 +-
 notebooks/100_datamodules/103_folder.ipynb    |  21 +-
 notebooks/100_datamodules/104_tiling.ipynb    |   2 +-
 notebooks/200_models/201_fastflow.ipynb       |   9 +-
 .../600_loggers/601_mlflow_logging.ipynb      |   5 +-
 notebooks/700_metrics/701a_aupimo.ipynb       |   3 +-
 .../700_metrics/701b_aupimo_advanced_i.ipynb  |   1 -
 .../700_metrics/701c_aupimo_advanced_ii.ipynb |   1 -
 src/anomalib/data/datamodules/base/image.py   |  63 -----
 .../data/datamodules/depth/folder_3d.py       |  20 --
 .../data/datamodules/depth/mvtec_3d.py        |  28 +-
 src/anomalib/data/datamodules/image/btech.py  |  30 +-
 src/anomalib/data/datamodules/image/folder.py |  22 --
 .../data/datamodules/image/kolektor.py        |  28 +-
 src/anomalib/data/datamodules/image/mvtec.py  |  32 +--
 src/anomalib/data/datamodules/image/visa.py   |  27 +-
 src/anomalib/data/datamodules/video/avenue.py |  26 +-
 .../data/datamodules/video/shanghaitech.py    |  27 +-
 .../data/datamodules/video/ucsd_ped.py        |  20 --
 src/anomalib/deploy/utils.py                  |  44 ---
 src/anomalib/engine/engine.py                 |  63 +----
 .../models/components/base/anomaly_module.py  | 119 ++++----
 .../models/components/base/export_mixin.py    |  13 +-
 .../models/image/cfa/lightning_model.py       |   7 +-
 .../models/image/cflow/lightning_model.py     |   4 +-
 .../models/image/csflow/lightning_model.py    |  17 +-
 .../models/image/dfkde/lightning_model.py     |   4 +-
 .../models/image/dfm/lightning_model.py       |   7 +-
 .../models/image/draem/lightning_model.py     |   7 +-
 .../models/image/dsr/lightning_model.py       |   7 +-
 .../image/efficient_ad/lightning_model.py     |  35 ++-
 .../models/image/fastflow/lightning_model.py  |  21 +-
 .../models/image/fre/lightning_model.py       |   7 +-
 .../models/image/ganomaly/lightning_model.py  |  33 ++-
 .../models/image/padim/lightning_model.py     |  22 +-
 .../models/image/patchcore/lightning_model.py |  47 ++--
 .../reverse_distillation/lightning_model.py   |  19 +-
 .../models/image/rkde/lightning_model.py      |   7 +-
 .../models/image/stfpm/lightning_model.py     |  12 +-
 .../models/image/uflow/lightning_model.py     |  82 +++---
 .../models/image/winclip/lightning_model.py   |  33 ++-
 .../models/video/ai_vad/lightning_model.py    |  21 +-
 src/anomalib/pre_processing/__init__.py       |   8 +
 src/anomalib/pre_processing/pre_processing.py | 177 ++++++++++++
 src/anomalib/pre_processing/utils/__init__.py |   4 +
 .../pre_processing/utils/transform.py         | 150 ++++++++++
 tests/integration/model/test_models.py        |   5 +-
 .../tools/upgrade/expected_draem_v1.yaml      |   7 +-
 .../data/datamodule/depth/test_folder_3d.py   |   1 -
 .../data/datamodule/depth/test_mvtec_3d.py    |   1 -
 .../unit/data/datamodule/image/test_btech.py  |   1 -
 .../data/datamodule/image/test_kolektor.py    |   1 -
 tests/unit/data/datamodule/image/test_visa.py |   1 -
 .../unit/data/datamodule/video/test_avenue.py |   1 -
 .../datamodule/video/test_shanghaitech.py     |   1 -
 .../data/datamodule/video/test_ucsdped.py     |   1 -
 tests/unit/engine/test_engine.py              |   4 -
 tests/unit/engine/test_setup_transform.py     | 260 ------------------
 .../pre_processing/test_pre_processing.py     | 127 +++++++++
 .../pre_processing/utils/test_transform.py    | 103 +++++++
 tools/upgrade/config.py                       |   4 -
 71 files changed, 903 insertions(+), 987 deletions(-)
 delete mode 100644 src/anomalib/deploy/utils.py
 create mode 100644 src/anomalib/pre_processing/__init__.py
 create mode 100644 src/anomalib/pre_processing/pre_processing.py
 create mode 100644 src/anomalib/pre_processing/utils/__init__.py
 create mode 100644 src/anomalib/pre_processing/utils/transform.py
 delete mode 100644 tests/unit/engine/test_setup_transform.py
 create mode 100644 tests/unit/pre_processing/test_pre_processing.py
 create mode 100644 tests/unit/pre_processing/utils/test_transform.py

diff --git a/configs/data/avenue.yaml b/configs/data/avenue.yaml
index 396a9ba6b5..8fb07660ce 100644
--- a/configs/data/avenue.yaml
+++ b/configs/data/avenue.yaml
@@ -8,9 +8,6 @@ init_args:
   train_batch_size: 32
   eval_batch_size: 32
   num_workers: 8
-  transform: null
-  train_transform: null
-  eval_transform: null
   val_split_mode: from_test
   val_split_ratio: 0.5
   seed: null
diff --git a/configs/data/btech.yaml b/configs/data/btech.yaml
index 22bfd0d8fe..9aa030540c 100644
--- a/configs/data/btech.yaml
+++ b/configs/data/btech.yaml
@@ -5,9 +5,6 @@ init_args:
   train_batch_size: 32
   eval_batch_size: 32
   num_workers: 8
-  transform: null
-  train_transform: null
-  eval_transform: null
   test_split_mode: from_dir
   test_split_ratio: 0.2
   val_split_mode: same_as_test
diff --git a/configs/data/folder.yaml b/configs/data/folder.yaml
index 329fba6520..76be1382a7 100644
--- a/configs/data/folder.yaml
+++ b/configs/data/folder.yaml
@@ -12,9 +12,6 @@ init_args:
   eval_batch_size: 32
   num_workers: 8
   task: segmentation
-  transform: null
-  train_transform: null
-  eval_transform: null
   test_split_mode: from_dir
   test_split_ratio: 0.2
   val_split_mode: same_as_test
diff --git a/configs/data/kolektor.yaml b/configs/data/kolektor.yaml
index 1b2e6fe6b4..5daec435e4 100644
--- a/configs/data/kolektor.yaml
+++ b/configs/data/kolektor.yaml
@@ -4,9 +4,6 @@ init_args:
   train_batch_size: 32
   eval_batch_size: 32
   num_workers: 8
-  transform: null
-  train_transform: null
-  eval_transform: null
   test_split_mode: from_dir
   test_split_ratio: 0.2
   val_split_mode: same_as_test
diff --git a/configs/data/mvtec.yaml b/configs/data/mvtec.yaml
index 7728808ece..5fb206e144 100644
--- a/configs/data/mvtec.yaml
+++ b/configs/data/mvtec.yaml
@@ -6,9 +6,6 @@ init_args:
   eval_batch_size: 32
   num_workers: 8
   task: segmentation
-  transform: null
-  train_transform: null
-  eval_transform: null
   test_split_mode: from_dir
   test_split_ratio: 0.2
   val_split_mode: same_as_test
diff --git a/configs/data/mvtec_3d.yaml b/configs/data/mvtec_3d.yaml
index d880f92f8f..f567f80899 100644
--- a/configs/data/mvtec_3d.yaml
+++ b/configs/data/mvtec_3d.yaml
@@ -5,9 +5,6 @@ init_args:
   train_batch_size: 32
   eval_batch_size: 32
   num_workers: 8
-  transform: null
-  train_transform: null
-  eval_transform: null
   test_split_mode: from_dir
   test_split_ratio: 0.2
   val_split_mode: same_as_test
diff --git a/configs/data/shanghaitech.yaml b/configs/data/shanghaitech.yaml
index be4da54311..d18e7671dc 100644
--- a/configs/data/shanghaitech.yaml
+++ b/configs/data/shanghaitech.yaml
@@ -8,9 +8,6 @@ init_args:
   train_batch_size: 32
   eval_batch_size: 32
   num_workers: 8
-  transform: null
-  train_transform: null
-  eval_transform: null
   val_split_mode: FROM_TEST
   val_split_ratio: 0.5
   seed: null
diff --git a/configs/data/ucsd_ped.yaml b/configs/data/ucsd_ped.yaml
index 009a5ef224..1226e4f149 100644
--- a/configs/data/ucsd_ped.yaml
+++ b/configs/data/ucsd_ped.yaml
@@ -8,9 +8,6 @@ init_args:
   train_batch_size: 8
   eval_batch_size: 1
   num_workers: 8
-  transform: null
-  train_transform: null
-  eval_transform: null
   val_split_mode: FROM_TEST
   val_split_ratio: 0.5
   seed: null
diff --git a/configs/data/visa.yaml b/configs/data/visa.yaml
index c5656a2158..0d94e82fa4 100644
--- a/configs/data/visa.yaml
+++ b/configs/data/visa.yaml
@@ -5,9 +5,6 @@ init_args:
   train_batch_size: 32
   eval_batch_size: 32
   num_workers: 8
-  transform: null
-  train_transform: null
-  eval_transform: null
   test_split_mode: from_dir
   test_split_ratio: 0.2
   val_split_mode: same_as_test
diff --git a/notebooks/100_datamodules/101_btech.ipynb b/notebooks/100_datamodules/101_btech.ipynb
index ef188665e6..2b87763ff0 100644
--- a/notebooks/100_datamodules/101_btech.ipynb
+++ b/notebooks/100_datamodules/101_btech.ipynb
@@ -48,7 +48,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent / \"datasets\" / \"BTech\""
+    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"BTech\""
    ]
   },
   {
@@ -106,7 +106,6 @@
     "btech_datamodule = BTech(\n",
     "    root=dataset_root,\n",
     "    category=\"01\",\n",
-    "    image_size=256,\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=0,\n",
@@ -378,7 +377,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.14"
+   "version": "3.11.8"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/100_datamodules/102_mvtec.ipynb b/notebooks/100_datamodules/102_mvtec.ipynb
index 4c274939d6..9081f256ae 100644
--- a/notebooks/100_datamodules/102_mvtec.ipynb
+++ b/notebooks/100_datamodules/102_mvtec.ipynb
@@ -58,7 +58,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent / \"datasets\" / \"MVTec\""
+    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
    ]
   },
   {
@@ -84,7 +84,6 @@
     "mvtec_datamodule = MVTec(\n",
     "    root=dataset_root,\n",
     "    category=\"bottle\",\n",
-    "    image_size=256,\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=0,\n",
@@ -345,7 +344,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.14"
+   "version": "3.11.8"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/100_datamodules/103_folder.ipynb b/notebooks/100_datamodules/103_folder.ipynb
index 2f642e145a..328a069652 100644
--- a/notebooks/100_datamodules/103_folder.ipynb
+++ b/notebooks/100_datamodules/103_folder.ipynb
@@ -33,7 +33,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -42,7 +42,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent / \"datasets\" / \"hazelnut_toy\""
+    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"hazelnut_toy\""
    ]
   },
   {
@@ -63,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -91,7 +91,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -102,7 +102,6 @@
     "    abnormal_dir=\"crack\",\n",
     "    task=TaskType.SEGMENTATION,\n",
     "    mask_dir=dataset_root / \"mask\" / \"crack\",\n",
-    "    image_size=(256, 256),\n",
     ")\n",
     "folder_datamodule.setup()"
    ]
@@ -114,7 +113,7 @@
    "outputs": [],
    "source": [
     "# Train images\n",
-    "i, data = next(enumerate(folder_datamodule.train_dataloader()))\n",
+    "data = next(iter(folder_datamodule.train_data))\n",
     "print(data.image.shape)"
    ]
   },
@@ -125,7 +124,7 @@
    "outputs": [],
    "source": [
     "# Test images\n",
-    "i, data = next(enumerate(folder_datamodule.test_dataloader()))\n",
+    "data = next(iter(folder_datamodule.test_data))\n",
     "print(data.image.shape, data.gt_mask.shape)"
    ]
   },
@@ -143,8 +142,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "img = to_pil_image(data.image[0].clone())\n",
-    "msk = to_pil_image(data.gt_mask[0].int() * 255).convert(\"RGB\")\n",
+    "img = to_pil_image(data.image.clone())\n",
+    "msk = to_pil_image(data.gt_mask.int() * 255).convert(\"RGB\")\n",
     "\n",
     "Image.fromarray(np.hstack((np.array(img), np.array(msk))))"
    ]
@@ -187,7 +186,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -369,7 +368,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.14"
+   "version": "3.11.8"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/100_datamodules/104_tiling.ipynb b/notebooks/100_datamodules/104_tiling.ipynb
index 949d6f1cf1..dd901c37e7 100644
--- a/notebooks/100_datamodules/104_tiling.ipynb
+++ b/notebooks/100_datamodules/104_tiling.ipynb
@@ -44,7 +44,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent / \"datasets\" / \"MVTec\" / \"transistor\""
+    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\" / \"transistor\""
    ]
   },
   {
diff --git a/notebooks/200_models/201_fastflow.ipynb b/notebooks/200_models/201_fastflow.ipynb
index ad93049ac0..492655f010 100644
--- a/notebooks/200_models/201_fastflow.ipynb
+++ b/notebooks/200_models/201_fastflow.ipynb
@@ -44,7 +44,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent / \"datasets\" / \"MVTec\""
+    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
    ]
   },
   {
@@ -120,7 +120,6 @@
     "datamodule = MVTec(\n",
     "    root=dataset_root,\n",
     "    category=\"bottle\",\n",
-    "    image_size=256,\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=0,\n",
@@ -319,7 +318,9 @@
    },
    "outputs": [],
    "source": [
-    "inference_dataset = PredictDataset(path=dataset_root / \"bottle/test/broken_large/000.png\")\n",
+    "pre_processor = Fastflow.configure_pre_processor()\n",
+    "transform = pre_processor.predict_transform\n",
+    "inference_dataset = PredictDataset(path=dataset_root / \"bottle/test/broken_large/000.png\", transform=transform)\n",
     "inference_dataloader = DataLoader(dataset=inference_dataset, collate_fn=inference_dataset.collate_fn)"
    ]
   },
@@ -554,7 +555,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.14"
+   "version": "3.11.8"
   },
   "orig_nbformat": 4,
   "vscode": {
diff --git a/notebooks/600_loggers/601_mlflow_logging.ipynb b/notebooks/600_loggers/601_mlflow_logging.ipynb
index b6b3c424cc..c3f37de763 100644
--- a/notebooks/600_loggers/601_mlflow_logging.ipynb
+++ b/notebooks/600_loggers/601_mlflow_logging.ipynb
@@ -135,7 +135,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent / \"datasets\" / \"MVTec\""
+    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
    ]
   },
   {
@@ -197,7 +197,6 @@
     "datamodule = MVTec(\n",
     "    root=dataset_root,\n",
     "    category=\"bottle\",\n",
-    "    image_size=256,\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=24,\n",
@@ -420,7 +419,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.14"
+   "version": "3.11.8"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/700_metrics/701a_aupimo.ipynb b/notebooks/700_metrics/701a_aupimo.ipynb
index ecafbbb7ba..c3be846a77 100644
--- a/notebooks/700_metrics/701a_aupimo.ipynb
+++ b/notebooks/700_metrics/701a_aupimo.ipynb
@@ -140,7 +140,6 @@
     "datamodule = MVTec(\n",
     "    root=dataset_root,\n",
     "    category=\"leather\",\n",
-    "    image_size=256,\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=8,\n",
@@ -405,7 +404,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.14"
+   "version": "3.11.8"
   },
   "orig_nbformat": 4
  },
diff --git a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
index 42c45e60aa..70f0968520 100644
--- a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
+++ b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
@@ -164,7 +164,6 @@
     "datamodule = MVTec(\n",
     "    root=dataset_root,\n",
     "    category=\"leather\",\n",
-    "    image_size=256,\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=8,\n",
diff --git a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
index a83abd5ee2..1d64e9ec44 100644
--- a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
+++ b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
@@ -158,7 +158,6 @@
     "datamodule = MVTec(\n",
     "    root=dataset_root,\n",
     "    category=\"leather\",\n",
-    "    image_size=256,\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=8,\n",
diff --git a/src/anomalib/data/datamodules/base/image.py b/src/anomalib/data/datamodules/base/image.py
index 28fd9499eb..8476bf5eeb 100644
--- a/src/anomalib/data/datamodules/base/image.py
+++ b/src/anomalib/data/datamodules/base/image.py
@@ -12,7 +12,6 @@
 from lightning.pytorch.trainer.states import TrainerFn
 from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
 from torch.utils.data.dataloader import DataLoader
-from torchvision.transforms.v2 import Resize, Transform
 
 from anomalib.data.utils import TestSplitMode, ValSplitMode, random_split, split_by_label
 from anomalib.data.utils.synthetic import SyntheticAnomalyDataset
@@ -40,14 +39,6 @@ class AnomalibDataModule(LightningDataModule, ABC):
             Defaults to ``None``.
         test_split_ratio (float): Fraction of the train images held out for testing.
             Defaults to ``None``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         seed (int | None, optional): Seed used during random subset splitting.
             Defaults to ``None``.
     """
@@ -61,10 +52,6 @@ def __init__(
         val_split_ratio: float,
         test_split_mode: TestSplitMode | str | None = None,
         test_split_ratio: float | None = None,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         seed: int | None = None,
     ) -> None:
         super().__init__()
@@ -75,18 +62,8 @@ def __init__(
         self.test_split_ratio = test_split_ratio
         self.val_split_mode = ValSplitMode(val_split_mode)
         self.val_split_ratio = val_split_ratio
-        self.image_size = image_size
         self.seed = seed
 
-        # set transforms
-        if bool(train_transform) != bool(eval_transform):
-            msg = "Only one of train_transform and eval_transform was specified. This is not recommended because \
-                    it could lead to unexpected behaviour. Please ensure training and eval transforms have the same \
-                    reshape and normalization characteristics."
-            logger.warning(msg)
-        self._train_transform = train_transform or transform
-        self._eval_transform = eval_transform or transform
-
         self.train_data: AnomalibDataset
         self.val_data: AnomalibDataset
         self.test_data: AnomalibDataset
@@ -228,46 +205,6 @@ def predict_dataloader(self) -> EVAL_DATALOADERS:
         """Use the test dataloader for inference unless overridden."""
         return self.test_dataloader()
 
-    @property
-    def transform(self) -> Transform:
-        """Property that returns the user-specified transform for the datamodule, if any.
-
-        This property is accessed by the engine to set the transform for the model. The eval_transform takes precedence
-        over the train_transform, because the transform that we store in the model is the one that should be used during
-        inference.
-        """
-        if self._eval_transform:
-            return self._eval_transform
-        return None
-
-    @property
-    def train_transform(self) -> Transform:
-        """Get the transforms that will be passed to the train dataset.
-
-        If the train_transform is not set, the engine will request the transform from the model.
-        """
-        if self._train_transform:
-            return self._train_transform
-        if getattr(self, "trainer", None) and self.trainer.lightning_module and self.trainer.lightning_module.transform:
-            return self.trainer.lightning_module.transform
-        if self.image_size:
-            return Resize(self.image_size, antialias=True)
-        return None
-
-    @property
-    def eval_transform(self) -> Transform:
-        """Get the transform that will be passed to the val/test/predict datasets.
-
-        If the eval_transform is not set, the engine will request the transform from the model.
-        """
-        if self._eval_transform:
-            return self._eval_transform
-        if getattr(self, "trainer", None) and self.trainer.lightning_module and self.trainer.lightning_module.transform:
-            return self.trainer.lightning_module.transform
-        if self.image_size:
-            return Resize(self.image_size, antialias=True)
-        return None
-
     @classmethod
     def from_config(
         cls: type["AnomalibDataModule"],
diff --git a/src/anomalib/data/datamodules/depth/folder_3d.py b/src/anomalib/data/datamodules/depth/folder_3d.py
index cebea42d02..2e2930be26 100644
--- a/src/anomalib/data/datamodules/depth/folder_3d.py
+++ b/src/anomalib/data/datamodules/depth/folder_3d.py
@@ -8,8 +8,6 @@
 
 from pathlib import Path
 
-from torchvision.transforms.v2 import Transform
-
 from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.depth.folder_3d import Folder3DDataset
@@ -51,14 +49,6 @@ class Folder3D(AnomalibDataModule):
             Defaults to ``8``.
         task (TaskType, optional): Task type. Could be ``classification``, ``detection`` or ``segmentation``.
             Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -87,10 +77,6 @@ def __init__(
         eval_batch_size: int = 32,
         num_workers: int = 8,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
@@ -101,10 +87,6 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
@@ -127,7 +109,6 @@ def _setup(self, _stage: str | None = None) -> None:
         self.train_data = Folder3DDataset(
             name=self.name,
             task=self.task,
-            transform=self.train_transform,
             split=Split.TRAIN,
             root=self.root,
             normal_dir=self.normal_dir,
@@ -143,7 +124,6 @@ def _setup(self, _stage: str | None = None) -> None:
         self.test_data = Folder3DDataset(
             name=self.name,
             task=self.task,
-            transform=self.eval_transform,
             split=Split.TEST,
             root=self.root,
             normal_dir=self.normal_dir,
diff --git a/src/anomalib/data/datamodules/depth/mvtec_3d.py b/src/anomalib/data/datamodules/depth/mvtec_3d.py
index 1e5b90e917..6a497ec952 100644
--- a/src/anomalib/data/datamodules/depth/mvtec_3d.py
+++ b/src/anomalib/data/datamodules/depth/mvtec_3d.py
@@ -22,18 +22,10 @@
 import logging
 from pathlib import Path
 
-from torchvision.transforms.v2 import Transform
-
 from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.depth.mvtec_3d import MVTec3DDataset
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    TestSplitMode,
-    ValSplitMode,
-    download_and_extract,
-)
+from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
 
 logger = logging.getLogger(__name__)
 
@@ -62,14 +54,6 @@ class MVTec3D(AnomalibDataModule):
             Defaults to ``8``.
         task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
             Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -90,10 +74,6 @@ def __init__(
         eval_batch_size: int = 32,
         num_workers: int = 8,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -104,10 +84,6 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
@@ -122,14 +98,12 @@ def __init__(
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = MVTec3DDataset(
             task=self.task,
-            transform=self.train_transform,
             split=Split.TRAIN,
             root=self.root,
             category=self.category,
         )
         self.test_data = MVTec3DDataset(
             task=self.task,
-            transform=self.eval_transform,
             split=Split.TEST,
             root=self.root,
             category=self.category,
diff --git a/src/anomalib/data/datamodules/image/btech.py b/src/anomalib/data/datamodules/image/btech.py
index 5abda6156e..818c9d71b5 100644
--- a/src/anomalib/data/datamodules/image/btech.py
+++ b/src/anomalib/data/datamodules/image/btech.py
@@ -14,19 +14,12 @@
 from pathlib import Path
 
 import cv2
-from torchvision.transforms.v2 import Transform
 from tqdm import tqdm
 
 from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.btech import BTechDataset
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    TestSplitMode,
-    ValSplitMode,
-    download_and_extract,
-)
+from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
 
 logger = logging.getLogger(__name__)
 
@@ -53,14 +46,6 @@ class BTech(AnomalibDataModule):
             Defaults to ``8``.
         task (TaskType, optional): Task type.
             Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         test_split_mode (TestSplitMode, optional): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float, optional): Fraction of images from the train set that will be reserved for testing.
@@ -79,12 +64,9 @@ class BTech(AnomalibDataModule):
         >>> datamodule = BTech(
         ...     root="./datasets/BTech",
         ...     category="01",
-        ...     image_size=256,
         ...     train_batch_size=32,
         ...     eval_batch_size=32,
         ...     num_workers=8,
-        ...     transform_config_train=None,
-        ...     transform_config_eval=None,
         ... )
         >>> datamodule.setup()
 
@@ -121,10 +103,6 @@ def __init__(
         eval_batch_size: int = 32,
         num_workers: int = 8,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -135,10 +113,6 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
@@ -153,14 +127,12 @@ def __init__(
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = BTechDataset(
             task=self.task,
-            transform=self.train_transform,
             split=Split.TRAIN,
             root=self.root,
             category=self.category,
         )
         self.test_data = BTechDataset(
             task=self.task,
-            transform=self.eval_transform,
             split=Split.TEST,
             root=self.root,
             category=self.category,
diff --git a/src/anomalib/data/datamodules/image/folder.py b/src/anomalib/data/datamodules/image/folder.py
index 7941ba2f7b..7fe51c32a0 100644
--- a/src/anomalib/data/datamodules/image/folder.py
+++ b/src/anomalib/data/datamodules/image/folder.py
@@ -9,8 +9,6 @@
 from collections.abc import Sequence
 from pathlib import Path
 
-from torchvision.transforms.v2 import Transform
-
 from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.folder import FolderDataset
@@ -47,14 +45,6 @@ class Folder(AnomalibDataModule):
             Defaults to ``8``.
         task (TaskType, optional): Task type. Could be ``classification``, ``detection`` or ``segmentation``.
             Defaults to ``segmentation``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -102,8 +92,6 @@ class Folder(AnomalibDataModule):
                 abnormal_dir="crack",
                 task=TaskType.SEGMENTATION,
                 mask_dir=dataset_root / "mask" / "crack",
-                image_size=256,
-                normalization=InputNormalizationMethod.NONE,
             )
             folder_datamodule.setup()
 
@@ -136,10 +124,6 @@ def __init__(
         eval_batch_size: int = 32,
         num_workers: int = 8,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
@@ -164,10 +148,6 @@ def __init__(
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
             val_split_ratio=val_split_ratio,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             seed=seed,
         )
 
@@ -186,7 +166,6 @@ def _setup(self, _stage: str | None = None) -> None:
         self.train_data = FolderDataset(
             name=self.name,
             task=self.task,
-            transform=self.train_transform,
             split=Split.TRAIN,
             root=self.root,
             normal_dir=self.normal_dir,
@@ -199,7 +178,6 @@ def _setup(self, _stage: str | None = None) -> None:
         self.test_data = FolderDataset(
             name=self.name,
             task=self.task,
-            transform=self.eval_transform,
             split=Split.TEST,
             root=self.root,
             normal_dir=self.normal_dir,
diff --git a/src/anomalib/data/datamodules/image/kolektor.py b/src/anomalib/data/datamodules/image/kolektor.py
index 2f8dc3b92b..c962e4fba7 100644
--- a/src/anomalib/data/datamodules/image/kolektor.py
+++ b/src/anomalib/data/datamodules/image/kolektor.py
@@ -20,18 +20,10 @@
 import logging
 from pathlib import Path
 
-from torchvision.transforms.v2 import Transform
-
 from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.kolektor import KolektorDataset
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    TestSplitMode,
-    ValSplitMode,
-    download_and_extract,
-)
+from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
 
 logger = logging.getLogger(__name__)
 
@@ -56,14 +48,6 @@ class Kolektor(AnomalibDataModule):
             Defaults to ``8``.
         task TaskType): Task type, 'classification', 'detection' or 'segmentation'
             Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -83,10 +67,6 @@ def __init__(
         eval_batch_size: int = 32,
         num_workers: int = 8,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -97,10 +77,6 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
@@ -114,13 +90,11 @@ def __init__(
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = KolektorDataset(
             task=self.task,
-            transform=self.train_transform,
             split=Split.TRAIN,
             root=self.root,
         )
         self.test_data = KolektorDataset(
             task=self.task,
-            transform=self.eval_transform,
             split=Split.TEST,
             root=self.root,
         )
diff --git a/src/anomalib/data/datamodules/image/mvtec.py b/src/anomalib/data/datamodules/image/mvtec.py
index 508a582380..a465ef52c1 100644
--- a/src/anomalib/data/datamodules/image/mvtec.py
+++ b/src/anomalib/data/datamodules/image/mvtec.py
@@ -28,18 +28,10 @@
 import logging
 from pathlib import Path
 
-from torchvision.transforms.v2 import Transform
-
 from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.mvtec import MVTecDataset
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    TestSplitMode,
-    ValSplitMode,
-    download_and_extract,
-)
+from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
 
 logger = logging.getLogger(__name__)
 
@@ -68,14 +60,6 @@ class MVTec(AnomalibDataModule):
             Defaults to ``8``.
         task TaskType): Task type, 'classification', 'detection' or 'segmentation'
             Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -103,10 +87,6 @@ class MVTec(AnomalibDataModule):
 
         >>> datamodule = MVTec(category="cable")
 
-        To change the image and batch size:
-
-        >>> datamodule = MVTec(image_size=(512, 512), train_batch_size=16, eval_batch_size=8)
-
         MVTec AD dataset does not provide a validation set. If you would like
         to use a separate validation set, you can use the ``val_split_mode`` and
         ``val_split_ratio`` arguments to create a validation set.
@@ -129,10 +109,6 @@ def __init__(
         eval_batch_size: int = 32,
         num_workers: int = 8,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -142,10 +118,6 @@ def __init__(
         super().__init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             num_workers=num_workers,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
@@ -172,14 +144,12 @@ def _setup(self, _stage: str | None = None) -> None:
         """
         self.train_data = MVTecDataset(
             task=self.task,
-            transform=self.train_transform,
             split=Split.TRAIN,
             root=self.root,
             category=self.category,
         )
         self.test_data = MVTecDataset(
             task=self.task,
-            transform=self.eval_transform,
             split=Split.TEST,
             root=self.root,
             category=self.category,
diff --git a/src/anomalib/data/datamodules/image/visa.py b/src/anomalib/data/datamodules/image/visa.py
index 30bf945c73..a445349702 100644
--- a/src/anomalib/data/datamodules/image/visa.py
+++ b/src/anomalib/data/datamodules/image/visa.py
@@ -28,18 +28,11 @@
 from pathlib import Path
 
 import cv2
-from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.visa import VisaDataset
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    TestSplitMode,
-    ValSplitMode,
-    download_and_extract,
-)
+from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
 
 logger = logging.getLogger(__name__)
 
@@ -66,14 +59,6 @@ class Visa(AnomalibDataModule):
             Defaults to ``8``.
         task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
             Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -94,10 +79,6 @@ def __init__(
         eval_batch_size: int = 32,
         num_workers: int = 8,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -108,10 +89,6 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
@@ -127,14 +104,12 @@ def __init__(
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = VisaDataset(
             task=self.task,
-            transform=self.train_transform,
             split=Split.TRAIN,
             root=self.split_root,
             category=self.category,
         )
         self.test_data = VisaDataset(
             task=self.task,
-            transform=self.eval_transform,
             split=Split.TEST,
             root=self.split_root,
             category=self.category,
diff --git a/src/anomalib/data/datamodules/video/avenue.py b/src/anomalib/data/datamodules/video/avenue.py
index 8914475081..86d068e761 100644
--- a/src/anomalib/data/datamodules/video/avenue.py
+++ b/src/anomalib/data/datamodules/video/avenue.py
@@ -21,18 +21,12 @@
 
 import cv2
 import scipy.io
-from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
 from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
 from anomalib.data.datasets.base.video import VideoTargetFrame
 from anomalib.data.datasets.video.avenue import AvenueDataset
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    ValSplitMode,
-    download_and_extract,
-)
+from anomalib.data.utils import DownloadInfo, Split, ValSplitMode, download_and_extract
 
 logger = logging.getLogger(__name__)
 
@@ -64,14 +58,6 @@ class Avenue(AnomalibVideoDataModule):
             Defaults to ``VideoTargetFrame.LAST``.
         task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
             Defaults to ``TaskType.SEGMENTATION``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         train_batch_size (int, optional): Training batch size.
             Defaults to ``32``.
         eval_batch_size (int, optional): Test batch size.
@@ -141,10 +127,6 @@ def __init__(
         frames_between_clips: int = 1,
         target_frame: VideoTargetFrame | str = VideoTargetFrame.LAST,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
@@ -156,10 +138,6 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             val_split_mode=val_split_mode,
             val_split_ratio=val_split_ratio,
             seed=seed,
@@ -175,7 +153,6 @@ def __init__(
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = AvenueDataset(
             task=self.task,
-            transform=self.train_transform,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
@@ -186,7 +163,6 @@ def _setup(self, _stage: str | None = None) -> None:
 
         self.test_data = AvenueDataset(
             task=self.task,
-            transform=self.eval_transform,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
diff --git a/src/anomalib/data/datamodules/video/shanghaitech.py b/src/anomalib/data/datamodules/video/shanghaitech.py
index b474f09547..2b5c6f428c 100644
--- a/src/anomalib/data/datamodules/video/shanghaitech.py
+++ b/src/anomalib/data/datamodules/video/shanghaitech.py
@@ -20,18 +20,11 @@
 from pathlib import Path
 from shutil import move
 
-from torchvision.transforms.v2 import Transform
-
 from anomalib import TaskType
 from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
 from anomalib.data.datasets.base.video import VideoTargetFrame
 from anomalib.data.datasets.video.shanghaitech import ShanghaiTechDataset
-from anomalib.data.utils import (
-    DownloadInfo,
-    Split,
-    ValSplitMode,
-    download_and_extract,
-)
+from anomalib.data.utils import DownloadInfo, Split, ValSplitMode, download_and_extract
 from anomalib.data.utils.video import convert_video
 
 logger = logging.getLogger(__name__)
@@ -53,14 +46,6 @@ class ShanghaiTech(AnomalibVideoDataModule):
         frames_between_clips (int, optional): Number of frames between each consecutive video clip.
         target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
         task TaskType): Task type, 'classification', 'detection' or 'segmentation'
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         train_batch_size (int, optional): Training batch size. Defaults to 32.
         eval_batch_size (int, optional): Test batch size. Defaults to 32.
         num_workers (int, optional): Number of workers. Defaults to 8.
@@ -77,10 +62,6 @@ def __init__(
         frames_between_clips: int = 1,
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
@@ -92,10 +73,6 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             val_split_mode=val_split_mode,
             val_split_ratio=val_split_ratio,
             seed=seed,
@@ -112,7 +89,6 @@ def __init__(
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = ShanghaiTechDataset(
             task=self.task,
-            transform=self.train_transform,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
@@ -123,7 +99,6 @@ def _setup(self, _stage: str | None = None) -> None:
 
         self.test_data = ShanghaiTechDataset(
             task=self.task,
-            transform=self.eval_transform,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
diff --git a/src/anomalib/data/datamodules/video/ucsd_ped.py b/src/anomalib/data/datamodules/video/ucsd_ped.py
index 2dd480ef37..4743d17044 100644
--- a/src/anomalib/data/datamodules/video/ucsd_ped.py
+++ b/src/anomalib/data/datamodules/video/ucsd_ped.py
@@ -7,8 +7,6 @@
 from pathlib import Path
 from shutil import move
 
-from torchvision.transforms.v2 import Transform
-
 from anomalib import TaskType
 from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
 from anomalib.data.datasets.base.video import VideoTargetFrame
@@ -34,14 +32,6 @@ class UCSDped(AnomalibVideoDataModule):
         frames_between_clips (int, optional): Number of frames between each consecutive video clip.
         target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
         task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
         train_batch_size (int, optional): Training batch size. Defaults to 32.
         eval_batch_size (int, optional): Test batch size. Defaults to 32.
         num_workers (int, optional): Number of workers. Defaults to 8.
@@ -58,10 +48,6 @@ def __init__(
         frames_between_clips: int = 10,
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
         task: TaskType | str = TaskType.SEGMENTATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
         train_batch_size: int = 8,
         eval_batch_size: int = 8,
         num_workers: int = 8,
@@ -73,10 +59,6 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
             val_split_mode=val_split_mode,
             val_split_ratio=val_split_ratio,
             seed=seed,
@@ -93,7 +75,6 @@ def __init__(
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = UCSDpedDataset(
             task=self.task,
-            transform=self.train_transform,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
@@ -104,7 +85,6 @@ def _setup(self, _stage: str | None = None) -> None:
 
         self.test_data = UCSDpedDataset(
             task=self.task,
-            transform=self.eval_transform,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
diff --git a/src/anomalib/deploy/utils.py b/src/anomalib/deploy/utils.py
deleted file mode 100644
index e2f23bf841..0000000000
--- a/src/anomalib/deploy/utils.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""Utility functions for Anomalib deployment module."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from torchvision.transforms.v2 import CenterCrop, Compose, Resize, Transform
-
-from anomalib.data.transforms import ExportableCenterCrop
-
-
-def make_transform_exportable(transform: Transform) -> Transform:
-    """Get exportable transform.
-
-    Some transforms are not supported by ONNX/OpenVINO, so we need to replace them with exportable versions.
-    """
-    transform = disable_antialiasing(transform)
-    return convert_centercrop(transform)
-
-
-def disable_antialiasing(transform: Transform) -> Transform:
-    """Disable antialiasing in Resize transforms.
-
-    Resizing with antialiasing is not supported by ONNX, so we need to disable it.
-    """
-    if isinstance(transform, Resize):
-        transform.antialias = False
-    if isinstance(transform, Compose):
-        for tr in transform.transforms:
-            disable_antialiasing(tr)
-    return transform
-
-
-def convert_centercrop(transform: Transform) -> Transform:
-    """Convert CenterCrop to ExportableCenterCrop.
-
-    Torchvision's CenterCrop is not supported by ONNX, so we need to replace it with our own ExportableCenterCrop.
-    """
-    if isinstance(transform, CenterCrop):
-        transform = ExportableCenterCrop(size=transform.size)
-    if isinstance(transform, Compose):
-        for index in range(len(transform.transforms)):
-            tr = transform.transforms[index]
-            transform.transforms[index] = convert_centercrop(tr)
-    return transform
diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index 13eef8a63c..36bfcc3bf4 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -8,7 +8,6 @@
 from pathlib import Path
 from typing import Any
 
-import torch
 from lightning.pytorch.callbacks import Callback
 from lightning.pytorch.loggers import Logger
 from lightning.pytorch.trainer import Trainer
@@ -292,60 +291,6 @@ def _setup_dataset_task(
                             )
                             data.task = self.task
 
-    @staticmethod
-    def _setup_transform(
-        model: AnomalyModule,
-        datamodule: AnomalibDataModule | None = None,
-        dataloaders: EVAL_DATALOADERS | TRAIN_DATALOADERS | None = None,
-        ckpt_path: Path | str | None = None,
-    ) -> None:
-        """Implements the logic for setting the transform at the start of each run.
-
-        Any transform passed explicitly to the datamodule takes precedence. Otherwise, if a checkpoint path is provided,
-        we can load the transform from the checkpoint. If no transform is provided, we use the default transform from
-        the model.
-
-        Args:
-            model (AnomalyModule): The model to assign the transform to.
-            datamodule (AnomalibDataModule | None): The datamodule to assign the transform from.
-                defaults to ``None``.
-            dataloaders (EVAL_DATALOADERS | TRAIN_DATALOADERS | None): Dataloaders to assign the transform to.
-                defaults to ``None``.
-            ckpt_path (str): The path to the checkpoint.
-                defaults to ``None``.
-
-        Returns:
-            Transform: The transform loaded from the checkpoint.
-        """
-        if isinstance(dataloaders, DataLoader):
-            dataloaders = [dataloaders]
-
-        # get transform
-        if datamodule and datamodule.transform:
-            # a transform passed explicitly to the datamodule takes precedence
-            transform = datamodule.transform
-        elif dataloaders and any(getattr(dl.dataset, "transform", None) for dl in dataloaders):
-            # if dataloaders are provided, we use the transform from the first dataloader that has a transform
-            transform = next(dl.dataset.transform for dl in dataloaders if getattr(dl.dataset, "transform", None))
-        elif ckpt_path is not None:
-            # if a checkpoint path is provided, we can load the transform from the checkpoint
-            checkpoint = torch.load(ckpt_path, map_location=model.device)
-            transform = checkpoint["transform"]
-        elif model.transform is None:
-            # if no transform is provided, we use the default transform from the model
-            image_size = datamodule.image_size if datamodule else None
-            transform = model.configure_transforms(image_size)
-        else:
-            transform = model.transform
-
-        # update transform in model
-        model.set_transform(transform)
-        # The dataloaders don't have access to the trainer and/or model, so we need to set the transforms manually
-        if dataloaders:
-            for dataloader in dataloaders:
-                if not getattr(dataloader.dataset, "transform", None):
-                    dataloader.dataset.transform = transform
-
     def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None:
         """Set up callbacks for the trainer."""
         _callbacks: list[Callback] = []
@@ -458,7 +403,6 @@ def fit(
         )
         self._setup_trainer(model)
         self._setup_dataset_task(train_dataloaders, val_dataloaders, datamodule)
-        self._setup_transform(model, datamodule=datamodule, ckpt_path=ckpt_path)
         if model.learning_type in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}:
             # if the model is zero-shot or few-shot, we only need to run validate for normalization and thresholding
             self.trainer.validate(model, val_dataloaders, datamodule=datamodule, ckpt_path=ckpt_path)
@@ -512,7 +456,6 @@ def validate(
         if model:
             self._setup_trainer(model)
         self._setup_dataset_task(dataloaders)
-        self._setup_transform(model or self.model, datamodule=datamodule, ckpt_path=ckpt_path)
         return self.trainer.validate(model, dataloaders, ckpt_path, verbose, datamodule)
 
     def test(
@@ -606,7 +549,6 @@ def test(
             raise RuntimeError(msg)
 
         self._setup_dataset_task(dataloaders)
-        self._setup_transform(model or self.model, datamodule=datamodule, ckpt_path=ckpt_path)
         if self._should_run_validation(model or self.model, ckpt_path):
             logger.info("Running validation before testing to collect normalization metrics and/or thresholds.")
             self.trainer.validate(model, dataloaders, None, verbose=False, datamodule=datamodule)
@@ -711,7 +653,6 @@ def predict(
         dataloaders = dataloaders or None
 
         self._setup_dataset_task(dataloaders, datamodule)
-        self._setup_transform(model or self.model, datamodule=datamodule, dataloaders=dataloaders, ckpt_path=ckpt_path)
 
         if self._should_run_validation(model or self.model, ckpt_path):
             logger.info("Running validation before predicting to collect normalization metrics and/or thresholds.")
@@ -781,7 +722,6 @@ def train(
             test_dataloaders,
             datamodule,
         )
-        self._setup_transform(model, datamodule=datamodule, ckpt_path=ckpt_path)
         if model.learning_type in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}:
             # if the model is zero-shot or few-shot, we only need to run validate for normalization and thresholding
             self.trainer.validate(model, val_dataloaders, None, verbose=False, datamodule=datamodule)
@@ -828,8 +768,7 @@ def export(
             Path: Path to the exported model.
 
         Raises:
-            ValueError: If Dataset, Datamodule, and transform are not provided.
-            TypeError: If path to the transform file is not a string or Path.
+            ValueError: If Dataset, Datamodule are not provided.
 
         CLI Usage:
             1. To export as a torch ``.pt`` file you can run the following command.
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py
index b22ee6981b..ff12db0cec 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomaly_module.py
@@ -5,8 +5,9 @@
 
 import logging
 from abc import ABC, abstractmethod
+from collections.abc import Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import lightning.pytorch as pl
 import torch
@@ -14,7 +15,7 @@
 from lightning.pytorch.trainer.states import TrainerFn
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 from torch import nn
-from torchvision.transforms.v2 import Compose, Normalize, Resize, Transform
+from torchvision.transforms.v2 import Compose, Normalize, Resize
 
 from anomalib import LearningType
 from anomalib.data import Batch, InferenceBatch
@@ -22,13 +23,10 @@
 from anomalib.metrics.evaluator import Evaluator
 from anomalib.metrics.threshold import Threshold
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .export_mixin import ExportMixin
 
-if TYPE_CHECKING:
-    from lightning.pytorch.callbacks import Callback
-
-
 logger = logging.getLogger(__name__)
 
 
@@ -40,6 +38,7 @@ class AnomalyModule(ExportMixin, pl.LightningModule, ABC):
 
     def __init__(
         self,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
@@ -51,14 +50,11 @@ def __init__(
         self.loss: nn.Module
         self.callbacks: list[Callback]
 
-        # set the post-processor
+        self.pre_processor = self._resolve_pre_processor(pre_processor)
         self.post_processor = post_processor or self.default_post_processor()
-
         self.evaluator = self._resolve_evaluator(evaluator)
 
-        self._transform: Transform | None = None
         self._input_size: tuple[int, int] | None = None
-
         self._is_setup = False  # flag to track if setup has been called from the trainer
 
     @property
@@ -82,6 +78,29 @@ def _setup(self) -> None:
         initialization.
         """
 
+    def _resolve_pre_processor(self, pre_processor: PreProcessor | bool) -> PreProcessor | None:
+        """Resolve and validate which pre-processor to use..
+
+        Args:
+            pre_processor: Pre-processor configuration
+                - True -> use default pre-processor
+                - False -> no pre-processor
+                - PreProcessor -> use the provided pre-processor
+
+        Returns:
+            Configured pre-processor
+        """
+        if isinstance(pre_processor, PreProcessor):
+            return pre_processor
+        if isinstance(pre_processor, bool):
+            return self.configure_pre_processor() if pre_processor else None
+        msg = f"Invalid pre-processor type: {type(pre_processor)}"
+        raise TypeError(msg)
+
+    def configure_callbacks(self) -> Sequence[Callback] | Callback:
+        """Configure default callbacks for AnomalyModule."""
+        return [self.pre_processor] if self.pre_processor else []
+
     def forward(self, batch: torch.Tensor, *args, **kwargs) -> InferenceBatch:
         """Perform the forward-pass by passing input tensor to the module.
 
@@ -94,7 +113,7 @@ def forward(self, batch: torch.Tensor, *args, **kwargs) -> InferenceBatch:
             Tensor: Output tensor from the model.
         """
         del args, kwargs  # These variables are not used.
-        batch = self.exportable_transform(batch)
+        batch = self.pre_processor(batch) if self.pre_processor else batch
         batch = self.model(batch)
         return self.post_processor(batch) if self.post_processor else batch
 
@@ -150,36 +169,48 @@ def learning_type(self) -> LearningType:
         """Learning type of the model."""
         raise NotImplementedError
 
-    @property
-    def transform(self) -> Transform:
-        """Retrieve the model-specific transform.
+    @classmethod
+    def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
+        """Configure the pre-processor.
 
-        If a transform has been set using `set_transform`, it will be returned. Otherwise, we will use the
-        model-specific default transform, conditioned on the input size.
-        """
-        return self._transform
+        The default pre-processor resizes images to 256x256 and normalizes using ImageNet statistics.
+        Individual models can override this method to provide custom transforms and pre-processing pipelines.
 
-    def set_transform(self, transform: Transform) -> None:
-        """Update the transform linked to the model instance."""
-        self._transform = transform
+        Args:
+            image_size (tuple[int, int] | None, optional): Target size for resizing images.
+                If None, defaults to (256, 256). Defaults to None.
+            **kwargs (Any): Additional keyword arguments (unused).
+
+        Returns:
+            PreProcessor: Configured pre-processor instance.
+
+        Examples:
+            Get default pre-processor with custom image size:
 
-    def configure_transforms(self, image_size: tuple[int, int] | None = None) -> Transform:  # noqa: PLR6301
-        """Default transforms.
+            >>> preprocessor = AnomalyModule.configure_pre_processor(image_size=(512, 512))
 
-        The default transform is resize to 256x256 and normalize to ImageNet stats. Individual models can override
-        this method to provide custom transforms.
+            Create model with custom pre-processor:
+
+            >>> from torchvision.transforms.v2 import RandomHorizontalFlip
+            >>> custom_transform = Compose([
+            ...     Resize((256, 256), antialias=True),
+            ...     CenterCrop((224, 224)),
+            ...     RandomHorizontalFlip(p=0.5),
+            ...     Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            ... ])
+            >>> preprocessor.train_transform = custom_transform
+            >>> model = PatchCore(pre_processor=preprocessor)
+
+            Disable pre-processing:
+
+            >>> model = PatchCore(pre_processor=False)
         """
-        logger.warning(
-            "No implementation of `configure_transforms` was provided in the Lightning model. Using default "
-            "transforms from the base class. This may not be suitable for your use case. Please override "
-            "`configure_transforms` in your model.",
-        )
         image_size = image_size or (256, 256)
-        return Compose(
-            [
+        return PreProcessor(
+            transform=Compose([
                 Resize(image_size, antialias=True),
                 Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-            ],
+            ]),
         )
 
     def default_post_processor(self) -> PostProcessor:
@@ -226,30 +257,12 @@ def input_size(self) -> tuple[int, int] | None:
         The effective input size is the size of the input tensor after the transform has been applied. If the transform
         is not set, or if the transform does not change the shape of the input tensor, this method will return None.
         """
-        transform = self.transform or self.configure_transforms()
+        transform = self.pre_processor.predict_transform if self.pre_processor else None
         if transform is None:
             return None
         dummy_input = torch.zeros(1, 3, 1, 1)
         output_shape = transform(dummy_input).shape[-2:]
-        if output_shape == (1, 1):
-            return None
-        return output_shape[-2:]
-
-    def on_save_checkpoint(self, checkpoint: dict[str, Any]) -> None:
-        """Called when saving the model to a checkpoint.
-
-        Saves the transform to the checkpoint.
-        """
-        checkpoint["transform"] = self.transform
-
-    def on_load_checkpoint(self, checkpoint: dict[str, Any]) -> None:
-        """Called when loading the model from a checkpoint.
-
-        Loads the transform from the checkpoint and calls setup to ensure that the torch model is built before loading
-        the state dict.
-        """
-        self._transform = checkpoint["transform"]
-        self.setup("load_checkpoint")
+        return None if output_shape == (1, 1) else output_shape[-2:]
 
     @classmethod
     def from_config(
diff --git a/src/anomalib/models/components/base/export_mixin.py b/src/anomalib/models/components/base/export_mixin.py
index b696ad2567..a0f84d1510 100644
--- a/src/anomalib/models/components/base/export_mixin.py
+++ b/src/anomalib/models/components/base/export_mixin.py
@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
-from collections.abc import Callable, Iterable
+from collections.abc import Iterable
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import TYPE_CHECKING, Any
@@ -14,12 +14,10 @@
 from lightning_utilities.core.imports import package_available
 from torch import nn
 from torchmetrics import Metric
-from torchvision.transforms.v2 import Transform
 
 from anomalib import TaskType
 from anomalib.data import AnomalibDataModule
 from anomalib.deploy.export import CompressionType, ExportType
-from anomalib.deploy.utils import make_transform_exportable
 
 if TYPE_CHECKING:
     from importlib.util import find_spec
@@ -34,8 +32,6 @@ class ExportMixin:
     """This mixin allows exporting models to torch and ONNX/OpenVINO."""
 
     model: nn.Module
-    transform: Transform
-    configure_transforms: Callable
     device: torch.device
 
     def to_torch(
@@ -136,7 +132,7 @@ def to_onnx(
         dynamic_axes = (
             {"input": {0: "batch_size"}, "output": {0: "batch_size"}}
             if input_size
-            else {"input": {0: "batch_size", 2: "height", 3: "weight"}, "output": {0: "batch_size"}}
+            else {"input": {0: "batch_size", 2: "height", 3: "width"}, "output": {0: "batch_size"}}
         )
         onnx_path = export_root / "model.onnx"
         # apply pass through the model to get the output names
@@ -400,11 +396,6 @@ def val_fn(nncf_model: "CompiledModel", validation_data: Iterable) -> float:
 
         return nncf.quantize_with_accuracy_control(model, calibration_dataset, validation_dataset, val_fn)
 
-    @property
-    def exportable_transform(self) -> Transform:
-        """Return the exportable transform."""
-        return make_transform_exportable(self.transform)
-
 
 def _create_export_root(export_root: str | Path, export_type: ExportType) -> Path:
     """Create export directory.
diff --git a/src/anomalib/models/image/cfa/lightning_model.py b/src/anomalib/models/image/cfa/lightning_model.py
index 363bd2eae7..154ea4e3e8 100644
--- a/src/anomalib/models/image/cfa/lightning_model.py
+++ b/src/anomalib/models/image/cfa/lightning_model.py
@@ -19,6 +19,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .loss import CfaLoss
 from .torch_model import CfaModel
@@ -44,6 +45,9 @@ class Cfa(AnomalyModule):
             Defaults to ``3``.
         radius (float): Radius of the hypersphere to search the soft boundary.
             Defaults to ``1e-5``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -54,10 +58,11 @@ def __init__(
         num_nearest_neighbors: int = 3,
         num_hard_negative_features: int = 3,
         radius: float = 1e-5,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
         self.model: CfaModel = CfaModel(
             backbone=backbone,
             gamma_c=gamma_c,
diff --git a/src/anomalib/models/image/cflow/lightning_model.py b/src/anomalib/models/image/cflow/lightning_model.py
index 3b4cb731e2..b6118d8e4e 100644
--- a/src/anomalib/models/image/cflow/lightning_model.py
+++ b/src/anomalib/models/image/cflow/lightning_model.py
@@ -26,6 +26,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .torch_model import CflowModel
 from .utils import get_logp, positional_encoding_2d
@@ -69,10 +70,11 @@ def __init__(
         clamp_alpha: float = 1.9,
         permute_soft: bool = False,
         lr: float = 0.0001,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.model: CflowModel = CflowModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/csflow/lightning_model.py b/src/anomalib/models/image/csflow/lightning_model.py
index e3762da180..0ae381c65b 100644
--- a/src/anomalib/models/image/csflow/lightning_model.py
+++ b/src/anomalib/models/image/csflow/lightning_model.py
@@ -17,6 +17,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .loss import CsFlowLoss
 from .torch_model import CsFlowModel
@@ -46,25 +47,20 @@ def __init__(
         n_coupling_blocks: int = 4,
         clamp: int = 3,
         num_channels: int = 3,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        if self.input_size is None:
+            msg = "CsFlow needs input size to build torch model."
+            raise ValueError(msg)
 
         self.cross_conv_hidden_channels = cross_conv_hidden_channels
         self.n_coupling_blocks = n_coupling_blocks
         self.clamp = clamp
         self.num_channels = num_channels
 
-        self.loss = CsFlowLoss()
-
-        self.model: CsFlowModel
-
-    def _setup(self) -> None:
-        if self.input_size is None:
-            msg = "CsFlow needs input size to build torch model."
-            raise ValueError(msg)
-
         self.model = CsFlowModel(
             input_size=self.input_size,
             cross_conv_hidden_channels=self.cross_conv_hidden_channels,
@@ -73,6 +69,7 @@ def _setup(self) -> None:
             num_channels=self.num_channels,
         )
         self.model.feature_extractor.eval()
+        self.loss = CsFlowLoss()
 
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the training step of CS-Flow.
diff --git a/src/anomalib/models/image/dfkde/lightning_model.py b/src/anomalib/models/image/dfkde/lightning_model.py
index 8b67e56907..9bd8388d49 100644
--- a/src/anomalib/models/image/dfkde/lightning_model.py
+++ b/src/anomalib/models/image/dfkde/lightning_model.py
@@ -16,6 +16,7 @@
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.models.components.classification import FeatureScalingMethod
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .torch_model import DfkdeModel
 
@@ -48,10 +49,11 @@ def __init__(
         n_pca_components: int = 16,
         feature_scaling_method: FeatureScalingMethod = FeatureScalingMethod.SCALE,
         max_training_points: int = 40000,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.model = DfkdeModel(
             layers=layers,
diff --git a/src/anomalib/models/image/dfm/lightning_model.py b/src/anomalib/models/image/dfm/lightning_model.py
index 9b6f52979c..b0449d1e69 100644
--- a/src/anomalib/models/image/dfm/lightning_model.py
+++ b/src/anomalib/models/image/dfm/lightning_model.py
@@ -17,6 +17,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .torch_model import DFMModel
 
@@ -39,6 +40,9 @@ class Dfm(MemoryBankMixin, AnomalyModule):
             Defaults to ``0.97``.
         score_type (str, optional): Scoring type. Options are `fre` and `nll`.
             Defaults to ``fre``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -49,10 +53,11 @@ def __init__(
         pooling_kernel_size: int = 4,
         pca_level: float = 0.97,
         score_type: str = "fre",
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.model: DFMModel = DFMModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py
index ccfb52cbbd..a072bcae0f 100644
--- a/src/anomalib/models/image/draem/lightning_model.py
+++ b/src/anomalib/models/image/draem/lightning_model.py
@@ -20,6 +20,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .loss import DraemLoss
 from .torch_model import DraemModel
@@ -38,6 +39,9 @@ class Draem(AnomalyModule):
         anomaly_source_path (str | None): Path to folder that contains the anomaly source images. Random noise will
             be used if left empty.
             Defaults to ``None``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -46,10 +50,11 @@ def __init__(
         sspcab_lambda: float = 0.1,
         anomaly_source_path: str | None = None,
         beta: float | tuple[float, float] = (0.1, 1.0),
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.augmenter = Augmenter(anomaly_source_path, beta=beta)
         self.model = DraemModel(sspcab=enable_sspcab)
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index 8ae8633c9c..a4ed2df231 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -24,6 +24,7 @@
 from anomalib.models.image.dsr.loss import DsrSecondStageLoss, DsrThirdStageLoss
 from anomalib.models.image.dsr.torch_model import DsrModel
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 __all__ = ["Dsr"]
 
@@ -42,16 +43,20 @@ class Dsr(AnomalyModule):
     Args:
         latent_anomaly_strength (float): Strength of the generated anomalies in the latent space. Defaults to 0.2
         upsampling_train_ratio (float): Ratio of training steps for the upsampling module. Defaults to 0.7
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
         self,
         latent_anomaly_strength: float = 0.2,
         upsampling_train_ratio: float = 0.7,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.automatic_optimization = False
         self.upsampling_train_ratio = upsampling_train_ratio
diff --git a/src/anomalib/models/image/efficient_ad/lightning_model.py b/src/anomalib/models/image/efficient_ad/lightning_model.py
index 152f50c36a..88b29f7215 100644
--- a/src/anomalib/models/image/efficient_ad/lightning_model.py
+++ b/src/anomalib/models/image/efficient_ad/lightning_model.py
@@ -15,7 +15,7 @@
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 from torch.utils.data import DataLoader
 from torchvision.datasets import ImageFolder
-from torchvision.transforms.v2 import CenterCrop, Compose, Normalize, RandomGrayscale, Resize, ToTensor, Transform
+from torchvision.transforms.v2 import CenterCrop, Compose, Normalize, RandomGrayscale, Resize, ToTensor
 
 from anomalib import LearningType
 from anomalib.data import Batch
@@ -23,6 +23,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .torch_model import EfficientAdModel, EfficientAdModelSize, reduce_tensor_elems
 
@@ -60,6 +61,9 @@ class EfficientAd(AnomalyModule):
         pad_maps (bool): relevant if padding is set to False. In this case, pad_maps = True pads the
             output anomaly maps so that their size matches the size in the padding = True case.
             Defaults to ``True``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -71,10 +75,11 @@ def __init__(
         weight_decay: float = 0.00001,
         padding: bool = False,
         pad_maps: bool = True,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.imagenet_dir = Path(imagenet_dir)
         if not isinstance(model_size, EfficientAdModelSize):
@@ -207,6 +212,13 @@ def _get_quantiles_of_maps(self, maps: list[torch.Tensor]) -> tuple[torch.Tensor
         qb = torch.quantile(maps_flat, q=0.995).to(self.device)
         return qa, qb
 
+    @classmethod
+    def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
+        """Default transform for EfficientAd. Imagenet normalization applied in forward."""
+        image_size = image_size or (256, 256)
+        transform = Compose([Resize(image_size, antialias=True)])
+        return PreProcessor(transform=transform)
+
     def configure_optimizers(self) -> torch.optim.Optimizer:
         """Configure optimizers."""
         optimizer = torch.optim.Adam(
@@ -247,9 +259,12 @@ def on_train_start(self) -> None:
         if self.trainer.datamodule.train_batch_size != 1:
             msg = "train_batch_size for EfficientAd should be 1."
             raise ValueError(msg)
-        if self._transform and any(isinstance(transform, Normalize) for transform in self._transform.transforms):
-            msg = "Transforms for EfficientAd should not contain Normalize."
-            raise ValueError(msg)
+
+        if self.pre_processor and self.pre_processor.train_transform:
+            transforms = self.pre_processor.train_transform.transforms
+            if transforms and any(isinstance(transform, Normalize) for transform in transforms):
+                msg = "Transforms for EfficientAd should not contain Normalize."
+                raise ValueError(msg)
 
         sample = next(iter(self.trainer.train_dataloader))
         image_size = sample.image.shape[-2:]
@@ -322,13 +337,3 @@ def learning_type(self) -> LearningType:
             LearningType: Learning type of the model.
         """
         return LearningType.ONE_CLASS
-
-    @staticmethod
-    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
-        """Default transform for EfficientAd. Imagenet normalization applied in forward."""
-        image_size = image_size or (256, 256)
-        return Compose(
-            [
-                Resize(image_size, antialias=True),
-            ],
-        )
diff --git a/src/anomalib/models/image/fastflow/lightning_model.py b/src/anomalib/models/image/fastflow/lightning_model.py
index 75aff99584..935df8468d 100644
--- a/src/anomalib/models/image/fastflow/lightning_model.py
+++ b/src/anomalib/models/image/fastflow/lightning_model.py
@@ -17,6 +17,7 @@
 from anomalib.metrics import AUROC, Evaluator, F1Score
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .loss import FastflowLoss
 from .torch_model import FastflowModel
@@ -35,7 +36,10 @@ class Fastflow(AnomalyModule):
         conv3x3_only (bool, optinoal): Use only conv3x3 in fast_flow model.
             Defaults to ``False``.
         hidden_ratio (float, optional): Ratio to calculate hidden var channels.
-            Defaults to ``1.0`.
+            Defaults to ``1.0``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -45,10 +49,14 @@ def __init__(
         flow_steps: int = 8,
         conv3x3_only: bool = False,
         hidden_ratio: float = 1.0,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        if self.input_size is None:
+            msg = "Fastflow needs input size to build torch model."
+            raise ValueError(msg)
 
         self.backbone = backbone
         self.pre_trained = pre_trained
@@ -56,14 +64,6 @@ def __init__(
         self.conv3x3_only = conv3x3_only
         self.hidden_ratio = hidden_ratio
 
-        self.model: FastflowModel
-        self.loss = FastflowLoss()
-
-    def _setup(self) -> None:
-        if self.input_size is None:
-            msg = "Fastflow needs input size to build torch model."
-            raise ValueError(msg)
-
         self.model = FastflowModel(
             input_size=self.input_size,
             backbone=self.backbone,
@@ -72,6 +72,7 @@ def _setup(self) -> None:
             conv3x3_only=self.conv3x3_only,
             hidden_ratio=self.hidden_ratio,
         )
+        self.loss = FastflowLoss()
 
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the training step input and return the loss.
diff --git a/src/anomalib/models/image/fre/lightning_model.py b/src/anomalib/models/image/fre/lightning_model.py
index b4628e6446..f3de232667 100755
--- a/src/anomalib/models/image/fre/lightning_model.py
+++ b/src/anomalib/models/image/fre/lightning_model.py
@@ -18,6 +18,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .torch_model import FREModel
 
@@ -41,6 +42,9 @@ class Fre(AnomalyModule):
         latent_dim (int, optional): Reduced size of feature after applying dimensionality reduction
             via shallow linear autoencoder.
             Defaults to ``220``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -51,10 +55,11 @@ def __init__(
         pooling_kernel_size: int = 2,
         input_dim: int = 65536,
         latent_dim: int = 220,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.model: FREModel = FREModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/ganomaly/lightning_model.py b/src/anomalib/models/image/ganomaly/lightning_model.py
index 362a713050..de3a479aa8 100644
--- a/src/anomalib/models/image/ganomaly/lightning_model.py
+++ b/src/anomalib/models/image/ganomaly/lightning_model.py
@@ -18,6 +18,7 @@
 from anomalib.metrics import AUROC, Evaluator, F1Score
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .loss import DiscriminatorLoss, GeneratorLoss
 from .torch_model import GanomalyModel
@@ -51,6 +52,9 @@ class Ganomaly(AnomalyModule):
             Defaults to ``0.5``.
         beta2 (float, optional): Adam beta2.
             Defaults to ``0.999``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -66,10 +70,14 @@ def __init__(
         lr: float = 0.0002,
         beta1: float = 0.5,
         beta2: float = 0.999,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        if self.input_size is None:
+            msg = "GANomaly needs input size to build torch model."
+            raise ValueError(msg)
 
         self.n_features = n_features
         self.latent_vec_size = latent_vec_size
@@ -82,6 +90,15 @@ def __init__(
         self.min_scores: torch.Tensor = torch.tensor(float("inf"), dtype=torch.float32)  # pylint: disable=not-callable
         self.max_scores: torch.Tensor = torch.tensor(float("-inf"), dtype=torch.float32)  # pylint: disable=not-callable
 
+        self.model = GanomalyModel(
+            input_size=self.input_size,
+            num_input_channels=3,
+            n_features=self.n_features,
+            latent_vec_size=self.latent_vec_size,
+            extra_layers=self.extra_layers,
+            add_final_conv_layer=self.add_final_conv_layer,
+        )
+
         self.generator_loss = GeneratorLoss(wadv, wcon, wenc)
         self.discriminator_loss = DiscriminatorLoss()
         self.automatic_optimization = False
@@ -94,20 +111,6 @@ def __init__(
 
         self.model: GanomalyModel
 
-    def _setup(self) -> None:
-        if self.input_size is None:
-            msg = "GANomaly needs input size to build torch model."
-            raise ValueError(msg)
-
-        self.model = GanomalyModel(
-            input_size=self.input_size,
-            num_input_channels=3,
-            n_features=self.n_features,
-            latent_vec_size=self.latent_vec_size,
-            extra_layers=self.extra_layers,
-            add_final_conv_layer=self.add_final_conv_layer,
-        )
-
     def _reset_min_max(self) -> None:
         """Reset min_max scores."""
         self.min_scores = torch.tensor(float("inf"), dtype=torch.float32)  # pylint: disable=not-callable
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index 2a80171931..aed2163def 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -10,14 +10,13 @@
 
 import torch
 from lightning.pytorch.utilities.types import STEP_OUTPUT
-from torchvision.transforms.v2 import Compose, Normalize, Resize, Transform
 
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
-from anomalib.post_processing import PostProcessor
-from anomalib.post_processing.one_class import OneClassPostProcessor
+from anomalib.post_processing import OneClassPostProcessor, PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .torch_model import PadimModel
 
@@ -39,6 +38,9 @@ class Padim(MemoryBankMixin, AnomalyModule):
         n_features (int, optional): Number of features to retain in the dimension reduction step.
             Default values from the paper are available for: resnet18 (100), wide_resnet50_2 (550).
             Defaults to ``None``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -47,10 +49,11 @@ def __init__(
         layers: list[str] = ["layer1", "layer2", "layer3"],  # noqa: B006
         pre_trained: bool = True,
         n_features: int | None = None,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.model: PadimModel = PadimModel(
             backbone=backbone,
@@ -128,17 +131,6 @@ def learning_type(self) -> LearningType:
         """
         return LearningType.ONE_CLASS
 
-    @staticmethod
-    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
-        """Default transform for Padim."""
-        image_size = image_size or (256, 256)
-        return Compose(
-            [
-                Resize(image_size, antialias=True),
-                Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-            ],
-        )
-
     @staticmethod
     def default_post_processor() -> OneClassPostProcessor:
         """Return the default post-processor for PADIM."""
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index d633141af3..f855a61d8e 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -12,14 +12,14 @@
 
 import torch
 from lightning.pytorch.utilities.types import STEP_OUTPUT
-from torchvision.transforms.v2 import CenterCrop, Compose, Normalize, Resize, Transform
+from torchvision.transforms.v2 import CenterCrop, Compose, Normalize, Resize
 
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
-from anomalib.post_processing import PostProcessor
-from anomalib.post_processing.one_class import OneClassPostProcessor
+from anomalib.post_processing import OneClassPostProcessor, PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .torch_model import PatchcoreModel
 
@@ -40,6 +40,9 @@ class Patchcore(MemoryBankMixin, AnomalyModule):
             Defaults to ``0.1``.
         num_neighbors (int, optional): Number of nearest neighbors.
             Defaults to ``9``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -49,10 +52,11 @@ def __init__(
         pre_trained: bool = True,
         coreset_sampling_ratio: float = 0.1,
         num_neighbors: int = 9,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.model: PatchcoreModel = PatchcoreModel(
             backbone=backbone,
@@ -63,6 +67,26 @@ def __init__(
         self.coreset_sampling_ratio = coreset_sampling_ratio
         self.embeddings: list[torch.Tensor] = []
 
+    @classmethod
+    def configure_pre_processor(
+        cls,
+        image_size: tuple[int, int] | None = None,
+        center_crop_size: tuple[int, int] | None = None,
+    ) -> PreProcessor:
+        """Default transform for Padim."""
+        image_size = image_size or (256, 256)
+        if center_crop_size is None:
+            # scale center crop size proportional to image size
+            height, width = image_size
+            center_crop_size = (int(height * (224 / 256)), int(width * (224 / 256)))
+
+        transform = Compose([
+            Resize(image_size, antialias=True),
+            CenterCrop(center_crop_size),
+            Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ])
+        return PreProcessor(transform=transform)
+
     @staticmethod
     def configure_optimizers() -> None:
         """Configure optimizers.
@@ -129,21 +153,6 @@ def learning_type(self) -> LearningType:
         """
         return LearningType.ONE_CLASS
 
-    @staticmethod
-    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
-        """Default transform for Padim."""
-        image_size = image_size or (256, 256)
-        # scale center crop size proportional to image size
-        height, width = image_size
-        center_crop_size = (int(height * (224 / 256)), int(width * (224 / 256)))
-        return Compose(
-            [
-                Resize(image_size, antialias=True),
-                CenterCrop(center_crop_size),
-                Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-            ],
-        )
-
     @staticmethod
     def default_post_processor() -> OneClassPostProcessor:
         """Return the default post-processor for the model.
diff --git a/src/anomalib/models/image/reverse_distillation/lightning_model.py b/src/anomalib/models/image/reverse_distillation/lightning_model.py
index 916541ebda..a0cd8521f9 100644
--- a/src/anomalib/models/image/reverse_distillation/lightning_model.py
+++ b/src/anomalib/models/image/reverse_distillation/lightning_model.py
@@ -17,6 +17,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .anomaly_map import AnomalyMapGenerationMode
 from .loss import ReverseDistillationLoss
@@ -35,6 +36,9 @@ class ReverseDistillation(AnomalyModule):
             Defaults to ``AnomalyMapGenerationMode.ADD``.
         pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
             Defaults to ``True``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -43,24 +47,20 @@ def __init__(
         layers: Sequence[str] = ("layer1", "layer2", "layer3"),
         anomaly_map_mode: AnomalyMapGenerationMode = AnomalyMapGenerationMode.ADD,
         pre_trained: bool = True,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        if self.input_size is None:
+            msg = "Input size is required for Reverse Distillation model."
+            raise ValueError(msg)
 
         self.backbone = backbone
         self.pre_trained = pre_trained
         self.layers = layers
         self.anomaly_map_mode = anomaly_map_mode
 
-        self.model: ReverseDistillationModel
-        self.loss = ReverseDistillationLoss()
-
-    def _setup(self) -> None:
-        if self.input_size is None:
-            msg = "Input size is required for Reverse Distillation model."
-            raise ValueError(msg)
-
         self.model = ReverseDistillationModel(
             backbone=self.backbone,
             pre_trained=self.pre_trained,
@@ -68,6 +68,7 @@ def _setup(self) -> None:
             input_size=self.input_size,
             anomaly_map_mode=self.anomaly_map_mode,
         )
+        self.loss = ReverseDistillationLoss()
 
     def configure_optimizers(self) -> optim.Adam:
         """Configure optimizers for decoder and bottleneck.
diff --git a/src/anomalib/models/image/rkde/lightning_model.py b/src/anomalib/models/image/rkde/lightning_model.py
index 2d48da35c4..8d618127c0 100644
--- a/src/anomalib/models/image/rkde/lightning_model.py
+++ b/src/anomalib/models/image/rkde/lightning_model.py
@@ -18,6 +18,7 @@
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.models.components.classification import FeatureScalingMethod
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .region_extractor import RoiStage
 from .torch_model import RkdeModel
@@ -47,6 +48,9 @@ class Rkde(MemoryBankMixin, AnomalyModule):
             Defaults to ``FeatureScalingMethod.SCALE``.
         max_training_points (int, optional): Maximum number of training points to fit the KDE model.
             Defaults to ``40000``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -59,10 +63,11 @@ def __init__(
         n_pca_components: int = 16,
         feature_scaling_method: FeatureScalingMethod = FeatureScalingMethod.SCALE,
         max_training_points: int = 40000,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
         self.model: RkdeModel = RkdeModel(
             roi_stage=roi_stage,
diff --git a/src/anomalib/models/image/stfpm/lightning_model.py b/src/anomalib/models/image/stfpm/lightning_model.py
index eca57f6850..32cace71f1 100644
--- a/src/anomalib/models/image/stfpm/lightning_model.py
+++ b/src/anomalib/models/image/stfpm/lightning_model.py
@@ -18,6 +18,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .loss import STFPMLoss
 from .torch_model import STFPMModel
@@ -33,21 +34,22 @@ class Stfpm(AnomalyModule):
             Defaults to ``resnet18``.
         layers (list[str]): Layers to extract features from the backbone CNN
             Defaults to ``["layer1", "layer2", "layer3"]``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
         self,
         backbone: str = "resnet18",
         layers: Sequence[str] = ("layer1", "layer2", "layer3"),
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
-        self.model = STFPMModel(
-            backbone=backbone,
-            layers=layers,
-        )
+        self.model = STFPMModel(backbone=backbone, layers=layers)
         self.loss = STFPMLoss()
 
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
diff --git a/src/anomalib/models/image/uflow/lightning_model.py b/src/anomalib/models/image/uflow/lightning_model.py
index 03ef56a2b0..ce88d4ae2e 100644
--- a/src/anomalib/models/image/uflow/lightning_model.py
+++ b/src/anomalib/models/image/uflow/lightning_model.py
@@ -13,13 +13,14 @@
 from lightning.pytorch.core.optimizer import LightningOptimizer
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 from torch.optim.lr_scheduler import LRScheduler
-from torchvision.transforms.v2 import Compose, Normalize, Resize, Transform
+from torchvision.transforms.v2 import Compose, Normalize, Resize
 
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .loss import UFlowLoss
 from .torch_model import UflowModel
@@ -47,10 +48,32 @@ def __init__(
         affine_clamp: float = 2.0,
         affine_subnet_channels_ratio: float = 1.0,
         permute_soft: bool = False,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        """Uflow model.
+
+        Args:
+            backbone (str): Backbone name.
+            flow_steps (int): Number of flow steps.
+            affine_clamp (float): Affine clamp.
+            affine_subnet_channels_ratio (float): Affine subnet channels ratio.
+            permute_soft (bool): Whether to use soft permutation.
+            pre_processor (PreProcessor, optional): Pre-processor for the model.
+                This is used to pre-process the input data before it is passed to the model.
+                Defaults to ``None``.
+            post_processor (PostProcessor, optional): Post-processor for the model.
+                This is used to post-process the output data after it is passed to the model.
+                Defaults to ``None``.
+            evaluator (Evaluator, optional): Evaluator for the model.
+                This is used to evaluate the model.
+                Defaults to ``True``.
+        """
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        if self.input_size is None:
+            msg = "Input size is required for UFlow model."
+            raise ValueError(msg)
 
         self.backbone = backbone
         self.flow_steps = flow_steps
@@ -58,15 +81,6 @@ def __init__(
         self.affine_subnet_channels_ratio = affine_subnet_channels_ratio
         self.permute_soft = permute_soft
 
-        self.loss = UFlowLoss()
-
-        self.model: UflowModel
-
-    def _setup(self) -> None:
-        if self.input_size is None:
-            msg = "Input size is required for UFlow model."
-            raise ValueError(msg)
-
         self.model = UflowModel(
             input_size=self.input_size,
             backbone=self.backbone,
@@ -75,18 +89,18 @@ def _setup(self) -> None:
             affine_subnet_channels_ratio=self.affine_subnet_channels_ratio,
             permute_soft=self.permute_soft,
         )
+        self.loss = UFlowLoss()
 
-    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
-        """Training step."""
-        z, ljd = self.model(batch.image)
-        loss = self.loss(z, ljd)
-        self.log_dict({"loss": loss}, on_step=True, on_epoch=False, prog_bar=False, logger=True)
-        return {"loss": loss}
-
-    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
-        """Validation step."""
-        predictions = self.model(batch.image)
-        return batch.update(**predictions._asdict())
+    @classmethod
+    def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
+        """Default pre-processor for UFlow."""
+        if image_size is not None:
+            logger.warning("Image size is not used in UFlow. The input image size is determined by the model.")
+        transform = Compose([
+            Resize((448, 448), antialias=True),
+            Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ])
+        return PreProcessor(transform=transform)
 
     def configure_optimizers(self) -> tuple[list[LightningOptimizer], list[LRScheduler]]:
         """Return optimizer and scheduler."""
@@ -106,6 +120,18 @@ def configure_optimizers(self) -> tuple[list[LightningOptimizer], list[LRSchedul
         )
         return [optimizer], [scheduler]
 
+    def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
+        """Training step."""
+        z, ljd = self.model(batch.image)
+        loss = self.loss(z, ljd)
+        self.log_dict({"loss": loss}, on_step=True, on_epoch=False, prog_bar=False, logger=True)
+        return {"loss": loss}
+
+    def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
+        """Validation step."""
+        predictions = self.model(batch.image)
+        return batch.update(**predictions._asdict())
+
     @property
     def trainer_arguments(self) -> dict[str, Any]:
         """Return EfficientAD trainer arguments."""
@@ -119,15 +145,3 @@ def learning_type(self) -> LearningType:
             LearningType: Learning type of the model.
         """
         return LearningType.ONE_CLASS
-
-    @staticmethod
-    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
-        """Default transform for Padim."""
-        if image_size is not None:
-            logger.warning("Image size is not used in UFlow. The input image size is determined by the model.")
-        return Compose(
-            [
-                Resize((448, 448), antialias=True),
-                Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-            ],
-        )
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index 2651c588e3..3ce35f46f4 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -13,7 +13,7 @@
 
 import torch
 from torch.utils.data import DataLoader
-from torchvision.transforms.v2 import Compose, InterpolationMode, Normalize, Resize, Transform
+from torchvision.transforms.v2 import Compose, InterpolationMode, Normalize, Resize
 
 from anomalib import LearningType
 from anomalib.data import Batch
@@ -21,6 +21,7 @@
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalyModule
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .torch_model import WinClipModel
 
@@ -41,6 +42,9 @@ class WinClip(AnomalyModule):
             Defaults to ``(2, 3)``.
         few_shot_source (str | Path, optional): Path to a folder of reference images used for few-shot inference.
             Defaults to ``None``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     EXCLUDE_FROM_STATE_DICT = frozenset({"model.clip"})
@@ -51,10 +55,12 @@ def __init__(
         k_shot: int = 0,
         scales: tuple = (2, 3),
         few_shot_source: Path | str | None = None,
+        pre_processor: PreProcessor | bool = True,
         post_processor: PostProcessor | None = None,
         evaluator: Evaluator | bool = True,
     ) -> None:
-        super().__init__(post_processor=post_processor, evaluator=evaluator)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+
         self.model = WinClipModel(scales=scales, apply_transform=False)
         self.class_name = class_name
         self.k_shot = k_shot
@@ -77,7 +83,10 @@ def _setup(self) -> None:
         if self.k_shot:
             if self.few_shot_source:
                 logger.info("Loading reference images from %s", self.few_shot_source)
-                reference_dataset = PredictDataset(self.few_shot_source, transform=self.model.transform)
+                reference_dataset = PredictDataset(
+                    self.few_shot_source,
+                    transform=self.pre_processor.test_transform if self.pre_processor else None,
+                )
                 dataloader = DataLoader(reference_dataset, batch_size=1, shuffle=False)
             else:
                 logger.info("Collecting reference images from training dataset")
@@ -173,17 +182,17 @@ def load_state_dict(self, state_dict: OrderedDict[str, Any], strict: bool = True
             state_dict.update(restore_dict)
         return super().load_state_dict(state_dict, strict)
 
-    @staticmethod
-    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
-        """Configure the default transforms used by the model."""
+    @classmethod
+    def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
+        """Configure the default pre-processor used by the model."""
         if image_size is not None:
             logger.warning("Image size is not used in WinCLIP. The input image size is determined by the model.")
-        return Compose(
-            [
-                Resize((240, 240), antialias=True, interpolation=InterpolationMode.BICUBIC),
-                Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711)),
-            ],
-        )
+
+        transform = Compose([
+            Resize((240, 240), antialias=True, interpolation=InterpolationMode.BICUBIC),
+            Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711)),
+        ])
+        return PreProcessor(val_transform=transform, test_transform=transform)
 
     @staticmethod
     def default_post_processor() -> OneClassPostProcessor:
diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py
index 8c36a689c7..9625f4b565 100644
--- a/src/anomalib/models/video/ai_vad/lightning_model.py
+++ b/src/anomalib/models/video/ai_vad/lightning_model.py
@@ -11,12 +11,12 @@
 from typing import Any
 
 from lightning.pytorch.utilities.types import STEP_OUTPUT
-from torchvision.transforms.v2 import Transform
 
 from anomalib import LearningType
 from anomalib.data import VideoBatch
 from anomalib.models.components import AnomalyModule, MemoryBankMixin
 from anomalib.post_processing.one_class import OneClassPostProcessor, PostProcessor
+from anomalib.pre_processing import PreProcessor
 
 from .torch_model import AiVadModel
 
@@ -59,6 +59,9 @@ class AiVad(MemoryBankMixin, AnomalyModule):
             Defaults to ``1``.
         n_neighbors_deep (int): Number of neighbors used in KNN density estimation for deep features.
             Defaults to ``1``.
+        pre_processor (PreProcessor, optional): Pre-processor for the model.
+            This is used to pre-process the input data before it is passed to the model.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -77,10 +80,10 @@ def __init__(
         n_components_velocity: int = 2,
         n_neighbors_pose: int = 1,
         n_neighbors_deep: int = 1,
+        pre_processor: PreProcessor | bool = True,
         **kwargs,
     ) -> None:
-        super().__init__(**kwargs)
-
+        super().__init__(pre_processor=pre_processor, **kwargs)
         self.model = AiVadModel(
             box_score_thresh=box_score_thresh,
             persons_only=persons_only,
@@ -165,11 +168,15 @@ def learning_type(self) -> LearningType:
         """
         return LearningType.ONE_CLASS
 
-    @staticmethod
-    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform | None:
-        """AI-VAD does not need a transform, as the region- and feature-extractors apply their own transforms."""
+    @classmethod
+    def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
+        """Configure the pre-processor for AI-VAD.
+
+        AI-VAD does not need a pre-processor or transforms, as the region- and
+        feature-extractors apply their own transforms.
+        """
         del image_size
-        return None
+        return PreProcessor()  # A pre-processor with no transforms.
 
     @staticmethod
     def default_post_processor() -> PostProcessor:
diff --git a/src/anomalib/pre_processing/__init__.py b/src/anomalib/pre_processing/__init__.py
new file mode 100644
index 0000000000..d70565f882
--- /dev/null
+++ b/src/anomalib/pre_processing/__init__.py
@@ -0,0 +1,8 @@
+"""Anomalib pre-processing module."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .pre_processing import PreProcessor
+
+__all__ = ["PreProcessor"]
diff --git a/src/anomalib/pre_processing/pre_processing.py b/src/anomalib/pre_processing/pre_processing.py
new file mode 100644
index 0000000000..27cffc7605
--- /dev/null
+++ b/src/anomalib/pre_processing/pre_processing.py
@@ -0,0 +1,177 @@
+"""Anomalib pre-processing module."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import TYPE_CHECKING
+
+import torch
+from lightning import Callback, LightningModule, Trainer
+from lightning.pytorch.trainer.states import TrainerFn
+from torch import nn
+from torch.utils.data import DataLoader
+from torchvision.transforms.v2 import Transform
+
+from .utils.transform import (
+    get_dataloaders_transforms,
+    get_exportable_transform,
+    set_dataloaders_transforms,
+    set_datamodule_stage_transform,
+)
+
+if TYPE_CHECKING:
+    from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
+
+    from anomalib.data import AnomalibDataModule
+
+
+class PreProcessor(nn.Module, Callback):
+    """Anomalib pre-processor.
+
+    This class serves as both a PyTorch module and a Lightning callback, handling
+    the application of transforms to data batches during different stages of
+    training, validation, testing, and prediction.
+
+    Args:
+        train_transform (Transform | None): Transform to apply during training.
+        val_transform (Transform | None): Transform to apply during validation.
+        test_transform (Transform | None): Transform to apply during testing.
+        transform (Transform | None): General transform to apply if stage-specific
+            transforms are not provided.
+
+    Raises:
+        ValueError: If both `transform` and any of the stage-specific transforms
+            are provided simultaneously.
+
+    Notes:
+        If only `transform` is provided, it will be used for all stages (train, val, test).
+
+        Priority of transforms:
+        1. Explicitly set PreProcessor transforms (highest priority)
+        2. Datamodule transforms (if PreProcessor has no transforms)
+        3. Dataloader transforms (if neither PreProcessor nor datamodule have transforms)
+        4. Default transforms (lowest priority)
+
+    Examples:
+        >>> from torchvision.transforms.v2 import Compose, Resize, ToTensor
+        >>> from anomalib.pre_processing import PreProcessor
+
+        >>> # Define transforms
+        >>> train_transform = Compose([Resize((224, 224)), ToTensor()])
+        >>> val_transform = Compose([Resize((256, 256)), CenterCrop((224, 224)), ToTensor()])
+
+        >>> # Create PreProcessor with stage-specific transforms
+        >>> pre_processor = PreProcessor(
+        ...     train_transform=train_transform,
+        ...     val_transform=val_transform
+        ... )
+
+        >>> # Create PreProcessor with a single transform for all stages
+        >>> common_transform = Compose([Resize((224, 224)), ToTensor()])
+        >>> pre_processor_common = PreProcessor(transform=common_transform)
+
+        >>> # Use in a Lightning module
+        >>> class MyModel(LightningModule):
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.pre_processor = PreProcessor(...)
+        ...
+        ...     def configure_callbacks(self):
+        ...         return [self.pre_processor]
+        ...
+        ...     def training_step(self, batch, batch_idx):
+        ...         # The pre_processor will automatically apply the correct transform
+        ...         processed_batch = self.pre_processor(batch)
+        ...         # Rest of the training step
+    """
+
+    def __init__(
+        self,
+        train_transform: Transform | None = None,
+        val_transform: Transform | None = None,
+        test_transform: Transform | None = None,
+        transform: Transform | None = None,
+    ) -> None:
+        super().__init__()
+
+        if transform and any([train_transform, val_transform, test_transform]):
+            msg = (
+                "`transforms` cannot be used together with `train_transform`, `val_transform`, `test_transform`.\n"
+                "If you want to apply the same transform to the training, validation and test data, "
+                "use only `transforms`. \n"
+                "Otherwise, specify transforms for training, validation and test individually."
+            )
+            raise ValueError(msg)
+
+        self.train_transform = train_transform or transform
+        self.val_transform = val_transform or transform
+        self.test_transform = test_transform or transform
+        self.predict_transform = self.test_transform
+        self.export_transform = get_exportable_transform(self.test_transform)
+
+    def setup_datamodule_transforms(self, datamodule: "AnomalibDataModule") -> None:
+        """Set up datamodule transforms."""
+        # If PreProcessor has transforms, propagate them to datamodule
+        if any([self.train_transform, self.val_transform, self.test_transform]):
+            transforms = {
+                "fit": self.train_transform,
+                "val": self.val_transform,
+                "test": self.test_transform,
+                "predict": self.predict_transform,
+            }
+
+            for stage, transform in transforms.items():
+                if transform is not None:
+                    set_datamodule_stage_transform(datamodule, transform, stage)
+
+    def setup_dataloader_transforms(self, dataloaders: "EVAL_DATALOADERS | TRAIN_DATALOADERS") -> None:
+        """Set up dataloader transforms."""
+        if isinstance(dataloaders, DataLoader):
+            dataloaders = [dataloaders]
+
+        # If PreProcessor has transforms, propagate them to dataloaders
+        if any([self.train_transform, self.val_transform, self.test_transform]):
+            transforms = {
+                "train": self.train_transform,
+                "val": self.val_transform,
+                "test": self.test_transform,
+            }
+            set_dataloaders_transforms(dataloaders, transforms)
+            return
+
+        # Try to get transforms from dataloaders
+        if dataloaders:
+            dataloaders_transforms = get_dataloaders_transforms(dataloaders)
+            if dataloaders_transforms:
+                self.train_transform = dataloaders_transforms.get("train")
+                self.val_transform = dataloaders_transforms.get("val")
+                self.test_transform = dataloaders_transforms.get("test")
+                self.predict_transform = self.test_transform
+                self.export_transform = get_exportable_transform(self.test_transform)
+
+    def setup(self, trainer: Trainer, pl_module: LightningModule, stage: str) -> None:
+        """Configure transforms at the start of each stage.
+
+        Args:
+            trainer: The Lightning trainer.
+            pl_module: The Lightning module.
+            stage: The stage (e.g., 'fit', 'validate', 'test', 'predict').
+        """
+        stage = TrainerFn(stage).value  # Ensure stage is str
+
+        if hasattr(trainer, "datamodule"):
+            self.setup_datamodule_transforms(datamodule=trainer.datamodule)
+        elif hasattr(trainer, f"{stage}_dataloaders"):
+            dataloaders = getattr(trainer, f"{stage}_dataloaders")
+            self.setup_dataloader_transforms(dataloaders=dataloaders)
+
+        super().setup(trainer, pl_module, stage)
+
+    def forward(self, batch: torch.Tensor) -> torch.Tensor:
+        """Apply transforms to the batch of tensors for inference.
+
+        This forward-pass is only used after the model is exported.
+        Within the Lightning training/validation/testing loops, the transforms are applied
+        in the `on_*_batch_start` methods.
+        """
+        return self.export_transform(batch) if self.export_transform else batch
diff --git a/src/anomalib/pre_processing/utils/__init__.py b/src/anomalib/pre_processing/utils/__init__.py
new file mode 100644
index 0000000000..8361223189
--- /dev/null
+++ b/src/anomalib/pre_processing/utils/__init__.py
@@ -0,0 +1,4 @@
+"""Utility functions for pre-processing."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pre_processing/utils/transform.py b/src/anomalib/pre_processing/utils/transform.py
new file mode 100644
index 0000000000..37eb1e9dd1
--- /dev/null
+++ b/src/anomalib/pre_processing/utils/transform.py
@@ -0,0 +1,150 @@
+"""Utility functions for transforms."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+
+from torch.utils.data import DataLoader
+from torchvision.transforms.v2 import CenterCrop, Compose, Resize, Transform
+
+from anomalib.data import AnomalibDataModule
+from anomalib.data.transforms import ExportableCenterCrop
+
+
+def get_dataloaders_transforms(dataloaders: Sequence[DataLoader]) -> dict[str, Transform]:
+    """Get transforms from dataloaders.
+
+    Args:
+        dataloaders: The dataloaders to get transforms from.
+
+    Returns:
+        Dictionary mapping stages to their transforms.
+    """
+    transforms: dict[str, Transform] = {}
+    stage_lookup = {
+        "fit": "train",
+        "validate": "val",
+        "test": "test",
+        "predict": "test",
+    }
+
+    for dataloader in dataloaders:
+        if not hasattr(dataloader, "dataset") or not hasattr(dataloader.dataset, "transform"):
+            continue
+
+        for stage in stage_lookup:
+            if hasattr(dataloader, f"{stage}_dataloader"):
+                transforms[stage_lookup[stage]] = dataloader.dataset.transform
+
+    return transforms
+
+
+def set_dataloaders_transforms(dataloaders: Sequence[DataLoader], transforms: dict[str, Transform | None]) -> None:
+    """Set transforms to dataloaders.
+
+    Args:
+        dataloaders: The dataloaders to propagate transforms to.
+        transforms: Dictionary mapping stages to their transforms.
+    """
+    stage_mapping = {
+        "fit": "train",
+        "validate": "val",
+        "test": "test",
+        "predict": "test",  # predict uses test transform
+    }
+
+    for loader in dataloaders:
+        if not hasattr(loader, "dataset"):
+            continue
+
+        for stage in stage_mapping:
+            if hasattr(loader, f"{stage}_dataloader"):
+                transform = transforms.get(stage_mapping[stage])
+                if transform is not None:
+                    set_dataloader_transform([loader], transform)
+
+
+def set_dataloader_transform(dataloader: DataLoader | Sequence[DataLoader], transform: Transform) -> None:
+    """Set a transform for a dataloader or list of dataloaders.
+
+    Args:
+        dataloader: The dataloader(s) to set the transform for.
+        transform: The transform to set.
+    """
+    if isinstance(dataloader, DataLoader):
+        if hasattr(dataloader.dataset, "transform"):
+            dataloader.dataset.transform = transform
+    elif isinstance(dataloader, Sequence):
+        for dl in dataloader:
+            set_dataloader_transform(dl, transform)
+    else:
+        msg = f"Unsupported dataloader type: {type(dataloader)}"
+        raise TypeError(msg)
+
+
+def set_datamodule_stage_transform(datamodule: AnomalibDataModule, transform: Transform, stage: str) -> None:
+    """Set a transform for a specific stage in a AnomalibDataModule.
+
+    Args:
+        datamodule: The AnomalibDataModule to set the transform for.
+        transform: The transform to set.
+        stage: The stage to set the transform for.
+
+    Note:
+        The stage parameter maps to dataset attributes as follows:
+        - 'fit' -> 'train_data'
+        - 'validate' -> 'val_data'
+        - 'test' -> 'test_data'
+        - 'predict' -> 'test_data'
+    """
+    stage_datasets = {
+        "fit": "train_data",
+        "validate": "val_data",
+        "test": "test_data",
+        "predict": "test_data",
+    }
+
+    dataset_attr = stage_datasets.get(stage)
+    if dataset_attr and hasattr(datamodule, dataset_attr):
+        dataset = getattr(datamodule, dataset_attr)
+        if hasattr(dataset, "transform"):
+            dataset.transform = transform
+
+
+def get_exportable_transform(transform: Transform | None) -> Transform | None:
+    """Get exportable transform.
+
+    Some transforms are not supported by ONNX/OpenVINO, so we need to replace them with exportable versions.
+    """
+    if transform is None:
+        return None
+    transform = disable_antialiasing(transform)
+    return convert_center_crop_transform(transform)
+
+
+def disable_antialiasing(transform: Transform) -> Transform:
+    """Disable antialiasing in Resize transforms.
+
+    Resizing with antialiasing is not supported by ONNX, so we need to disable it.
+    """
+    if isinstance(transform, Resize):
+        transform.antialias = False
+    if isinstance(transform, Compose):
+        for tr in transform.transforms:
+            disable_antialiasing(tr)
+    return transform
+
+
+def convert_center_crop_transform(transform: Transform) -> Transform:
+    """Convert CenterCrop to ExportableCenterCrop.
+
+    Torchvision's CenterCrop is not supported by ONNX, so we need to replace it with our own ExportableCenterCrop.
+    """
+    if isinstance(transform, CenterCrop):
+        transform = ExportableCenterCrop(size=transform.size)
+    if isinstance(transform, Compose):
+        for index in range(len(transform.transforms)):
+            tr = transform.transforms[index]
+            transform.transforms[index] = convert_center_crop_transform(tr)
+    return transform
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index 4fc266d190..2ffd2188f4 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -187,12 +187,9 @@ def _get_objects(
         extra_args = {}
         if model_name in {"rkde", "dfkde"}:
             extra_args["n_pca_components"] = 2
+
         if model_name == "ai_vad":
             pytest.skip("Revisit AI-VAD test")
-
-        # select dataset
-        elif model_name == "win_clip":
-            dataset = MVTec(root=dataset_path / "mvtec", category="dummy", image_size=240, task=task_type)
         else:
             # EfficientAd requires that the batch size be lesser than the number of images in the dataset.
             # This is so that the LR step size is not 0.
diff --git a/tests/integration/tools/upgrade/expected_draem_v1.yaml b/tests/integration/tools/upgrade/expected_draem_v1.yaml
index f59a21d5e9..882e27b74e 100644
--- a/tests/integration/tools/upgrade/expected_draem_v1.yaml
+++ b/tests/integration/tools/upgrade/expected_draem_v1.yaml
@@ -3,16 +3,10 @@ data:
   init_args:
     root: ./datasets/MVTec
     category: bottle
-    image_size:
-      - 256
-      - 256
     train_batch_size: 72
     eval_batch_size: 32
     num_workers: 8
     task: segmentation
-    transform: null
-    train_transform: null
-    eval_transform: null
     test_split_mode: from_dir
     test_split_ratio: 0.2
     val_split_mode: same_as_test
@@ -27,6 +21,7 @@ model:
     beta:
       - 0.1
       - 1.0
+    pre_processor: true
     post_processor: null
     evaluator: true
 normalization:
diff --git a/tests/unit/data/datamodule/depth/test_folder_3d.py b/tests/unit/data/datamodule/depth/test_folder_3d.py
index 6ed01bfff5..9ebf82e3f2 100644
--- a/tests/unit/data/datamodule/depth/test_folder_3d.py
+++ b/tests/unit/data/datamodule/depth/test_folder_3d.py
@@ -29,7 +29,6 @@ def datamodule(dataset_path: Path, task_type: TaskType) -> Folder3D:
             normal_depth_dir="train/good/xyz",
             abnormal_depth_dir="test/bad/xyz",
             normal_test_depth_dir="test/good/xyz",
-            image_size=256,
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
diff --git a/tests/unit/data/datamodule/depth/test_mvtec_3d.py b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
index 70966b7774..6a94f1b279 100644
--- a/tests/unit/data/datamodule/depth/test_mvtec_3d.py
+++ b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
@@ -23,7 +23,6 @@ def datamodule(dataset_path: Path, task_type: TaskType) -> MVTec3D:
             root=dataset_path / "mvtec_3d",
             category="dummy",
             task=task_type,
-            image_size=256,
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
diff --git a/tests/unit/data/datamodule/image/test_btech.py b/tests/unit/data/datamodule/image/test_btech.py
index cf7b207e1d..2f483da7c8 100644
--- a/tests/unit/data/datamodule/image/test_btech.py
+++ b/tests/unit/data/datamodule/image/test_btech.py
@@ -23,7 +23,6 @@ def datamodule(dataset_path: Path, task_type: TaskType) -> BTech:
             root=dataset_path / "btech",
             category="dummy",
             task=task_type,
-            image_size=256,
             train_batch_size=4,
             eval_batch_size=4,
         )
diff --git a/tests/unit/data/datamodule/image/test_kolektor.py b/tests/unit/data/datamodule/image/test_kolektor.py
index 703c3927a3..7fc061c09d 100644
--- a/tests/unit/data/datamodule/image/test_kolektor.py
+++ b/tests/unit/data/datamodule/image/test_kolektor.py
@@ -22,7 +22,6 @@ def datamodule(dataset_path: Path, task_type: TaskType) -> Kolektor:
         _datamodule = Kolektor(
             root=dataset_path / "kolektor",
             task=task_type,
-            image_size=256,
             train_batch_size=4,
             eval_batch_size=4,
         )
diff --git a/tests/unit/data/datamodule/image/test_visa.py b/tests/unit/data/datamodule/image/test_visa.py
index 0c663a6e54..8b173f38cc 100644
--- a/tests/unit/data/datamodule/image/test_visa.py
+++ b/tests/unit/data/datamodule/image/test_visa.py
@@ -22,7 +22,6 @@ def datamodule(dataset_path: Path, task_type: TaskType) -> Visa:
         _datamodule = Visa(
             root=dataset_path,
             category="dummy",
-            image_size=256,
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
diff --git a/tests/unit/data/datamodule/video/test_avenue.py b/tests/unit/data/datamodule/video/test_avenue.py
index 42365d059f..5069b93def 100644
--- a/tests/unit/data/datamodule/video/test_avenue.py
+++ b/tests/unit/data/datamodule/video/test_avenue.py
@@ -29,7 +29,6 @@ def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: i
             root=dataset_path / "avenue",
             gt_dir=dataset_path / "avenue" / "ground_truth_demo",
             clip_length_in_frames=clip_length_in_frames,
-            image_size=256,
             task=task_type,
             num_workers=0,
             train_batch_size=4,
diff --git a/tests/unit/data/datamodule/video/test_shanghaitech.py b/tests/unit/data/datamodule/video/test_shanghaitech.py
index fda0d1a84d..4e96cfbaa7 100644
--- a/tests/unit/data/datamodule/video/test_shanghaitech.py
+++ b/tests/unit/data/datamodule/video/test_shanghaitech.py
@@ -29,7 +29,6 @@ def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: i
             root=dataset_path / "shanghaitech",
             scene=1,
             clip_length_in_frames=clip_length_in_frames,
-            image_size=(256, 256),
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
diff --git a/tests/unit/data/datamodule/video/test_ucsdped.py b/tests/unit/data/datamodule/video/test_ucsdped.py
index 1148e9313a..669d72278a 100644
--- a/tests/unit/data/datamodule/video/test_ucsdped.py
+++ b/tests/unit/data/datamodule/video/test_ucsdped.py
@@ -30,7 +30,6 @@ def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: i
             category="dummy",
             clip_length_in_frames=clip_length_in_frames,
             task=task_type,
-            image_size=256,
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
diff --git a/tests/unit/engine/test_engine.py b/tests/unit/engine/test_engine.py
index 1fdb7532a4..c927733595 100644
--- a/tests/unit/engine/test_engine.py
+++ b/tests/unit/engine/test_engine.py
@@ -85,10 +85,6 @@ def fxt_full_config_path(tmp_path: Path) -> Path:
                 train_batch_size: 32
                 eval_batch_size: 32
                 num_workers: 8
-                image_size: null
-                transform: null
-                train_transform: null
-                eval_transform: null
                 test_split_mode: FROM_DIR
                 test_split_ratio: 0.2
                 val_split_mode: SAME_AS_TEST
diff --git a/tests/unit/engine/test_setup_transform.py b/tests/unit/engine/test_setup_transform.py
deleted file mode 100644
index ebb60f81c0..0000000000
--- a/tests/unit/engine/test_setup_transform.py
+++ /dev/null
@@ -1,260 +0,0 @@
-"""Tests for the Anomalib Engine."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import tempfile
-from collections.abc import Generator
-from pathlib import Path
-
-import pytest
-import torch
-from torch.utils.data import DataLoader
-from torchvision.transforms.v2 import Resize, Transform
-
-from anomalib import LearningType, TaskType
-from anomalib.data import AnomalibDataModule, AnomalibDataset, InferenceBatch
-from anomalib.engine import Engine
-from anomalib.models import AnomalyModule
-from anomalib.post_processing import PostProcessor
-
-
-class DummyDataset(AnomalibDataset):
-    """Dummy dataset for testing the setup_transform method."""
-
-    def __init__(self, transform: Transform = None) -> None:
-        super().__init__(TaskType.CLASSIFICATION, transform=transform)
-        self.image = torch.rand(3, 10, 10)
-        self._samples = None
-
-    def _setup(self, _stage: str | None = None) -> None:
-        self._samples = None
-
-    def __len__(self) -> int:
-        """Return the length of the dataset."""
-        return 1
-
-
-class DummyPostProcessor(PostProcessor):
-    """Dummy post-processor for testing the setup_transform method."""
-
-    @staticmethod
-    def forward(batch: InferenceBatch) -> InferenceBatch:
-        """Return the batch unmodified."""
-        return batch
-
-
-class DummyModel(AnomalyModule):
-    """Dummy model for testing the setup_transform method."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.model = torch.nn.Linear(10, 10)
-
-    @staticmethod
-    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
-        """Return a Resize transform."""
-        if image_size is None:
-            image_size = (256, 256)
-        return Resize(image_size)
-
-    @staticmethod
-    def trainer_arguments() -> dict:
-        """Return an empty dictionary."""
-        return {}
-
-    @staticmethod
-    def learning_type() -> LearningType:
-        """Return the learning type."""
-        return LearningType.ZERO_SHOT
-
-    @staticmethod
-    def default_post_processor() -> PostProcessor:
-        """Return a dummy post-processor."""
-        return DummyPostProcessor()
-
-
-class DummyDataModule(AnomalibDataModule):
-    """Dummy datamodule for testing the setup_transform method."""
-
-    def __init__(
-        self,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
-        image_size: tuple[int, int] | None = None,
-    ) -> None:
-        super().__init__(
-            train_batch_size=1,
-            eval_batch_size=1,
-            num_workers=0,
-            val_split_mode="from_test",
-            val_split_ratio=0.5,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
-        )
-
-    def _create_val_split(self) -> None:
-        pass
-
-    def _create_test_split(self) -> None:
-        pass
-
-    def _setup(self, _stage: str | None = None) -> None:
-        self.train_data = DummyDataset(transform=self.train_transform)
-        self.val_data = DummyDataset(transform=self.eval_transform)
-        self.test_data = DummyDataset(transform=self.eval_transform)
-
-
-@pytest.fixture()
-def checkpoint_path() -> Generator:
-    """Fixture to create a temporary checkpoint file that stores a Resize transform."""
-    # Create a temporary file
-    transform = Resize((50, 50))
-    with tempfile.TemporaryDirectory() as temp_dir:
-        file_path = Path(temp_dir) / "model.ckpt"
-        checkpoint = {"transform": transform}
-        torch.save(checkpoint, file_path)
-
-        yield file_path
-
-
-class TestSetupTransform:
-    """Tests for the `_setup_transform` method of the Anomalib Engine."""
-
-    # test update single dataloader
-    @staticmethod
-    def test_single_dataloader_default_transform() -> None:
-        """Tests if the default model transform is used when no transform is passed to the dataloader."""
-        dataset = DummyDataset()
-        dataloader = DataLoader(dataset, batch_size=1)
-        model = DummyModel()
-        # before the setup_transform is called, the dataset should not have a transform
-        assert dataset.transform is None
-        Engine._setup_transform(model, dataloaders=dataloader)  # noqa: SLF001
-        # after the setup_transform is called, the dataset should have the default transform from the model
-        assert dataset.transform is not None
-
-    # test update multiple dataloaders
-    @staticmethod
-    def test_multiple_dataloaders_default_transform() -> None:
-        """Tests if the default model transform is used when no transform is passed to the dataloader."""
-        dataset = DummyDataset()
-        dataloader = DataLoader(dataset, batch_size=1)
-        model = DummyModel()
-        # before the setup_transform is called, the dataset should not have a transform
-        assert dataset.transform is None
-        Engine._setup_transform(model, dataloaders=[dataloader, dataloader])  # noqa: SLF001
-        # after the setup_transform is called, the dataset should have the default transform from the model
-        assert dataset.transform is not None
-
-    @staticmethod
-    def test_single_dataloader_custom_transform() -> None:
-        """Tests if the user-specified transform is used when passed to the dataloader."""
-        transform = Transform()
-        dataset = DummyDataset(transform=transform)
-        dataloader = DataLoader(dataset, batch_size=1)
-        model = DummyModel()
-        # before the setup_transform is called, the dataset should have the custom transform
-        assert dataset.transform == transform
-        Engine._setup_transform(model, dataloaders=dataloader)  # noqa: SLF001
-        # after the setup_transform is called, the model should have the custom transform
-        assert model.transform == transform
-
-    # test if the user-specified transform is used when passed to the datamodule
-    @staticmethod
-    def test_custom_transform() -> None:
-        """Tests if the user-specified transform is used when passed to the datamodule."""
-        transform = Transform()
-        datamodule = DummyDataModule(transform=transform)
-        model = DummyModel()
-        # assert that the datamodule uses the custom transform before and after setup_transform is called
-        assert datamodule.train_transform == transform
-        assert datamodule.eval_transform == transform
-        Engine._setup_transform(model, datamodule=datamodule)  # noqa: SLF001
-        assert datamodule.train_transform == transform
-        assert datamodule.eval_transform == transform
-        assert model.transform == transform
-
-    # test if the user-specified transform is used when passed to the datamodule
-    @staticmethod
-    def test_custom_train_transform() -> None:
-        """Tests if the user-specified transform is used when passed to the datamodule as train_transform."""
-        model = DummyModel()
-        transform = Transform()
-        datamodule = DummyDataModule(train_transform=transform)
-        # before calling setup, train_transform should be the custom transform and eval_transform should be None
-        assert datamodule.train_transform == transform
-        assert datamodule.eval_transform is None
-        Engine._setup_transform(model, datamodule=datamodule)  # noqa: SLF001
-        # after calling setup, train_transform should be the custom transform and eval_transform should be the default
-        assert datamodule.train_transform == transform
-        assert datamodule.eval_transform is None
-        assert model.transform != transform
-        assert model.transform is not None
-
-    # test if the user-specified transform is used when passed to the datamodule
-    @staticmethod
-    def test_custom_eval_transform() -> None:
-        """Tests if the user-specified transform is used when passed to the datamodule as eval_transform."""
-        model = DummyModel()
-        transform = Transform()
-        datamodule = DummyDataModule(eval_transform=transform)
-        # before calling setup, train_transform should be the custom transform and eval_transform should be None
-        assert datamodule.train_transform is None
-        assert datamodule.eval_transform == transform
-        Engine._setup_transform(model, datamodule=datamodule)  # noqa: SLF001
-        # after calling setup, train_transform should be the custom transform and eval_transform should be the default
-        assert datamodule.train_transform is None
-        assert datamodule.eval_transform == transform
-        assert model.transform == transform
-
-    # test update datamodule
-    @staticmethod
-    def test_datamodule_default_transform() -> None:
-        """Tests if the default model transform is used when no transform is passed to the datamodule."""
-        datamodule = DummyDataModule()
-        model = DummyModel()
-        # assert that the datamodule has a transform after the setup_transform is called
-        Engine._setup_transform(model, datamodule=datamodule)  # noqa: SLF001
-        assert isinstance(model.transform, Transform)
-
-    # test if image size is taken from datamodule
-    @staticmethod
-    def test_datamodule_image_size() -> None:
-        """Tests if the image size that is passed to the datamodule overwrites the default size from the model."""
-        datamodule = DummyDataModule(image_size=(100, 100))
-        model = DummyModel()
-        # assert that the datamodule has a transform after the setup_transform is called
-        Engine._setup_transform(model, datamodule=datamodule)  # noqa: SLF001
-        assert isinstance(model.transform, Resize)
-        assert model.transform.size == [100, 100]
-
-    @staticmethod
-    def test_transform_from_checkpoint(checkpoint_path: Path) -> None:
-        """Tests if the transform from the checkpoint is used."""
-        model = DummyModel()
-        Engine._setup_transform(model, ckpt_path=checkpoint_path)  # noqa: SLF001
-        assert isinstance(model.transform, Resize)
-        assert model.transform.size == [50, 50]
-
-    @staticmethod
-    def test_precendence_datamodule(checkpoint_path: Path) -> None:
-        """Tests if transform from the datamodule goes first if both checkpoint and datamodule are provided."""
-        transform = Transform()
-        datamodule = DummyDataModule(transform=transform)
-        model = DummyModel()
-        Engine._setup_transform(model, ckpt_path=checkpoint_path, datamodule=datamodule)  # noqa: SLF001
-        assert model.transform == transform
-
-    @staticmethod
-    def test_transform_already_assigned() -> None:
-        """Tests if the transform from the model is used when the model already has a transform assigned."""
-        transform = Transform()
-        model = DummyModel()
-        model.set_transform(transform)
-        datamodule = DummyDataModule()
-        Engine._setup_transform(model, datamodule=datamodule)  # noqa: SLF001
-        assert model.transform == transform
diff --git a/tests/unit/pre_processing/test_pre_processing.py b/tests/unit/pre_processing/test_pre_processing.py
new file mode 100644
index 0000000000..36394d54a3
--- /dev/null
+++ b/tests/unit/pre_processing/test_pre_processing.py
@@ -0,0 +1,127 @@
+"""Test the PreProcessor class."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from unittest.mock import MagicMock
+
+import pytest
+import torch
+from torch.utils.data import DataLoader
+from torchvision.transforms.v2 import Compose, Resize, ToDtype, ToImage
+from torchvision.tv_tensors import Image, Mask
+
+from anomalib.data import ImageBatch
+from anomalib.pre_processing import PreProcessor
+
+
+class TestPreProcessor:
+    """Test the PreProcessor class."""
+
+    @pytest.fixture(autouse=True)
+    def setup(self) -> None:
+        """Set up test fixtures for each test method."""
+        image = Image(torch.rand(3, 256, 256))
+        gt_mask = Mask(torch.zeros(256, 256))
+        self.dummy_batch = ImageBatch(image=image, gt_mask=gt_mask)
+        self.common_transform = Compose([Resize((224, 224)), ToImage(), ToDtype(torch.float32, scale=True)])
+
+    def test_init(self) -> None:
+        """Test the initialization of the PreProcessor class."""
+        # Test with stage-specific transforms
+        train_transform = Compose([Resize((224, 224)), ToImage(), ToDtype(torch.float32, scale=True)])
+        val_transform = Compose([Resize((256, 256)), ToImage(), ToDtype(torch.float32, scale=True)])
+        pre_processor = PreProcessor(train_transform=train_transform, val_transform=val_transform)
+        assert pre_processor.train_transform == train_transform
+        assert pre_processor.val_transform == val_transform
+        assert pre_processor.test_transform is None
+
+        # Test with single transform for all stages
+        pre_processor = PreProcessor(transform=self.common_transform)
+        assert pre_processor.train_transform == self.common_transform
+        assert pre_processor.val_transform == self.common_transform
+        assert pre_processor.test_transform == self.common_transform
+
+        # Test error case: both transform and stage-specific transform
+        with pytest.raises(ValueError, match="`transforms` cannot be used together with"):
+            PreProcessor(transform=self.common_transform, train_transform=train_transform)
+
+    def test_forward(self) -> None:
+        """Test the forward method of the PreProcessor class."""
+        pre_processor = PreProcessor(transform=self.common_transform)
+        processed_batch = pre_processor(self.dummy_batch.image)
+        assert isinstance(processed_batch, torch.Tensor)
+        assert processed_batch.shape == (1, 3, 224, 224)
+
+    def test_no_transform(self) -> None:
+        """Test no transform."""
+        pre_processor = PreProcessor()
+        processed_batch = pre_processor(self.dummy_batch.image)
+        assert isinstance(processed_batch, torch.Tensor)
+        assert processed_batch.shape == (1, 3, 256, 256)
+
+    @staticmethod
+    def test_different_stage_transforms() -> None:
+        """Test different stage transforms."""
+        train_transform = Compose([Resize((224, 224)), ToImage(), ToDtype(torch.float32, scale=True)])
+        val_transform = Compose([Resize((256, 256)), ToImage(), ToDtype(torch.float32, scale=True)])
+        test_transform = Compose([Resize((288, 288)), ToImage(), ToDtype(torch.float32, scale=True)])
+
+        pre_processor = PreProcessor(
+            train_transform=train_transform,
+            val_transform=val_transform,
+            test_transform=test_transform,
+        )
+
+        # Test train transform
+        test_batch = ImageBatch(image=Image(torch.rand(3, 256, 256)), gt_mask=Mask(torch.zeros(256, 256)))
+        processed_batch = pre_processor.train_transform(test_batch.image)
+        assert isinstance(processed_batch, torch.Tensor)
+        assert processed_batch.shape == (1, 3, 224, 224)
+
+        # Test validation transform
+        test_batch = ImageBatch(image=Image(torch.rand(3, 256, 256)), gt_mask=Mask(torch.zeros(256, 256)))
+        processed_batch = pre_processor.val_transform(test_batch.image)
+        assert isinstance(processed_batch, torch.Tensor)
+        assert processed_batch.shape == (1, 3, 256, 256)
+
+        # Test test transform
+        test_batch = ImageBatch(image=Image(torch.rand(3, 256, 256)), gt_mask=Mask(torch.zeros(256, 256)))
+        processed_batch = pre_processor.test_transform(test_batch.image)
+        assert isinstance(processed_batch, torch.Tensor)
+        assert processed_batch.shape == (1, 3, 288, 288)
+
+    def test_setup_transforms_from_dataloaders(self) -> None:
+        """Test setup method when transforms are obtained from dataloaders."""
+        # Mock dataloader with dataset having a transform
+        dataloader = MagicMock()
+        dataloader.dataset.transform = self.common_transform
+
+        pre_processor = PreProcessor()
+        pre_processor.setup_dataloader_transforms(dataloaders=[dataloader])
+
+        assert pre_processor.train_transform == self.common_transform
+        assert pre_processor.val_transform == self.common_transform
+        assert pre_processor.test_transform == self.common_transform
+
+    def test_setup_transforms_priority(self) -> None:
+        """Test setup method prioritizes PreProcessor transforms over datamodule/dataloaders."""
+        # Mock datamodule
+        datamodule = MagicMock()
+        datamodule.train_transform = Compose([Resize((128, 128)), ToImage(), ToDtype(torch.float32, scale=True)])
+        datamodule.eval_transform = Compose([Resize((128, 128)), ToImage(), ToDtype(torch.float32, scale=True)])
+
+        # Mock dataloader
+        dataset_mock = MagicMock()
+        dataset_mock.transform = Compose([Resize((64, 64)), ToImage(), ToDtype(torch.float32, scale=True)])
+        dataloader = MagicMock(spec=DataLoader)
+        dataloader.dataset = dataset_mock
+
+        # Initialize PreProcessor with a custom transform
+        pre_processor = PreProcessor(transform=self.common_transform)
+        pre_processor.setup_datamodule_transforms(datamodule=datamodule)
+
+        # Ensure PreProcessor's own transform is used
+        assert pre_processor.train_transform == self.common_transform
+        assert pre_processor.val_transform == self.common_transform
+        assert pre_processor.test_transform == self.common_transform
diff --git a/tests/unit/pre_processing/utils/test_transform.py b/tests/unit/pre_processing/utils/test_transform.py
new file mode 100644
index 0000000000..6974bcdbc8
--- /dev/null
+++ b/tests/unit/pre_processing/utils/test_transform.py
@@ -0,0 +1,103 @@
+"""Test the pre-processing transforms utils."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import pytest
+import torch
+from torch.utils.data import DataLoader, TensorDataset
+from torchvision.transforms.v2 import CenterCrop, Compose, Resize, ToTensor
+
+from anomalib.data.transforms import ExportableCenterCrop
+from anomalib.pre_processing.utils.transform import (
+    convert_center_crop_transform,
+    disable_antialiasing,
+    get_exportable_transform,
+    set_dataloader_transform,
+)
+
+
+def test_set_dataloader_transform() -> None:
+    """Test the set_dataloader_transform function."""
+
+    # Test with single DataLoader
+    class TransformableDataset(TensorDataset):
+        def __init__(self, *tensors) -> None:
+            super().__init__(*tensors)
+            self.transform = None
+
+    dataset = TransformableDataset(torch.randn(10, 3, 224, 224))
+    dataloader = DataLoader(dataset)
+    transform = ToTensor()
+    set_dataloader_transform(dataloader, transform)
+    assert dataloader.dataset.transform == transform
+
+    # Test with sequence of DataLoaders
+    dataloaders = [DataLoader(TransformableDataset(torch.randn(10, 3, 224, 224))) for _ in range(3)]
+    set_dataloader_transform(dataloaders, transform)
+    for dl in dataloaders:
+        assert dl.dataset.transform == transform
+
+    # Test with unsupported type
+    with pytest.raises(TypeError):
+        set_dataloader_transform({"key": "value"}, transform)
+
+
+def test_get_exportable_transform() -> None:
+    """Test the get_exportable_transform function."""
+    # Test with None transform
+    assert get_exportable_transform(None) is None
+
+    # Test with Resize transform
+    resize = Resize((224, 224), antialias=True)
+    exportable_resize = get_exportable_transform(resize)
+    assert isinstance(exportable_resize, Resize)
+    assert not exportable_resize.antialias
+
+    # Test with CenterCrop transform
+    center_crop = CenterCrop((224, 224))
+    exportable_center_crop = get_exportable_transform(center_crop)
+    assert isinstance(exportable_center_crop, ExportableCenterCrop)
+
+    # Test with Compose transform
+    compose = Compose([Resize((224, 224), antialias=True), CenterCrop((200, 200))])
+    exportable_compose = get_exportable_transform(compose)
+    assert isinstance(exportable_compose, Compose)
+    assert isinstance(exportable_compose.transforms[0], Resize)
+    assert not exportable_compose.transforms[0].antialias
+    assert isinstance(exportable_compose.transforms[1], ExportableCenterCrop)
+
+
+def test_disable_antialiasing() -> None:
+    """Test the disable_antialiasing function."""
+    # Test with Resize transform
+    resize = Resize((224, 224), antialias=True)
+    disabled_resize = disable_antialiasing(resize)
+    assert not disabled_resize.antialias
+
+    # Test with Compose transform
+    compose = Compose([Resize((224, 224), antialias=True), ToTensor()])
+    disabled_compose = disable_antialiasing(compose)
+    assert not disabled_compose.transforms[0].antialias
+
+    # Test with non-Resize transform
+    to_tensor = ToTensor()
+    assert disable_antialiasing(to_tensor) == to_tensor
+
+
+def test_convert_centercrop() -> None:
+    """Test the convert_centercrop function."""
+    # Test with CenterCrop transform
+    center_crop = CenterCrop((224, 224))
+    converted_crop = convert_center_crop_transform(center_crop)
+    assert isinstance(converted_crop, ExportableCenterCrop)
+    assert converted_crop.size == list(center_crop.size)
+
+    # Test with Compose transform
+    compose = Compose([Resize((256, 256)), CenterCrop((224, 224))])
+    converted_compose = convert_center_crop_transform(compose)
+    assert isinstance(converted_compose.transforms[1], ExportableCenterCrop)
+
+    # Test with non-CenterCrop transform
+    resize = Resize((224, 224))
+    assert convert_center_crop_transform(resize) == resize
diff --git a/tools/upgrade/config.py b/tools/upgrade/config.py
index 71bf17a4b5..5f1f3278e1 100644
--- a/tools/upgrade/config.py
+++ b/tools/upgrade/config.py
@@ -27,7 +27,6 @@
 import yaml
 
 from anomalib.models import convert_snake_to_pascal_case
-from anomalib.utils.config import to_tuple
 
 
 def get_class_signature(module_path: str, class_name: str) -> inspect.Signature:
@@ -144,9 +143,6 @@ def upgrade_data_config(self) -> dict[str, Any]:
             self.old_config["dataset"],
         )
 
-        # Input size is a list in the old config, convert it to a tuple
-        init_args["image_size"] = to_tuple(init_args["image_size"])
-
         return {
             "data": {
                 "class_path": class_path,

From 1471974891b63d628ab11e6df15e559e44fc5d7d Mon Sep 17 00:00:00 2001
From: Dick Ameln 
Date: Fri, 15 Nov 2024 17:14:08 +0100
Subject: [PATCH 12/45] Update v2 with the recent changes on main (#2421)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Update timm requirement from <=1.0.7,>=1.0.7 to >=1.0.7,<=1.0.9 (#2274)

* Update timm requirement from <=1.0.7,>=1.0.7 to >=1.0.7,<=1.0.9

Updates the requirements on [timm](https://github.com/huggingface/pytorch-image-models) to permit the latest version.
- [Release notes](https://github.com/huggingface/pytorch-image-models/releases)
- [Commits](https://github.com/huggingface/pytorch-image-models/compare/v1.0.7...v1.0.9)

---
updated-dependencies:
- dependency-name: timm
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] 

* Update pyproject.toml

---------

Signed-off-by: dependabot[bot] 
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Samet Akcay 

* 🐞Update `setuptools` requirement for PEP 660 support (#2320)

Update setup tools

Signed-off-by: Samet Akcay 

* Fix transforms for draem, dsr and rkde (#2324)

Signed-off-by: Blaz Rolih 

* Add check before loading metrics data from checkpoint (#2323)

Add check before loading from checkpoint

Signed-off-by: Blaz Rolih 
Co-authored-by: Samet Akcay 

* Add PIMO (#2329)

* PIMO (#1726)

* update

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* test binclf curves numpy and numba and fixes

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct som docstrings

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* torch interface and tests

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* torch interface and tests

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* constants regrouped in dataclass as class vars

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* result class was unneccesary for per_image_binclf_curve

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* factorize function _get_threshs_minmax_linspace

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* small docs fixes

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add pimo numpy version and test

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* move validation

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add `shared_fpr_metric` option

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add pimo torch functional version and test

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add torchmetrics interface and test

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* renames and put things in init

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* validate inputs in result objects

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* result objects to from dict and tests

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add save and load methods to result objects and test

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor validations and minor changes

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* test result objects' properties

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minor refactors

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add missing docstrings

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minore vocabulary fix for consistency

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add per image scores statistics and test it

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor constants notation

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add stats tests and test it

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* change the meaning of AUPIMO.num_thresh

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* interface to format pairwise test results

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* improve doc

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add optional `paths` to result objects and some minor fixes and refactors

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* remove frozen from dataclasses and some done todos

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* review headers

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* doc modifs

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor `score_less_than_thresh` in `_binclf_one_curve_python`

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct license comments

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* fix doc

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* numba as extra requirement

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor copyrights from jpcbertoldo

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* remove from __future__ import annotations

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor validations names

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* dedupe file path validation

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* fix tests

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* Add todo

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor enums

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* only logger.warning

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor test imports

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor docs

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* refactor some docs

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct pre commit errors

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* remove author tag

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add thrid party program

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* Update src/anomalib/metrics/per_image/pimo.py

* move HAS_NUMBA

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* remove PIMOSharedFPRMetric

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* make torchmetrics compute avg by dft

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* pre-commit hooks corrections

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct numpy.trapezoid

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Co-authored-by: Samet Akcay 

* 🗑️ Remove numba (#2313)

* remove numba

Signed-off-by: Ashwin Vaidya 

* fix pre-commit checks

Signed-off-by: Ashwin Vaidya 

* add third-party-programs.txt

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* 🗑️ Remove unused methods (#2315)

* remove numba

Signed-off-by: Ashwin Vaidya 

* fix pre-commit checks

Signed-off-by: Ashwin Vaidya 

* remove all unused methods

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* PIMO: Port Numpy → Torch (#2316)

* remove numba

Signed-off-by: Ashwin Vaidya 

* fix pre-commit checks

Signed-off-by: Ashwin Vaidya 

* remove all unused methods

Signed-off-by: Ashwin Vaidya 

* replace numpy with torch

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* 🔨Refactor methods across files (#2321)

* remove numba

Signed-off-by: Ashwin Vaidya 

* fix pre-commit checks

Signed-off-by: Ashwin Vaidya 

* remove all unused methods

Signed-off-by: Ashwin Vaidya 

* replace numpy with torch

Signed-off-by: Ashwin Vaidya 

* refactor code

Signed-off-by: Ashwin Vaidya 

* refactor
move functional inside update
remove path from the metric

* Add changes from comments

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* Remove model to model comparison (#2325)

* rename to pimo

Signed-off-by: Ashwin Vaidya 

* minor refactor

Signed-off-by: Ashwin Vaidya 

* remove model to model comparison

Signed-off-by: Ashwin Vaidya 

* fix test

Signed-off-by: Ashwin Vaidya 

* PR comments

Signed-off-by: Ashwin Vaidya 

* Minor refactor

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* PR comments

Signed-off-by: Ashwin Vaidya 

* Remove unused enums

Signed-off-by: Ashwin Vaidya 

* update doc strings

Signed-off-by: Ashwin Vaidya 

* update param names

Signed-off-by: Ashwin Vaidya 

* add aupimo basic usage tutorial notebook (#2330)

* add aupimo basic usage tutorial notebook

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* update scipy import

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add cite us

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minor

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* modify texts and add illustration

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* udpate working dir

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Signed-off-by: Ashwin Vaidya 
Co-authored-by: Joao P C Bertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Co-authored-by: Samet Akcay 

* Makes batch size dynamic (#2339)

Made batch dimension of ONNX export dynamic when specifying input shape.

* Add pimo tutorial advanced i (fixed) (#2336)

* uset all padim features to make it deterministic

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add aupimo notebook advanced i

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* update readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* modify changelog

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct again

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minor corrections

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* Pimo tutorials/02 advanced ii (#2347)

* uset all padim features to make it deterministic

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add aupimo notebook advanced i

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* update readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* modify changelog

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct again

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* minor corrections

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add aupimo notebook advanced ii (pimo curve and integration bounds)

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* fix links

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* correct change log

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* Create epic.yaml

* 🔨 Update the issue templates (#2363)

* Update epic.yaml

* Update epic.yaml

* Update epic.yaml

* Update epic.yaml

* Update task.yaml

* Create user_story.yaml

* Update epic.yaml

* Pimo tutorials/03 advanced iii (#2348)

* add aupimo notebook advanced iii (aupimo score of a random model)

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add cite us

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* update notebooks readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Co-authored-by: Samet Akcay 

* 🔨 Deprecate try import and replace it with Lightning's package_available (#2373)

Replace try_import with lightnings package_available function

Signed-off-by: Samet Akcay 

* Refactor folder3d to avoid complex-structure (C901) issue (#2185)

* Refactored-make_folder3d_dataset-ruff-error-C901 (#1926)

Signed-off-by: sahusiddharth 

* Simplify folder 3d dataset (#2184)

---------

Signed-off-by: sahusiddharth 
Co-authored-by: Siddharth Sahu <112792547+sahusiddharth@users.noreply.github.com>

* 🚀 Add datumaro annotation dataloader (#2377)

* Add datumaro annotation dataloader

Signed-off-by: Ashwin Vaidya 

* Update changelog

Signed-off-by: Ashwin Vaidya 

* Add examples

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* Pimo tutorials/04 advanced iv  (#2352)

* add notebook 701e_aupimo_advanced_iv on load/save and statistical comparisons

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* make `AUPIMOResult.num_thresholds` optional

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* add aupimo notebook advanced iv (load/save and statistical tests)

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* simplify cite us and mention intal

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

* fix readme

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>

---------

Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Co-authored-by: Samet Akcay 

* 🐞 Defer OpenVINO import to avoid unnecessary warnings (#2385)

* Fix openvino import issue

Signed-off-by: Samet Akcay 

* Fix pre-commit issues

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 

* 🚀 Add VLM based Anomaly Model (#2344)

* [Draft] Llm on (#2165)

* Add TaskType Explanation

Signed-off-by: Bepitic 

* Add llm model

Signed-off-by: Bepitic 

* add ollama

Signed-off-by: Bepitic 

* better description for descr in title

Signed-off-by: Bepitic 

* add text of llm into imageResult visualization

* add text of llm into imageResult visualization

Signed-off-by: Bepitic 

* latest changes

Signed-off-by: Bepitic 

* add wip llava/llava_next

Signed-off-by: Bepitic 

* add init

Signed-off-by: Bepitic 

* add text of llm into imageResult visualization

Signed-off-by: Bepitic 

* latest changes

Signed-off-by: Bepitic 

* upd Lint

Signed-off-by: Bepitic 

* fix visualization with description

Signed-off-by: Bepitic 

* show the images every batch

Signed-off-by: Bepitic 

* fix docstring and error management

Signed-off-by: Bepitic 

* Add compatibility for TaskType.EXPLANATION.

Signed-off-by: Bepitic 

* Remove, show in the engine-Visualization.

* fix visualization and llm openai multishot.

* fix Circular import problem

* Add HugginFace To LLavaNext

Signed-off-by: Bepitic 

---------

Signed-off-by: Bepitic 

* 🔨 Scaffold for refactor (#2340)

* initial scafold

Signed-off-by: Ashwin Vaidya 

* Apply PR comments

Signed-off-by: Ashwin Vaidya 

* rename dir

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* Add ChatGPT (#2341)

* initial scafold

Signed-off-by: Ashwin Vaidya 

* Apply PR comments

Signed-off-by: Ashwin Vaidya 

* rename dir

Signed-off-by: Ashwin Vaidya 

* delete llm_ollama

Signed-off-by: Ashwin Vaidya 

* Add ChatGPT

Signed-off-by: Ashwin Vaidya 

* Add ChatGPT

Signed-off-by: Ashwin Vaidya 

* Remove LLM model

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* Add Huggingface (#2343)

* initial scafold

Signed-off-by: Ashwin Vaidya 

* Apply PR comments

Signed-off-by: Ashwin Vaidya 

* rename dir

Signed-off-by: Ashwin Vaidya 

* delete llm_ollama

Signed-off-by: Ashwin Vaidya 

* Add ChatGPT

Signed-off-by: Ashwin Vaidya 

* Add ChatGPT

Signed-off-by: Ashwin Vaidya 

* Remove LLM model

Signed-off-by: Ashwin Vaidya 

* Add transformers

Signed-off-by: Ashwin Vaidya 

* Remove llava

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* 🔨 Minor Refactor (#2345)

Refactor

Signed-off-by: Ashwin Vaidya 

* undo changes

Signed-off-by: Ashwin Vaidya 

* undo changes

Signed-off-by: Ashwin Vaidya 

* undo changes to image.py

Signed-off-by: Ashwin Vaidya 

* Add explanation visualizer (#2351)

* Add explanation visualizer

Signed-off-by: Ashwin Vaidya 

* bug-fix

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* 🔨 Allow setting API keys from env (#2353)

Allow setting API keys from env

Signed-off-by: Ashwin Vaidya 

* 🧪 Add tests (#2355)

* Add tests

Signed-off-by: Ashwin Vaidya 

* remove explanation task type

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 

* minor fixes

Signed-off-by: Ashwin Vaidya 

* Update changelog

Signed-off-by: Ashwin Vaidya 

* Fix tests

Signed-off-by: Ashwin Vaidya 

* Address PR comments

Signed-off-by: Ashwin Vaidya 

* update name

Signed-off-by: Ashwin Vaidya 

* Update src/anomalib/models/image/vlm_ad/lightning_model.py

Co-authored-by: Samet Akcay 

* update name

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Bepitic 
Signed-off-by: Ashwin Vaidya 
Co-authored-by: Paco 
Co-authored-by: Samet Akcay 

* Add ensembling methods for tiling to Anomalib (#1226)

* Fixed broken links in readme

* Fixed inference command in readme

* Add tiling for ensemble

* Add tests for tiling for ensemble

* Moved ensemble tiler to separate file

* Modify padim config for ensemble

* Add tiling to dataset

* Revert changes to train

* Add tiling to collate fn

* Fix tiling in collate

* Change val. function to protected

* Add tile number logic

* Move collate fn to separate file

* Update tests for tiler

* Add training loop for ensemble

* Add model input size setup

* Move ens config to separate file

* Revert mvtec modifications

* Remove unused imports in mvtec

* Add batch adjustment to untiling

* Add predict step to ensemble

* Add comment and docstring to tile joining function

* Move tile joining to separate function

* Add joining for all tiled data

* Add joining for all box data

* Refactor pred. joining as modular class

* Fix box joining

* Add label and score joining

* Add ensemble visualization

* Add end of predict hook

* Add metric computation

* Fix metric thresholds

* Add removal of individual visualization

* Add demo1 notebook

* Add docstrings and cleanup

* Add memory benchmark

* Add modular class for storing predictions

* Add metric to separate class

* Refactor to support prediction data class

* Rename predictions class

* Add filesystem predictions class

* Add resized predictions class

* Fix joiner for classification task

* Add page peak to memory benchmark

* Add global stats calculation

* Add docstrings to stats calculation

* Refactor joiner for pipeline

* Refactor stats into pipeline

* Refactor metrics as pipeline block

* Refactor visualization as pipeline block

* Refactor postprocessing into a pipeline

* Add normalization and thresholding on joined predictions

* Refactor tiler to accept config file

* Add smoothing of tile joins.

* Refactor ensemble datamodule preparation

* Remove unused changes in dataloader

* Fix metric configuration

* Fix box coordinates in joining

* Add ensemble callbacks preparation function

* Fix box prediction bug in postprocess

* Add ensemble params to config

* Refactor postprocessing.

* Refactor post-processing

* Refactor predictions

* Code cleanup

* Optimize prediction storage

* Make join smoothing configurable

* Cleanup before PR

* Fix stats pipeline

* Fix logging strings

* Fix memory benchmark

* Fix tiler issues

* Fix import issues

* Fix naming in metrics and visualization

* Fix cyclic import

* Make logging lazy

* Refactor tiler tests

* Added collate tiling tests

* Added ensemble helper functions tests

* Refactor for dummy ensemble config

* Refactor for dummy base config

* Add tests for prediction storage

* Add tests for prediction joiner

* Add tests for visualization

* Fix small issues in tests

* Add metrics test

* Add post-processing tests

* Fix tiler to work with different instance

* Move seed setting inside train loop

* Fix pipeline stats bug

* Rename ensemble config fixture

* Add pipeline tests

* Fix config in pipeline tests

* Add training script test

* Fix types and docstrings

* Move and rename to tiled_ensemble

* Fix bug in label joining.

* Remove memory benchmark

* Cleanup files

* Fix metrics setup

* Rename collate function

* Add license to test files

* Rename fixtures

* Add more comments to tiled ensemble training

* Add start of training log message

* Refactor tiler to have explicit arguments

* Refactor pred. storage to have explicit arguments

* Refactor metrics to have explicit arguments

* Refactor visualization to have explicit arguments

* Refactor post-processing to have explicit arguments

* Sort imports

* Add test ensemble script

* Fix join smoothing bug

* Add more documentation to doc-strings

* Remove unused import

* Add brief tiled ensemble documentation

* Update typehints

* Make training args more clear

* Revert addition of no threshold option.

* Refactor normalization and threshold config

* Remove tiled ensemble from docs index

* Add comments to clarify parts of ensemble config

* Improve ensemble config comments

* Add num_tiles attribute to tiler.

* Fix metrics process docstring

* Fix visualization bug and cover with test

* Replace strings with enum

* Improve comments in joiner.

* Fix bug when model doesn't have anomaly maps.

* Improve docstrings (types, clarify).

* Fix visualization tests

* Fix dict membership checks

* Add saving of ensemble config file

* Update test script args

* Cover test script with tests

* Update export warning

* Fix case when no test or val data

* Improve documentation images

* Add images for documentation

* Add codacy suggestion

* Refactor joiner to single class

* Refactor storage names and config

* Update normalization and threshold stage names

* Add transforms independent input size to models

Signed-off-by: blaz-r 

* Make collate function a datamodule attribute

Signed-off-by: blaz-r 

* Refactor tiled ensemble train into pipeline step

Signed-off-by: blaz-r 

* Refactor tiled ensemble prediction into pipeline step

Signed-off-by: blaz-r 

* Refactor tiled ensemble merging into pipeline step

Signed-off-by: blaz-r 

* Refactor tiled ensemble seam smoothing into pipeline step

Signed-off-by: blaz-r 

* Refactor tiled stats calculation into pipeline step

Signed-off-by: blaz-r 

* Fix ckpt loading when predicting on test set.

Signed-off-by: blaz-r 

* Add logging and add tqdm to pipeline steps.

Signed-off-by: blaz-r 

* Refactor normalization pipeline step

Signed-off-by: blaz-r 

* Refactor thresholding into new pipeline job

* Fix transforms issue when predicting with dataloader

* Add visualization as new pipeline step

* Add metrics as new pipeline step

* Format the code and address some lint problems

Signed-off-by: Blaz Rolih 

* Add code to skip test if test split is none

Signed-off-by: Blaz Rolih 

* Add accelerator to metrics and smoothing

Signed-off-by: Blaz Rolih 

* Make threshold acq helper function and add to threshold to metrics

Signed-off-by: Blaz Rolih 

* Make a separate test pipeline

Signed-off-by: Blaz Rolih 

* Restructure tiled ensemble files into directories

Signed-off-by: Blaz Rolih 

* Pipeline code cleanup

Signed-off-by: Blaz Rolih 

* Remove old tiled ensemble files

Signed-off-by: blaz-r 

* Remove old post processing files

Signed-off-by: blaz-r 

* Fix sigma value read in smoothing

Signed-off-by: blaz-r 

* Update stats calc and normalization

Signed-off-by: blaz-r 

* Update args naming convention

Signed-off-by: blaz-r 

* Refactor code for nice config

Signed-off-by: blaz-r 

* Update docs structure for new system

Signed-off-by: blaz-r 

* Cleanup train code

Signed-off-by: blaz-r 

* Fix test script args

Signed-off-by: blaz-r 

* Update box merging

Signed-off-by: blaz-r 

* Refactor helper function tests

Signed-off-by: blaz-r 

* Small changes in helper and engine

Signed-off-by: blaz-r 

* Refactor merging tests

Signed-off-by: blaz-r 

* Refactor tiling tests

Signed-off-by: blaz-r 

* Refactor metrics test

Signed-off-by: blaz-r 

* Add support for different threshold methods

Signed-off-by: blaz-r 

* Format tests

Signed-off-by: blaz-r 

* Change test to predict

Signed-off-by: blaz-r 

* Refactor stats calculation tests

Signed-off-by: blaz-r 

* Refactor prediction data tests

Signed-off-by: blaz-r 

* Update metrics tests

Signed-off-by: blaz-r 

* Move metrics tests to components

Signed-off-by: blaz-r 

* Refactor seam smoothing tests

Signed-off-by: blaz-r 

* Refactor normalization tests

Signed-off-by: blaz-r 

* Move mock stats to conftest

Signed-off-by: blaz-r 

* Fix typehints for generator

Signed-off-by: blaz-r 

* Refactor threshold tests

Signed-off-by: blaz-r 

* Temporarily disable box minmax

Signed-off-by: blaz-r 

* Add tiled ensemble integration test

Signed-off-by: blaz-r 

* Fix normalization tests and add additional merging test

Signed-off-by: blaz-r 

* Add tile collater tests

Signed-off-by: blaz-r 

* Change dataset in tests to dummy

Signed-off-by: blaz-r 

* Format and fix linter errors

Signed-off-by: blaz-r 

* Format and some cleanup

Signed-off-by: blaz-r 

* Rename predict to eval

Signed-off-by: blaz-r 

* Update docs for refactored version of code

Signed-off-by: blaz-r 

* Cleanup the docs

Signed-off-by: blaz-r 

* Update ensemble engine

Signed-off-by: blaz-r 

* Remove boxes from pipelines and tests

Signed-off-by: blaz-r 

* Fix TODO comment issue

Signed-off-by: blaz-r 

* Fix unused model in ens. engine

Signed-off-by: blaz-r 

* Fix path case in test

Signed-off-by: blaz-r 

* Change temporary dir to project_path

Signed-off-by: blaz-r 

* Change mvtec to MVTec in test path

Signed-off-by: Blaz Rolih 

---------

Signed-off-by: blaz-r 
Signed-off-by: Blaz Rolih 
Co-authored-by: Samet Akcay 

* 📚 Add training from a checkpoint example (#2389)

* Add training from a checkpoint example

Signed-off-by: Samet Akcay 

* Replace patchcore example with efficient-ad

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 

* Export experiment duration in seconds in CSV. (#2392)

* Export experiment duration in seconds in CSV.

Signed-off-by: Weilin Xu 

* Update CHANGELOG

Signed-off-by: Weilin Xu 

* Log fit and test durations separately.

Signed-off-by: Weilin Xu 

---------

Signed-off-by: Weilin Xu 
Co-authored-by: Samet Akcay 

* Make single GPU benchmarking 5x more efficient (#2390)

* Use SerialRunner if only one CUDA device is available.

Signed-off-by: Weilin Xu 

* Resolve PLR6201.

Signed-off-by: Weilin Xu 

* Update CHANGELOG.

Signed-off-by: Weilin Xu 

* Keep the same logging level in benchmarking.

Signed-off-by: Weilin Xu 

---------

Signed-off-by: Weilin Xu 
Co-authored-by: Samet Akcay 

* 🐞 Fix installation package issues (#2395)

* Update the coverage settings

Signed-off-by: Samet Akcay 

* Remove VlmAd's relative import

Signed-off-by: Samet Akcay 

* Revert relative imports

Signed-off-by: Samet Akcay 

* Add type checking

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 

* Export the flattened config in benchmark CSV. (#2391)

* Export the flattened config in benchmark CSV.

Signed-off-by: Weilin Xu 

* Update CHANGELOG

Signed-off-by: Weilin Xu 

* Reuse the existing flatten_dict().

Signed-off-by: Weilin Xu 

---------

Signed-off-by: Weilin Xu 
Co-authored-by: Samet Akcay 

* `v1.2.0` Release (#2397)

Prepare v1.2.0 release (#2396)

* Update changelog



* Update the version in __init__



---------

Signed-off-by: Samet Akcay 

* Bump Anomalib version to `2.0.0dev` in `main` (#2402)

Update __init__.py

* 🐞Replace package_available with module_available (#2407)

* fix datumaro config

* fix edge case in benchmarking pipeline

* fix vlm ad

* remove ensemble tiling in preparation of refactor

---------

Signed-off-by: dependabot[bot] 
Signed-off-by: Samet Akcay 
Signed-off-by: Blaz Rolih 
Signed-off-by: jpcbertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Signed-off-by: Ashwin Vaidya 
Signed-off-by: sahusiddharth 
Signed-off-by: Bepitic 
Signed-off-by: blaz-r 
Signed-off-by: Weilin Xu 
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Samet Akcay 
Co-authored-by: Blaž Rolih <61357777+blaz-r@users.noreply.github.com>
Co-authored-by: Ashwin Vaidya 
Co-authored-by: Joao P C Bertoldo <24547377+jpcbertoldo@users.noreply.github.com>
Co-authored-by: Marcus Pertlwieser <116986601+Marcus1506@users.noreply.github.com>
Co-authored-by: Siddharth Sahu <112792547+sahusiddharth@users.noreply.github.com>
Co-authored-by: Paco 
Co-authored-by: Weilin Xu 
Co-authored-by: Harim Kang 
---
 CHANGELOG.md                                  |   56 +
 configs/data/datumaro.yaml                    |   11 +
 .../images/tiled_ensemble/ensemble_flow.png   |  Bin 0 -> 87660 bytes
 docs/source/markdown/get_started/anomalib.md  |   30 +-
 .../how_to/pipelines/custom_pipeline.md       |  254 +++
 .../markdown/guides/how_to/pipelines/index.md |  264 +--
 .../guides/how_to/pipelines/tiled_ensemble.md |  157 ++
 docs/source/snippets/train/api/default.txt    |   11 +-
 docs/source/snippets/train/cli/default.txt    |    7 +-
 notebooks/700_metrics/701a_aupimo.ipynb       |    2 +-
 .../700_metrics/701e_aupimo_advanced_iv.ipynb | 1507 +++++++++++++++++
 notebooks/README.md                           |    1 +
 pyproject.toml                                |   14 +-
 src/anomalib/__init__.py                      |    2 +-
 src/anomalib/cli/pipelines.py                 |    4 +-
 src/anomalib/cli/utils/openvino.py            |    4 +-
 src/anomalib/data/__init__.py                 |    8 +-
 src/anomalib/data/dataclasses/generic.py      |   13 +-
 src/anomalib/data/datamodules/__init__.py     |    3 +-
 .../data/datamodules/image/__init__.py        |   10 +-
 .../data/datamodules/image/datumaro.py        |  104 ++
 src/anomalib/data/datasets/__init__.py        |    3 +-
 src/anomalib/data/datasets/image/__init__.py  |    2 +
 src/anomalib/data/datasets/image/datumaro.py  |  126 ++
 src/anomalib/data/image/datumaro.py           |  226 +++
 src/anomalib/data/utils/tiler.py              |   14 +-
 src/anomalib/data/validators/numpy/depth.py   |   10 +
 src/anomalib/data/validators/numpy/image.py   |   51 +
 src/anomalib/data/validators/numpy/video.py   |   11 +
 src/anomalib/data/validators/torch/depth.py   |   10 +
 src/anomalib/data/validators/torch/image.py   |   51 +
 src/anomalib/data/validators/torch/video.py   |   11 +
 .../deploy/inferencers/openvino_inferencer.py |   21 +-
 src/anomalib/loggers/wandb.py                 |    4 +-
 src/anomalib/metrics/pimo/dataclasses.py      |    6 +-
 src/anomalib/models/__init__.py               |    4 +-
 .../models/components/base/anomaly_module.py  |    2 +-
 .../models/components/base/export_mixin.py    |    6 +-
 src/anomalib/models/image/__init__.py         |    2 +
 .../models/image/dsr/lightning_model.py       |    6 +-
 src/anomalib/models/image/vlm_ad/__init__.py  |    8 +
 .../models/image/vlm_ad/backends/__init__.py  |   11 +
 .../models/image/vlm_ad/backends/base.py      |   30 +
 .../models/image/vlm_ad/backends/chat_gpt.py  |  109 ++
 .../image/vlm_ad/backends/huggingface.py      |   98 ++
 .../models/image/vlm_ad/backends/ollama.py    |   73 +
 .../models/image/vlm_ad/lightning_model.py    |  132 ++
 src/anomalib/models/image/vlm_ad/utils.py     |   25 +
 src/anomalib/pipelines/benchmark/generator.py |    4 +
 src/anomalib/pipelines/benchmark/job.py       |   27 +-
 src/anomalib/pipelines/benchmark/pipeline.py  |   11 +-
 src/anomalib/utils/exceptions/imports.py      |    2 +-
 src/anomalib/utils/logging.py                 |    4 +-
 src/anomalib/utils/visualization/__init__.py  |    2 +
 .../utils/visualization/explanation.py        |  106 ++
 tests/helpers/data.py                         |   38 +
 tests/integration/model/test_models.py        |    6 +
 .../data/datamodule/image/test_datumaro.py    |   39 +
 tests/unit/pipelines/__init__.py              |    4 +
 tools/tiled_ensemble/ens_config.yaml          |   43 +
 tools/tiled_ensemble/eval.py                  |   28 +
 tools/tiled_ensemble/train.py                 |   17 +
 62 files changed, 3519 insertions(+), 326 deletions(-)
 create mode 100644 configs/data/datumaro.yaml
 create mode 100644 docs/source/images/tiled_ensemble/ensemble_flow.png
 create mode 100644 docs/source/markdown/guides/how_to/pipelines/custom_pipeline.md
 create mode 100644 docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md
 create mode 100644 notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb
 create mode 100644 src/anomalib/data/datamodules/image/datumaro.py
 create mode 100644 src/anomalib/data/datasets/image/datumaro.py
 create mode 100644 src/anomalib/data/image/datumaro.py
 create mode 100644 src/anomalib/models/image/vlm_ad/__init__.py
 create mode 100644 src/anomalib/models/image/vlm_ad/backends/__init__.py
 create mode 100644 src/anomalib/models/image/vlm_ad/backends/base.py
 create mode 100644 src/anomalib/models/image/vlm_ad/backends/chat_gpt.py
 create mode 100644 src/anomalib/models/image/vlm_ad/backends/huggingface.py
 create mode 100644 src/anomalib/models/image/vlm_ad/backends/ollama.py
 create mode 100644 src/anomalib/models/image/vlm_ad/lightning_model.py
 create mode 100644 src/anomalib/models/image/vlm_ad/utils.py
 create mode 100644 src/anomalib/utils/visualization/explanation.py
 create mode 100644 tests/unit/data/datamodule/image/test_datumaro.py
 create mode 100644 tests/unit/pipelines/__init__.py
 create mode 100644 tools/tiled_ensemble/ens_config.yaml
 create mode 100644 tools/tiled_ensemble/eval.py
 create mode 100644 tools/tiled_ensemble/train.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 24f95c932c..a18ebac732 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,62 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### New Contributors
 
+## [v1.2.0]
+
+### Added
+
+- 🚀 Add ensembling methods for tiling to Anomalib by @blaz-r in https://github.com/openvinotoolkit/anomalib/pull/1226
+- 📚 optimization/quantization added into 500 series by @paularamo in https://github.com/openvinotoolkit/anomalib/pull/2197
+- 🚀 Add PIMO by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2329
+- 📚 Add PIMO tutorial advanced i (fixed) by @jpcbertoldo in https://github.com/openvinotoolkit/anomalib/pull/2336
+- 🚀 Add VLM based Anomaly Model by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2344
+- 📚 Add PIMO tutorials/02 advanced ii by @jpcbertoldo in https://github.com/openvinotoolkit/anomalib/pull/2347
+- 📚 Add PIMO tutorials/03 advanced iii by @jpcbertoldo in https://github.com/openvinotoolkit/anomalib/pull/2348
+- 📚 Add PIMO tutorials/04 advanced iv by @jpcbertoldo in https://github.com/openvinotoolkit/anomalib/pull/2352
+- 🚀 Add datumaro annotation dataloader by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2377
+- 📚 Add training from a checkpoint example by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2389
+
+### Changed
+
+- 🔨 Refactor folder3d to avoid complex-structure (C901) issue by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2185
+- Update open-clip-torch requirement from <2.26.1,>=2.23.0 to >=2.23.0,<2.26.2 by @dependabot in https://github.com/openvinotoolkit/anomalib/pull/2189
+- Update sphinx requirement by @dependabot in https://github.com/openvinotoolkit/anomalib/pull/2235
+- Refactor Lightning's `trainer.model` to `trainer.lightning_module` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2255
+- Revert "Update open-clip-torch requirement from <2.26.1,>=2.23.0 to >=2.23.0,<2.26.2" by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2270
+- Update ruff configuration by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2269
+- Update timm requirement by @dependabot in https://github.com/openvinotoolkit/anomalib/pull/2274
+- Refactor BaseThreshold to Threshold by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2278
+- 🔨 Lint: Update Ruff Config - Add Missing Copyright Headers by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2281
+- Reduce rich methods by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2283
+- Enable Ruff Rules: PLW1514 and PLR6201 by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2284
+- Update nncf export by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2286
+- Linting: Enable `PLR6301`, # could be a function, class method or static method by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2288
+- 🐞 Update `setuptools` requirement for PEP 660 support by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2320
+- 🔨 Update the issue templates by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2363
+- 🐞 Defer OpenVINO import to avoid unnecessary warnings by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2385
+- 🔨 Make single GPU benchmarking 5x more efficient by @mzweilin in https://github.com/openvinotoolkit/anomalib/pull/2390
+- 🐞 Export the flattened config in benchmark CSV. by @mzweilin in https://github.com/openvinotoolkit/anomalib/pull/2391
+- 🔨 Export experiment duration in seconds in CSV. by @mzweilin in https://github.com/openvinotoolkit/anomalib/pull/2392
+- 🐞 Fix installation package issues by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2395
+
+### Deprecated
+
+- 🔨 Deprecate try import and replace it with Lightning's package_available by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2373
+
+### Fixed
+
+- Add check before loading metrics data from checkpoint by @blaz-r in https://github.com/openvinotoolkit/anomalib/pull/2323
+- Fix transforms for draem, dsr and rkde by @blaz-r in https://github.com/openvinotoolkit/anomalib/pull/2324
+- Makes batch size dynamic by @Marcus1506 in https://github.com/openvinotoolkit/anomalib/pull/2339
+
+## New Contributors
+
+- @Marcus1506 made their first contribution in https://github.com/openvinotoolkit/anomalib/pull/2339
+
+**Full Changelog**: https://github.com/openvinotoolkit/anomalib/compare/v1.1.1...v1.2.0
+
+### New Contributors
+
 **Full Changelog**:
 
 ## [v1.1.1]
diff --git a/configs/data/datumaro.yaml b/configs/data/datumaro.yaml
new file mode 100644
index 0000000000..c6b7c863e1
--- /dev/null
+++ b/configs/data/datumaro.yaml
@@ -0,0 +1,11 @@
+class_path: anomalib.data.Datumaro
+init_args:
+  root: "datasets/datumaro"
+  train_batch_size: 32
+  eval_batch_size: 32
+  num_workers: 8
+  test_split_mode: FROM_DIR
+  test_split_ratio: 0.2
+  val_split_mode: FROM_TEST
+  val_split_ratio: 0.5
+  seed: null
diff --git a/docs/source/images/tiled_ensemble/ensemble_flow.png b/docs/source/images/tiled_ensemble/ensemble_flow.png
new file mode 100644
index 0000000000000000000000000000000000000000..7a5a81fa79819261f77be24d3e74b1dc8cd495ac
GIT binary patch
literal 87660
zcmXtgWmFtZ*DVb0?(PH#?(XgZfZ(3x?|q~?QdL<71(6UD0s;a>PF7MK0s;VnfPh4ThXs$om&g->e;{4dWyB$>Cy9?B
zAjl!)B*ip54Ntq^vJA|#h2OK>LGv2q`61+crSRIdL6z;t0d5~rf%FA=x9bMuQwD3A
zkQCSy-y!k~N2*Vznk%Af3tY{MKXrvAB&7fOb5{E1KXsGC5t`mMIx&H6&;D>dO1HKC
zW#cBtCFkKqcra>*SNdSiItXPNQ1g1nQ0aO6b!D#dOe8oRIkSeg4k6UqWZ?Sjck}SH!*So2`}I{5
zrE8J<<=cgwi1G6qN6+Bf)cSpxe-BT*<=qP_Uk=apOMIhKkI3_3pO^D50Vfum)QA4{$)6ooMw*SU!@zWqj
zyzz;S1Cc>rGt-*@;TNo9U$j5RIo~JRd2G9#crKHmK{xvopkAM|)9N|E*&?7c$D4uQ
zxZ|yQoYqG&{{7nc^m@I4d-*2w4_3$9@(Y{oUmseRpPuAQ
zQtol+c5&}@zp=Xmk6eNG%EtdYN~akd&|wqy;^jn7^wGnFQAXy+?ZuMa!TsI_PXKMr$NxRf%iRT3wh)l`
z^E4!gXxMGVHLm_0Q&sOdZ~wb%<|B-K$DAz$zcSyM#-o2A
zeN^IvnOF!hW1Ltf@vswmSiUk1q6BYs#fBYdXk-Lla7xU|3fm1bZcjGYSrdGCyA%#IdIOa*(PcDiccIii!ibIt-LD~HIw_1#P
z8S-#5cqa7W#QURm=1GwcUq#v_!{^sGZLXcBEW6-1EM;EERC9_LD(&W2-|9f`rji@x
zRC#{7;U;uwNbe3G)tW^NJ?`sewTzPgDg7rj?UKKnv_=0a8a!;9P1CGIC*
z(t&}2OF@}|w0O^C0oq5%OSQG=AP-oH);&aQs8#w)ONVJ9OrgR-S(
z;ei((^C%J9vTtK?#J`*HPk+Ykk-MAp?tf&w1TKy?e{SfUa4^x1gOOx?h&CUnUoH#k
zMZ*YZL)U3HWE0o!+|*wL0EcI~hTd(RU>L(DHa^=kisPrhOni?XiBIyotdSkgf1~+$
zdq|p6vgrwMH>QzqYuo9)@0M9LUZFxff34sPDS{)7G{155uOehpr`kP7S
zHj*vj^imE+Z}J}1&-$9{@?Ms=-%$O@jt$2>b>@$`T75}jDA0e`Qa0xl-Zxjm$Jq{C
z6C314EXvryw5CD@ctZDdT#d+`Jxq08lM6S4ELYCia!FO;fGuamN5o68_Ccsi>%Az#
z3m!Z(uKbLk(j0$So2He+=q&OYeFg-4OyoJQKnPtH768`p-{@qAdif^6uoFx>Lc$Jx
z@QK&+fF0&p~3Qs$eCd*96@;VRBC>x(8^V1Sd@VeP
zx7GFbar64LgQ6yPpzjw7h`nbJ_nR9vx@-b5+%s<6a34(zlmQPE^)d{yBiGJng~c=w
z2b}pplieEJr&`p3Ku?2*^n+`DfmXjOOWLN5kLz@qx{1@TYqFkZrw=crUJ~rA$jLjL
zA@-y|pw4jv^xA3iX#-)_a3ZV^>Yoelv<32oK;xVm9FR@GI!EewP&wqDe&9n$GntHT
z59t%(uS-4?m`+(-;_-#<;Ji3`)NeNg{gda~5&ih6#N^QZ`IPUMHN%Q!{u_{>FK@9M
zd>@Vf0UI6|*c7R;sg{I~f0}Oc=0H#|F8a>Ywf{~lOV$X77cYm7dlf3XZOf^U=SZ76
zXt=B=fc7`;6<7C*HSK1SfGT+s|NAiv$Wy~d09KS&;Wa-g1wePBIAZ^dG<^)JxnoGN
z0lZEqWRqVfDKKYfOtU2tA&3n-4U?o1SA^J9Md@>w_5u3P#D2n3%Pp+C@z(xAGA?5n
z?o$|&V9u0MeSq249#mm0eC;rN(43*|9ocgxR75v(B2NMk1vfhPmW#-cQ3!%0xOZsA
zp8+3+LpY+9S|=lB9I&-@lw@JrtO4&o03@-`Z$9y@hIU2bP3@R9xp`c{yrCz{&l#H&
z78_=FDPMVFV5qq^DXLxmkSD(7q^$pZYghK1Fo&--g_Hx;!$5eEEFJKD*|iV~RWp7@
z#@jbe1#MO)!R97fh)0mM#W6j2qFrg*!F~8WS<*Fas8A=E^#n}e)%<;XVtC{-_eJ&9
zjN8Z1v$*`$mMZF`_~%bEB2`o5!6oT8oE3;IUSow!NElF1OI!I|rMt}5;pPv&)WG%G
zKu%6$fo5Z@UoNnH&FHXhDE=m>hMrZto!|7raZjhkH7YmJKHP7A96ylMc8M9)WM?-y
zA-VRt6B%VGT}=}P#qB8bilxl^eogDmEg6&0TGQsc-|{MiHdWY6!qMSqI_XC{
zK0G?o8jL3o9>?UYZ@06eLp{E;0c?L(6Z;cA3o%n&-APXez%DYOzQtLjxQt00_oh#g
zM^L3`qNcNfPV*7!y_dA7h9>b1aw1o+N=+QKP^*C(LBxJ3=eMY@&QG|#r$iM0JpO_9
z^c-Ihnq*2*Dkfq6Lt5N;;^v`KQJn<2>CL7%Ot&h^m!jtAntYpE2wDxf#}ManTUb(n
zV)H8(`XzfDtny%iHC1qduW;!G-lP$0Szh6qH8uFHb{n<#X;jL=L~2*jPJ~@fi3$CJ
zDo?_6CEAo_C8#Tqw}E5)D;ZvCg5?L@k@5N;rEyW_}%)dN94^b
z+d%8%XN&2+k5kzLpii7dfyNN7X1L~SsQo~VFM0L%m9R_?3<^o^T&|F4GtsF7xy{8b
zGkvIOzRj(M(d{~jZ`n}jsPe5O5{p}FB@6-|(Ik>h=uTz90s-Eq)DJIlM585-Ij323
zC5r&?`#mz4YZfk)o;w=O^-aphpZA4ai{3Yw{(Dfz47bP--;pSKeG^U+RxLgWai)uc
zgv+FxHeh{XuD9pZ(xF=01kf1;zdPN1Uz(ZPf#X-7q{Pb0_AXs_dY
znn6?b>9-O9s%Rc1@Ms>vwE9cf;ja`KbdQS?Iq@ccrh-
zS@dlgmWo1uv%NdM;jt}9CI6?mI&S`6GzMCOS?ByV6a@r8>AgR)%qg=5Ui%#7^p4$Y
z;3;uCQ$1~O8HqFJ&S3jv!)SL})%D(M;3_o>#1>I3yM(wB1OR6I#k@q)Vgno)8(#~sdBIA07o+v?gAJ1-(^2TzKzkk?rKI}VK%
z-Tu4OBjDUd6@`#ux^fac8yk2w@X|o}^>4jUXq!dJ%7hQyD{hMhPLq5Gc{MdP#U47A
z#iO=CmbreomN{Ou-Omd(ChUe*GnRQsgZD=mV00%wjXwSsKI&rMz!9>f
z-Ksv3XcR-nSLaMp&9XaTU=ImT3H-1fA#u`g{yl{?cuS~9%YVl1x2KHDqiKoS5<5>C
z6sUKLOp@=tJ(&53zZh^XpTBh*^xk`P-;iW^ta~k4WZFp^H9&j5=0G^yUC^BfbsF~p
z?7*}TmtLu4Uk^%WH-33K$c>*fM!JTRBUcPTdhDrr&omynM4EV@RirQ&s(e08
zgL-!nAiWA{m7x%|;I1gzp@YA|Egp3b1z)%ZCU`TbKtIy)e@%W%h~XWAcx^iK
zh&9d}fItyvTCRyj)#a{xUy6`+em*K4{~mgvY;*vFv~T)vF$mQ0{QFkRuWY_y%|2gQ
zbb|jmibuY-1Wyu+KAnn1u|R+SSy}+>i;~m-SsAIbR7MjO(LhHv?NZK4!KnMi!n8$~*Nq#OTt$
z7LIkRD-vXi)&IJC#iTfELZS+Cdl#}h2F+|JwiZ_D7wc*!88D|Uw7Ge>rSJAGi4QfY
zr5H6>Vj@~Ao$wZJq48UQQd!uNpB{Ny(qU^ZH)87d+b#uXT}7VR8QWNq_ry-&xQc6L
zpwj#31=FgltJMN0{MZc~zQBNDLrv&%d;$Fl-w5Lb8(2Co0slE(?OWRvSvfM=dVFd*$p1EQdgj;0#Y@`>4mTFxzSkh<&|69Ce~u%7+P;b`ua6~o6JCKj491mapB@K~
z+P7$NZQ?i#OdJUrSt99R-iD5NWZEXIBRhO&GjaLiTE;Rqk5Z;r@2FH`CmTjMn
zmv!F5hm;!MJ+2pm4v4F{Wy{=H7XPd0$ElCksTn(!#sJa>mnore2~
zzUE+OFStnGlp(k7htX$Uix(Au|2d5(3-PrE)3ZbVCsp3**@?tNO}y4I_9Yy-%G4ge
z-6lEtgtjp$+QWb!K-*raL<
zapaj()~tOyMO4y3A%JYUiit#Zq=s~A&d{=N$S$%4-RbnQ`56S*+9SW-%H2mFnsAu2zu9pZL(r3xpH?Kgc`v>h=BpqD`PB9@tUy
z%>EBFcckm@oh_&c5&D)@0-omuHJjLn7|TMIz%OXZmM4#B?U^G_+u7K;$2!~
zvEy;Q*g~{_G-1q;44}&tqmVSbxZ@BISW$hk(#|rd`Q9hZQ!<7cMV-1#zqnc8tZlbL
z5@#-$>uqj4*sjFSo;1c(-7zjiF%0ULY7=W6Oj&RMdMiKb#_R-QAm~c7tbsYRzaO0y
z<`6^Z)r)gd_5^ooPTb6}MeKU{A4W~7$>~rJye^f`%DQ9>PR?krT5=-!gWLPZWYEp1!vXW0m3hIg!JeQ
z#m27pr^`DK`%7Xn90k9np;FxJ;_HS*+>OB@d^`zqF;whAkAo|ztxa?j+6-+#y311dmKM+>jlUmcGPw(eRXnOr#aUY`MJqV-#3!u4sg}r*KPteOi0l=LU5-zab
zxFb>ZwDF6|+*3mht8+Hh%KynN=Mf6HlXa6&p_lEZMZ;+D;OcZ3=`>NRuty1dS2-}R3EAEE~B8iq4L2okvuL6W6-e164T=NgnsCTic{nOpp7RASKU
zP8GC!JiG$m>zuwIb^sO+w1}e;XhQR~>f>&-SipFpX6fN}T8M0|$uF!uB{xc-VhmYB
zKLeBUrY0HPNC!!C9lY8J+rAxnJ0d*-&q`a7oR~eCzI!LS>><6}Jf9?)P_$G03+EFPpEbkgFCfo^D$skJqfN;ZUq}nkNpO%BL
z6~G{l&okG+UXKdF(CauDT$P@T9M-dBPioTt&0*uKx&q
zQRH}gSD?=jIj(fVXW(u)5}TTW))e=_DQ^
z;Nr=*&vC&{;pA$g(h#dNZ5#(up_xpKFQ~h$J=x#XbnEpKeDjnbQX<(e5wD!W|F2>B
z4)at7#?3gf289Rz8?(0pL(=`Mh*8-4=Ld<6Rlh~VcA}uO9==zLiTWcxtHIX0BEi>X)9k@D@o%JV~Z(s=_U{7ruE@taYMS#>iijfmR$o`kskuvUDo1710
zDJMc9dzNh|cxxfv?v$?*0mxI&p&0LV(ehCys3#v4>eSZ0DW
z*MwMum}vh+{0eGnL&0m3*U_}|*WTm8+3AExEh}%}7fRANL;fCuW26Eqi`BY`@yNjt
zzxD~%N2HKjV1=b9p%h|gXR_xOYuWL1#L`9X(UIg;vVdQX{cN-G%OjS~
zGWWt#g1A`lzCP*z)voBlmi8_q93Z;#6;t*v)R#|MnwhUhKj%?<(Ew(L^IM+ygrvc?
z9R-Q_x>C}jKQ|i;A810UaYD|?p}|QREsbFP)HsTu@;&HAH?1GZW1OGpDg_%>n9F5>
zk6XL1V`FGVSqZQvz7dQxJJLy`7OD(d(+h)${Hiqzu36AsYX(BvgQiO5dzIJGg-Tz4
zkk31X-+JO)WC5lK+uPfv5Ga~Lhx^^Pyb@a`5SyOjD3H;~R%;ee){2JQI#jDQM&{&x
z@w;ihKD`7h@EA-aCfO_*hJcODC-4J=9lfIf%96-Wy1ThBj7*p;qdOxqt|^n|aJ6(8-G
z{J{M07Kaa+3`_Q@4MK_J&IN&4qXmhI(1d#V$}v@O@i_d-t_GR;8H$bTD}az8t>r~<
z2An^>83r^gA7cT0&={nt3cB}-vwNJc4mlSWyLX39sb8s>r$$z^yN2(C`Ku%6E;o9K
zDa--smUpBcMInW!79r7_J)$Nit_b6H2?sSacU&`jZG$r-3P1k^l7^)|(6b5F#6Fk{
zpwIu~N4Yry@gR){A2}osD$
zPo7;4xV_~utA5r+T+>Pti^zmuzIW!LZb#y5BETKQBs_#b>fWdHHPaID$cbdL@pLd$#%(Ws=)
zuJ`KH@zuo%qQ)Yat^bai+Pz*cR168OYpu!7nr?IdrCISWxc~X9K3m=DFC3WCeJME9R7H&N6ofwU?-FLHuGAR6
zCc>RQKUPm!jrTP}2n&JWQ&$v(dVQi8F%bG4w!XMZ2I)dfq^hJKl4E&X_&ExRafVIx
z@L0T99}~yoPBqJ>jaqf`tQON=GK=_YLebDw+w3-9LI;#<$9VV
zD`o&srJb7}pKnPmKUxp_k*3S7lI$kh()DTG5)h2(IB?56zn1wCcRB$?q7oQ)xqK)u
zY{EPJj!``Qjthv*IXzvu7FZsLuWzBeOD!8oCK9M`i=B&sl8tT51|9$?R9QZFVp77t
z#;F0GL7%4gHeLII$I;O?9x`6?!TD5}B*9b-YOg_@uX&m?)Yb++R7TvBhOKo9g04Ef
zL~ckIMcIqAg4S=U^VRs`o&)&D2b(vqYCk`g*3=9i^6^IOHRPQWos6GX?{-g)x)?qL
zy&a2kAp7n7rP9^Rd&xSf?V2+#2P=&2EpxQ4lBx`hsIJ>h-}xw({&A)7%*?FNzj^$D
zTjm}rk3&Wzu4qCJ9DlNIQV|$I&Wo4GXQw^;0fbdiv^qf5s)F+qJ|)A3f2AL)HV;`N
zQfYX-ny_o#74Ny@c6Q4>Jd5H*A?1NIFIMO!8rZ
zXQzt3;F{Yn3|LYrM8~xxv|>3Fo0snn(XNbqO^~~ib}-d}x1}f`eDQ@4IO%mZ_2hH-
z!B7^AdZ1%HC+DXeJC*jEUn?CGHP{=1(ZmAgBB=dnXIb(?k~zSv50xpD%6#=HAkMlB
zjQw%l{t7@v&ZI`1p=agzJGYz&k1qZX-nB_>(wh}gqjm%P=$zTI@CV86SzD-U+wHLU
zt`*a^`B%Tn_KOArT}-<1PsA|`>8aCIgz1a#rMkhLEs~1
zP8VBgwmp%BuY0LgseAsYVY2%Vo-w~^f0{6yRa_?YXADK#umNp>V{?Kb0BHn@R0L=<
z{NwzXo!G_Dft1J6Xf{ZH;z8|G%JdqDgFm|e?oVa-*6j_=AC^b)9_OpQ9Z?x@t}H~v
zCC^HuabWk&`!2~A>k6lMLm0BZB0L16!!mfHiVJQSREH$T+VeL82Q$tm|t3>U0y
zg~b(>DxIKYT+x#r06`Q)hRAEdq>`uq9S5Ykp$&wmGHM8g2AyKP#(qkRL^TYdn{wN9
z;h!m1&wj&qWWqH!SVR_Jn6_1vUu7>yY?AJQIbtj5CPbK3X3$Dh*
zvZ6X}@C}3gvFI#AAF7#eVDZ&PDc_VBAIZ^2^z=8`I4s%!?*+g#V;7|hi;nPPYs6fn
z=Ln48GyX=lZ#)Wl8Uq8hYkgp|TCeR`@A>ZQ`bhkX778B~T+>M;8)&jpvV|3@Bcj;n
z?hT4XL7&GPZ#}^qZkoR^`as?AL_33M-Wa(tO7p9UZ0KSJ9WmMJ=Gj?O(`ESr(CZi!
z7`q#7hHM;l$g>s}k(gT{vWrHQXLp}h|JVXR)`PjAp3T>re=tU#3E@6pn$2aoEc7#q
z$XZSDWCt06%n_M{a&teB-S4TsT_EcaCAd~tcMxYSd<6!eUJ{S_Q=r-@bu1|Ju?!!I|oNfen0|9Jr_^wb+0IpQ?L3Z
zw;34R9%fP(dY)r1^y`4ep`k`P`Ep
zX0#1IyY9@mRaB4;Pb>7~I_g=Q`|QW%N*DTn1PwT_ch8u$x8d4%?UG-$>R~7`ECx1U
zVN_JRnHkI(7XA8-%Q#xesW;M|#r11$T)JP;)PY|^RJred+3weEm2&&h$~(b0ReY-8L%J+p?%Ed_dd3~
z+aNDGu>F|vGnNq$Ov2Cea+tbYV}JV-)m`BdzgASPa{0%RN8T~%ohjgU$#-h#n*h31
zhnEVmFN(wAI!zY_^q=K@{j9~1SX`Jab4TOvxZ=4Pd7hk&!>t(F@Ct6)3;gG=Pjx%J
z?qEt+x8G@Ak_FTAxw%!#J#iKAOAKwiH2{u3kowhZAN1Ib0b}TUC3Q%xO|!215_64)Ba)yi6+<@!l3uVHOtKx1te5ghA}MhWSFF06n;%s|n#ZFFsqCU5s&Y
z41+}UmC2A3)s+)d_WiB&-B8m|!UN&bq2(1C4C@F#^=GrJJdW@kyft@u@gsiKkUOHH
z49as7d@(3#+OOb%A_j&QWEG_ZIA6THJVWn3oszfW5`P;>S((@PGAJ$E`KnWP(5;yF
zBj3BOe!|+fnGX(v_*O+@*=&71W!_FH{9C?4ybRb?NLk>5&F09>wDlmS_P?_>2=L>nJKW-Y;?~ch
z3_w*hh`i&9?)5bXm=svACqpk6Y)VD|Ip{Zqjx
z%bUY_$fpbW-bz|g{}!Gb3(l?0UC-ygxjW872{kE7{MizZK+1pMv(YE_If^!tM5B)K
zgOmCoDUl*f1xReF_%jK@Vd#=YDs7XK?GC!2kiTRMWWbu`6D&2Z?v|oytl9Ued%{eu
z;_JkZ8m7;3XRK<+^Q6<0b>gTzj7Hl*L~M=>5cjr~>qFZ0yJIDN_Ycf%8r|1~*c}AE
zH-H^V=vE%Wad=t8BMsD&N(M|>krWfONbLUJgJAMkpbXAi{{(ZX}be*>@UeLr~ZbUElUVv8Z>rX
zt24RkVq#}|5O(Oc$Q2%c@&MN9-L7-V^e_}7LlI1y8^SGEx;RS5@1``7DZnNuP%kpC
z
zJL$^li4Q)TQx-7jUV?&x0+*JRLcb5$g|MRuCop$fk^XfU8N|##{}_oVt|iNjQxuWCY5;Yavv^7B$hJ0
z@g8VTjnHI9B9#nO*pe8=sES+#PEp`xg%Ai2qQC@e+9160wo(UDZ&Ja>$ol3%;lSl$
z>t%?tI<>8hI3|8FlBNHYpOsF$Mh3kA$#_CsWR3e<^{b+NNSGcidMu4Siam*>Sd33K
zfzh)4uC(*LO3o0gAXC-+<*Fk_0RMB@mzoEQk%VgGc_;GB&v95H-WZZb9&V#nwtf^6*oNmHagqW_LwoN24+-$
zn_sgvaYj(PE6E*vDq3hU`}zCc)y}gYm~Xn)rR|!W!If8cK3YsGX9ZKKoGLrN>%W9B
zAZTvqD_P7}jdbI^(fjFzwPHLH60HB(&5=JiffFxsW!9B&qw{4#@ZdBL^&Q*(0
z4EuqB74bU_PXzNwv%*nm>^-?5QoS7t5Bm42*J{Z7;ZrL@+|iQ7YXeR8|+$1
zU#lTQ(l8w54SaUpM-l0WA?Gzt4tOy&9wpPK@2UE*5(kkV`_g*4em!P-7W?n38@`TzP(9WMw46TxLwtAVA!pMAd
zIgwFQ6p~e+iL^|2s;BoVmcEI7HtfOHovYHT6RLYjFwba}K5fO|RZL>v5_WrEXVseW
z>c9oTqF~Djgst@5#{!&8e@T&l{+%-Yqu`6gvK$w@pd~6VGFS8@RkyyuQW$1VlKnt=
zz_xvVSGe0i+rdLSGbGM}s4Bx&_XlrVv44;7)XAMe%a>)t4cybpp0dVXaBb`9#~gII
zP7@VjMC#4=X5kv3O1IV7kmg0=~DPD<_qJ$`nY
z;L*>)q2^tQFrv~KG11PWT(z*i<8bG^VG(NyL|tBX}PF|5(*
zEF#*y9<>){;>u3GoQ(&b3%cE4&ls3%a6iQ(X-WD{YMwxYUR-{V>hu9U6Ej^ew(N`%u0g5>+OLxU;sMnGo%J
znOY?zJxHX)6rpWpdjQhuGc3a$IAt)QZOFYQXA}-2VEp1{H9twqGlq)~PS53fCbcai
z)SBjHB81ami7`*YcjiU2&j)$YFhhY0}^ckzWzTb|!!nXoq#==S3l=bfkWyCbx)W*y}52P|me>
zPE(*!qoxluWB(-eg(lc8s@m#GCPAX-=%+?xy(m*Qx;i3^RF>d{p8dPioISM!V~)mM
zeT4(Z>f^Kv@9UX^7}#ZKn=nV5$-za8+eLjX_<HZlL-4iC_v&&z-4tBu
z`YcGn{XI5Fgrn`NaNr&&IF)W44XBlg8Iw5U4sibG^F6$yoS*Ucg~qxWme%@`!ju9G
zg(O?1I5xhKN-ZShBpzVpp&&?KZ)afgERnF^1CqoINEHWN(d6b7x7;U%mCw`i`v-)uzg=b<%f*wjj(xO^x(ccM;sy&w3m5(>RqzDl=HS#g78iPU~P9|W+FtBf*tk1@^D#X=RBKIn1
zAa3$j+RWE2D@d3qkdIeY>Vv|Y=s^Ep5PQ1;u1Xs5y;J}ap#7k$@r*cCIFqy_lMCo2
zamzIUHl~a+wKCJ>wtT^Hy)sQ&GSw9dUoM~#|s0
zY?eU@eF~i_>k4j2llAu^bs&xWK
zZZ2;`guB3WdAkxhRQXTRsY8)L*OsY79G;r;t`KvUeHr7(4&uUw
zO$tE?5^gi37PJW-;$_tZBr!?KARLJ&Ek)H*p3FSg#Kk0wHR*qmjiYBoF8{WW`D%wc
ziJ4es!ICx2TP^!Lowx82_uX@?PN^d?>j8AYWvYQ11ec=|7a(H8@(+~mzYm#5ESLpZ
zp*D`vSeCOX7N@89c^M|}CquK2)=4!7K(E#@F-tAxA4|MP041<8G%e9lr$ow$dR!*&
zFV(FsC5#=s)wB_|GWcNT{#Ms5H_9T^Ku3&guHK9%>mEOx%&O4&EGwJ))ax}ibj3Eo
zNcY{RTLwt6=xflu{an=c22$(+k_8TvJo>!S4TLpqiU{y+W%?{r?|
zhJ%rtn4VCK8ZtMZ9o@_kU5>P+d^{aFimFon;Ew&rL-Xm3qIj9pD!sLIcnUAS>*YH+
zKHkAkK~q}BXIE%8ToY`?k_7_}P13xPWs2?}daboS*wEmGR&s)>zdrsJ)+(>qZCKgWHDOgDC_b&+55Bt8F-0?sEHFh
zdMw|xk#JBX#&Xb>?-$t-?D6R#s711kMxxP9P?~LEn~5d@ns5g|MC9HM3=f|KBsA;f
z)>t*om+_K%CLp6G?oWay-CclFv-_1hqR@<<1;dD|bb2`btuYWc+mvceQ!?#HH!8OYUd|j?z)f1MmVn`sSsu-7A3Gy`O%Nqj&
zXQnM-`2MyyTfKtX%jaYp(_cG7sflOHB6fuGgP5sIZQg~2iFsl@ADPJkX1sma6MVfj
zJrDos2~_e^ZCY`mdO(o1A=0EV{?d?q)fT+MPkBbs8QMRa5xOMln;2H=Qwc>(83)FoCG@EfddwcQ=xPlF{u*hIU);R`dy&PFWJ>VO;OvF(N3*%77xizl
zT%EWr`9Pm3Zvn8Lh;m^baJrJ@+}!k2?mc7w73S_M2x(%Z1DR1v^nKP*=M$MJ3L!61
z)~Ka4+zz25^$IeIu@HZM=&$02--u0eK(3Vbv7ayaI>O<*`~4w>H;IMh#Lej>u&p=y
zR|rW&Aw+VS#@UnKTy-~593XMHfBqfDV<;uYu`g8fEyDk%RfE_D=zdfAh)|w2bJysV
zG9DU(9uS159&xdhqKo=$whGRPN(yz%xIXKATxv#c!3Qr>Og*i8;MmMXS*ag?sAXbM
zoug2a?Kw;371Y$ArI;*B2GaR=q}WKMXgLod-2Z@Y(@iRe*uShb?EM}}D!w9FY$5p*
zaDcGz&B{vqO?+W_7iN5eo{*D6ik85M^L?%UGFi`m7VJyGG|`v0*M#r04LHF;IFC<@
zasQM!Zn{p}-^~O{p{JM|zJ$b|jnWjK`o8a!CF$VZm5{R?{z69+?b5<&r9HF|NT#ba
z8x8d~VZ!jaCE>e(-6a_3QVUNC5|(nW$7I6(?N_=-*oWB1&3JU@9cW7n0h)jxTpt;8
z|CjsR34j++NU*H@uorqD|3_g0^$u;f-lbi{(JQ+!UqBYB9nbg*9yl;S=_*cm$&4i2WPe1e7tnjO6KXm>#4B6L;lD~##=N}WP@KMPt?BWH
ze)ykSey&>7vEH!`dbqgtD1=imKoZeAbK`EeyjbR@Q`3K!5e)cf^L9VKRx@2#8MAyR
z;K|SdpLr41M3e1?))}-IEE^iJo`RQ+u{wJJM=nV&dJ-NUHCqpW?KRwMn6BUQm6Q8Q
z3-iC7W$3Ae|74iOD&eqXjvj6OInv)5F&52Y2rP7Ws=VFXEAL}~Bm3JZZ`#QlAN1w+
zySOq-NcXzopw-EqbZ?Tj_7(4;!XG>*0bfFdL1mE>U{~iZ4hqsi_KQ%~Y=KphXqE1#
z^iaXHZDB176eEy!K7r^#n@(sV3yXdCJ~mvAW9X9!j$M)cs`%sVu4u1gFBOWcUk~kZ
z#2~y!?iQD3l~Gx$<`qo>H80NB%wCRb8eNXXwLqnASp;>5?x)m}HCfd6zWClTN2fjV
z=K+4)Tt8^AbJustr66>1?r`|QwPQ8rJt!*r^ZgRCu7x4dL&kxsH3z^agL^*jl2t+KD)-mU^}gGEjB^(
zugli1fxCSVf9s*QMKAg~Y1fTCC!{}M>-d`L23TXRX_
z)E=uHKMy-YIHG`RHzO(-584zm{hfMeV~}M(%i?KJQ3S68orP}qeVlbdoj3b7inp#0
zIsXA3${v1Or}u5AX_)hK!Yk+rE$T#{l&~+Rn(6)QXUn&B2R$q$%&})pGJ@zS=t4P4
z_!77t$R1WGY#lBB2-&lQWTXZ^US7^Al&2J|UyR4X1hR)>wpKjC@Ux#9cS8mp7xu)J
z*%&|(4XDbnYMnO6mX1OVjy5Fm4Mmd#nvX1)}iYYZVC3bS@dEsnAISB9S6a;We&`dEc_TX;X
zCWlvtCL~Z~ZZu2QKee?B95)}}0hxeUBb91;e@`X_=1d|3$yO#X;7h~>n>3MkuiIv9
zxUep+*I+ovYYA@ElW>f6i)lv8AdrGkEd>uJCa!Ik-gg>B+)!#+k8U~T#pBuVNAngWD)rmP0<-F9cfYWNJhI4qAJ!aR?De92#W$(l_Len!RJU3NW2hnX@!=x*TnW
zSgn9MJGT}HBrLy!1ZC~1nZMj}Oa@QD6;f6yA-nP0{keeW?0(1&5TmnBT7^<3$iRcI
z$jJg+Ft`$cbTd0Q5b?*vuCnrXsnMoFAAW`fP1jN4tkj85zAKiD-&1Mm%ecDsRG-+enERuDM%nSrKGBlzr*>h(5-+%44`GxNky1p*_
zdeicb0ako8_LV>O#!p`~B{Yp`n4`?;hCfPs;|&+|Q?28OuN)cD1LMR6nTJorAeQIm
z%wZw1PuQFi-&Y2c2oj#5S84gP8?ZZJugeak6g=~wQ!&Y2?tUvzwc;gQd^-5C)Q=(p
zT#wz|*SqN7WE`(`EeclYa&YK0FXhPx*NGXD7s^-0rjhXDb2K~9AEO9&+D6Rl3AIbq
zjxmF1f{35QdBA6F=Z#`-#3@UtRmCvXa(Q(fYh~Nft@%3FcR%Vck}SlNxW(clJ5{zp
zSd-kAA>KaTu4mQSg6ozY=}X6>l|YxMm-Li?LA{n$IMAOZud2KbirC%I%x~r<+B&JK
zrmu@FX#MZtA`KTanvzKAIL!B?yXmEinIK6H%qS9`5TdA;Lng`<0AqtNo`ZzX{MH;ZOq2oQtl~V9$H%y?ByT
z4DVTwzrk>nxS4_`N_OaXkNjM2HGlQyGW8|Yoz8kzLlhrr5>n2{sOB}5U?`E!%Hj~u&&tkYUO8^T0SoZ0
zmj^OV9W}WYr@9pHM>$#I>=3*t{TP*J+749mBk*5yDD67o_DIyn7&0{AI+Xd_Z!2!x
zNe8mpHCcN1F`<(}@K*!=@4EojmiRN@*pVD(r2ZA()l(LLuu_`92Ja)HQW&ir_)sPD
zNaN7Opia%;v&z>ZiKgOo!w2kKMO7iwedHi~8cMAS-5SQ+0Y@k8#mL3jyb$B8#YN<}
zKY=le*<@EOniwVUv2(L^pYK?
z);(0Lw9^)BvCN-=JfpsL3S!(**;?AMkuC=fK~N~k#MZ4#C1;p)F!wjQntrJdh+;7&
zWmp(>fx>(jmGHFZ=s*#^&S@%LmC~;qJvV&nHNoIUrHR0}QD{)b7^Bmf!9hrX1BYp8
zQ^+|iVDv4n10k=9j|4p%zs2tX9jrKu#-khEh_Nk*A@xxc%p_!@LKxO76T`d>y&N%I
z0%-zC`zKnjr!C|%L0jJ^y>y;_xe)A}n_7e`Mir&snFR%|dQYfQ$FL3Ohd!;O42XP*PDdrn#WG?2FKoT(L^dfbif|Iu`gVVQp4+pjwtldY*H
zo0DzZuF1A-+qUb@wmsRlYnrBd?(hG1Ja4a8*Ku8Y?X}jqKkM8>xDXJ_>*53jsFIIb
zWL3x?V;y-WPvm8Tpw29sCM?TXqNG*TVKw&fa3lNtwO+vHS2xUqYW&A1DLtVu=nQ1p
z27g8xL|p*3AQTSXBshMSh6uig3gku8yMJJ4F31ZcLjx6fpAprhY*(q9y1KkoXUGLf
z73q-c2mif2E=Xn3o$X5w;1t)v@yL1^t~k68Dz2CT_Ve<3LuiZziPFgpNw|s?=N!P~
zQbVrg=Y<2xD?iY_QB&OK2Ji;9O6i+GapcBvrn;I;me~ytEd~|g;9%tyT8%OzJ;#Yf0eICFkW<_|kr)z8TwIpJN)PVH?B8wb
zEM{a+e^n7?Fq_~-k&6XF0Y+JdG`%{R*tiO`VAWea2_+5gb;lz9#ym%EAtKsuskV4*
z!!daNtQ+FT*iX|Lbq1#M`wOVgc+6Q7<&`9MJMY`?#l`GZxZ6Z4{HyQC;IQTRPl^^W
zTZA;Fpc5SalyanaZ#H;bnN!g~eyKP!MLAh+Hd!=uD&TOc`-t51pIofDcd}Fjx1MvM*@OXG1k_5a1~&dSNPzA5UV!
zHAEYq94Haz72F%Rl*i*7{||D#Ui}Ku=j`v=`HA0UD}X@NS3KWjxfq53iM16G2IfK*
zbmQOAWSL?JnS-Zw@yR5t|2cY$(Nyx-bSyjQcKU{gFQ#oy87Ro%xtGVa*=SoA`LDeL
zC9`=Rb5tEuH~4N1(P88(j!=)4(+O2Iy8Sf#u=Zz{crANyIZhL1e*KB&zo
zhaE>4qd7fy3|L!`=E8%w?aac>`fiV3g(Q}jg}d*6qzhA{*j47Gpn(qU*^rbueG`#Z
zJWv$fX|U9Ro&0hDrZS5WStqox%&jnoYp1ehFV>B+NfZ#FVXy2@u>1n%#_
zn)nKeA|9SFAImZ{KyXn67D!$@RN?r|rTCoNu@!E)5>skcKC&S
zY8YTgS}sL^C$Q85SG>IcqSNPzF7P_s9tY(=4aUa(Up;d(XY^~ItvAT!!6xS}4iOYd
z(kb$Iv0OIfn_M;p5=JSM4M%aGyUUXFbbG150f90us0tI6ZFsTNO48#n?~W{
z58^;S@7pfih8|LI&V3vRx!5)84aB#Ik4{KBPMFkJRT8{x)DXHiE&Ui^KWHy<`X%js?$xG>1kxmcqtJ6+^{s
zOC(d1u?DngWNhnpHDIKhjvFV=3$4#D
zIF+dsnz~wTiWOJPfoW@J$1Ek5f1u~97qcNd6MBW13kdf+P26oaVokfq{lnImIvc-u-A2`&
z%@5k$z5nau1{jDdN=EP24bkS+A%^`TYHZ1GdB&Ao-A5>n^-0tzu1NwXhOxmuoBe@9g|qvYR)EF4!phx(hM^_|
zkBC~lCvHg)_s7|gqG8C&h;n6(m7n^~IAf_E=3CekuDO~vCMSaihaLRU=gZSm1&uT*
zb}rr@`>2t{-KBsOm;7$(6>aW&&6AXBTTze5sW3-eW)7#A){|ghbu~h&lT^?c8%8+F
zmQ$j--)LN-ts;3F*Bg%Yz|jDm9ni$%=;{6DhC|TaQu4jShTMTX^K9WiT(;OQ;&HXoTv-yYHi@ECfv3e3&=RU
z=6OSK^uTaITFU^@-Tn*5pNP&xt1`|w7c6=?6tz*tOEm^%redI3xaO&>_-modVa&E|
zqG?fb9PtdK5ArZUc4AwGThSd-t3HZyE8R(3Ld*X9CdOaaY5a4|E=-&SZH-6<%9BrD
z33A)sz;!MJG;a9eTL2Ghd}pX@uh&F%UK(|Z2I)ZiJM@4`>j5T%*z
zr&QlnsmaoMtTpuobSyn&EF6=bIx5~q9rQ;Qc%c@lR+_9hATcuF4=gdF7>2m&E>h)4
z7PPG1H(b|Pjjy5A6omEWgx8=7NT`%#;uw{LBx9KIaLn>~bb;_TQQMU&OQ-f5Ys3D)
z<}q+{%b{rF>FJ|JH3e*r%h{r~J*$4X8SrR`V{3kg4yc9
zklSiou1g-XAXfC~x!r_!a|@Nefx+0tw;5(+)_B6T$=71$_R%`FtaA{?(w*zEh3?v4AJTKaaY1
z(uf8&ZoMu&Y=-v5VP$NUnmH!CL;Je0x>|2rE<`PTYf@FvZ5_J_LEH3G{I7NSOW+YY
zzC5#@B+KYTq5fFQ`4V&cFHEPmAiq=l;-4E7re+I8Vzw&ld6qoBMflljeV|Q`AjQEv
zOwH+`NeazKEe)c|-S;Zl!CK_c%$#3bpfp^)&jB%045HT%UeM`h&^B-v9>#7nxb3=u
z9bO9=+RAy%(rk0BsB}wZQ)vCw@vg%AkoSc12PJjk=A|{zo+&hrj1e0dzc+lD~cag!-gOaxjTC=U8NGYLiy5dYh2N;}wC
zg#^MywBrnIF_@T;eNPx5XIuS)650rqX~=34D;m>`N&F1!Vzx;`QDY${gnTG|J5r<%*n^Y5wi3=s7;n%x*T0|ezCdwX~NNjb?Z)I-kOzySH}
zbUSVj@(*rsn3L0$avc&ls*ePC=58-e?>R8d#<)|%jQnii`?p(dVEV}P10{}$YEhu$aY
zS`~|72w+ZGs+{Jt#voOL%QuO;mVOf406K?(!a%{u3)tTZ>6BQhm_3>0*en?uQ{&T&
zH}^ve02Sn=c6KB*_1G{^FM(zvBvBw|SCuKvHt8CK^5C;{E=EKJmF_aJ$AN27=O!td
zWJ3zDMTUnJmVC|R@Xh*DGdj1qww@?4{mjt!?*RzD`3;T&G`|W8ofhO05rp!-bzPGxB36!{Y-rXvrTzkiwH5?>>2#UF^2%Ub|Kx9=whL0o`HP=IuzXzc2K&7i4|H$mxscH@Df^!5n&^
z7{e-kFU@;4e^Go!9)l1T-Sn1M`ZHh?v?ToBkDP{|dVzsKr+bII(*xk%S3#K{z7e9X
zk&2Zm_lq)9iYLt^=>suZ*(RegnUSkLC6K*l$Ea=p%((s9x~VS&9hL-!q5w9HbGrva
zn{%Tx0)HE+f4%7no!0s>R!a=2tbEAyKn%2C
z{`<|7V@;myK|@C{T8-Ly%Y-?t#Yivj
zzf3*;JYJ6<A@+UIvgY8hlOGl#C277D9|h
zE3O0Hp4Z8zPTb{d{7+BLhLK+D9!SXlJ{+;HC#sStOe(65`|(|zt+`3_`G?m|vj>YV
z!LXp?clFdTS)A0%Lf+lb&%E=qIeC$`Rirs{|JM7(Dm)?_f&po)Q0ROK&k^OPxo!BR
z9Mq|NF9OHCp$Sj(G{HfSUy?Y+BBUkzvEi=DPL>eTtJvg-K*Gmf(wPzD%XX7{rT+qo
z4>2TZt_^U*!VbZpJPE9Qw
zZrJL4R1y49_yi#v)2X*aiggZv5Y&K!$zZpv#)3W3&2e|~R
zDcRBkdH)=a#jFceiI|IiDw|!na%VBMha!~(!oRKmVtjjy}u3G=y}zHJ@gebvGFvVAME<}_sssjK0#p`S155{^@SJ2BY$9^i>ThbPu+Ne#ve66TEhKKMi8{f3HD8!_Xq{Gl`$^h5IU^pT7^2!U|CY_}FpPik)%
zrNdjSS5q!gq=XSu51*z6Cp~Qr`yLHFy&%d9^wnznK7rMclTEqln>md@Z4{qx~Zv4^K2ZrJ2d
z(|xf-TXJc2oTF|Ltb^Ap;#JG>?3&R#=g^F2Q>gDjX!^Z?!q3nO{SkTA$2Geff~TjK
zffqW_CNwt60NIKZ3-)bZ;f<|OE|cBbEGKdh&kM?tpKl`?s+BudUc@^c+qy2;POu;F
zMBabvJ+3mxlxkA!PDFOcK4qu0swNbeW5PqCYE^Eby0=v>>R+>Eo>`EA8J~%E
zoTG29meaWAqn*iht_haDv;x^&WJ_Vh>{AG08*#16heu_prVG&SZIIN+VdYwwUX!(-
z9jkKHei1>mRoyevKOvZN|Zy~!Yb*X=JR3rX&TM`I@ZsfDaO7c+y0kM+443J#gLjG
zhh<}+W?pSp%KP&2V%XNlha-S|TC_?eL_bUNIRC+QSZqJw?Y@hf>4R<8ca7bC@DPfF
z`@<-}aBjBP->a{ms{XWQ#+=r?8!x5tIZbCjnfTq?=P5Z~Xmo~}@FvUu3)9c-E12s~
zt#jk6j=Pw@eIHmcq<;>n)Z!1Vxwvl%uD!aP*}VGH9Etc+A`RO`mJgF%#6k>*2g@HX
z!+u@2WL?AM`M!7tyoZR0h{yw^{g|PVzFc7%PH_7D|-DPGcN%vzytnG8jB|)Yedw0u;-fqkK9^D7>qXW3_etE|%OQ3dQz(L?LM*C&b*SwqTLiORUvA
z0rdSI7$4~Noi~qk8^IB;mFno|>{hf~n1!c#RMe$38Z#xYaBppSrkAVR4=0OtE?(^^
z@-F8kcgBC)-}=_0tmzZ?Z^Qpr$MIc&{0zy%5yXAoDa-h3TNYI^NM1Lr(+olRM&;IO
zL-c-NaPoOvQp-)brNJ1J6DmJz^6Gk|N)3{)L@(s*wmiNyGf2JLjl;Tq70_EUtXbvs
z_^L`bk^Xi!9s$-MEKSi)!O1zlOt`X#af2g>pEc=-t|{Cgqxju$*S3POsSBNC4o?Cd
za2^DHdhUliRy#aavtQr@W|Z_ki3cl5J!&P=DVQQXnmSPa9^q)Jh?ze?_SWr(|Lh+Z
zR1#!Op3eG|i4o)MrN1IPHlU`#V1?hnr)2Xi8V~6Nr25N7o<$)@(Hahc3Qdbrqx+*l
zZZ)I_nF}Bg-3FR}{0fqG!{XnFz{5o0$H4F?!l`8EWJ-G!63UHDg{#oi9c@!pfmox+}x@y`CbF)U4
z?IGbrei%B_S#h?&Ekr+6u?`kQo)S$0NK@H8q*@}ehq@(r$Ui3%V@u_fQPu|Oe!DT2
zP1;q4_1A5KTeu%is~xBD?)!yfM4~zIhS;Eiuye!Apz@aj8L19UG0j*d{F?qsR4|>h
z+nX`J+f5W!i@8MK0~6Zn_OD}fI^IF7PZ`bo>0&Q;=#q3LcfoKhELX``csXS%Tr(G9
zQbUxY{x!rTs=5LyiCf{nHoKnJf7)NPwwsx&t<}AYtFYqh4#gLZhioaTYZ=$5&T9$Dga(_br&u|s&SlcHa&3#Lt-&c;
zr*{5vJ(7GBQ|MCzO5thtr#efeG9YE|w~z#CD7d$EcEXh~+ffrxG$_kS$GwqDXvD-I
zp6hZu?Cla<-Fd`*6xE-*#!+G@4>1ua%bo3!MY9p-$?Thnqc{g9QiyB%Ejq^J?dZ=C
z%+u87)_!IAaE2r!?w>DRl%f
zmX+{`1`ES|k%>R=$`j_?_vcUqf;Mm33B&(=j3vx%Y673Q7ow@d4z8drR4sQU*~k@w
zs0XumUkX8ylVw|NE|$!uBSL_`jeCT;>ZqE%FFz_PYGF|Y|-b5(q%@6vr@{6GJ*+lvuH%=X)nqAh9jWrN`;D&ob~y$+s|;&xzWEX8=8
zgj7>GRNttUVw@XYj|A2hj@f+xnA1i(;XaJhIpPd(P5i4nwMl)a)OfX6_~#!IicXyD?b8ZeII*HcyLtOb@v!{c@njp7EHT;|>8qofuiuuJAkYS);*{QU=Q
z=`dAIuJ
zzbA7@nN_YLSY70YYTG`roPlcudZCED_s_QlZT_8QQD4XZqVLC5=Jt}`uS0F!*AUgm
z#~%c5I9jk>=wMa~jh0Q6OMY=3IgbJ95^PkTtwA|ynBRVIx94^nZ!6bxazc}xD}cub
z5i|Ug(R&q~SS+(QKX-e*cRgu`gcL&vTnxN12+1281>b?jjqh2WZ?2h>#~2&mP|U`H
zj~7<@mR%73+}Ard^JDj2evp_s5fe)+`8eD#V?FodBs&u{OI^NqWD+mrr_V{PEGmar
zatRKggA6-lp%4nrs)GLa+Gj9eo%_388d?v_Fr*7j{x6Xc1xZIasf#+=aws
zZP;|SKkYJ@WULgrw>%r6R0yt^ktb|yNH{HyAlyqbDKmv;2|sA&aL`UVlz1~4xOzQS
zbX={psT;j4OZ5cJGiG{Jc;}lo%c&Qys##cs+*pP6(_vq~E767R_8XcU(MlU{r$tF&
zT_yO}+ZiDaA>|)a#;Xow7uw0t^`da`1Vap+C4I9dWwyHmu@q4fYQw1wTT82#erlYA
z{M=xZcs%3>u&rg({@{_-o3VW-U5!#QA+5M{|(C0|6(mhZ;r
zPTtM#oxC>*3h1uh&e;?G4;iej&*(c%nu4HTkn#A-sIvk0=2M<-!^c?emyIjryfaj0
zb#W46yaFaxXAk|KyY1IR(2-JSq2h6r`n`_{8YIpWg=`9H;&Ox&dbq>0=KNJj(7fZq
zP=-Ea`?=9fny0F#_47O>4ea*b#6-c2Qs8h(RRr_og;SkJ@}F=aZ&M4kK)bNvTXoy@
zjh{6WLZX;LRr>3{D&W)(Hx5eZv2?6Qw8{b2ZqzI)4)tV?vo!0}p=X
zqZ>hzYCtr97x8VK~l17i7;JRl-H@_6mUyWZi
zpW`;9*^KN=bb$nd{#sHqLM((*M7s%UbpPoiOFur_Mg1S@4Df8QZUVr(of*OaxDq5T8xs<{qnM?G`F?+l>9+1oi
z$T`nk)9r@(`uHb<{O^3TnUhl9GsqS3YkMcC4al)4?agW~n?FjDb@HQBR+&?3MWf<=
z*G0|=Cfql+)uv6VdWy-_%Q9a*kwUL|sZ8#DDDe7!!F8@L+IO}kDXK%}j>se72^Dcf
z5F~C7Ms>oIaJxK&Z8>_n>lYM&9x!4iZ0-jg!$D4ki%uvEk8UP9B*X??O{Cp3{zP1~
zpf!VKv)zQ0`dw{))a6WL4O;}67cYv;a45}oO;ZawR|?X~iEIH!y6TcdjD5VJyx)l3
z(W^A;lw`kICw|+SGbyg$jjU*b)E9nD>$LgHFKQ!Bn^+4qjnR}HwKfe9s5#3!;`QS5O%WPk&`mn
zq-Z^>irT(2RJou#{fxLDN<;rzZVmWrP!)uRYPiD^N}*_6ygp9SB?l%|L|X;lru9@A
z2Tc~?ZU@X*IWuzNvqTCh1jAD*Uo_tcXdn3%DrIk&#~5fDJ~Y6&#SzEd0aSF&4#*iX
zH_PVM)=N?>lRFbjb?5oyaHIH!cJT7<{O#zBUM)Ywy`#ArNT
zx_ZFZhDpT}xEXgba31fz?MQoZd6|%z8yN@z&C+lv>JD}HmW8IW>|xfm4&Sv6)x185
z2SKg{8O1a0`|6vbaT73=86-iJ6;hMq!`8W7VP!LLLBAR3fsw5Zpx#zSj@FMC`HMla
zR3ni)H%3+o?(1cI)IjQeExw3$CP`uS(CI91jOzMGf2gFUhZI~epd^7LBCpRcaK??q
zLSU8)xNo%5sa_d0W{h4RcR|IwY}@$+i@o8oWOv;1p6j8exqxz4jrPV$GfJt%V(fWB
zpEKG>#A*`-H(9`;Z`biXoG44=5oH4+;#XcUR+6e?aPI&=Qho^3+kB<5CG~h2e?Jpn
zTp(jbTcB|5IMY?MpgKb#5s&tW#mWrrL7TZ5a%o0`VraL~uGwtIlTrTwYaR;uNA$*2
ziUZDv35LP$$0y8YO_*QZ&VZboxm7r>G&H^pw}^{jzZEu`1$|Uzb~s!tK4{ZeT-Jyd
zD}-JhU19U9A1KcGP;ptf6od|6p;JM+&_za0&yJZqJF@`_EaU+~*WJFv
z?GT}5;E3I@5XAdn;*FpxtPq>1;qO0%A=@^#xS?=Ovtc+f4H;MSqb(7h6gJvDxUKB1
z^E80J&llk)FvKuz#A}L&5-o**R?rnVtU?PFk$o*0r0Ar4%@sj%gqpuUn649YBB|%Y
zIF^JZDvN}x{e+MYFEdU2f#d&*I}&5?IpeHipEkao?O->^3BC(F@(&JMQ1>G~+4@&cf$E3_Gh;gv3y}qNEoqM`9;olfS<6)+ruqBe4|v
zFFF4z2?S>ZKS{xWX|rDMl`B7Nkt^Dn4+`jo(18x}IHDoW#sar>`R2q~C?=>g%_Gsg
z1QExdeo?9VT=)^OD(PmuKIxyefGYe+l3!0+Ja(v3kNYjG%tX+R1DJ+!xPd>$
z%6C4kA}{Wy&OsoLZH&72>ZPQjC*PybMZgfJn_dZT#x!v3)aViOLQ79Sa%$iMVbC8f
z6)!hXKprPbjV>f-OQ?>KK4{2t*lO<=fB~+o0(m3*G^ZdIU-Oe-u?;&)X3F7VLE;n9
zh2rABD6_mh?TV)KK0bapc-g?O6Xn7X%Ho4c*LCCGBt~B=^^|jt$z
zkV3*$>p^z2su_q_XHU=}0HJOVwS~D8-y%DTKJ%ShhAdfkt;U`zM1iLrkf@M&
zahpv0!+sG5wW?KYHKbL>;?)9jEfukIj%FqGln+vvTBUoiAXh?j2Dm`H|xH>OzwW`sI87kQ4;-YFyf0IL#Ra+_iEa;#$I-}!j<#Z)|
ztfD7|eN?K39iMeX_QE_0c!2XJ`26w^s^p6m8$(te80tg)x)AQs`0CYqAG+u*ir(3^
z*^<*003WZrgm^%C$q#r0)(&U|GAE&cOmsrb%s`f4C%`CAV8^Yk5T#2@RcrD^o9q}S
za`^ILAv(;6Y8wNSWlY7fysfL7W#KafVST~hm}*IiBL{<=2)&~@tNOxGBVmCM??dO3`yENC
zneh(u@soeGVRPy%1(~iwS4>4@l?ynt)@j>1D)X?V5qb@#_Z*%o5FBry(n;!8j4#?`
z8jL5LxE?zP($XSVHmlkn6OLO7{L3IPOEFRiTtbQt4_cf>oxrpo6j;rnLrJC&=p31vsUI>1J)yf{jl5!=`F%It
ztggfFV(Y2%uY$TVXvK2G2nI#?%MW5UdVJze-|JrNJn8Zl!XKf6C~MMW^~k8K2XqVWRi+<6Xm38zaF5tHkaex
z=?8K(N+9LKw2JsCoJ)|KZdOD{1*O!wmfNqGH`g+X{79@5g`C;bnefR!0WEBH%7Ok0!!-?%x_Gw
zqpI`LfJQ~w+uq0j>c9!+yQ|(p6K$A}^B2#K3mJ7oI=U3%>jUXdHL3Cen
zpgv2`is=Fk9$K5PdIdq~~*)+~&OnaI|UZ)zAyh
z(~%sxd7cG)Uqmud<_+$@Rly$A+%ulRyay6w&SrB@>n-S*_N0{SdErfcx&p
zIWaeL$}#a*d?r}4((jfw6&5^6bLDP`mVx+*%fk}cE6`ezWLT+cr=9wksMgaCJ~IlKM{D$vpI+D!_mzbge!C|1U_quPq*IG
z7Z(6cMcv>HXkz0}RAW`E)zS6HkP51!J5t361Q*2^N}KmpAt_h#bIbpG53$LI)~SYG
z4?g2WrZ{{@M2%M|*1bu|!{u>9iV$;mR%}5Gnj!~SOtHG^eL={qNPGi*<+u}bl$s(a
z3j%*=IxlSC@}C7=mC!7DYgEKHa3?ZSoGgf7#021o~oq1Vs6|>-tk+`F5RA5j#Fb6uU1PZ&*^S?sy@6`fm2{wh_9HROClc
zZXViv15HXNrLOtz>h1ckqU_|p%jdjKK1lC`j9SuT(k@{K95#vWC+#K+}Yx;$9365)@*qdT5_e$n+?XC67e4PgxvLJxv0J^MHFa
z;hBJlJ>?-PY6rV+R8UZ46~3NW
zURbuTxN{A1IvrFj&aDKHR#niV#*zVg!BkZL1Wx8{3|mv}-ZsEDOwj70;;1eH0=5W*
z3t>;Dxg8*r-WTQVZ-q&C`$0i$PF^}71sfuA2je4)S;Q@*njkXUiF#XCKLE3u11Po}
zw#fI7;oQjyJ&Yra>%Ou9YSPhMAT=+*2d{$_%f}}rIoa%VV&TPhHY~v5EpxKnaZ~BD
z-rujDcqXk(@Pc7U&1yr?*Aw8d{(=bnG-zT@m{
zG<`sl!jyD_by%Ik
z1y2H3Y%TAMdT(9@Kn6hpLTd&NV4%{%WM^rkeok2nkm@9syEV0=Ae{NH&aAnNNHnXM
z<|qU#V45N=K6;ZFP6?_85CcTO-
zs4D`nbdXM5`AocWijmR&jO6v+l%8sT;5oW0o^R9e_rN3jV>5xZ97-Yi^AzqU`rdB`
zO9bjP-T6icm{Q6#S^P9rkUnzqaZ@zW&L7vBt#0z%naXq~M&Pw3cmqTg;3cQ}#uFUp
zyDPOMasoyHJn`nz$iwvev>aEWpeZivBzk_1ZOFdjGWmncWU10nIU0Pj0l#dc6JH_h
ziB|OvUlbrT-*#cA8da=c?`C`6F#ttyp}zR%0ojGeMb_f&W`*`u8YhSP?oV@o?cZM8
z{x)*3j>`;G2VbWHl{L%?VBj(l9|AX5eeC--bO;O*{}q*B^3GwjLhnDgb~}j5`VWg)
z`T5jV$=!l8sqf?3p4YeHd{h|dsE=~bA(diz0Q<;k;Ewatt+%R}LivClh7JDuy$|lww%1;DmAGsL*5{
zOX?y%@emO-Vcj65`609AYBJhj@YY@un^7)AX##Nh8P$#j42PkAznnIfz%j&4q#Fls
zU&t|3Xz$dsp`__XrP7xl$OFqTQk7OUQL;yhZcH!=6Erw684u8fL0p(2>W*ZDZ%(W>
zxr;Wgcn=y+HB@6mNWv}xF_aKwaK%mEvr_S^Wmc
zs{(aErKzy4opJG%0^WrCu5bAMP&k!e?RBtX4f%Xymt~R_ThsLC2D1~{{revwan%wN
zh7R=l+Ks^1dVXBWU}WpnIuLanPb$EPU7qiTMN>WLI8Pc*O3O}|GD>>J76B=u+3_F|
z;zNY|ZfRp>3eFg4Q(O@)us4dm%NV${KUjevzTd(+Yi4)JXYU(&OFJPQZ(Pleih*00
zMhQz%HZv(v(S)v@jH#_P`uf%T)CRuU^<8eUo0M;q&wUG83?|3_({qb?LRLmZ-wxbB
zWOa
zaAw~Nin0vU)~Fx4j(39^t`tfhft68lm^b4UgZr=tct~eLf-C&dBTS8N=_Mf{Z$kx_fo8cDN4&_L1-j+?f52U2
zTRSTD1#_h)pTSphXQIxKLCD$a26PPsS1mdX|JWs=VfKxx+QDn$!Gsj0z`f+O6Ss3i
zhDN~)8{8tgd;9LwSVwTYLsFvN3F)~d77VVoS;S6$6Axg9ixL-pV;xEc6(^)?J92E5
zXBbx%KgLj^vB}WkjPK?Lwj5b>YQ`DQkP~_ZWnSvwFD`y5_7>-ap8e}D8TW?X-a}S&
z6{FYA`WSa9+mHD+8&HGO&^sG!=u2M(tT)S2%kcqDI7$~e7ij}oQcKviGIr8ig==3T
zTmt7$l`JHdBNBx3+-w|L4X##k+Urn%|Kvnre0
zbHLj5F0PG%|Htz$Ois{++4XC+!Fi#0A=H04L4tfANS6t#z>DFE6L81)6@;$+`zvDl
zhVS018wIfSYe{fdd15(@Ejhx3^%_SzBT7{%7$X`}yy_%r*IrhrSs>t-0_<-3s-cz@
zCSY0k`|YpTX_~*XO5ryz7}P~r+qHNlH2h8JX02^X3KMQFCZ+W3IXL1zPF|9lVrcYX
zY~4D#fg1&o#N5G($AN?XK7>F|tBvXaqv?FkYkvd#}Jg~MHcmo^+
zcQ&JBUTAx|xCZh41de2AF8WTWn>6SQ6n^MY`lCvt>&+TBKr`EB-F-W;#4x%YN2{AUH{5Zv8Ic@ybU5LM5zd_EE#~-Qj|E%<2B#mRHzRh&??-!dkn`bE=ZF5)E>P
zV;Oq%B4nO3Kz|X02w@;J^_yVPb+}gq;vBg*6wd~usN0YHJ5YwK6eC;}UY2Y>xC0>4
zI)U!w*>^B!q8B?JMSIh##aS{~F&2nKRr}0g9ziZR@|d(N;aMl?Q?z#vhV!gl^mAm)Z=?*wgdg1o|firI2+_R
z6{=JfL%kK$<=K!yvhUS)%a_SjE2ABSe~f)bcd_hnD(QM5$7@du&dd%I#5G^wO`T`{
zpN<`D&ZJ?1}`%Z!Wmm82Yl=^HSv76a{%9@-v+DG)hDlgM-8en@M*oMv2
zOlxQdvAMeKW!t6uz;WY&kMdU#Y!lQ|GJt$6F`t*N-8vIN^Ye1DMtgTDBhV_+<5u>eLmNw5VY^U3ykVNPHB+v@p-0R
z3yikybQQ}&x=`TTsJOl_5l^`h-7)^}4|>W0@ud#(|BY?3BzoqbwQUd^dcV$<9jK9s
z;cnR5Z%g`}zoWMvMUI*8rTOpVs5WdTmb+`1bsaV@taEMh4!o>r#7Zz>7$WdCx&A`%
zF#56rCM7ew-|$L;W-Ltf_>}3ep71@vcd$`{FtAB}nP$+o?K35#e0AS>tkkOk_&*(p
z%zOU;Af(gDQ>TGKERt1wNyP2jc|jQAxKN(k4yS!YffX9$zxh6?Ki`I@D$q@1W|f#M
z&lF9|%`1vzGPxXS6tdrlj`GCd@71BW0=3vEw#2sLi|cy$%X){3pS!Ey?Z8BBrvbd2kcH-+(9dY<0||%{((YD;)%W_ht9?HX-+eUa
z*4pg-^}yy9l-2OB&E507HO#zk8QQ+e6Lp=DgbTrR@X@{pQe&u!eJ7C!;6R1lt8F`R
zGUL^fN^Y6NKq7|1t5?2i~(QL=5?H0r1^r!B=s@a(g_Z;_k?=CF|{Uhp%T*-KwFti6M;FN5lIIrP^5LVN8jL>irN)M~`~
z>2LKtMDy(i!BZdu`%no1?nWG+X$~j}<92A7YA3y|D(1!QFlk_0!NY)3;#e+lc<+?58
zwatQ!8AofdM0d5*qUbAGqOjspZ5O&?EYbS;hVG9C9L;ThUT}%8PB1X?#b|X20Pc1a
zjCQFVg3EK!Rj@Dl5-AjqG>Cm#aV~tUT}XaGv<)!r=OsOPccZq)_G=lrIzP<9#uV@w
z99qw7T!Z^r`RQi}71kMe7c)=eW7!I4{PrIuxr?R>>U`erwg5#Rkn*f9*j82rkV}#jm$U3W|ni!#EBK0B&uBsCVfIaH9_f
zHX4*K?8JAb~9d&tqRc2{s1)TZu9>KSJBS?(Xu$%SgYkVe7pR-V-B3^!8v
z@tdD51xx~+(Y&CB^c^3&Qn+Gkn;WWQbW@Lr7m!IUR@hX
zbrx^${^VX9)^hf8dfvE}dS(_Vx^hN}-+fVY(O#)-T0GLi1~t}l(cC$8|GU+8dt9x@
z>e(f8%BQ$de=Vv19<1`w_N>sCltyG&xnxBxbBF2{J8mhfM1%4Nv@ij)NF`%ob8{$3I~gEMej_wH7*c~(
zNGBFX31?>>p=c{>K@R(CWDHcItJJp2O4yz-G;U6TPNw%+oNBm{RH?{UypB$|v(
z09vtP0@Di4zBsP`Pi}mCR~c&=T!SuARlmlp#4K)mBu>u8Lar>g5#R6SXfaori@d)>
zEb)HBap|s&QAT4k`##A~>Ez`Ph#uy~=GHCXy%t?Jv;1D7TL-tIHNWUAxpY!uyRFY(
zvw_!+1|loY^s2R*@<|Du{I&j&2^X2u?|rL%USDns!T9t1zAf5|=k)N)vu<{jtvjTm
zLFFY+v3^9q!IME-uW-_c}h`BccaOf2%}xVd-8ws{d=iw
zwa5&X3BV*Pc*OV($HZyOii5Y`Z#FkT9yegd_zrH7nHQ)-tW#?e
zNsh-V&5qGm?m0C)AKDrJG(jHRi*OOt4YA^T8YaMl9MfSyQ7Po})g|1dL=zj|5>pk9
zi@=+mPzA$jDdh}rR0p1friLI?@N=VQUBEo&>&awimd%dG_kj#5DltCncKHia3K@&Q}^E-yN1|0u(=6DQMB98DK9$x}W<#
z7dzqau1Csb%#xWtRmNRANyabI)J2;lKg}v@Xz}pW!Pzj#=;)@LNYyNGxyfDuex)<8
z9uE(X(>HKIH!$}s=SMIghfToe!p4z)rSfP6;Qm+?O4ix)=Kp*Tzvu$}tJiClyI>{o
ztjBesOYQX(|6>KH=@Q8FpKW4)zeodYL&MIXW5GVh@8$e3PJO9#n_f
zZ9@qXdocP(7$THI)GdR8QW-AC%bsq^KlOkZxS6mL+2j%70&M8t?!rMqqTI{;WWk3L
zRR$dd-_{y9+%}6ykX1JIF&I=up%h}>Nqkiu=x$|^ja2c4au5PY6W~N_dISNj)Q~&7
z3Tpl78R2ouf?qGn`(CY2D3+zAWr*=6O_B7eH&@e=!aG}_P|s}^omEi;UfCHY%;oJ_
zOKk+}&1O6pX4uc$x1H>osL0wrT%1;V5+wq3d_KXUlA)wVkQHl44{*RpQ647RB)OGw
z3rmhh$c8UjY(3u!-H1vCd-9y(anT9$!d4s|m0v1m)pZfsGSOz;Jd@Nk%|Z>@u~X0~
ztil$i!w%_dUScdkVPzfE!Bi93lO{<&a>-ODN$|%SKkzNS^SIC$7gArX%=nT|^eLuwlW)Yk$1D@r_TMl&+qdI^h!&*KgxcHRhtAC>5qD};D{I8`Ucs8{dRiavSLUy
z))Qp2&=W`&o)nc9xPDV+=w(nR;NeBQFu0bT;Rv5WUE4=5rA9h4}|Lm-(cyfL>CIUdf#drQMr_*W=bV1D;
zFgHQ@c1$svCR*d``9Q`mI1>NIqPk&fKVM^9R1mamyb1Ni-6=im5$`eKf*1pH3V
zEN-uW#mfupHQ~wEe4HDKLyOe?4lkdT#PAyZtr|JuB%_sNF@Nl>#~unP
znM%Pb_`z%xaKwLzg135or;}S!-H*)H4Uzig9(Vx4ycEJ#uT>sB`k`=cMF{-ukNoa#qJhZb1*bSh
zUbkjlVxgFl-@0d*Krve)*O&WW5*cc1B*Z!q(T%vF;;1Czm5fQIW%7G4aE70pN
zXLt!1M3>j`Q`AIg5=?PMV?U_)VtMBuupcj^NmHpbM0IbwW%BYtKBKldl}D#PutrJ|
zvG0i&--|tn?7aj9`>Jo$^yp!u(3DjUeXJBO}yNXu>E^(jb5PFt;tX;c-^9Roe5%P
zx8VEt^2u#1fnRi($TYQW7R*9H@*J^D<;5nuKN-7$Js9x{erL@K|H4?Ym^#&VUHpi}
z`m=11-#p?p;hkQ$0}Gv62*Q>)fv$-!k1&hMq46BP%TJ56d1L0dm>9vsL@E!@Mh#>A
zM0p0J2!T|245ZW&NUg70#igYvW%+_wx*L8>$f&ge4}o)dnf)7c3F^6j2(0BXC`V}d
zJMbk;R}jwn;iWiNFw#m8p22{AoBN)5JAbzt5=jz@*20{{@2uWFJNB(&`R
z+;xt(SdFHai|6BIU+y@(ZOx=F#cn$(#BRW1cl+r6Ffv|OF_e7jMvBvo+dLuq1GW8)
zL*66TndIyW;`pua&q$3NXaD{3U5>lY`F=rok|lWvrrW;7F(F{PkQ;eQ>e%Xc{vA@!
zm6
zt4q-H6+VVn05h}Wa6e7ETOEg&U3t|hleHlHmQ`#lRjIP|xdnxgHI7&4B>@Jn`Gl5`c
z6L9~9O#mIy-D($~BKu1s3II_G?N_vk*5*y%)e~O<6^{t6fWQ(Ed+)b}1w3N|H0qNS
z!qZ!BjZ#x*8&xBNQRPfTNHi4X+yWm35wJ*Cf*gg|gZV_+p<6Tvj9=m%!zfb9N8}?T
zf3>I_rJ_0hD?>dkZ5;(m`l&#avf@V6pdF^072a(iHQG)fV7*jMRf3OznH$Xuj_Ar^dE2AC05#Pvw+xEe4F?
zdzC$L>Hbk{St_wk2%#>Gsv36?mXqw-UvC7tNDMEpN=*J*R*Ye_CImM*Q!mm7hwl(8y#Qi`;*D0v&JAA}L6$`_E*Fx{
zB%s0BB#dMLfu^<&YRHV)WUc@>;?iiFovG5p<-1d^uc-rkYXnm(`!|ALP;GkOsbo>a
z5LJa_3LR%kY}Kr+cO|AB3I{F9D=Vbjk8BVOU}q?zFCkc5*mU=J;-bo#Ee#bA|2pX<
zce->U+vfXnXbKFgg+TA^N;xaZNSCmiS+t@{gc<2Taj=owRmrhqM9N#9#Bm8
z&q3vokyKK`o)z)YI`7+`SV=8NOC;pVk9ZV=Per_GwLtiJ^;=VIz@lCwTBENnet2u`PCJVu00!=MRF0cS!rL47y!(aMi09p5
zlymd$g))vP>lWt6&Sijbd38kumabHoa0oexk5HjBX3}6?yC2i9Uq9Vm&V0=VFR?N4
zVS-v~2)KGpqMyZKG-hD*X-0?)L^W(BVkpLdkCD^T)G3yjRariPpC#az-Ki<3IS&7h
z)xDwTuJJwNpa`_#C#RPeO;e+jh3rb)o@qz*1fxfgpq0p(i~jNGENQ7BoW}*P6sVBZ
zqY}go=MhUVfL!MPUZ$wmXioaqbv@~3N&r5z+e0`351GtBD}vVBWYx5E1oW^mj>gBK
z$nA`3)Q~kXO^iByblU|%;~G-TKf@!lZSt4sP^O3VDCqNu0@HME?pLkpRG>QZH!~sq
zn~*^jSBV+*GPy0suloY_Y@@JoCc7_c#`U+WF2GVNkOhwWDEkb4XK+y*=$ZAYKChJ&l!>RsRlh
zVew4ld^&15vK*zOjQAXfd^8q-_eVHZMq!jC#%Q}js`}HwXzAq3{i-~H)5fJKzp?>I
zup4H;zLj{%EW7hG`Sn(b+IytS+D%I8QN)Zx*o1v#{{BxaxyVjT)O=aipiz!k(lV3)
z%&YP!0v3J;B6Y)=i2QaD_w9OmN#X@dYbl5vqSw((sPd&Ily@L`94}g$M6HP{9P~+6
zImY*Sd;cQoTP3KiCP@p9&H-N}`F;lOI5;B8xY`0W)
z&m54JDTA8ewh@Hr-U|90RkGGB2&13Qy7y57?c;44y8HgOGI1Ofgy^7@Vh+7iLN`91etd)mU?v^|
zO~~I9SZOHA$8NGJz2@A!V6tEj020g|Hz5Qb46+J-X&3x^WM-XfCg1kVqoK+4EuD+-f^ZP1TpI;RIXjKW;DZWGvK
zErg^YN@*(wOsEwNgwMH^*SK6U^xo^O^eLtO8)x^fW`7(xN^Q~Le5Q1Uc5I+=Q~%M!
zoLAyC)U)6#XXAh*5mg$6t=SkrSj<$5uFZIjNyu`ga%+|N)-hD1GjaL&#w0O#9VMh!
zbJTs^ju`@AQQ%45q(L0TOJaXyFxgY
z2LCq#4}y&@;d8!%huHO;2l&PF;#3;J=RDWWNw^l@;bv2xp}nBl;v9svX#xFIm4m}t
zBA5Q|xBHbgx>$v@FIa$iry-4lS6I)5g`JyTQv`jqM*4fpWD%hJXmUvm3A6^e+(U7X
ze7zun+n5IoE^azFDMaDK_swce-69zZ|gD$ozQdq9_Ma)1x1gK1V4qI5hX+IYFZM2>ZNq92T5x|D;>f
zbM1aIfB{M52A=z`o~x+TTP$+WbGjOe=dSFFG3!NrxvstpFi5dbFn5Tu!@>N)8^Rrh
z%cN7%@e^&q*cVro)L(GB7TO`kENF{oExke!TsJ?6KE62VIy8puo^G5d0=P;9I
zr_GjaR;m-oA9Wpf_ISS{Gpal_m_RrMvS{@9d30KvLBS-1oQCfbMs--kl|^aq1)R1}
zfU{ym5ZH{?(IHU(17&x#rb~nC)pQ^$S!g*bRV!YLJ%`u3%XJ$E4N1Wa&sgqf1DkNke_U
z>7XOXriQ*S27F>0*03O2)535H&C(jMcnY
zkr`opENBo~Q~Zn-H$BvKdA={Y?1y2I4YTZ3u9UuMpPld~DJUqq?PmjEBt^ZLen*Sp
zN$bUm&x~v#`xoNgRRzb6;AAE0^o%rd^On>!WC%fwpo$``6UC%yQr5U7Y`^JeQD2D!TI9HJ$b;6cW?3Ts7s6M
z^dH<^35L7rpO?;@7xrWu*h+jiFIMdP@AooIkwi4GtbW!FK5faTGX=~P%r)e4o$&l?
zsQ+vjED(9$uFvW&M!8t`Bm0~nh{vg#CrqfVolfAhOVLxLQ5i5@Sd=n=^yz117M{AX
zK3sAuqF^GPs2XxY05-`HT2>X_zN7169pSqjhHK9qt)2q}wO2XFa{ObN1i`nEB+H*8kQw7&OxifX8cBDLvQ(w!D3F7h;o5uT|?{FZ9-V`
zXx$I~Kq89ya!?*ViY*{lY~0b+e>E0i2u+@7EYVdG&q^F0z|5e>?f<)APwSiq!gVS!
z%AUqI1T{}qJYy`X9?E&caKp=PjnZPU=TIFI?HEO=pua;`g=I}N7p
ztcFgV5rm%c0HtZTJ4M(JAp;fR;wdY(+q=Dp72?`{txV4i2Dz4~Mz-n1R~xoko-I%K
zfm`q#r=yl_q%U_J)mc~TP>&W^0|wX@FafZr+eq4$lPYMRheDyj=`fWo`Y8n
zfKd4^Nx|{ANF4!uv5*8i?HZ`-f_GKW8>!JIzNeud#lF-$BZGgw7KdK}vn+RN0#UC%
zywPwJo8}qxgx?gsd}gfVTxdjGK5()L%rLn5n;7t2SGfyk
zs(6XNW(^{fUoX-HAPfzq@dNs}o23a;TJu$kOR&v&{zxj6m>qwGE^AoBJZw9EKG8=Z
zM3mEuQk>+=Gv;1OB_0dasj@E1t|(v?4;l#wdOA(ZGvWRwFZA|M<>bqKk=*TrMw1Am
zPff`>Sbth^b$D7lmb5A_+pYe4l5$AslR18~o}jx`8NLb~7z>Yf2ZzIpc;YeR#scXM
z7PcAC#qv2iFBEEzqHxHNicoUEtSx@Y1&1$5-G;^NK5K7BPA~AfV!d)yK
zMTG}k2{RZHQJG89H3=XD1LO&x-1V4cNdhLVvsx=)^_MBu+w8d$V4e-bku|CW-uc4T4;L^gMQna{uM)&$iHI+LaZ#zUkxuH1yPvRq9p`
z+&6G4XK@og2?(%fRqJUjhXHh2`$`jcE{;t0ozl|rD_npdzj#Azu!TfZ5E9=DR^{wS
z4liiv5=N}ycD-uk`{d$L3}`UL?#0VeS6^EVx32t(W*xF(q|7?O4k6@5O(=G!PqNU<
z_an4E!B{>d*H7-BF}8nQ21cAE9cqGVzQIPj2-2kB;4lXU2><7fd|zhC4N)Q|BY3_G
zwMjO;ed7}Bw)@9=VG!h>?&CcoiMhYXINb7eet;(qr#M50tGHm)PUJ`aWBZk0MLxYBn1oL$b+fn5Su8)sPm6%i;>TbZx8;nu
zw<7&->H>}=6WSe6bZYd*99-jEU7czy@nMi6DZ|>WJvnr$jbm4}$&I_Nnj$ZGs>)l`%!*m8wS(55s9d4&`Uc2ds#2pZUcf|eNu`T6+A
zlS?W0Ys&6=s|f=VfpW2J4G-LztsK{0(DGgU%ts2y%=ddZH@6Cp_vLf9yvlggnt8+u
zXQ1YRy$ziZ
zEO_OX9FBjP|2M{cWIqXZQU$fte`QpUr(d5rl1YmVOR|bM`@wRPx_s~$MeYiYkmd_r
z%GnwW(zG+f^EO5V^`iDB3FWyOvE6CYLofaBvswCtaCp0q>X
zqvi8Ha>!x@AG*5k*~F+%D_WHMZqaQ}d4<~5yQ5hJA&z}!Lf;h9V30J8Sy8$l9ex{V
z!x{%O!lCfPq_K&T&GXzbd>Rd>31=j;wzkd^dhq7v)^aEDH_#yxo^X*Ku(FhGQEi$)
zTlGKaCg8TiSb4>S-H)U_0h3ZFW}Sv-Z*(c)SXQ>jw1{Gd&9$r&MET+Mquc#X&)Cdc
zfo(g#i?Xh+6zBX_>m`pq^k`ioxYmJid)G!*D&2EQE++SnquYC)n`(l2=*~vh=7|sCOWZ~23
zk_>b2{5+0f(4;9Y6|^vY{H9|`NCvbWB*JEoB1p8ckz*qy)<AZVxW{MDGh!TyLLrSvSy!-Chk_IJMwGaCAIdLb+&xR{zwAB0%p?I2002vm?J8+rb~Uc
z`YIM+@ITS>fnUIoZ;>3_shVNk9wNaaBNe>P%Ygt5A=NA+pPXhdpU$_pKvi=2Xk+Yx-uf)ohTiN)-o;qC!#CA5|>E
z8{}AUXuno5m%e=vgG#izJ?yQECJ~rRLBBP0?MeJ+HF*kwkn1!j#C97wY8sh%o++_}
ze^!%bz;jv$UeluYogM?ur7m{LW+JweIeH(dNj6@XNfus|(}}>G+=6$#7!jFzwtNq)
z@&RYXvmUwWHSk8On9R}dd5o5Es>9bu3q@e(6Y`)I2)yTfgr;<=v=6UBC=Yo2&(Fbp
zP>scT*cNQkikh=898loFhL2w2F>PHBo~%zrFhqA$Px_UNHiPhV;t$v3Y}8Ot(
z;If<^S}@x`h9g)LD%60n%4&Wbv6o8umKv*VI1ZMRGjUsDIbBkk_wm>$JQn)yITU*?
z8M_wIXYzBGL!~L9J^n8h&5-+k%DZ3a8k*AsjK-#ihuL5sH*yQNe|=RKB#}Uri48Up
zlqffxC4&c{yTyiNP-g{{cDiB8)~`WE0G`GEgW+N}E2w-#?8AdIhRh2?)UbXMHJ2IhvA~b)*W3!FLbq$1+?_xHg=EbK7>437zKnT_DRUWr?xcsGpxk#^vlR*%
z_sDjXDKU|}NCV&>sr!)AJ(A?c4c-|k;IdTy^zLs-d+Xbt-L~R+BxO)x>6jb;VA;hO
zy$uO_`dLzxh2==n){|^{px}t7O>fLUlOi~o-W_%ev;E~mm@a)7YI;#{4f2n
zgGryA@n9mwp>NNbAo1c4uHR5&jy0Wl#pN;#I9qM59vx<(&Wd503}i+!VxD0F-2cZZ)Qt17LtGUPe
zMe_{v-RB8p&b*g@2w8=4;D1IFt
zz@@ngOnn;!ss+POvPQ;H1|yn}*tQw7;aYwtlCvM0N;X?6q;psoNqDsIF0WyW}_x{)n_a^)(p8>lexK
z+E$O(Qx0pbi!NdN|1CTf@DpifxE@AUYi1+PdQH4(>E%5><<3OObGM{%k)TAI@qWvC
z$@xcpiC|>(A>lq&>}vUuzvC<;0A)O(vv{hSl^}>R)wuPAOU`0u*@Ah|Aa36cLp74j
z9uIk!e>2n4ZNw^yfvz2&q0qKNslqOz|>;#9>anG?(JK_%67-RwHF~=Dj;na!^Ta9nadFJJB$1NHrj|v
z6h#bCfG%JbFGVm*gh`~?ajg;Tx*ljmDLu00%>mC9qg%!qsn!b>4qA)q;uM^@cM5QP
zfr=Q|vSWIavogRqdjR*Q$p3lT^3m?bB$HTTOz*?#QscjJgtRR+sMCrA&vg-4>qzsc
z@=Y&jMc`irA{}M%0@YFxw`SC}X{*+3W=Z%dGWmvlefYnWqZEdkW;9E@}9`SPX7HAPsf=|Cd*yP+Y~poL!LOS*#UtJ_LqIs
zOrwh41K4+sh5#KTvlOLxTx%YLsA9L{9d`RL57U&Lb##Shs(o~GIb)#nA*UucN%i_6
zb`b#ydls`%G}I6U6K6+`ciZXd7Qf48KZ0!W;>>h}U?|SSJ9}|G!}bh9$MZF>_{JNA054?uXx_k9R$v)!qPr$aLd*^xEXK?!Q
z6Qf?XI_`};a08M}+yBQ$uHf5xd!7l?azzA*HAmy%y
zKkXh9f9wj-!lqWaabG&^JlMl`uRiV)aKe$25I5@UPP-n=Lh)5}xGpO5nqHus$O}`o
zgq~kE++TkQBEgH6?CTc;RTO=kE`po
zqOgg*>Vn&JC2eJ5arc76n)E!Izu--=+<#Q~1EZWt)(w&^(M1qg?%ZK+Q}2bXa;Y+E
zF8aDpcr6??@F}-CPX_c(76~@ify0tWY&OuC=pp>y`peLTPhYr#+@x}%P)3w*pF{qN=5n{LD$A581c0158h;N=8j$6+x6%0wKi6z^Dz#3zTvL&Pg$?FRdox1niAnFr#
zTN$Dc9W{$e_%%I^a{l*yK#r-a-kNhTzbL;c28<*3I;<5f!c|6vv$gVWNc#=Zl*6U4g
z!kaO-zKT$=Ynb!$8;{Ck&Yr0QNa@h;=mA=%&3TS^&Nk&?}i@T?VTK!hB&{_HFMw@Rt8;N-#zM<)r(v4o&JCCfh(?!gpKH`4MrZ
z#ER?K?!-%d3nTai!>e)G(2XSaJ>Li9y_lnrrmUVoTl{z_fNya`9tyx6&lr&BwwTx|
zkT#qfXulweX1ef~o|Hj3XC~EOh_-yR1IkXPxtBVg)WIuZH~}z_Z=-Au#B8XSy-TvkK(bO@P(o1AdC7mKpYU?K)Kc2kemknk;beE`@d0H)Vj
z_SExdw)?pNu!RM(h{q~CFZwH)Or$t22Iic*xOcGrT?mK$;O4p$h{YP8QZ$lQK3TI+
z=#>?Fngdh6R4tq%36&&v36ml{X<@8rd%)0=#q!;PxhtItC+Unh;s^U3aoa&GzIyAq
zwHGgWQobG*YD+Y=A(dZ62|8_=dse%d^AN|#xt!L
z1Z3OUl=T-!g$N@EDV{e3rU%9S6Be3glzY&LEiuDEcqiP%!K#RI^p=au^|&X3jR=l#
zXs(HrYia#9VsI=tfD^7?#*ydgn^KWSv-k$1!`pG6i|Jcj`p}IkbO?P2beLo9G^u~P
z5%m1%|KpuIZD*#i3_1iREj)|lZdOT;ASY9MKF0FjZ3;5C?co(APY+2mPzu17+fT@g
zUp&#e(_JaXElj|}R#!!ELD1)^Do~*9Y?rC^x{rpP^+#El@}GHC{EE+sHyp_GU5ov9
z#srHYuSFYMaTg}Ahm=jts3WzZPmcc`viQh4+zN3)8)>|Y&_m)}iU)1rLC%cX&HH1#
zt4wUCH=M>(U*k>LcH5iLf2NufBJ1}AFBo%Lmf*$#De)Oc{qxd^u39{TGvvD9Fxk&%
zhZmtEXRc;B8+C1|$|4s*3iMTrZ}ozX*`-$O?dlphKQ`P*RX5@l(s1sUek3L525~}x
zFnahC;Z@dPxUpmK3d_VMUcLSayy3-yl4R>#)&jDK7;$$$bzXYk<%-X4!ih42u+X@Y
zt)uyHP)kxKC`>XpL!ewJk%h2i)O^`uc=)K(#;H<#ZTJ(|%;v|0>Ogqhfa+(6r!Vju
zchh5&`@V90
z)eLl{`E8Q0*;i-~E4H!XnWWIo_HAc>SL*&JXZdf}_V)9IK3d|$5yd1EL~p$B`~H`=
znr0t(7uV~5c6$zW8q@{-%w-4wdT
zbt(1b6uAIoqpK;zT3xD>U6?M?CSE)ccq1nPWz%MA4x4S34bdv94*>7NSd6KudL*bl
zhyTO4DNqNas;&?yl_$Q!j)BbKkzXrABu}wwO=fyE=VL4ebuJN2`-*z
zn$P&o6h~F+^)S%SiCswqbIMJlgk*KPLZe)EDUOw3Y$`muS``?yvKGvGPK^?6-KVFIjV}OUnagw?!PDXJ(
z$Eub$dNvmjSJyIw?PkF-5O3E?k|tIMlV^td=%nrE8*r%d5N@w3?SAwatvUV%S)j
zk_L@k>U{Z80}#_dixlU>5L_~TyD(H+4gG?|P|R0Kl}XM&RqyxZvJ5SJ{XXA+zUfeO
zdc;IdyjV`liQ0k&ScoFxXMQl8|?tfLQ%6bA{tnF?9;5r2~qI&F1In
z&p5#&AJpFhR-paPpYUf^(&U)G^fBGAN`X)Fxeax}_KIc~BiQ|9I!gjkHy<&$VK1u)#i4Za$+44q&bGY!e
zu$o3`h1O1^N*V1aOa!f&WZYLDlT{vuO1^RFNnZ_l$Grx(5d|#(Op4ze@sgQ^TYvbQ
zvLpyWv{aH-K#!ayVlHm<-TM%Y(PjoKum(W!6*00i#{{cXR9(vw3{QpLYyPVzG2fql
z4b-SJAgS+>QeY)X@^K@cZ&JydQ$sR7{laypC|H?W1+wJumGso0$@qsTFtG13rY%cc
z(F9lMf5V@)B4F5^1;&(^(Wug3Nm600o$xoyeDcB~(OBOCPTXEU
zbCD)z$E$kmBv7Vm2>EkBAbVH0_VQEd(d%Aq=&+`mNSxkcl*_T5gF}p|2bh|YGQKyx
zwi16w%)1#${wkMy-9A;))1%PAsl?~AS+C1iBtkaq9U4sLpE%V@L-UE@X?x~?_?hsPU#ngd*}NIh)Ck{gSVt~@u`xspc*ez>tY;HsFo
z@0VTe7VpVRGn0gj_9G1L4fmy~iN(IWd!YXb?j{f_CapdzF#|ALaWYn!)RS~+3AK1{
zje?Q~dxP&A?OX}rxU9^BP4SGMutF|9#DobD;6+)<{{l`zJkp&Io(jV3r!t?Wth8K?
zRmNq7@pKbg`gAE(EIz9-$*0HtDsVT>_IX3)2?sATZLx=yueWMW?%#hC%N0NmALIFp
z(RcT|%TvA5?h7}s%W<~_qDy$rcnX4D&Ino5yF77=msgR1%l7VrGEO#`H?xhr#-EOk
z7K^(M?a@vF7z0FhC_S(^JB>HA?q_4oZpK9en4Or!kzMyR^CL`Vk%*8OzcE%VuEv^s-(@ZSiJ;G{9;{r*?;7tS=dKA}5B7T>
zqCGqt8>2f*Z#R_%yQVLxFq&a!AV%yG!QW|MpDwHFi4dRJ-4AVsZ!(LB$TLm%K!VS?be7hu6v?k*YN&-moVnEeYbS0_W>1&}FY4NY
z)ug8=@oy#eIk>bFLCs`T_NfS}5Fe*>Jv>?y`oU+xE(4O9rP`b!~P4OdVLcYYUv-sK?`^7@75Bsvl#IsslQ5L
z_^}?btr|FgTf#UIDXVB5#hMTXVcDg|h*wHNX-2SgR7^ib@x3@3widRxYe!fhC}P($
z^!VM|y6;D4THXRv?W$`*y>BBUSCQnaVXdcy%o0G&~l{Vrf++Q3HB=6
zSs--Wb9Oe~_tt>BPpiHc1$7>4f*O}gr|W$nMEVc{@~2BVvn4#Q34pb1U63J><1><<
znIR;TF?5V7Q3e<%9pCBPXqPleBmHE;1oIaqwwN{CzHHS#`n1j{6Nc(f9s^$b+V_gE
zmYwoGupY>n(NfKiydJ*(dqdU?AyRgNMbY>Mut-{gJ@2AUi(O=ftv-Es
zq*)r!I*XFQ!6F7ZD>NE>R?=pDQ9F)){u6>$NTQM*i3`sjhlo(zvIBO_C|;%Uhm(Q`
zuw*fEQt|@+w>HQGISC~^L?gw`d3w)j*p+ZA2NUne`KC=Ud27MNy865y9&?|vg^!Ho
z3M*J+=81WW>x;;!SF)|CN6*D)m1$hMhjI%6c&4@EjS(X%RQlpH?
zH5*~P#zoW2gdr4@0DWUysX{*0PP+fFn9Be6fbUDRdXRP9_ZE}19kB_z0W2WN5*{bN
zVL7oGG?o8p44%C>C@)DGSXa(w-i^olMK!SvF}inM9$#sO$10lYhmuhtVY??}s%3_E
z+s)eGMzxuMzDHj@mMCnMGvK|Sm{XWLZ{sobJ=pf}^Uw^64lyMz?16Xfd9AU>r^)ui
z9J_L*?Lv-{tEJEnhMvGZZ#x&~{&ZcVgz?@R&D-zS1foG-yUHN=KsdipB_Jh&X=U?6
z4_J&j$oO(~3B&2?}Y=a&AEH^v5ZJZP!zOuu4dt-d+0?Re=
zfv=NCRa@-NNnL~Twbh-
z_1R1pL|D-2XTMtsI6l4(FPvL-d0y4vC6thdU8<_Z6MUseHV8mGrou8Vrw^j-1Q~dnpo_eOA29(H!`N<`QK-)4AtpOSXxp63HnewLPxx{<;`_G**^2f=~<9E9GOqI8w0AJG&Im
z4|6k-5*Ddpj*inchq>{`Ik8gXP{%l)p|n(D#=VL3--F+|ZwKpij^qo>MX9R+c;I8>
zJQtaUf?-wv^aus_4L5~^15TtKb8)pE6>b3?G~y0O9O^GIsITy3TF%baz%N6sJpME~
zA&$Ix(nGW60Jp&T*;sGY%(q|0^zYEN_Q~egu>BvhUbm(7HEi(IP9>sMmL7pzCIQaa
zEkBH;q0x7;iDtej7767IrBbh?PNR0!Ik05>AEv&+JI*g^H@0ni!p7#rwrv{?8ry0b
z+qN3JjosL`edqUm_pWvSfLSy1zUQ3%><9Z8+%*{VKL$5B-}VNaB0o{Q%}noh>-^}C
zkxMsmvuaaL(p-P>_@8ID6o{F?r!Mhi$L%1=V{YQ^%Wt}HQvc5^aSPnKl_rb)G(_8i
z8Cy=(#`3W4$Zn;bGlA&?pQD*;cYF%zwr36ns4{SDO3SAykdU3l1Zjgw0KDs@w-c&b
z4exg>fzNZ)3;^r-hDdcjBwMbN-|r?1mn}fj(4ByIUNb|s5%$u=ZR{(TXBQ({ECR%Nuje+;`@MO5#Zzgt
zO}#-51xZjpD5ZN&a0j5hKm?Aaz7ic8RjN#hs@SyhcGjb3rR-!@ZSxA=PZAVzBP!Ci
zP;d1h#b6^>clePPKUyWBY8obWp}byNJVzS^)7=8toqpIn5d#B^(ozr$uv3NmNz42-
zH4U8~N6dzCl;?&JaJ^^aEKB0}{L*$kdG&#%*Qp9ZaZ%b-;j9-Q)^XB?-e_ZXXxEJl
zv=*WYDYmp#^O?@d@aIeo*Lx7Mwupm%(v#%niEhjtsfc*7s(P<1tR;LF#@t*?u4K>~`a;-X
z%|pw~5ocA8rf&umyF$lC0@)~j4NZ8Q-Mnjb%}Ik$2k+4c?DZ|+&+P0fwcYD&S5G*o
zgE1k_SXm0)i_fOpsNl@%N}94z(ZUtiYeb2=!LxUy=~%EOflx~+`MsZ-=qBrI;CSqD
zZ_&{XtG#|!7_)#n8KL8fwgeG-{aWv_+BAma7L7qIK#JVzC>ypG3cl8?;SyF1h|ABi
z>(;eVQflDl~x%w7nZqz|EV~b*@?bmW4D*;DxQ#_$I%j
zQlF=nl5mgnRGZ6|QC{_H=;sUN=uYj6u$Y>e|KjxOO`k=AL7ceoblOwk+XRM|x&I`1sCItKZ|5UMQdGcq%)A-O+(?wahVWKw+%Zc_s
zqsc0?u?)W%g`_!XYCgYNOKa?|s?vT0ElR`#;}z+_6DN-j{1zo8c#E&0<>H$R>_?{m
zigBfG8)r_HI
zB|mV)pQR?=%%|BL-3nD`q(9IIvK{sPm#i8ZxMPF`9xznH1Ta)Ei%!jW-0$(I3ek(d
z;a4A@4^(~Vxbydb6~lYL6Zy|bGj6s+BmT5U|LDtTrCAAzd8p&xeSZ##*qe?q8l1Ol
z8$gQoR??$fdb~GLGeU_-unkf9OOXR>Y2bRw3{t_kldVWUu@5)=N%{ErhV4FZd!MO6
zwd>yka|R3zid`SK;)fOowb}FD{GaOuKvfd9Nn!YFeb5fF3Y9#j2_Q7y9p!AEz||6q
zDGol{@7NjKdYSQ5(kQ>EPo~C>hw3*B@hpy?uQ~esgqyRkg`Tw*2?hBzffn!FqR7;nzL!|7=mf?0%0MrP^N{
zpuW`^4#vga47Sr~`X_~b8(eW~KguXtOeT-1ItFY4UVIuM|IF+bZB%PiWK`)ZPqK$c
zxw~3A|Q1}>pE#Z
zkdHssWt@sbeDE%d$eukg8O|Wcn?3{$qM0J(Qp-ppzO_c;)Q@=c%x`%7&=<{JO&%d+
zslmM)q1aWiev)_EH`+Sw7GI##SgT%e!G=n_KQ2_{`{9G|K%|OUgUz6>KEEA!GO~hG
zhS3*p|07AkK-yF4^$k+_j!Iq`zsJr#7tY@
zj29+QrHw*CJ}ge7jn(5oLB8myDFAN^__~u+R36F4-ONbymc=AM=!ez&@Dpt1UkztY
zBXSXV*#}Xazp7&*NPYEtATFM{@Wi;CM!<(4PQ9ps-
z$|#Ohsh3zTokd(uoIR5uGfYik0s-L1_*I`XRms6yf-MDY6LJ=vGBqtWQ&zaB5rNSe
zq)kyf$2UBpq*3+q0>3MUu9vGeX0Gy=pAMP`S57y+`Z+0L%9t?V@b#7N{^?1s58j3b
zyKgcMW;m_MY7!r$0oQwWdfO7h6z)X+jaa*CM=o2W%iPDivy?9&tspH9an{H5aFOSG
zz+m)qQTs)yBZi@)?{_Ydv4cnA|4L6J6u=`C@GfkuW5x1$zfMtni$XZ!><5F(dz*>=
zXCyM5k4V_0*}gQOjV6K`uuMT}jmK_@MMMh?xSqYjx{hMI@U|YdTbY|rs3##aiI|yW
zmLDH1m{e)j1$k*^;vxb*YbrOS9dmsJNq+1?@3TW|lM{Mvdf@)IJ4=C0(C90zL*hIK
zAyl&7cQ&{G-rz~3B-JN+f`zZa3MmG2yY(QRx+){
zy=v*w)Vh?#{FMiem#Ab7Nze)L_-*lIMFW|B)4L~43@$354#}obaVeN#FNsm$h^a9m
z4I=HN#ba@mz8MbY3QJ@R7SR!W^CWKlH-1^<)62r^!6thK1(8X#k
zI}AhvK3irD!oyVs`dpV38lWrRws?}l03o1
zho&KA1EG?7Hblz=qfK^P#%BNe`(=<*O$6sxWAu%8LU$gdy&jA;tVj|j+gm|vh9&zG
z`T%Q)3=0hL>Ju8Yy9jp5o!>nW1UDdL4YF8$%-Mxp7pRE*k9m+tmnaAa{bp0BR{Pu}
z>gqiQB?Z!MuZ`PK0NH&SQf)hj!yC`fq8=Fy0%0ix`eYkHEw8Nd_?kmC>{bXDmAiOD
z!ak1+RO&;6_GN#>)wq5Q#Nj%&u@vrpy32C4a3d?P26WYYc|N7HuXGDPHoq8KgCWA)
z-~70ZZ&CsAt#-uVjsN;!$?}^yAa5RLum6Sjd%c3QM=J;lnPx_LB}kjPS)ndHJdv5&
z;BBr)K8}1}7#?T@ckUQRN__zIW>xPQyD@|*1}l3K>Z8(&OYxAT%ZFlxbpHjbNssuh
zHaOBFgr!e9iH<2c4s45Da^RThpuftey)eBv$g9#Nd-+6k6m3ve{f6O)RB~$Y6(hLUb%#p9P^W3pv4^oG_B!?K5?pzC85c8s)rP;ZMw^5r8u!s7KuKOgW=iR}6y&mVM5r@UwnK~U)@7Lr8
zeyFt=8yl8EXe|-8Vq>B5jBlz3R!bm|
z!o&r7-258^BfL5LNot@1gmT4mI#Bw4h^8EXV*qYa7Vs*u-gs^JucnY1e{^B~lUQqm
zHIJ28_+4mW&zVwoA4+9-3MLMm{eNiZ&f*?doNR!2Vo{
zv4raZ2H3$F<`+@h?Y7bOUx@Wtdv$cDze*63V(c;}LE2>HO-R19(
zUAA|N4;;T{-cT05cIByvHdC>#O
zW0PuKWMeJn5G^H^F{7Sfo)ec`X7Z3uQY~wdxX7q&MpHmN8(8eH^KUP+-dc|!${DJy
z`gHg@;;{b@F6+xsg7NL~j<)w169vlNk9X$w1}r|Tw!vHse!!XBVpL*frCzcE6F9*M
z&01&MxQFLnEa8?5N3v-DBkr-JYAY8Kgn-MN4hR&|L&M00)Indjr)ReEq;Mn<#z?C{
z7-VUZU3=UEB@3oww%e29w3}=x`C{U4xvlmlw?_m;{1+q{Nkq{gTysNW^~6f|3q)Kx
zh|^iWsofcenc|_F*=z!7IoV6&iz0@dXX-5l-cJ##&&~#u9OCd6H-m9o?M1H6f_IB_
z*AnXoye&_@3;3RbL5yF8y4-37+=RD8awHc`|Dv@c&O&%q^y
zVR}UH@m>w)F#%G*WG2Hmb90f=7~mqWy}mV+R3QpN4UAi^%t}%z5MMdOk>`2N%%BYv
zD$sLut|eX>#Dw3N^(p)~YSc>lQ))7^m9#+LnR!f3|E`=Te#muY^gYt9ZI1e7IN5vC
zjhL#YERk6RaBy=xaA%kK#%)~S^Dr$9=;$aW-6k~Vm=-$L17Y}>r1w}
zY9Sk+{dKrpr?l8qw0rEtBzM+iS`NCrOgLkG@>x1`XlJ}1ISaOekQljMFks-UG;K4bC`t*G9lc#0~-eERDG(@E+1J`oD1cI6-VWb2R_{#~4Gd#_FKQ
z1+lTQVX7rUEL&iLtxg_M5vzJ-T(zX><$zt-Dup^;MEsN!Kadvgo}Cdn%6Y)|daz>tsSk
z&5svB!W}f%lWJ}1kwWrrr->Ks$G#8km%k}9qeS5zMG3>@-gtSL3$c262I2NSbOYtt
zM}=hF<6sImc&){5Vh7}Ki|1(f)`#o9G89bOM)^q6k>_*8{nFW#=_yzAegoW5IwV297qeB>9Q=CZo2K_m>8T
z=ezI#B7NKe1HjwNZ6DJ$g3b^MA5osriQx0(K$xqb8~a}sYU|oaA03^e7OVu?(7XvV
z1_L6J!I!^hnmRhC8N6;r)ht&*CICMOh%B5Vc^ARknBS|8KIoK0Mvo3-A0CNMKv7(K+|4B&OShYW?xO8{GqB_^_S&}}&bQK;pfSuLpfC30S%14qH@E@rR!%M6y3ajmHf;@Ob9XM(sm6Qq$
znN%UpJT~Td2KQNnIk!eC$iPq>{S9{I7}sB1J`0uZZlRK=m*98xok}WR!oM2Dph}A(
zg=yj}W?O}Tn=!*1BY6?xQ2@~SkJ{^EC}8vSvJ@*K`miyL0MbF(%j0>bUQDK6BS*;G3ZLV$%mw!Cv6HmT=gi38h8&fBCuh1^bZ4@>X-Kj
zuU}6g9ZB6kP93f}Q3?7zhx*Kxb5)wGF?`_4a?}~4%QzEc;t-u(*V@DT3P@hWkG
zEyD^TC}d~KPwMrN;cJhCY!qQsofAdS(OICkPzw658ytpJv6|eIRW~>r?#(o^a-(*u
z$9$usM36crf|SgYQY*q;?Q=atpat5Ewel_sP+B7h;)+erv?`7@D<}CwmboE+V%y5B
z)$gnU=30U;avWY@zF!1^nQ#X7W={7lZ#IYtueenT)@^{-y%jd*Oyk}h0BY0b%Ok1a
z`;>TIhy*;p{JOtZiad|7ww%v%gB^NS9A~8;L9@ny-1^26WYPt2DZBFDZ*aoyNJpD)j~K>2eL
z5saq1WQLWr)OH;PB2&`cUEbJq|6=(%tt?@P(b#-PY&|$50+$x^-bT;o)i$d=iZ)q-6!e4rW
z@g$9y^%uK@5{vs&sj)Vfu5K1vbqT&DPxP>yVYmrYB!X2tX+VAyHknZjGe)+Pz>%{6
zi~+Ywp1nwC7v#gkWF&C#czvl9#p&(;c>$ud1%hgbbMV+qslIhEW-t2$7ArTLj$z5D
zC2TLudp@j^{Eag|#VvE(a&EX6`0?onlF8(0G!Uw;_~sr-gm=(79G9H_(Sc>BwT`4)
zy1RRrs=qlGzaB4%G-NP2ID5w7?QICTX7HHUulKOKmt0-e>+h`7u55Xq+Xl+4^fv
zT9Fm}+^kJr6tt&SyZa*WTcKDF5utBlNx2Gg9rP?3hqaxPSrG0b47X@`TI1l>fzhbZIzWJYuaLujGKb&M+Ev+b
zYY@69hrtY|2JfGg)-}j@L4HCRqi)FD+RCvYWC4$h{}62jFJE>yZLmabT>&emSK3Gf
z2hnBUutIctH39DtxZmgWMsRgyW^5XkFcNY+iFAuWkpkJv?aa(t1GHYNeJ~}3T}x|9
zy+*Q_3R$pPL)ZRCATg8+iu$z1qPwGCVE%Fcb+k9=ih5i2RH$TrUu&&$qIceob^cd-
zEfLy|B}g4;4E;Nmn~Tk##=c~m-q6sO(%e3PsmJ&+m(l5-qPpiP{fnHWlPsUKE9U48
zT;ncRlxp)IPnD}{N;XPCTt>$ZuxlX9r+O2!7|bM~h=4Di9w>XW6$Y{7{#Ab6ej+sq
z&0sEN?y?^;TKf8yW(HmZZu3DShx1X3Pm%vT1$E{#r$l#Zl8)b$QP{a!Z(D<-^F6>9!de1~!Gu2=
zf`URxEy!Kw(rmF#zlFt)c_$6)+88%*J7im>GUUMfNjB3wEQ?8$U%r8nH{%Y)neyfK
zzzExgf^;2eGMfz(RB;aYp*nt|pSU_h0!gh@V_d_CC<-F4|LsL(#M0ACQe>2b!1z4$
zB;2U+@*~Wc*u~=FGx2RFy7A&L?Z7JDOZ3%Zd6y^AfPifzZLY>mdXDH6xh)
z5;naZ?PM5rcxZyh*@-MgdMC8b_vI<@@i!SnPcrx1s{*qM>z7bWma2dKS8XOKQsm5T
zGXCNoREpE)MYG38bau8!W~|B-m_hVoIHb*;#JW3Bohf=Z-~XxAg7*oJ(vBrG@GS5a
zWQ(0pSrp6>RVShi|4v6su1R%zdb-a(OOirp0wK~x0>!SH?+fl5csOC{7B#9Ypa0-?stX}Ei^bVr%A
zUwbqVY8{E#{?XX>x>eDoLDCubC~U+>f?~7s-e236vv9xQfZ{Xby~_#>22{o%v&s`E
z4T_woWHkH%NE=SHiwpKXIZW0ac)C{a7u9472t(mF#usSa4kR20d6Y=LG}FIR9A;{?^sEa
z`oqNq7~HqkOD{BxylN#*9*)SPQQ4Wz4?9#BbBrMsl@fp0MZX4c95i}_>inX(;Y!WoY7qa%0a-|T7Z7Y<+4
zlxzx!VI4c<#yCAr?duO@3Ik6X*o#b2X2?Mj6uF5V6!}@ZTAD9B
z;r2;-I0#VRJDJHE-RvUNZC4A*?bDw(lG^GzQQnz5I#dbEO@s77g9?3!u6&X@n^VQyja7Zo_FeBZb(4Yn}cN#
zMQ#p+?3*rOq{9Y7L!%Bhbu~|`q2|Vgk_#(zT}@)f#3W~OWHtc*Q{XHC{S7_T3HL6!
za#+DbyN@7%`NZbk!`bj0CySPL=kRY^DwJJppU
z|I%3T?Rw>%o~KoEw%FJxm>pkM!Tz&dk-$VwOs%^Qdjg?XiU03ITr<69bQB|a%y3X4
zYT0%bBd(G7N+~w&M&UxXCH7AZZ%X?@Z3c!fH_bod;K9mZO;Zw6;}afIs5XQ+nVA^U
zOUpaItc+5%pD1aFqA#aNs`VRSs*e21Y`HP;t7M^9m#(il%a#~3vD#2s0@3U9)i8uz
zcWrR&;4*Z^wN5IESB`IcNAJgO|MgwPx}}q4{(|3c2*If@Zm-9zkmaCzk#FD}_L1Pr
z?f$7^MY%-vqiduc9or#3R7z#xf+0)ZwbLKcQ7CNm((fqfq5#yRFjiu3`wYN>GVCQW
z*Ev;=E4gGZp3bdX(URZro@+qv5^UoAngAnguJKSn-J^W+5lkQ%3tPl;$cU!ZQB-
zKo(;GVm-PTN9lr&q9
zNN;m{?iUiqE~6U8G7LnAgaNVYFZES)@y68yf#;7qp5d#bwti&%`AzGFa=!)W#JhEw
zuYzaJ;@#1%F231?1qu!KsRU`B(7WkRFMaoyrjmY{V`r4k0`PmQhtJyCw9Y;Ymqgia^h(nZBAa3Zg3K-lg1AyU}X
z(ZB5>Zi`YU4q<253$=JIk4@|$c&##agvJmP4L|TAd?XO`yE0P>Sk!+NgY6VOD{-%P
z=&Y0#FvuS-`E7;f4ia~ZX^&wc2;=&Avg|*7Jw#PvTIJT_Qni;H{(N9(shC0@OJS3}
zEAT$D;DsfJsoc)j8(sQ0M_&c1laF46ntbVUNh%@PWdj=l3tP>Sv8
z;sZ$5ap$f6yq1E(e~XMl-E}6}ScEBkAh;<@_M&O*n?Lawub!|`l9VWPEBxhgl+_un
zj_G7{k^Q}C4`kZ-%^IzrSSgcNWY72)-85G7sNc
zlBrvZHl58z40`GoDFY3qVfs3OT6C<5k}a0JT*V>_w7aT{$(43g!JV%ejVkVPri0qQ
zl%USBs$Ip?C-=?QO9)MVO$-WRU|s_p@zXIh(CwR|&!pQ#wYGeiVcak^ce(UE$ZNlC*lY1*z7JAt?lp!tN*>t
znEhUt_kA!Yk~k-Yxl4`LJ=H;pwBwKi)D4**B@+q^aw|_HcNs3t%|rpM1sTvYmIZoo
zFZKNRqMZ%XbM&ecSDO147+YRi?Wx^cI^fHW4J!O!+)m)?ooHUE)J(VFpG(M;nTd2f
zUp8rdsT{vgh^*}erwoci23`~}C$3}iG}Kjp!SIy@or9IIvIb5+f(Ez
z+pSZ$tQjf;xKQJY2g4QE~Q_F}jE26OvJfKjg%
z0pPgG$?E~KO{Mhoh(H8}#_xb97zq9+i(Q}@L|T88iFzTe>emN5V2Ip3a7OQ8Qx~gK
z{Z2qXD_$;tLjf#SU&gdlnaF4b+jT*;i->rk%HLaN;7i7k_o*2>yZyMJ;^t}mR!eOE8h5)rmsfkO>GSPQ7ogM!gtS0^a0
z+*KW-wu!dLXEJ59nY0-z))!3%TSaV}<5Rw*Rg`S>nxj1*O#%uNJ;
zaR*sYdQEN|xV}yS{@vWyJ6hJcD37bED!#o4ty|rie%~vFS(H2_l7mwrFh?qe55Alp
z(UYpv0QwkCI9s?(4<4K^DAC&qAfmI1cfF}w(R0`0gTg(T&H2Cfxu$7Btz*74tXced
zr~l}~c=pi{)C#V(0|eDoh6dA{m8B(`U71$*m+j|~Js0q!Zc$b4?ZjQOh44sq-!$dr
z#Fv4+lPAS`28u>9G!t_pBNiG3ypWp|n%&K>kGsdz+2E{E+%i9edB;vnLT>w^{=Jdi
z?4~cZzQ??;+m-*d#mO;usUHIM+$eSRbX`8fa6ur$+@C^6(YU2pcG^c%M)JU;FH5*i
zrjr(QYCC;bQ@wh=qTm;Gw`dTPraCQw(1kDG@tCOOu3CEc)w2UMzQjKFTHNveT0YfP
z*-;joC5JWCDjX;FKYID7f0dp7u&evsTI%__)zl~mQvY2}HyTB8COT0By!Yt;gLT>Q
z3(C>l-|_tbJH^bIXp|C4_USd)E#M}dI>`n#g8--*eaI4sc|lIq#FB}#8Q+|E%ArL4
zXeNzCNvL{4q|ggSf>=;AcaCs*jDPjR|
z9Qp3|xhid;A7DZIWR6s{0cVO81j|x;&N0;QCu@2CC99+vDLm_-W&`>oXcQ@JQDn!=
zIv{DXr@Hdq1tHkfBwbt`aUG{gfJGR@0H)A)lK)4{*y7c43
zHj#JIZy^YfWM_z{%8ao{rNGcvY5$7|(zoNZy
zq?!GXM8TjsBb;4crp>$Qve$s>RX^x4iC*`1yqTq;(-F7DPo4R4LGdB2y>_Ep@d<9WIQt
zIDC58?)X%<;9HnOO9^lUH6ch*Co0LzNCYy|pj5Zi9o4i+3L7NTbqv;w2~1IvBRjSf
z>?a(E?^6m>8jj6C7Ey9nW?Dj$xn`b23f%`kYIhGgiqkHeK;_OmY`@P9ELWA))Q+
zlSyR-tU+Z|zt3&fjX@5ApBKXnPEf=LfcmHFpeLf>#WSwm#kk+c^SUz$Fn9q_MY{j4
zZwpI~PtFI?VHG48LGll-mhs7YoyLXaZNJkx)6q0DdIjE--xs@WwJn;$$f@<>I5XYi
zvqhkSq|`6kNeH+Y0G6^X^#K*I5)PazhI?Pb&22C)nHX{0M+I*DN+mhqh0aO2&?S1y
z0P8mU&xBr9GgGj`ssV@Y?79IlO?!d5h6UQ&J9}HUjxi?
z)`U<~e$F@Q`TajVE6x(_Y8V#8unR&W#80DWn^89dt(7DZ!e0e_i<`04;bS3MCl=$A
z92BINxOdX90p{rYKBE+~u0-vPP85f%62}#Y54yFyeLp+1eYGpSuH3oEmJU;dV<=Bp6p`s6gY(t%|&ICrRr~5m90Sw^i}R>pukFu
zb}Bh5?1Yu28$U`>6x$T!4mHi9X@*x|e1RhauI#^!nY&qhGV-JM4O@K?9&X%hY4@CR
zA~`wrYccbpY8eTm_I~C0dV&*!G$6l&+dpC9syq8lZXor$k$$x?r!}Hpi$tX=*x!Xhs<0F#3EgX4>KeXYrwzDLc7rMI?>;fm(D2Y?m~p1(MI0SBof>$~mcvPX
z9qvqqwPU~)<2W+E$G%g8sm?BitLr&tvbkGRflU2DwS}OAnUPl`SeYT<2uCZk|u5WTL&#o=;b3IVt9pq$9bOHhXgV
z+HV%ubXU0FT$YZMMhtrW!TkNPtR
zRq)i!s3r%B4CS;MY+_X*{I=%+b&>rOCuQeSMy(NhFPtqLMRhDC$@C{?%*)Xjm*XCa
zEW3>s7Qj4FR>gqscK(@@u*Jb!eVUD!Wdy(mx4zd0h)ZeYzv}_HciXR@o16D)ja;fg
zsz+R0@!1@B$OvIBhFgqTxHk~6jMSi&Dp**kF>Wahj21&Ysi));5bubCE7B{c0*6=&
z>1Sxu2rcNiw$?aGb~O)%-yc_oGFw|~@Eg`Gew*Vlztb=)(D-nrzW%}tp1xcsgKw*w*&DqpzRI^tr
z*_Ip-);%6Q4_QcQ&Yqn{uUN)hH{^<5I
zR27lu)j#EWAO@h!5H-)d>9HUR8WwZ#e8BQUBTd9LzoAg=za!mMCdyQymMRt;Sw4&072CSy~o)JU>6*u9FfXy9}2`YigRhv}5Wpq@ek@-9(E`3cDgV
zB9PDwSB}nvf}s=>X;k0Av$o^)=zj#B?2C(mhs*EgTRSTT?d#T;GVQjK2lJEw$_^?0U0rbOR+ym|(P8p{LL@^7jLp-d*D
zT10#QH(7Zb#sVQ6aXB+ckV~3I{|vpR#yI$`(<8_GbL7qodJVGuzW|CIwt}o~162CS
zM8bM0N>J;M_w$J$sAj0ppuq9IX2N~T1ZEwmK7n-oXAICViu5yK!N*kyV{WMwm%W>4
z8mzG=vZdhl?Z$TXRt*!yP^fLR75>^riqHaUk$aINFV%^?f-J9=PyTJm#xk_izPm3&
z%K9?nEczrrH2bS}@20KASDz;=`zv+=84yL?9i@eVY9YFMvc-=&5#Re`-fS^icss+>
z!^7c=w`1{#FJ0%v*YIeg#h-Ab6%uJWF1(dm&;}zD$uFft3F0wx4x!pWS<~!kgPPtq
zV$Uulnq*7|u@36`@b7q}SDnpqR0k44%AN?JbIP|R2*Z=){OHx~(b^h;LflUGznDeZ
zJBD2
zxpmfi$0VaMMCQJaQJOF?fR~pYa`67kbdbj4^?)C^#*qz0z(qtdsyxcvsT%WC@NxQi
zj4_;_y!`(Eya3D20vhJHvP3c9mD}8jrp)anK_(=B444G6vbKDgD8fAz~
zxPj+<p;6bQcyhV{EUns8?4XNL<8q^mLu64{~irC0qMxZ%>-&;;Ug
z(?#_eRTNJnu$@65WgQEX@taX#U_Ccn@#3C^BIPEZuMlWkLIo+jYV4`cr33KDW}
zxMMQ6Z$o7N_ir}WDZKWps;ejwW)L_f;wqbw
zQ4hF4BP{*2sc1PJqh~Rkdy`lj+`SW^Rc=
z;C{lVJPw_AXFs-TGQQE`-g)mH|B8oT{POP`s1(P-MN|#>nkr4ed1Q@89<+OEmJC|0ua>g5eme?V8e{;WG~McEk{
zqkGO1_h?$)m*w@oNMahqMcZtdm+d38f3OJ_=z5_g79>5Q1PRO(iiZ5u?Tx$zixfs#
z%Tb~5Q3>2iG$M&C{Q0Z{QpZ8n-;ZFiq)D79R{?D;kSw=ectMcHZ&$3xPDgr|^xA&>
z(;jp^%enDem(BB_Gby^INa`mpwQ6TZ@*Ugu-V$|A8U!3&DcM}+`n8+B7x^h_7N+&&Q-QN%p&<_Et0xNsN0k*b
zsce%)wpm;lKNYR`L|1-hTa
z!Im09ni`G});C!=u$ZdksooiBPJFx9x_dC{p%;AfbTTDF~@7;rcZ#f5-n#0}wY
zk;-+6whMhQWLuYirO(yB+Wd!
z_%&@^j2olM5RB*g<@oZ)_&PaxM6K#D_N`6+{QTyOOJRC3~2e(Cw6dd=*|hnIkj3|
zq@i(3jbb-^=O%*o4Pjj|b1XF4zHG0%?#gv(7y``T_#l$SNSYUc*B(q`8C8a&)fj~L
zO7kTVum(Ug+CjGX3=_vMKT$^37ahRt<2xgUw74NRCvHy!Yl_|<2&PLUV
zIArj4Z-SpToKP#+v}6`OGDn5o_UewgZf*)V)<2X$e{<^1RwBhz=ID*#J|^Iu;#jRU
z7%IA$%2{ZRIkhz)vkq~lG=js1++vUVg@ld>3pv&y5)&S6AIS~gh1#{KoG~f+Na`WoAWwgb3Iy?vep0K_)(TygvbX1J96;JD!EKq
z$6R2=g6swEP&fc@#+ae@FX(-f_{xvs#Sv
z!1&R2#1`Kda<{{6ORw*u{W|Z}1UNlSOZXp&
zBl5w#b}vTLXbi6a5N&^L>L{86&LGtH{|{Gh9oKZ&y^kxR(y7uQY=j^o-AIkmqJnhD
z1c?y>qd`KtHcCkeMQH{Mqy>cmQj%k&AV`dquHPG<=Xt%pzt2DWb9bC`pL1Q;IrsZk
zu(&3!#?=!TUPX8@29^1k{efHE>(RXr4K?i!E7HMl?fTnQGL}<+qlyB*lTSaf{ftty
z80}|3<`k3B1wK_98MitK?uaj(+(hlRFb@@~eBu9+G#77ZwiEaLRE7U%4}R*W!@bJre
zP*Jp@Ny5hs2EB5{5NHa`r>UCT1&(r
z`D)w~16TP#bf+|N#C89wP*OSKh*_Hmifhs5r%D#NVmJiX9G7PD8}*2$f-Ap4K9!V^
zPl@lNJ6Ecqez7~`CfscM53xOc&qeRCyV=sXfxgRl)yOWf7ISIO|J-S#%=p3X*zk(9+Z;{o4zm}AT8xcVz_EqMa)h1;WIx^>AtMMa8z{g
zbrG9W;%B4K7_G#JWT9hF$6nazMd-n^3wojTzhZ|5MY-sMnbUeAJHgV|K?-=)S&zx;
zgR#?HTH~{U$h_f!^DAt@JXV{dgcb&1#tslpqY%wef4dh@-yju7g7K}}TOvg_;@(#G
z$dGdcrMIUj4BoZmi&g3NFzIz04qg+pE4~^@&XJq-`&n7fR=L3VF17-mFMaWBo@G)b0o8%R
z^8U-}EB&njyN=SoPyL&jbd)Pxx-qH`$ynq4m2^t!h^xbT2?Guo){
z{GgK5VMBdu`C(ieuLAj#G_jqm_TV_i;0fft$x%7cMBT-eTh+D`@uESUz?0MKVMs-J
zl1R-*D4ml&Z6W4vROd>8@nbr??FgAuKsEFB`W&OGKnxOMM9cjyoFTV@1BcMYsH1ou
zpyLhIDtM`Xj=l{t>I>-}YHD
zL1Lgc%s!VXmma71_=qh)VY7~g7>8)wyqtqd?C%9*Vy1#2XqMM^*
ztnU1V?WomZ4n1M-y^9tty+@GPW%#VnOV#jv`JuJ%_*08)Q!u{v{y!Y|XccPM^
z_~^77@si@WQsE!)w#C^IhjwWp(19_II67FDeQ}gE;^2b0_E5Ic6dD^Jc0Y(M;I$qI*Eqa
z>a?w8ZmUF?x|MJHel+Oti8Rms=jxQF?E+fCHe5-@USafYJ*ugl13eRl#W41uD)hJZ
zz?1kGHbX|Fpq&yYORZP@u(p9xf>n+D5xS;^u`@o9|ME;+4u@JX#N7+MajoqWk0a*Y
zBFIp9>eE5O&Ad6`YmraXCO$n54Su9OeWjZPVu-Z9wJ4UKAW;)bR%se-korc!8l1fH
zMAqcR+oxZ|EiGxs$v_MK2kSOBY4Qx9Ge^jsLnr0(QE0o)rI+m{ELM{Ujv+cl1NgMt
ztOO=F1%06D?!1NCrTGag(eCW4Z*cE!Lf^*kN3Rl>;QGX8?`w*x(>ySt15F#xB&2qA
zz`BU%qU#u&JG=CaYHxVZKK9$n$Z%AZ%CXNHjHPv50RJTNxfrq7nFuf1mU>U@=~a}lDvVVdR~gLG`tcN8h&MA}x}P4{XV)wjrxrmrVeNulgA6daRD
z@aY%el)Il#1*ApUij$Csq!D@-~{@_;fQTg#g^mD0-1-Eg92`Mneel}OKJ?5Zho=_2zH`jJ@xB4A^J!coqIKeTCZ?@N>_JW>?(|
znBSiOouA^U?^`xkIAjN10xBQUeRp!JCcFKbSC3g^M(myroGwAOm^+~E%nYKkRe1}9
zPNe4Vv@!6ZyRQ`yPY>G7yXx5XgjzsenU2Hw5q*D6b!j0h>dr_f=yR_vwcg=YsB!+{
z$K&4Mk#{*zL*P|!48zGxhB#@dUUikX0T1$F_JcH?Z&vq>cM3V-?Gnz9%!x-otF}?J
z#ao%bCC>jC!8Xzkn=xK~rx_SG%xzM(#}&6T#>lI$!dZ}7>ubzK{ecIfP6fvMNR#)d
z$DJkfYhV)+Dqa-Q1;5CU+D_l=##l?xy$b}^`px&wuP~7v-0I|C_Z4GNWHw`WF__u7
zswqq@l;FLem7vjRYvGawij}`MV#Gw6TWaUcZ*ZGbTuz(hqNDJM{8ZeiK*ftz=DX!O
zI-$huCEp8A=}Vxd)_>-99m(H+`bbkuy&jopNoo}eMiNK@R{X`U--cz5lo&^w{8{NZ!y_Ioy^#UTb}1>#oR+U7bB
z7dj(48|puSbu*BQc@RcTF)f3MbXcDIpGX4+{HMC!1ekr1*BE1}D8E3SO$S70ATCf0
z-Cctx{fH|sm;FIQ)U#`op?#b=f}1@3SY5qTA0v9
z7E-R0tl!Gkx7lA4Yel)~J|R3Xjs1CB&u%t&UiJeiN{@IdL)<}LoT2hnFdvHzFXZ`8
zSI6Mz`CL50wkwJORWde(OxmE2dWxMlcPCegA9|q-X>20Ns>0G4HSB|pacxgsNYWm`
zM1D1g(b0~CsS?F#$K-X=^sB>p}??01tsDot|Bl*l?
zd^`(5I1G<2T6icRu3XX@DJ>t9HSXFObt`C|6`12MFvo{x$Tdh@hYq^T~xTi(Nzf?U*`8=ZUaOp?1q3>A%BuvdxC+2b0jtKVXEBu
zN>Qp2$eoLAtg!oqK&v>^i;I+-n{pzIl;^eNeW#aLTe4WjmEWXAr4VU|=#y@5;|eAY
z@p`?S>ylMkq{B5VAEKTQ{T1sbNn=xEQspnUm!D$v%8b9JPN&l!`ty#?
z+xz$6B>Kz7@n9?#!vMnr!Hmj5g;cU6C+zlv$^b5&1E#K!g2j;3WLwPyiS_Z&j!%7d
zKN$1_OJ58b8A-A1(misDqqYRvAe!!I>xg|OEl=NW``$zGyxH;2_wQN6&bBERwneAU
zVU5^NKf(g5ZqB8I7xMTLE54nhzT8Ik;!;s|q6Z=Ly{FudTH&nE5~;iS1Z{kol6r8~
zdtJzvU#pEQqT|3Cr$*rcvgtY@@^bv+Y8=kO&GWW3
z>O=_0Q(gB|D27}j#{er}BW)>oIm>faeJ=vn4RJcWXT$Boaa
z^`pOy*Gef}@yTDjt+e*t(X9?X-LubkU~aDhGozEKgBiT4$4Yp|=4R#&6WYFEF%k|a
z^_|CFA-HrLZ9yq3N+ZrrEI(bOrsMFs+2bsG)<(;)oBGx;kwiAB1TZtGw)3iBXSyIt
zZ-lNo%7;`7oFKwwU}W0Ewd8Y4jE)R^bjSp`@PWhQmY5shKn$UUEr^|N;;0BHe5nY=d-yOUoQhkf
zl=bepyp?eqnB!1U9|E7MC)JKytfe^$k!boTll*59M5^?BWZmwNK?Kz&4dXXWI8;2)
zaTx`mBHnV{-{~h9I+lVI@TG98&TyO4jboT
z^zDLfG%>98LXGs`j<@)QaDu
z(J^d@(4WMX$m`rv>z?vPn#6M?S`1|5xNEWQ4R(|Q0>+QcVe(UzVJ>k{4DHqLtBiav
z9uzlj4U?0T?;5}2)`BO!EFk`bUZwF*diOV7v#R(KRF!Eaf7bGd1K)X_*V?%V35c>;
zLpr|Bus!V%?=tqf_JJB&YJz2o=G@S{(;(^jJ#LSw+ixAFTB>bjI|7x8D%$p^(FT9B
z;@R0sCj~urN$Ko3A&&OfN=zhX|IKoAg+r$SGb1ePQjC;VfSD%q7_f)RF#9}SMDho?
ziR?TuMu9iFQ(W-YO%W+KN@7G*e&`K~CpdPk3P*XtQw>y*8cnnw?4y#!jGVzz`wyHV
zHQ&bhFMLKpeAQBZJ>+yOZM(aU{ce!|IF&lO_}bQXN!Y8&gZx=Om%zqpX)uUZT`7q0
zGzlIDvpR`w$-9eRA6G1f(6z?rti?^s!i2Gia*rW`tW)SBLvL&7IlT3;-N#|g3i4ME?gUIN@AkPFfhQ|15K@V~L~#s}Chw$yHzxiDHc+
zf(NN*{tnzAPBdGq!iHm~3mbYhci2J~au93r6f_j*SWFmJP)6-HAI3au`~=}r)Dkz1
zS@$1$*RV%W!>A)aBBEZipyPL>MqWH~o-oy@?khq07$Cou*=54OHJcx3+}4urt*EoQ
zjE+LTX;4{d)BdD|!7_pW%P~E(CjHyulyP|dfy+Jgruw}58lKR}$rR0ZyzR6c;e0bB
z%?zyzoN?n?n#7ecPWlxZt5e^LEDEWdS>w}C#<~#;h{}m&fCnA!PL~#JHg!;Ugj$k{OOR2CtSxD-N?w$w<7x#d1;YYZ
ztR%sITj4_kbMzs0-sy5S_P_u8XIKp1<9TNWDYULA%57t~trW4A^uU0^YWL2wHvd?u
z%GQf|e;Mcw8P&L5VjrB;lxy_{)1?KF=HM?PDSPG8bn5DOp_)GS^87rD0>zmv|q4)o3?adR;ax>$GWWD22H?A;G_{(bxi_i_{7q_@JyR1dykA*lw#1@U
zs2NDOk{X1YsrKicQuyOnzh1od{v!2Ss9DkoR?I4s%=OfkEH2PRRNQIiakRqPczLLt
z%Mo{+&uQWyVckP)f93n3^m`U`88LCU9uNvqNGK8e!IGu);-}|YFtdtOZgknW9}RBI
zNugnE;L*v28+2G@z3%8?s!j{Exb`33;HR;
z428*Q%*i*zVKEwQ{Of6_u__|mjXx>h|wtoR!)t!p8Ed-
zUhM|Df-f#q+(nwiK1hln*QV_oKQbg@P4E>~O8Ymh4lP+{HivA;*YWbynDJ8@%d>I*
zd#p>r3gj7{H>7!nXm9K{tCH1)7U;dHQ=BH|6|V@bxO1-b*}d*Z19gIadBkLSYe-97
zd@A#^gFX09k*iXBGdJIGYbc-W=GyrWQY|Z;6D*AD8i^gf?}up*DCQ9GwHNH9PWJKP
zhHgBiJ#u1eK|=ieWLrX%n}ed~+)dRZ!>^_*fegM*FN}4WcmdAOARM_~T<@1#_B_PT
z&W7{myrcLp$Q)R?;mHEf3r)Sst^+Qn$T-*uN?Rye&{*!7e&{tbrPpcMH&hD7lu+$9
z^T&18UypHaE|H3Z)g2!mkN2B2G0m9NFbS;;-4WWDFeYsN|SOlI!@#~M;4jff$46eZXY`rT_HFtinWuP+diF&>+Os;PF?t;}T
zmXPvSDsANJUP(yfWo;zRKmShrX+1^?bI!Gk9hAy>v!y3+KIi3Z>X1IuS{R
zgIn!>_G+%zyyGYo@Oj()IW=l`|1?l<$6d}%v_BeASKVJbnrLeV#;dxtUj0#sD;IW_
zoBymaUl!cjPp2UBWoaCbgO@{|*D{g3zX@NOi}$qmb*jHVC@F+wo{j0DZjD^9j>sfF}7=F20q8;4SenarR
zp<-reCLr(I^ym!QS-*^V$!uH6ou92$N;6#$>WB3}HqsrNWEuAiF{
zo1e7$Ylx_B%Pbx?)8zZez~HLXjE^m|GjHT`-~u$6dMQ0qBx@J3riUlqWko%I(uWPO
zzf^+NrN2CP(l|Gv;B7VSK13K~wrAa4iEwU|VZ0f=9qyi}l?<24Am~JA*u*+7%zSH@
zOt#9t9(>YUFo;%vGDOIzVnY%rw(bsX4CY;{ah+uc-pJqt%uRKj?Yu4I8q+;}o@A{%
z+&$S?=|yQ2L3Ri}rRRGk>A3af(@ZQz$~y^|K`}C_jN{1uLDs1w_X1uW9wUH*1o+&h
zaZ05_VkI&2x3$$kc%S$fN3b2Kws8s48pcwKmqik=y->@bqZg2m+iwa_;>7x2Gl|)W
z{OSV<9O9yAL5!S5&+Ld{tmy1G*!0b?tBwc2t2Y*f7Kx*sB!mZ0b+)!~KYA
zq~~Ap!QC642FptDpv#6G88J!0WA?hRfW}Xw?x{$(fKsoL?LZGwrN)82-#26&>XIXk
zKX3-sVF8
z`}zkp8#_wvVn;r`3|re{!gE<;MPFs$dh{(+EG>=lS2u<9+x7MO!g8}5JC4QvV(gZZ
zE4{Yw|CtCTso9tjp5B?u@!BGcUxZ@pXKtIe6BsVVsY3+!#r=fTalsb>jpG>W3rj=L
zb_aqPBuC_eMPPmg*UfmodE6}7AAv>eOO(+oR5|Gxz^~Fg(FIJvhO?A8@q6i|!XaJn
zrB_ILP#(Y8o@Zh8F$6xe!8=&_`(FFQH3(*CtCHTO6)R~7qMcbP&68=+JvX6}ODzLN
z>~YUN=0X#0_I!<>2Oy_Str?olmx)wJ3-gCmz4m)ud7LUH8F?4y;;~whw>0<>O7G&~
zX(m}5Uy=vH*@gQb$Q~l#(x53d%=b+XB{Nj;K0SQ7>e5`_WqY7%@FK(v7mXA;{v`y%
z9PL{ot**~kEa9
z&sK^5&bag)H|Ki()Eoq`#-GXB5?9q;=|yLl+-f*W0e&{{P1^=HdzAV!OHGjDiLxoh|Z9db*;ut|gc2PG9Pq20;6
z9dlp90zp%vR5HnN-zfZ2KvU3q0|?j2&ur(&2kmS|=)m1RscT2}I61zrr)XgH$}foA%kM`>db_-=zo3K<
zjL5Y&&j&8NF4-aHt-264zqoVXSc#>dFnH4sQJ>N*Wxs9bV?Sh9U#MYLU+-_WZ~1-Q
zpfYHGVK8sN?d7b!F+{qF3vkbBf=Zwg^|kp+qd=4YW0c((=L6|#^5IujxYl$dAS2Do
z!sLXgnk^a;Nc?n=v?o*KebiltIudAo2_lH-lXpVLnzbm$jE;B+x`{YNRl>8oA~ZFc
z&iLK^5FuZ~m0;J`&)YE1Zm)Nf^xDh$wb{${hgK&XQ}oL^B5#GuomUg@8$N9_ut$XP
z5Pnm$^$5G%AowLDGY=1R1|`9TVPHnwQiU|J8dmAV_Zg$@Wg=SRQ-1urg~Mp4~~AHv_uW-vFtmDM9CPId6qxGrUu~;6joIH@;rde_Sv0Nq?(Uaqm-C
zOYOR{(03&>_M1`y4itUN;t?^;X72-sB`cS=f+n84koPe+o?#0bY4L}c&zQerv=jUs
z5i}i>=UR8;F{98)YnSyxmssA~z-HLOz>2V!pd=*nTS4bfh7-3C4w#vj1f3A*K?l88
zJE6mf1V&N;c%CLO`62fx=U6V_6>1w)<`drUu7N9=1=lVi$y#4!b6;g;J|Q5
z0`Qq*THL;<^3QvBRl?0SEQj-IUBb;e>rO&u&s9f79DAPs*$zXvt!kE?F`_!Ru7>=!
za($yNAo;a&twD7m;(JxJvwaHE7{s^Paw4>jOO}!8jjYY*1k=8pX_AR!meAVaKUor`
zGO3M&{b=fb^iH0*Tg@|A>qqZ3Y+dxsTo!%kZu!*kZ7PByC9~uOkyfT)vgrX;uTp4%
zWO>M5QO-@dgiSuLvL_3+nJFDdY$t7`f{lDD1G>BhV0=_pgV&mMf0oQ*?zD5l>vF@D
z+-V);x`J-
zn&S|&qljZEa{Ulujfp=mDAt)kxnqmz!53To9*>@ylT73HA_`d4D>5iH3VT+sZJkf9
z>`5BtK5@A-^HTd6+tpJKzh$m{jiuV)eZEiT$NDd)>={#X&c)tov*BIvb+mU}eaOpK
zgPi8V@ziKS5fIU3kL4)
zCXe*5STnzmyy`G~P0QksjxRVvSr4Yj(hO%M5q~02xpUsiUyamUy7f|!Pg8za+|n){UHu
z%4h9IJdFo;G$6&Omp>Y<`~V`dBNHi#5G!Xv-B^rK%WyL*z>6Bdr}AV`a0?PCB*E>t
zlFzK{r&8lr&HrvYAhX~4?S_eE!Sw@W{H8cHOvjhc|CzC@GAbEv{^tKl>t1&+XNE$C
z59{A}QLA;aZbv2BGTkSgKMn|2>ik&%RDS}K%aW4{8|Bab5~sS4a@NRp+x>%aero28
zW)q*^4|6`Th!3AVzC}S=v}Od@|L)xd{B#`1PY?;eRJw#*U}p8qq(ZzhyKXLysr}}i
zoc`RP2Nf#+QmS?=i>9lr#S8FKH1UUd9<*R{_8+1|+DE|uyyXXQao45f_ITR~khtOn
zbVi|EEd&3SvaTKqcEprb@X>FWW9%5Qh)1+8N?6Hm=qp_9b~EHdFd{5J&Xs}fQc*Rs-0o&fF+ciI0d{barxR2%PisgCc?O#Qbwk&om?q^x5dSfYzXTRrd#gf0#dd;?bAB+tqe2a4k24
zb5affkm~&32v0A4bKNVna2j=Y-m=c0^ywHY$#zV1X3nR3VQgzBszLM0eDDUU9@G1g
zVU2ok!sHrNOnP6e1V7tQxLOG>NvN<}Zwgomc=^Rf!ddz(V8UcZbBgA=U~f!DJDefz
z(O|L%!#|htX$VKInFBk0Eg{a;TP)#EttBtC+^UgmqyBfg$ggcBmAdMIGW#)M`^{|LP=-pQm82^kKi$Im5o-aq!>{
zI`X|{;)RjZ%d{EG6KDCU>0Ug&q1`-;j$p1kp5hni^rLY1)d)jWKE&Mfb=582Y#(;!=QM#$A4$*|4AA~W{Kx0Slz%pf15=dtz9hk!F>1BjvRwF$Zs4S-tnytG
zH3RG?cKzS*<)o;oa~%EkN&Iw`vOLE${P=ME!G|djO
z17(ugz+2y-#RuBu9!UT`v;6}=Ms}kwQOQl;68_jFXVi1z5y%5`EXLy2v}Q$)puLv!$k>>g4
z?h}RwT?Wjy)JtYNKHA+lqS!GEa<&D)qnz~7p`F%`E!FC>ogfgp42G-SP}>XY_CjBh
z3JRcAMVeZG6Ty|Qr^dhy*4rVkgW>&}@8gyTjoDr}1R<45VT5gf4`gc}YK?HF9R075^P@p+RjETsmo+$JU57T_Pn=
zgj;2IMxCuZIs{h=wV2R-Cl_1Ib!!h{W3PKr@T^|cz@19j`6cEl#Ic*=CtvxY+Mdgh
zLGkI031p|8T)3@nHi-OS#$PxkC1nvUrQ-kJ9p%Cg=uBQ=$PMHQsPuFKC~HQ1<6PK)
z)W-wIy8f>AciD-zXBr!jaPchqjq~5Gs=fu3?H=7Dm8b2R>kDtzW<#&9*>`+lJAODo
z%FRC`q-WK0e^A%_)SAK~_+VgYN|9c6#vVJHi1n2z1RgHpGR%PQnZ
z4SM&?(Qm(;Ar)Ytsh7@@C4z;z2`$0YJbu3S&EbM&YIOUbZUv;l{(v>BlFQ{^U2M*O
zMe2`#Uda}~_1l%?zM?H^rUUYsba**)_i}D9RieT^qx|+a`bU2wr
zZs;p?JXY<03D+JC=b0)7b6cuo3c#QT$%I(pmWl23uf@guZB~lQKi;Xr%u=F1PJaG7
zfKnZI5W38tq^hCd{x`{sfTmme%q4L^f+gfTV(g{pruXj0n3|NZ)<}XcrE4Qrl6Q3?
zfuj_}59&^wSzui3skYzCPAq0h|SVzwJj!ARVeVao-w})G)s>nE%9v6y#fE?5l7VQtyI@@2^KVhp`MY_DRhlSZj299pK%scXL~2?0a)_%fYF(9D;aiLO*6%{)MP~Juvq!`A?ghv!
zyMs4{E}1=hh5w@9G#%KW8XlvdpC=Ski2)hGH13Uifu-GqC_DfFxaK!&oo_%QHC*2V}
zHX=2Qm^ITKrf8r<+J87=M{>alh!Ri03W>F*w
zu9ik}aBw1UAI2hRq+H*87jIAuY47Gm5qA6K61lYjJA+5pU6qdi6!^h1wRL<#KV<7m
zB%7C9EE16SJ$z$KKrVVyo?LiF=?4eBaM9l9hu4%VESrCRr8{TekSb#3^qygQ2xKMO
z*#Dx6%StYpJy0ejKzpE5N$|!`akWZCT0E!ZZ7W4%?_Eg$VahdtlU8W3k{+BN=|5B+
zUU+XaZuK$GjSG)}hfNMFxlhvpXZ+o>Asr0T+V(@z11xkSx1L65bM$tGgwSoagvmF=Aqpn~Hl0&1
zM0V109Af|1x?G$6^*^|*s1co5j4af;kV%bKv5!r7t6`WmNsB9Qr1sKFs%f-MauYVG
zzDC6=`)f6VtoQo|4b0a!R#w!h>RoN)8dlVqnU-WlF8*W*_%ojSO8Y{Gz+DdMmBwzj
zp9#;5GY|AL@(CjV&1^p#_e#bLkfYfQ0jdBO(8SOg47G))uG?|p^}rL9xTTg1?MJUT
zPkv_h&4=;<(l#k7IJfZzzthhA)G)pzG~;-PIOMvv!224JtF3=Vkyy-h#y4fia|Rp+
zg#SdquqOdwU<$@kmMiHkNWtzF!Xwn}FNSG8cbYiJ?RI|OZuk4qR4E&4@muP6*^66L
zrN_@EU)xr^CDH9~`syF{iuGzRiZyTz_w$)Q0H~9B*@}@{*h&+kS6yu0ZDIrR9U{vu
zgVD|&Wf-rJdSW2dbgq^9idZJWSv&kTh}1D3Tuc65cfs!eA2#eE6DEy%xZ-YW^z3Ym19$)|b+RIkIzkUnau3ztOxZg)>P0odHTQyH)
zkQw-kCoGqlkDWhBqsP8-~n8kKy7=Gigl`s}#=n`s8hwBg2{(?l#eadW=
zyYgh#gmSc&^d-KS>DHaaWfuwyCO#sGTGEMA0z01&Hu7q^XDCKPs@PV4q#Mw8yF;Au
z+~afQd051>zs!A7lwHXJ1mnK3^aqnIHKtG;FS(|MDYy?(F74}%8`ILw&u~~%>{Y{5
z={NH8@pogMaLFSH506YToH^tJh_zx^9$H$88i&37n?(!d*?nJpERrI@$A!+OR2Syr
z#dX%4$eR@^14O_O@;sd_5wU6>U#OcY`Q@R-W`^(X($#aO2hWKG65p<l>5;uuze;CaBa_BoQxr0a>vlN;4El0$UMc{A`HPFgC&lBFYx^ZD
zPKs?MP|@_fb{1CeZg9cydJuHbJjeTbO$|OL(;WBuW+&d!UY#K8ed7B1;XRYS)BlnJ
zugQ0bP6Hz$7BK(41w!8boFo(?{Rx$O^L21(g_@>&cda81hbhDIN)D?J~7z
zSqoWER?t`2ODXzr@$|%A$~!m8m4PrD9~Tb5Jp(E$Ijy80XuF0axJ6wW0NY2A$>hRK
zG(ru3^5e8^p2Ziw8h>njv64JkW3d?*ZpMplK5e1n6S^Y(Wpgv{XuD{w;mjQ8<#R!0
zEV`E?8z}yAimrju=ci$-vSpKP$K%6SW5a_4OsgE-Wu8cZftAaxFjeX#ei%hH#ese8
zVkpPENo$od$BXq&9@<%<$yT7VjsJ`{=GEb(!HN#74hxr}6f
zEZSL^&4{SzFFWz=O$7#r_Orbvr4H{BMJ?e?O@?U-4R1v&&o8ykU8DyQIq7XPwv#fG
zKL2XsVYF9st9`_ps$Ytk|11zRpK2ELuXw)CXRLJM{%6o$x@J@C{(`yTtgEsSXy_Gi
z^+G1w`~9R{(Klbig-Hw;JS4(z>c6fqIq(U*gWm)Y~=6K(na(bv2oxGzUV}-ou{&-Yc`N-aI
z-+r|Vun88!A#iJo5uiDFr4YKQeK&U8#wRO_b&8&Mcy4IMgKo8Y0Oh^(|A$yKIE&#L
z^_^OxXqY+vrrUVCTBLZIqV@_+NLI4Ih=MCI{7P$|rRp^I82
zcFZErAeO#X>~L~)ULv9PTF5QR}I&i970jum{2*vJK>7~UU)`ptqZy8$&
z@gmAU{e0dPZ~G_#iyYm3G|d6jKcZGgb5or;4qZr{O~sify}mpaXpdL(Ux*ohZ;|Mq
zH#D?UbjxEz6}W?JX$A>)3VpTo4hFUxStqIMhsjZeH!3d_{GFYUG3HaLk9JJ91PSuB8BwP9!j^pq`$!dQ51d8Q=fmK>khvjEjiK&}v2Wpq1mFK6QDxVB_2!7PXr#C`$tlshpW=-PF>!iz4uHoqVG5-97GWEUE=D$95n
zFhw)*>(%#ak*g|W?zNWaTD3``ibp
z(^#gvp&_^Yeq^J~qyW7K5Af73L!juaJB8fag@+iX`EvwdtM%3hmgs#cU_ZO=p%S(v
z3W+t9i)feZfN_z;nsVkyH&-he(jCWxv7|D_%A!wTnJiJX8)dm?Y*ZW*v`b}l
z+W6Sanvh-gb5R9vpm`bwu9||#=*zamn>Sp!a=TnpP5CL`MOO7!MGMBKpoc?F{`b2VrwS0juhvU$Imf>5Mr;OMPzt1--As_dP)-GnU)yVYyERf!
z8Hm4A|F^aLb-JYw(9^Vtpyk8|LF${qlhTRU9%!iNl5zsPZWi#AFIcGPbcGs*yO~LX
zLFF|TL!+a`a(x99#%jiUQR=D8CQDu&w}>t&x2-Y?h+pMd%Hnv}J-MUXu84
z#s}+s*1-5?Ru~0*oqWrEPoCf94Q0V1bp1iYd27ebjyeDHE4_+V<{Atw{^L|;eHfFm
z_LJXd^R0b5jEw_l6Vyu&)VeVo;drO~zGb#<;_ka_j!Cv_i$7k_gR7_4)iBkZYPrjy
zuN^O&@YYLc3KJ<_IcJ}G>>IwC<@!O2f?|S4)*h$bj}DgN)yh8&qhF_9YB5Z7_7Lr(
zzb``zQR`!N1KMQYF=mpAS-KYCmNsotriI8{(>f;tH-bL=_D|x(Thh6-MoIREU@@nP
zq@%Z$)q(b{NXN`?W5%N}v%RxB-yOjXv@>_5T365L7R^g-BeR`BUm;(jOp@W;<#xZ~
z0a{jt>Cs<@zLG@4xsUV!WNw;;lJU|hPT|ITksMH$heP_NbH!J9hXC0@FQ*%11_ThG
z#3&pneZw?0o1~1HBc1j$wUlm{zyPy(QJ+|{WE*8*qn*0XwPs$YnME5cDjlqEg+#Vyw=kPjtb8YU59_t2>=&VFUEQ~`
zUi>Uw0W}*y;#d^3`9{;v?DpNQ}zOyBq%e{6PLc3E>=mp#Ip<@VaehTnO-hXkn3KPCEbk`W;0+
z`*K<3SJVBeB7}wIxtcMhekc${V`t7ssAwPQV!Tq3pLQNB=6YPX40kK71s&YXzT2%?
z1wh>KEseR)T^z8%Z9X(0ZJ5FZ`j;lB`MdWC-ik?88<=c6{O6xB9R8qZ=rTZX)~y+`
z`wctE@!tpmDBxEhqs#+69@b6~#Qp#w8*K9Rs9#6-GBR~CpvKd!f|zoAev$GC3)^o7
zo*ym8F?y){(Buz7Y&IXLXlh2o<<^!&=>J^3cB2hmH*K^mTOEjCiN!l(C<$y5j!&~A
zZ_1sN!tf4Mdep$Xcgvn(YHyquPA}6fT*>@}XXit-!bytvs_q{YJAD4v1{`;CyIKS2
zluJ~NRP4wL%(Y?St#Fc{6VvP;?E=csXN|g27o{g`rQ|qBmXEmqmIBE7lpeIo%4e&A
z;rMcKur-G*S_2zS&X=K_@tS&BV{ernI?p_%H7>+c;t;C!VRt8ARy<}R^l%lo9Z=3rhM8-KOl@{dNZqw
zS>+6Hdkst<%p}4Yk9-ve{J`V(t-)E^nps@<-gMy#`tMTswL5Zbz}+Td&0SV8T7ZG#
zrtSy2K-&00RjL|54^4F(aj-8yh8J@ee&?QT5g9;}#OZD2Gp7B*8&jQa{e$BCF$*(g
z$F7P-JncE!5_D^(%UXkm8%zLnaUo|9*zH3-a5GOA5arRm0r-w30V~<_Xx-A>^!XV3
ztD|TrOcroDI$9?sJ5sH37+${Iq#8b!03^27`0PtN``%v&c;g5p+jOwuD0J$WvBU`9
zV2@Q|L2Cv?tM&Stjh?6%`O9ei4?V{lYWx737xqhHE<004O8^N>ZL3f#VB2)cFg4Oy
zo9cO{GwEB7mIK73rN5xF={9rC
z?mecTRN7WAz+6cB9P1Uee0MrME9NCqSsA&as9Hn0a#1w=W|JZP#(u2Ga6Da#*nt-0
zc}@u%P%I+U;VBM$)G$)7ExzG57}R$L_UXEvXW_D!W}Ou2fu6R#>Adnt69a5LTa@JF
zvSui(Ti7&u?m6pSvj|4z+#LSqF{Ry}Q7z()ZN!6nTcuTTCy7EH_TtabN
z_^HPRT~<8`{_bROQt}hArj+Dx?Jtr~Ja|O78AE;<8x9gypVeWSGtdw|R_e313^WHe
zspauAMUN`3b1b)c%>ey3u8$kj?An_h2Lg(#2~_>Y7G)XEYnJigachzzdoFyC>2
zpKxIe(B7=?UpLRMu`t9(6!iMHd$Zgj=4X3QP@EbU&SFp&BTK)Qq;rF6dt$N9>X;u(k=y4-KMJxkwrII+XI60k|YS_*|P}@3>
z^3JBm_`?^vidp`C{z^I@9t5aafBi|uC#cgV?C15@ePk|@3(a=Q?Bl5Xs9&B0O(0&(
zURVYS;-2Ym>OB5sw~xilnm*6?CeuoQn-6)vBb+yto>CTkydS}?^zvp=&WLG|15!|k
z#`t{C$hhV?Jw;==oVbhedVZ0cMe$PzUHRv(uF3aVUuH#7Is#fSImHtT#78yE3)+Hx
zep-?qrIM_$Csr;n@Wk@cCRN*rw-G>4NXrskZd^a|4SK6<>+|{{oQu?~6@Trzudm1)
zN^fxg4}?7~-!)yU1o=m<&&TWz;FKlI(b!d>W~zKI2mUk};1%CIIDX5ny+8FR-@oBL
zoz8;z`jK$+y(E(4xexP`t3=n2js`d0Lfo``$*(uRsQ`qCc{4GGSOD>;VLqhC2$5X5
z3M_uy5q$Nbwkp|Onv~!>BJmkCMB%Twh~LI74ry@cBG$$zWxZBYs_+kNJKO5r7j9AN
zP9MH`_^98Um#MpcMSJcWM)$HwL9|^FzG2EJKNl(sPookDslKV0?)4>2mx;J}Gb62*
zO=6Jz>U8%$76}SDt+w=se2@TmN2-V0YHwNGH)<9K3Y9it;+>X5;KKo^Ke-pD%S@y|
z>}X9>BS-@%Hv9i8>e}O(-rqP`*$U0&kXtt2nbL7Yp-i>8%v_^R3dj8`CpMQOQ!Ww9
zC6Nuuy`-kxj%iC0MVMQil4+(o4!AdD`i|jAhtBM7
zPDcNsdA0>MDO8D^1P%8-6#Z#%>abwa9+4T~^sVrAYYez2pgleMZ@wvxi)>>is(N3Y
z<9-Zin@nEEqAS=ybpwsuSTjbO6?aq%aOEh)CL1Blm>&Qu6ux-cP
z?w7}apI3u+<?8
zN!)1GkUu1Hkyc!I5=JLQ3~vDG;j(cLWrbMSh1|3*8pZ+k_I?E4hwvr3VNbOcT$K=xix-&OUP
ze$0Ic4hBvr2W$G9D9>JWe_v@K!j6uIIk`LYR$E@X9%@IKgDakUn5NLxQKK_YK=1eK
z^ubfjx_@qi8ZslUsWKI~PouY&&TItI2lug17b+$)B^5~GPN%nr)^W~&j4q`Kbl~+I
zxHp1&_=}d97ak6pmkH8<?6YQ-E#sUi%T*NI<8Zop6GC$W#bs6UIhmVN(e|KDtC$KL0R-x}8}<*0Kfq}8%kDdDcw{}&Gr7~iF<^pC@gRIlf{!9*W&W0>
zw2>l)Go#mRJWDta6LKpVU?9r;9-sj)L%6${A0m-aiwyvL1(RJ(AF6sN99xi<)1n&1
zfuWf>BoPq(YzraJ!GRY)
zr!^!LBpe=j!L|_ZXVrw_!;<|h$zZ>3sc!D_wm!;xoZfX?B1~Wum-6XIwJaw*0x4~U
zfstsTf-w19=V%q4Vqx##?s8uyM1d;bw~$l19Z_`WgLLr9ns?ACP=^n4J!B_g(`Ex;
zf$8CJAFl+iAJi6L=NzP~DGT$I-5@cUKa|1$v2~7K#bMvg<6T)PW&7gJD_pJA)`=5xf@<0TQ27#;!nc9vZZDaKJm2<$6C?pN
z4vvntsmfuXCb-2Qgd)*1RjlXY>q{{e926@*KVMw!{L<&U77#kwspcz}i+4^|HT3*K
zP_(_)lhbj9Z>FP$3gpSIv;BQyG)u1RjCgWsqNVaAR$>iITcB#V!0biFe;jzC+b3i?
zQsp-ZPHiR^VADv;~#6n43|)A>~qpq4|a&n`y91@Io~-4$5~xX#d1nl-#pD1x7RF>
zxNVZC?ypqfPEEB<2R|;ds8JQ?e#_0$G;en{f0YNs%yf
zX;>jeRwsU^;cx@qc42=%t$($-Gx;+&V$3SlG%ZYc+!O
z8g2sKtA;ki=T(&o&czr+1)HbJ33-l{DxJEyPF>kZ=q&fI&@}covVd-&Y;8|gYMRE%
z0F5T0|4;z>A2GDwE!PVm7mi|~cy#N$B^VpJoX7aSJb3T`H(wu~?xs58IW#*g*9kG6tUxaF$rFJ1{csh+$J{ysllIzMUS8r=NlPFi2+m}*pSYrf
zVu5PL`7)0kqnseeOV1~5$OFT%&b$G{;C7B-K=3Fe(%lk7AU$(=`%|nM3$!I~53!R7
zJzi`H<=my{8_g_Q)WoNz@$A4MTbs%qKCBsP5zRbEaa91YDFxmwapp^s
zK?pm#6$~>(I^?KeMJ4^cKSK{gPvxtyLvR&af*?^?cC9{VCNu6TNun;~4U{`_yi}A3O&SQz&QCGA1e_?r8fbosRqZ>TBn5u dict:
+        print(f"Training with lr: {self.lr}, backbone: {self.backbone}, stride: {self.stride}")
+        time.sleep(2)
+        score = np.random.uniform(0.7, 0.1)
+        return {"lr": self.lr, "backbone": self.backbone, "stride": self.stride, "score": score}
+```
+
+Ignore the `task_id` for now. It is used for parallel jobs. We will come back to it later.
+
+````{note}
+The `name` attribute is important and is used to identify the arguments in the job config file.
+So, in our case the config `yaml` file will contain an entry like this:
+
+```yaml
+...
+train:
+    lr:
+    backbone:
+    stride:
+...
+````
+
+Of course, it is up to us to choose what parameters should be shown under the `train` key.
+
+Let's also add the `collect` method so that we return a nice dict object that can be used by the next job.
+
+```python
+def collect(results: list[dict]) -> dict:
+        output: dict = {}
+        for key in results[0]:
+            output[key] = []
+        for result in results:
+            for key, value in result.items():
+                output[key].append(value)
+        return output
+```
+
+We can also define a `save` method that writes the dictionary as a csv file.
+
+```python
+@staticmethod
+def save(results: dict) -> None:
+    """Save results in a csv file."""
+    results_df = pd.DataFrame(results)
+    file_path = Path("runs") / TrainJob.name
+    file_path.mkdir(parents=True, exist_ok=True)
+    results_df.to_csv(file_path / "results.csv", index=False)
+```
+
+The entire job class is shown below.
+
+```{literalinclude} ../../../../snippets/pipelines/dummy/train_job.txt
+:language: python
+```
+
+Now we need a way to generate this job when the pipeline is run. To do this we need to subclass the [JobGenerator](../../reference/pipelines/base/generator.md) class.
+
+The job generator is the actual object that is attached to a runner and is responsible for parsing the configuration and generating jobs. It has two methods that need to be implemented.
+
+- `generate_job`: This method accepts the configuration as a dictionary and, optionally, the results of the previous job. For the train job, we don't need results for previous jobs, so we will ignore it.
+- `job_class`: This holds the reference to the class of the job that the generator will yield. It is used to inform the runner about the job that is being run, and is used to access the static attributes of the job such as its name, collect method, etc.
+
+Let's first start by defining the configuration that the generator will accept. The train job requires three parameters: `lr`, `backbone`, and `stride`. We will also add another parameter that defines the number of experiments we want to run. One way to define it would be as follows:
+
+```yaml
+train:
+  experiments: 10
+  lr: [0.1, 0.99]
+  backbone:
+    - resnet18
+    - wide_resnet50
+  stride:
+    - 3
+    - 5
+```
+
+For this example the specification is defined as follows.
+
+1. The number of experiments is set to 10.
+2. Learning rate is sampled from a uniform distribution in the range `[0.1, 0.99]`.
+3. The backbone is chosen from the list `["resnet18", "wide_resnet50"]`.
+4. The stride is chosen from the list `[3, 5]`.
+
+```{note}
+While the `[ ]` and `-` syntax in `yaml` both signify a list, for visual disambiguation this example uses `[ ]` to denote closed interval and `-` for a list of options.
+```
+
+With this defined, we can define the generator class as follows.
+
+```{literalinclude} ../../../../snippets/pipelines/dummy/train_generator.txt
+:language: python
+```
+
+Since this is a dummy example, we generate the next experiment randomly. In practice, you would use a more sophisticated method that relies on your validation metrics to generate the next experiment.
+
+```{admonition} Challenge
+:class: tip
+For a challenge define your own configuration and a generator to parse that configuration.
+```
+
+Okay, so now we can train the model. We still need a way to find out which parameters contribute the most to the final score. We will do this by computing the shapely values to find out the contribution of each parameter to the final score.
+
+Let's first start by adding the library to our environment
+
+```bash
+pip install shap
+```
+
+The following listing shows the job that computes the shapely values and saves a plot that shows the contribution of each parameter to the final score. A quick rundown without going into the details of the job (as it is irrelevant to the pipeline) is as follows. We create a `RandomForestRegressor` that is trained on the parameters to predict the final score. We then compute the shapely values to identify the parameters that have the most significant impact on the model performance. Finally, the `save` method saves the plot so we can visually inspect the results.
+
+```{literalinclude} ../../../../snippets/pipelines/dummy/significance_job.txt
+
+```
+
+Great! Now we have the job, as before, we need the generator. Since we only need the results from the previous stage, we don't need to define the config. Let's quickly write that as well.
+
+```{literalinclude} ../../../../snippets/pipelines/dummy/significance_job_generator.txt
+
+```
+
+## Experiment Pipeline
+
+So now we have the jobs, and a way to generate them. Let's look at how we can chain them together to achieve what we want. We will use the [Pipeline](../../reference/pipelines/base/pipeline.md) class to define the pipeline.
+
+When creating a custom pipeline, there is only one important method that we need to implement. That is the `_setup_runners` method. This is where we chain the runners together.
+
+```{literalinclude} ../../../../snippets/pipelines/dummy/pipeline_serial.txt
+:language: python
+```
+
+In this example we use `SerialRunner` for running each job. It is a simple runner that runs the jobs in a serial manner. For more information on `SerialRunner` look [here](../../reference/pipelines/runners/serial.md).
+
+Okay, so we have the pipeline. How do we run it? To do this let's create a simple entrypoint in `tools` folder of Anomalib.
+
+Here is how the directory looks.
+
+```{literalinclude} ../../../../snippets/pipelines/dummy/tools_dir_structure.txt
+:language: bash
+```
+
+As you can see, we have the `config.yaml` file in the same directory. Let's quickly populate `experiment.py`.
+
+```python
+from anomalib.pipelines.experiment_pipeline import ExperimentPipeline
+
+if __name__ == "__main__":
+    ExperimentPipeline().run()
+```
+
+Alright! Time to take it on the road.
+
+```bash
+python tools/experimental/experiment/experiment.py --config tools/experimental/experiment/config.yaml
+```
+
+If all goes well you should see the summary plot in `runs/significant_feature/summary_plot.png`.
+
+## Exposing to the CLI
+
+Now that you have your shiny new pipeline, you can expose it as a subcommand to `anomalib` by adding an entry to the pipeline registry in `anomalib/cli/pipelines.py`.
+
+```python
+if try_import("anomalib.pipelines"):
+    ...
+    from anomalib.pipelines import ExperimentPipeline
+
+PIPELINE_REGISTRY: dict[str, type[Pipeline]] | None = {
+    "experiment": ExperimentPipeline,
+    ...
+}
+```
+
+With this you can now call
+
+```{literalinclude} ../../../../snippets/pipelines/dummy/anomalib_cli.txt
+:language: bash
+```
+
+Congratulations! You have successfully created a pipeline that trains a model and computes the significance of the parameters to the final score 🎉
+
+```{admonition} Challenge
+:class: tip
+This example used a random model hence the scores were meaningless. Try to implement a real model and compute the scores. Look into which parameters lead to the most significant contribution to your score.
+```
+
+## Final Tweaks
+
+Before we end, let's look at a few final tweaks that you can make to the pipeline.
+
+First, let's run the initial model training in parallel. Since all jobs are independent, we can use the [ParallelRunner](../../reference/pipelines/runners/parallel.md). Since the `TrainJob` is a dummy job in this example, the pool of parallel jobs is set to the number of experiments.
+
+```{literalinclude} ../../../../snippets/pipelines/dummy/pipeline_parallel.txt
+
+```
+
+You now notice that the entire pipeline takes lesser time to run. This is handy when you have large number of experiments, and when each job takes substantial time to run.
+
+Now on to the second one. When running the pipeline we don't want our terminal cluttered with the outputs from each run. Anomalib provides a handy decorator that temporarily hides the output of a function. It suppresses all outputs to the standard out and the standard error unless an exception is raised. Let's add this to the `TrainJob`
+
+```python
+from anomalib.utils.logging import hide_output
+
+class TrainJob(Job):
+    ...
+
+    @hide_output
+    def run(self, task_id: int | None = None) -> dict:
+        ...
+```
+
+You will no longer see the output of the `print` statement in the `TrainJob` method in the terminal.
diff --git a/docs/source/markdown/guides/how_to/pipelines/index.md b/docs/source/markdown/guides/how_to/pipelines/index.md
index ed3d66f81d..c7f2c44706 100644
--- a/docs/source/markdown/guides/how_to/pipelines/index.md
+++ b/docs/source/markdown/guides/how_to/pipelines/index.md
@@ -1,254 +1,30 @@
-# Pipelines
+# Pipeline Tutorials
 
-This guide demonstrates how to create a [Pipeline](../../reference/pipelines/index.md) for your custom task.
+This section contains tutorials on how to use different pipelines of Anomalib and how to creat your own.
 
-A pipeline is made up of runners. These runners are responsible for running a single type of job. A job is the smallest unit of work that is independent, such as, training a model or statistical comparison of the outputs of two models. Each job should be designed to be independent of other jobs so that they are agnostic to the runner that is running them. This ensures that the job can be run in parallel or serially without any changes to the job itself. The runner does not directly instantiate a job but rather has a job generator that generates the job based on the configuration. This generator is responsible for parsing the config and generating the job.
+::::{grid}
+:margin: 1 1 0 0
+:gutter: 1
 
-## Birds Eye View
+:::{grid-item-card} {octicon}`stack` Tiled Ensemble
+:link: ./tiled_ensemble
+:link-type: doc
 
-In this guide we are going to create a dummy significant parameter search pipeline. The pipeline will have two jobs. The first job trains a model and computes the metric. The second job computes the significance of the parameters to the final score using shapely values. The final output of the pipeline is a plot that shows the contribution of each parameter to the final score. This will help teach you how to create a pipeline, a job, a job generator, and how to expose it to the `anomalib` CLI. The pipeline is going to be named `experiment`. So by the end of this you will be able to generate significance plot using
+Learn more about how to use the tiled ensemble pipelines.
+:::
 
-```{literalinclude} ../../../../snippets/pipelines/dummy/anomalib_cli.txt
-:language: bash
-```
-
-The final directory structure will look as follows:
-
-```{literalinclude} ../../../../snippets/pipelines/dummy/src_dir_structure.txt
-
-```
-
-```{literalinclude} ../../../../snippets/pipelines/dummy/tools_dir_structure.txt
-:language: bash
-```
-
-## Creating the Jobs
-
-Let's first look at the base class for the [jobs](../../reference/pipelines/base/job.md). It has a few methods defined.
-
-- The `run` method is the main method that is called by the runner. This is where we will train the model and return the model metrics.
-- The `collect` method is used to gather the results from all the runs and collate them. This is handy as we want to pass a single object to the next job that contains details of all the runs including the final score.
-- The `save` method is used to write any artifacts to the disk. It accepts the gathered results as a parameter. This is useful in a variety of situations. Say, when we want to write the results in a csv file or write the raw anomaly maps for further processing.
-
-Let's create the first job that trains the model and computes the metric. Since it is a dummy example, we will just return a random number as the metric.
-
-```python
-class TrainJob(Job):
-    name = "train"
+:::{grid-item-card} {octicon}`gear` Custom Pipeline
+:link: ./custom_pipeline
+:link-type: doc
 
-    def __init__(self, lr: float, backbone: str, stride: int):
-        self.lr = lr
-        self.backbone = backbone
-        self.stride = stride
-
-    def run(self, task_id: int | None = None) -> dict:
-        print(f"Training with lr: {self.lr}, backbone: {self.backbone}, stride: {self.stride}")
-        time.sleep(2)
-        score = np.random.uniform(0.7, 0.1)
-        return {"lr": self.lr, "backbone": self.backbone, "stride": self.stride, "score": score}
-```
-
-Ignore the `task_id` for now. It is used for parallel jobs. We will come back to it later.
-
-````{note}
-The `name` attribute is important and is used to identify the arguments in the job config file.
-So, in our case the config `yaml` file will contain an entry like this:
-
-```yaml
-...
-train:
-    lr:
-    backbone:
-    stride:
-...
-````
-
-Of course, it is up to us to choose what parameters should be shown under the `train` key.
-
-Let's also add the `collect` method so that we return a nice dict object that can be used by the next job.
-
-```python
-def collect(results: list[dict]) -> dict:
-        output: dict = {}
-        for key in results[0]:
-            output[key] = []
-        for result in results:
-            for key, value in result.items():
-                output[key].append(value)
-        return output
-```
-
-We can also define a `save` method that writes the dictionary as a csv file.
-
-```python
-@staticmethod
-def save(results: dict) -> None:
-    """Save results in a csv file."""
-    results_df = pd.DataFrame(results)
-    file_path = Path("runs") / TrainJob.name
-    file_path.mkdir(parents=True, exist_ok=True)
-    results_df.to_csv(file_path / "results.csv", index=False)
-```
-
-The entire job class is shown below.
-
-```{literalinclude} ../../../../snippets/pipelines/dummy/train_job.txt
-:language: python
-```
-
-Now we need a way to generate this job when the pipeline is run. To do this we need to subclass the [JobGenerator](../../reference/pipelines/base/generator.md) class.
-
-The job generator is the actual object that is attached to a runner and is responsible for parsing the configuration and generating jobs. It has two methods that need to be implemented.
-
-- `generate_job`: This method accepts the configuration as a dictionary and, optionally, the results of the previous job. For the train job, we don't need results for previous jobs, so we will ignore it.
-- `job_class`: This holds the reference to the class of the job that the generator will yield. It is used to inform the runner about the job that is being run, and is used to access the static attributes of the job such as its name, collect method, etc.
-
-Let's first start by defining the configuration that the generator will accept. The train job requires three parameters: `lr`, `backbone`, and `stride`. We will also add another parameter that defines the number of experiments we want to run. One way to define it would be as follows:
-
-```yaml
-train:
-  experiments: 10
-  lr: [0.1, 0.99]
-  backbone:
-    - resnet18
-    - wide_resnet50
-  stride:
-    - 3
-    - 5
-```
-
-For this example the specification is defined as follows.
-
-1. The number of experiments is set to 10.
-2. Learning rate is sampled from a uniform distribution in the range `[0.1, 0.99]`.
-3. The backbone is chosen from the list `["resnet18", "wide_resnet50"]`.
-4. The stride is chosen from the list `[3, 5]`.
-
-```{note}
-While the `[ ]` and `-` syntax in `yaml` both signify a list, for visual disambiguation this example uses `[ ]` to denote closed interval and `-` for a list of options.
-```
-
-With this defined, we can define the generator class as follows.
-
-```{literalinclude} ../../../../snippets/pipelines/dummy/train_generator.txt
-:language: python
-```
-
-Since this is a dummy example, we generate the next experiment randomly. In practice, you would use a more sophisticated method that relies on your validation metrics to generate the next experiment.
-
-```{admonition} Challenge
-:class: tip
-For a challenge define your own configuration and a generator to parse that configuration.
-```
-
-Okay, so now we can train the model. We still need a way to find out which parameters contribute the most to the final score. We will do this by computing the shapely values to find out the contribution of each parameter to the final score.
-
-Let's first start by adding the library to our environment
-
-```bash
-pip install shap
-```
+Learn more about how to create a new custom pipeline.
+:::
 
-The following listing shows the job that computes the shapely values and saves a plot that shows the contribution of each parameter to the final score. A quick rundown without going into the details of the job (as it is irrelevant to the pipeline) is as follows. We create a `RandomForestRegressor` that is trained on the parameters to predict the final score. We then compute the shapely values to identify the parameters that have the most significant impact on the model performance. Finally, the `save` method saves the plot so we can visually inspect the results.
+::::
 
-```{literalinclude} ../../../../snippets/pipelines/dummy/significance_job.txt
+```{toctree}
+:caption: Model Tutorials
+:hidden:
 
+./feature_extractors
 ```
-
-Great! Now we have the job, as before, we need the generator. Since we only need the results from the previous stage, we don't need to define the config. Let's quickly write that as well.
-
-```{literalinclude} ../../../../snippets/pipelines/dummy/significance_job_generator.txt
-
-```
-
-## Experiment Pipeline
-
-So now we have the jobs, and a way to generate them. Let's look at how we can chain them together to achieve what we want. We will use the [Pipeline](../../reference/pipelines/base/pipeline.md) class to define the pipeline.
-
-When creating a custom pipeline, there is only one important method that we need to implement. That is the `_setup_runners` method. This is where we chain the runners together.
-
-```{literalinclude} ../../../../snippets/pipelines/dummy/pipeline_serial.txt
-:language: python
-```
-
-In this example we use `SerialRunner` for running each job. It is a simple runner that runs the jobs in a serial manner. For more information on `SerialRunner` look [here](../../reference/pipelines/runners/serial.md).
-
-Okay, so we have the pipeline. How do we run it? To do this let's create a simple entrypoint in `tools` folder of Anomalib.
-
-Here is how the directory looks.
-
-```{literalinclude} ../../../../snippets/pipelines/dummy/tools_dir_structure.txt
-:language: bash
-```
-
-As you can see, we have the `config.yaml` file in the same directory. Let's quickly populate `experiment.py`.
-
-```python
-from anomalib.pipelines.experiment_pipeline import ExperimentPipeline
-
-if __name__ == "__main__":
-    ExperimentPipeline().run()
-```
-
-Alright! Time to take it on the road.
-
-```bash
-python tools/experimental/experiment/experiment.py --config tools/experimental/experiment/config.yaml
-```
-
-If all goes well you should see the summary plot in `runs/significant_feature/summary_plot.png`.
-
-## Exposing to the CLI
-
-Now that you have your shiny new pipeline, you can expose it as a subcommand to `anomalib` by adding an entry to the pipeline registry in `anomalib/cli/pipelines.py`.
-
-```python
-if try_import("anomalib.pipelines"):
-    ...
-    from anomalib.pipelines import ExperimentPipeline
-
-PIPELINE_REGISTRY: dict[str, type[Pipeline]] | None = {
-    "experiment": ExperimentPipeline,
-    ...
-}
-```
-
-With this you can now call
-
-```{literalinclude} ../../../../snippets/pipelines/dummy/anomalib_cli.txt
-:language: bash
-```
-
-Congratulations! You have successfully created a pipeline that trains a model and computes the significance of the parameters to the final score 🎉
-
-```{admonition} Challenge
-:class: tip
-This example used a random model hence the scores were meaningless. Try to implement a real model and compute the scores. Look into which parameters lead to the most significant contribution to your score.
-```
-
-## Final Tweaks
-
-Before we end, let's look at a few final tweaks that you can make to the pipeline.
-
-First, let's run the initial model training in parallel. Since all jobs are independent, we can use the [ParallelRunner](../../reference/pipelines/runners/parallel.md). Since the `TrainJob` is a dummy job in this example, the pool of parallel jobs is set to the number of experiments.
-
-```{literalinclude} ../../../../snippets/pipelines/dummy/pipeline_parallel.txt
-
-```
-
-You now notice that the entire pipeline takes lesser time to run. This is handy when you have large number of experiments, and when each job takes substantial time to run.
-
-Now on to the second one. When running the pipeline we don't want our terminal cluttered with the outputs from each run. Anomalib provides a handy decorator that temporarily hides the output of a function. It suppresses all outputs to the standard out and the standard error unless an exception is raised. Let's add this to the `TrainJob`
-
-```python
-from anomalib.utils.logging import hide_output
-
-class TrainJob(Job):
-    ...
-
-    @hide_output
-    def run(self, task_id: int | None = None) -> dict:
-        ...
-```
-
-You will no longer see the output of the `print` statement in the `TrainJob` method in the terminal.
diff --git a/docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md b/docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md
new file mode 100644
index 0000000000..3550efb5fd
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md
@@ -0,0 +1,157 @@
+# 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/openvinotoolkit/anomalib/issues) and feel free to ask any question in [Discussions](https://github.com/openvinotoolkit/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: "gpu"
+default_root_dir: "results"
+```
+
+### Tiling
+
+This section contains the following settings, used for image tiling:
+
+```{code-block} yaml
+
+tiling:
+    tile_size: 256
+    stride: 256
+```
+
+These settings determine the tile size and stride. Another important parameter is image_size from `data` section later in the config. It determines the original size of the image.
+
+Input image is 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:
+  method: F1AdaptiveThreshold
+  stage: image
+```
+
+- **Normalization**: Can be applied per each tile location separately (`tile` option), after combining prediction (`image` option), or skipped (`none` option).
+
+- **Thresholding**: Can also be applied at different stages, but it is limited to `tile` and `image`. Another setting for thresholding is the method used. It can be specified as a string or by the class path.
+
+### Data
+
+The `data` section is used to configure the input `image_size` and other parameters for the dataset used.
+
+```{code-block} yaml
+data:
+  class_path: anomalib.data.MVTec
+  init_args:
+    root: ./datasets/MVTec
+    category: bottle
+    train_batch_size: 32
+    eval_batch_size: 32
+    num_workers: 8
+    task: segmentation
+    transform: null
+    train_transform: null
+    eval_transform: null
+    test_split_mode: from_dir
+    test_split_ratio: 0.2
+    val_split_mode: same_as_test
+    val_split_ratio: 0.5
+    image_size: [256, 256]
+```
+
+Refer to [Data](../../reference/data/image/index.md) for more details on parameters.
+
+### 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
+
+  metrics:
+    pixel: AUROC
+    image: AUROC
+
+  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.
+- **Metrics**: Defines evaluation metrics for pixel and image level.
+- **Trainer**: _optional_ parameters, used to control the training process. Refer to [Engine](../../reference/engine/index.md) for more details.
diff --git a/docs/source/snippets/train/api/default.txt b/docs/source/snippets/train/api/default.txt
index 30293cf501..1fe6cb895c 100644
--- a/docs/source/snippets/train/api/default.txt
+++ b/docs/source/snippets/train/api/default.txt
@@ -1,12 +1,15 @@
 # Import the required modules
 from anomalib.data import MVTec
-from anomalib.models import Patchcore
 from anomalib.engine import Engine
+from anomalib.models import EfficientAd
 
 # Initialize the datamodule, model and engine
-datamodule = MVTec()
-model = Patchcore()
-engine = Engine()
+datamodule = MVTec(train_batch_size=1)
+model = EfficientAd()
+engine = Engine(max_epochs=5)
 
 # Train the model
 engine.fit(datamodule=datamodule, model=model)
+
+# Continue from a checkpoint
+engine.fit(datamodule=datamodule, model=model, ckpt_path="path/to/checkpoint.ckpt")
diff --git a/docs/source/snippets/train/cli/default.txt b/docs/source/snippets/train/cli/default.txt
index 3f64f687ad..1990dbf97e 100644
--- a/docs/source/snippets/train/cli/default.txt
+++ b/docs/source/snippets/train/cli/default.txt
@@ -2,10 +2,13 @@
 anomalib train -h
 
 # Train by using the default values.
-anomalib train --model Patchcore --data anomalib.data.MVTec
+anomalib train --model EfficientAd --data anomalib.data.MVTec --data.train_batch_size 1
 
 # Train by overriding arguments.
-anomalib train --model Patchcore --data anomalib.data.MVTec --data.category transistor
+anomalib train --model EfficientAd --data anomalib.data.MVTec --data.train_batch_size 1 --data.category transistor
 
 # Train by using a config file.
 anomalib train --config 
+
+# Continue training from a checkpoint
+anomalib train --config  --ckpt_path 
diff --git a/notebooks/700_metrics/701a_aupimo.ipynb b/notebooks/700_metrics/701a_aupimo.ipynb
index c3be846a77..10e198fef9 100644
--- a/notebooks/700_metrics/701a_aupimo.ipynb
+++ b/notebooks/700_metrics/701a_aupimo.ipynb
@@ -404,7 +404,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.10.14"
   },
   "orig_nbformat": 4
  },
diff --git a/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb b/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb
new file mode 100644
index 0000000000..e117006951
--- /dev/null
+++ b/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb
@@ -0,0 +1,1507 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AUPIMO statistical comparison between two models\n",
+    "\n",
+    "Model A has a higher average AUPIMO than model B. Can you be _sure_ that A is better than B? \n",
+    "\n",
+    "We'll use statistical tests here to make informed decisions about this.\n",
+    "\n",
+    "This notebook covers:\n",
+    "- load/save functions to import/export AUPIMO scores;\n",
+    "- statistical tests between two models, in particular:\n",
+    "  -  parametrical test with Student's t-test;\n",
+    "  -  non-parametrical test with Wilcoxon signed-rank test;\n",
+    "\n",
+    "> AUPIMO is pronounced \"a-u-pee-mo\".\n",
+    "\n",
+    "> For basic usage, please check the notebook [701a_aupimo.ipynb](./701a_aupimo.ipynb)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# What is AUPIMO?\n",
+    "\n",
+    "The `Area Under the Per-Image Overlap [curve]` (AUPIMO) is a metric of recall (higher is better) designed for visual anomaly detection.\n",
+    "\n",
+    "Inspired by the [ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) and [PRO](https://link.springer.com/article/10.1007/s11263-020-01400-4) curves, \n",
+    "\n",
+    "> AUPIMO is the area under a curve of True Positive Rate (TPR or _recall_) as a function of False Positive Rate (FPR) restricted to a fixed range. \n",
+    "\n",
+    "But:\n",
+    "- the TPR (Y-axis) is *per-image* (1 image = 1 curve/score);\n",
+    "- the FPR (X-axis) considers the (average of) **normal** images only; \n",
+    "- the FPR (X-axis) is in log scale and its range is [1e-5, 1e-4]\\* (harder detection task!).\n",
+    "\n",
+    "\\* The score (the area under the curve) is normalized to be in [0, 1].\n",
+    "\n",
+    "AUPIMO can be interpreted as\n",
+    "\n",
+    "> average segmentation recall in an image given that the model (nearly) does not yield false positives in normal images.\n",
+    "\n",
+    "References in the last cell.\n",
+    "\n",
+    "![AUROC vs. AUPRO vs. AUPIMO](./roc_pro_pimo.svg)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Install `anomalib` using `pip`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO(jpcbertoldo): replace by `pip install anomalib` when AUPIMO is released  # noqa: TD003\n",
+    "%pip install ../.."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import urllib.request\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.ticker import FixedLocator, IndexLocator, MaxNLocator, PercentFormatter\n",
+    "from scipy import stats\n",
+    "\n",
+    "from anomalib.metrics.pimo import AUPIMOResult"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pd.options.display.float_format = \"{:.3f}\".format"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load AUPIMO scores\n",
+    "\n",
+    "Unlike previous notebook, we will not train and evaluate the models here.\n",
+    "\n",
+    "We'll load the AUPIMO scores from the benchmark presented in our paper (check the reference in the last cell).\n",
+    "\n",
+    "These scores can be found in AUPIMO's official repository in [`jpcbertoldo:aupimo/data/experiments/benchmark`](https://github.com/jpcbertoldo/aupimo/tree/main/data/experiments/benchmark). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading benchmark results for model 'patchcore_wr101' and dataset 'mvtec/capsule'\n",
+      "Dowloading JSON file from https://raw.githubusercontent.com/jpcbertoldo/aupimo/refs/heads/main/data/experiments/benchmark/patchcore_wr101/mvtec/capsule/aupimo/aupimos.json\n",
+      "Converting payload to dataclass\n",
+      "Done!\n",
+      "Loading benchmark results for model 'patchcore_wr50' and dataset 'mvtec/capsule'\n",
+      "Dowloading JSON file from https://raw.githubusercontent.com/jpcbertoldo/aupimo/refs/heads/main/data/experiments/benchmark/patchcore_wr50/mvtec/capsule/aupimo/aupimos.json\n",
+      "Converting payload to dataclass\n",
+      "Done!\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_benchmark_scores_url(model: str, dataset: str) -> str:\n",
+    "    \"\"\"Generate the URL for the JSON file of a specific model and dataset.\"\"\"\n",
+    "    root_url = \"https://raw.githubusercontent.com/jpcbertoldo/aupimo/refs/heads/main/data/experiments/benchmark\"\n",
+    "    models = {\n",
+    "        \"efficientad_wr101_m_ext\",\n",
+    "        \"efficientad_wr101_s_ext\",\n",
+    "        \"fastflow_cait_m48_448\",\n",
+    "        \"fastflow_wr50\",\n",
+    "        \"padim_r18\",\n",
+    "        \"padim_wr50\",\n",
+    "        \"patchcore_wr101\",\n",
+    "        \"patchcore_wr50\",\n",
+    "        \"pyramidflow_fnf_ext\",\n",
+    "        \"pyramidflow_r18_ext\",\n",
+    "        \"rd++_wr50_ext\",\n",
+    "        \"simplenet_wr50_ext\",\n",
+    "        \"uflow_ext\",\n",
+    "    }\n",
+    "    if model not in models:\n",
+    "        msg = f\"Model '{model}' not available. Choose one of {sorted(models)}.\"\n",
+    "        raise ValueError(msg)\n",
+    "    datasets = {\n",
+    "        \"mvtec/bottle\",\n",
+    "        \"mvtec/cable\",\n",
+    "        \"mvtec/capsule\",\n",
+    "        \"mvtec/carpet\",\n",
+    "        \"mvtec/grid\",\n",
+    "        \"mvtec/hazelnut\",\n",
+    "        \"mvtec/leather\",\n",
+    "        \"mvtec/metal_nut\",\n",
+    "        \"mvtec/pill\",\n",
+    "        \"mvtec/screw\",\n",
+    "        \"mvtec/tile\",\n",
+    "        \"mvtec/toothbrush\",\n",
+    "        \"mvtec/transistor\",\n",
+    "        \"mvtec/wood\",\n",
+    "        \"mvtec/zipper\",\n",
+    "        \"visa/candle\",\n",
+    "        \"visa/capsules\",\n",
+    "        \"visa/cashew\",\n",
+    "        \"visa/chewinggum\",\n",
+    "        \"visa/fryum\",\n",
+    "        \"visa/macaroni1\",\n",
+    "        \"visa/macaroni2\",\n",
+    "        \"visa/pcb1\",\n",
+    "        \"visa/pcb2\",\n",
+    "        \"visa/pcb3\",\n",
+    "        \"visa/pcb4\",\n",
+    "        \"visa/pipe_fryum\",\n",
+    "    }\n",
+    "    if dataset not in datasets:\n",
+    "        msg = f\"Dataset '{dataset}' not available. Choose one of {sorted(datasets)}.\"\n",
+    "        raise ValueError(msg)\n",
+    "    return f\"{root_url}/{model}/{dataset}/aupimo/aupimos.json\"\n",
+    "\n",
+    "\n",
+    "def download_json(url_str: str) -> dict[str, str | float | int | list[str]]:\n",
+    "    \"\"\"Download the JSON content from an URL.\"\"\"\n",
+    "    with urllib.request.urlopen(url_str) as url:  # noqa: S310\n",
+    "        return json.load(url)\n",
+    "\n",
+    "\n",
+    "def load_aupimo_result_from_json_dict(payload: dict[str, str | float | int | list[str]]) -> AUPIMOResult:\n",
+    "    \"\"\"Convert the JSON payload to an AUPIMOResult dataclass.\"\"\"\n",
+    "    if not isinstance(payload, dict):\n",
+    "        msg = f\"Invalid payload. Must be a dictionary. Got {type(payload)}.\"\n",
+    "        raise TypeError(msg)\n",
+    "    try:\n",
+    "        return AUPIMOResult(\n",
+    "            fpr_lower_bound=payload[\"fpr_lower_bound\"],\n",
+    "            fpr_upper_bound=payload[\"fpr_upper_bound\"],\n",
+    "            # `num_threshs` vs `num_thresholds` is an inconsistency with an older version of the JSON file\n",
+    "            num_thresholds=payload[\"num_threshs\"] if \"num_threshs\" in payload else payload[\"num_thresholds\"],\n",
+    "            thresh_lower_bound=payload[\"thresh_lower_bound\"],\n",
+    "            thresh_upper_bound=payload[\"thresh_upper_bound\"],\n",
+    "            aupimos=torch.tensor(payload[\"aupimos\"], dtype=torch.float64),\n",
+    "        )\n",
+    "\n",
+    "    except KeyError as ex:\n",
+    "        msg = f\"Invalid payload. Missing key {ex}.\"\n",
+    "        raise ValueError(msg) from ex\n",
+    "\n",
+    "    except (TypeError, ValueError) as ex:\n",
+    "        msg = f\"Invalid payload. Cause: {ex}.\"\n",
+    "        raise ValueError(msg) from ex\n",
+    "\n",
+    "\n",
+    "def get_benchmark_aupimo_scores(model: str, dataset: str, verbose: bool = True) -> AUPIMOResult:\n",
+    "    \"\"\"Get the benchmark AUPIMO scores for a specific model and dataset.\n",
+    "\n",
+    "    Args:\n",
+    "        model: The model name. See `_get_json_url` for the available models.\n",
+    "        dataset: The \"collection/dataset\", where 'collection' is either 'mvtec' or 'visa', and 'dataset' is\n",
+    "                 the name of the dataset within the collection. See `_get_json_url` for the available datasets.\n",
+    "        verbose: Whether to print the progress.\n",
+    "\n",
+    "    Returns:\n",
+    "        A `AUPIMOResult` dataclass with the AUPIMO scores from the benchmark results.\n",
+    "\n",
+    "        More details in our paper: https://arxiv.org/abs/2401.01984\n",
+    "    \"\"\"\n",
+    "    if verbose:\n",
+    "        print(f\"Loading benchmark results for model '{model}' and dataset '{dataset}'\")\n",
+    "    url = get_benchmark_scores_url(model, dataset)\n",
+    "    if verbose:\n",
+    "        print(f\"Dowloading JSON file from {url}\")\n",
+    "    payload = download_json(url)\n",
+    "    if verbose:\n",
+    "        print(\"Converting payload to dataclass\")\n",
+    "    aupimo_result = load_aupimo_result_from_json_dict(payload)\n",
+    "    if verbose:\n",
+    "        print(\"Done!\")\n",
+    "    return payload, aupimo_result\n",
+    "\n",
+    "\n",
+    "json_model_a, aupimo_result_model_a = get_benchmark_aupimo_scores(\"patchcore_wr101\", \"mvtec/capsule\")\n",
+    "_, aupimo_result_model_b = get_benchmark_aupimo_scores(\"patchcore_wr50\", \"mvtec/capsule\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's remove the `nan` values from the normal images."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "modela.shape=(109,) modelb.shape=(109,) labels.shape=(109,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# corresponding paths to the images\n",
+    "# where the AUPIMO scores were computed from\n",
+    "paths = json_model_a[\"paths\"]\n",
+    "\n",
+    "# extract the labels (i.e. anomaly type or 'good')\n",
+    "labels = np.array([p.split(\"/\")[-2] for p in paths])\n",
+    "\n",
+    "# let's extract only the AUPIMO scores from anomalies\n",
+    "modela = aupimo_result_model_a.aupimos[labels != \"good\"].numpy()\n",
+    "modelb = aupimo_result_model_b.aupimos[labels != \"good\"].numpy()\n",
+    "labels = labels[labels != \"good\"]\n",
+    "print(f\"{modela.shape=} {modelb.shape=} {labels.shape=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(6, 3))\n",
+    "ax.boxplot(\n",
+    "    [modela, modelb],\n",
+    "    tick_labels=[f\"A mean: {modela.mean():.0%}\", f\"B mean: {modelb.mean():.0%}\"],\n",
+    "    vert=False,\n",
+    "    showmeans=True,\n",
+    "    meanline=True,\n",
+    "    widths=0.5,\n",
+    ")\n",
+    "ax.invert_yaxis()\n",
+    "ax.set_title(\"AUPIMO scores distributions from two models\")\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Is this difference significant?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Image by image comparison\n",
+    "\n",
+    "Since we have the scores of each model for each image, we can compare them image by image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(5, 5))\n",
+    "modela_is_better = modela > modelb\n",
+    "ax.scatter(modela[modela_is_better], modelb[modela_is_better], alpha=0.3, s=10, color=\"red\", marker=\"o\")\n",
+    "ax.scatter(modela[~modela_is_better], modelb[~modela_is_better], alpha=0.3, s=10, color=\"blue\", marker=\"o\")\n",
+    "ax.plot([0, 1], [0, 1], color=\"black\", linestyle=\"--\")\n",
+    "ax.set_xlabel(\"Model A\")\n",
+    "ax.set_ylabel(\"Model B\")\n",
+    "ax.set_title(\"AUPIMO scores direct comparison\")\n",
+    "ax.grid()\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The dashed line is where both models have the same AUPIMO score.\n",
+    "\n",
+    "Notice that there are images where one performs better than the other and vice-versa."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Parametric Comparison\n",
+    "\n",
+    "Before using the statistical test, let's first visualize the data seen by the test.\n",
+    "\n",
+    "We'll use a _paired_ t-test, which means we'll compare the AUPIMO scores of the same image one by one."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num_samples = modela.shape[0]\n",
+    "indexes = np.arange(num_samples)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(18, 4))\n",
+    "\n",
+    "# plot sample index vs score and their mean\n",
+    "ax.scatter(indexes, modela, s=30, color=\"tab:blue\", marker=\"o\", label=\"Model A\", zorder=3, alpha=0.6)\n",
+    "ax.axhline(modela.mean(), color=\"tab:blue\", linestyle=\"--\", label=\"Mean\", zorder=3)\n",
+    "ax.scatter(indexes, modelb, s=30, color=\"tab:red\", marker=\"o\", label=\"Model B\", zorder=3, alpha=0.6)\n",
+    "ax.axhline(modelb.mean(), color=\"tab:red\", linestyle=\"--\", label=\"Mean\", zorder=3)\n",
+    "\n",
+    "# configure the x-axis\n",
+    "ax.set_xlabel(\"Sample index\")\n",
+    "ax.set_xlim(0 - (eps := 0.01 * num_samples), num_samples + eps)\n",
+    "ax.xaxis.set_major_locator(IndexLocator(5, 0))\n",
+    "ax.xaxis.set_minor_locator(IndexLocator(1, 0))\n",
+    "\n",
+    "# configure the y-axis\n",
+    "ax.set_ylabel(\"AUPIMO [%]\")\n",
+    "ax.set_ylim(0 - 0.05, 1 + 0.05)\n",
+    "ax.yaxis.set_major_locator(MaxNLocator(6))\n",
+    "ax.yaxis.set_major_formatter(PercentFormatter(1))\n",
+    "\n",
+    "# configure the grid, legend, etc\n",
+    "ax.grid(axis=\"both\", which=\"major\", linestyle=\"-\")\n",
+    "ax.grid(axis=\"x\", which=\"minor\", linestyle=\"--\", alpha=0.5)\n",
+    "ax.legend(ncol=4, loc=\"upper left\", bbox_to_anchor=(0, -0.08))\n",
+    "ax.set_title(\"AUPIMO scores direct comparison\")\n",
+    "\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Notice that several images actually have the same AUPIMO score for both models (e.g. from 10 to 15).\n",
+    "\n",
+    "Others like 21 show a big difference -- model B didn't detect the anomaly at all, but model A did a good job (60% AUPIMO).\n",
+    "\n",
+    "Let's simplify this and only show the differences."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "differences = modela - modelb\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(9, 3))\n",
+    "ax.hist(differences, bins=np.linspace(-1, 1, 61), edgecolor=\"black\")\n",
+    "ax.axvline(differences.mean(), color=\"black\", linestyle=\"--\", label=\"Mean\")\n",
+    "\n",
+    "# configure the x-axis\n",
+    "ax.set_xlabel(\"AUPIMO [%]\")\n",
+    "ax.set_xlim(-1, 1)\n",
+    "ax.xaxis.set_major_locator(MaxNLocator(9))\n",
+    "ax.xaxis.set_minor_locator(MaxNLocator(41))\n",
+    "ax.xaxis.set_major_formatter(PercentFormatter(1))\n",
+    "\n",
+    "# configure the y-axis\n",
+    "ax.set_ylabel(\"Count\")\n",
+    "\n",
+    "# configure the grid, legend, etc\n",
+    "ax.grid(axis=\"both\", which=\"major\", linestyle=\"-\", alpha=1, linewidth=1.0)\n",
+    "ax.grid(axis=\"x\", which=\"minor\", linestyle=\"-\", alpha=0.3)\n",
+    "ax.legend(loc=\"upper right\")\n",
+    "ax.set_title(\"AUPIMO scores differences distribution (Model A - Model B)\")\n",
+    "\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It looks like there is a bias to the right indeed (so model A > model B). \n",
+    "\n",
+    "Is that statistically significant or just random?\n",
+    "\n",
+    "> **Dependent t-test for paired samples**\n",
+    "> \n",
+    "> - null hypothesis: `average(A) == average(B)` \n",
+    "> - alternative hypothesis: `average(A) != average(B)`\n",
+    "> \n",
+    "> See [`scipy.stats.ttest_rel`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_rel.html) and [\" Wikipedia's page on \"Student's t-test\"](https://en.wikipedia.org/wiki/Student's_t-test#Dependent_t-test_for_paired_samples).\n",
+    ">\n",
+    "> **Confidence Level**\n",
+    "> \n",
+    "> Instead of reporting the p-value, we'll report the \"confidence level\" [that the null hypothesis is false], which is `1 - pvalue`.\n",
+    ">  \n",
+    "> *Higher* confidence level *more confident* that `average(A) > average(B)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "test_result=TtestResult(statistic=2.8715471705520033, pvalue=0.004917091449731462, df=108)\n",
+      "confidence=99.5%\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_result = stats.ttest_rel(modela, modelb)\n",
+    "confidence = 1.0 - float(test_result.pvalue)\n",
+    "print(f\"{test_result=}\")\n",
+    "print(f\"{confidence=:.1%}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So, we're very confident that model A has a higher AUPIMO score than model B.\n",
+    "\n",
+    "Maybe is that due to some big differences in a few images?\n",
+    "\n",
+    "What if we don't count much for these big differences?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Non-parametric (rank comparison)\n",
+    "\n",
+    "In non-parametric comparison, bigger differences don't matter more than smaller differences. \n",
+    "\n",
+    "It's all about their relative position.\n",
+    "\n",
+    "Let's look at the analogous plots for this type of comparison."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# the `-` sign is to sort in descending order because higher AUPIMO is better\n",
+    "# the rank values are 1 or 2 because there are only two models\n",
+    "# where 1 is the best and 2 is the worst\n",
+    "# when the scores are the same, 1.5 is assigned to both models\n",
+    "ranks = stats.rankdata(-np.stack([modela, modelb], axis=1), method=\"average\", axis=1)\n",
+    "ranksa, ranksb = ranks[:, 0], ranks[:, 1]\n",
+    "\n",
+    "num_samples = ranks.shape[0]\n",
+    "indexes = np.arange(num_samples)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(18, 2.5))\n",
+    "\n",
+    "# plot sample index vs score and their mean\n",
+    "ax.scatter(indexes, ranksa, s=30, color=\"tab:blue\", marker=\"o\", label=\"Model A\", zorder=3, alpha=0.6)\n",
+    "ax.axhline(ranksa.mean(), color=\"tab:blue\", linestyle=\"--\", label=\"Mean\", zorder=3)\n",
+    "ax.scatter(indexes, ranksb, s=30, color=\"tab:red\", marker=\"o\", label=\"Model B\", zorder=3, alpha=0.6)\n",
+    "ax.axhline(ranksb.mean(), color=\"tab:red\", linestyle=\"--\", label=\"Mean\", zorder=3)\n",
+    "\n",
+    "# configure the x-axis\n",
+    "ax.set_xlabel(\"Sample index\")\n",
+    "ax.set_xlim(0 - (eps := 0.01 * num_samples), num_samples + eps)\n",
+    "ax.xaxis.set_major_locator(IndexLocator(5, 0))\n",
+    "ax.xaxis.set_minor_locator(IndexLocator(1, 0))\n",
+    "\n",
+    "# configure the y-axis\n",
+    "ax.set_ylabel(\"AUPIMO Rank\")\n",
+    "ax.set_ylim(1 - 0.1, 2 + 0.1)\n",
+    "ax.yaxis.set_major_locator(FixedLocator([1, 1.5, 2]))\n",
+    "ax.invert_yaxis()\n",
+    "\n",
+    "# configure the grid, legend, etc\n",
+    "ax.grid(axis=\"both\", which=\"major\", linestyle=\"-\")\n",
+    "ax.grid(axis=\"x\", which=\"minor\", linestyle=\"--\", alpha=0.5)\n",
+    "ax.legend(ncol=4, loc=\"upper left\", bbox_to_anchor=(0, -0.15))\n",
+    "ax.set_title(\"AUPIMO scores ranks\")\n",
+    "\n",
+    "fig.text(\n",
+    "    0.9,\n",
+    "    -0.1,\n",
+    "    \"Ranks: 1 is the best, 2 is the worst, 1.5 when the scores are the same.\",\n",
+    "    ha=\"right\",\n",
+    "    va=\"top\",\n",
+    "    fontsize=\"small\",\n",
+    ")\n",
+    "\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again, blue seems to have a slight advantage, but -- again -- is it significant enough to be sure that model A is better than model B?\n",
+    "\n",
+    "Remember that AUPIMO is a recall metric, so it is basically a ratio of the area of anomalies. \n",
+    "\n",
+    "Is it relevant if model A has 1% more recall than model B in a given image?\n",
+    "\n",
+    "> You can check that out in [`701b_aupimo_advanced_i.ipybn`](./701b_aupimo_advanced_i.ipynb).\n",
+    "\n",
+    "We'll --arbitrarily -- assume that only differences above 5% are relevant."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "
"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "MIN_ABS_DIFF = 0.05\n",
+    "scores = np.stack([modela, modelb], axis=1)\n",
+    "ranks = stats.rankdata(-scores, method=\"average\", axis=1)\n",
+    "abs_diff = np.abs(np.diff(scores, axis=1)).flatten()\n",
+    "ranks[abs_diff < MIN_ABS_DIFF, :] = 1.5\n",
+    "ranksa, ranksb = ranks[:, 0], ranks[:, 1]\n",
+    "\n",
+    "num_samples = ranks.shape[0]\n",
+    "indexes = np.arange(num_samples)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(18, 2.5))\n",
+    "\n",
+    "# plot sample index vs score and their mean\n",
+    "ax.scatter(indexes, ranksa, s=30, color=\"tab:blue\", marker=\"o\", label=\"Model A\", zorder=3, alpha=0.6)\n",
+    "ax.axhline(ranksa.mean(), color=\"tab:blue\", linestyle=\"--\", label=\"Mean\", zorder=3)\n",
+    "ax.scatter(indexes, ranksb, s=30, color=\"tab:red\", marker=\"o\", label=\"Model B\", zorder=3, alpha=0.6)\n",
+    "ax.axhline(ranksb.mean(), color=\"tab:red\", linestyle=\"--\", label=\"Mean\", zorder=3)\n",
+    "\n",
+    "# configure the x-axis\n",
+    "ax.set_xlabel(\"Sample index\")\n",
+    "ax.set_xlim(0 - (eps := 0.01 * num_samples), num_samples + eps)\n",
+    "ax.xaxis.set_major_locator(IndexLocator(5, 0))\n",
+    "ax.xaxis.set_minor_locator(IndexLocator(1, 0))\n",
+    "\n",
+    "# configure the y-axis\n",
+    "ax.set_ylabel(\"AUPIMO Rank\")\n",
+    "ax.set_ylim(1 - 0.1, 2 + 0.1)\n",
+    "ax.yaxis.set_major_locator(FixedLocator([1, 1.5, 2]))\n",
+    "ax.invert_yaxis()\n",
+    "\n",
+    "# configure the grid, legend, etc\n",
+    "ax.grid(axis=\"both\", which=\"major\", linestyle=\"-\")\n",
+    "ax.grid(axis=\"x\", which=\"minor\", linestyle=\"--\", alpha=0.5)\n",
+    "ax.legend(ncol=4, loc=\"upper left\", bbox_to_anchor=(0, -0.15))\n",
+    "ax.set_title(\"AUPIMO scores ranks\")\n",
+    "\n",
+    "fig.text(\n",
+    "    0.9,\n",
+    "    -0.1,\n",
+    "    \"Ranks: 1 is the best, 2 is the worst, 1.5 when the scores are the same.\",\n",
+    "    ha=\"right\",\n",
+    "    va=\"top\",\n",
+    "    fontsize=\"small\",\n",
+    ")\n",
+    "\n",
+    "fig  # noqa: B018, RUF100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The advantage of A over B is clearer now.\n",
+    "\n",
+    "Most of cases where B was better were within the difference margin of 5%.\n",
+    "\n",
+    "The average ranks also got more distant.\n",
+    "\n",
+    "Could it be by chance or can we be confident that model A is better than model B?\n",
+    "\n",
+    "> **Wilcoxon signed rank test**\n",
+    "> \n",
+    "> - null hypothesis: `average(rankA) == average(rankB)` \n",
+    "> - alternative hypothesis: `average(rankA) != average(rankB)`\n",
+    "> \n",
+    "> See [`scipy.stats.wilcoxon`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.wilcoxon.html#scipy.stats.wilcoxon) and [\"Wilcoxon signed-rank test\" in Wikipedia](https://en.wikipedia.org/wiki/Wilcoxon_signed-rank_test).\n",
+    ">\n",
+    "> Confidence Level (reminder): *higher* confidence level *more confident* that `average(rankA) > average(rankB)`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "test_result=WilcoxonResult(statistic=1823.0, pvalue=0.0002876893285960681)\n",
+      "confidence=100.0%\n"
+     ]
+    }
+   ],
+   "source": [
+    "MIN_ABS_DIFF = 0.05\n",
+    "differences = modela - modelb\n",
+    "differences[abs_diff < MIN_ABS_DIFF] = 0.0\n",
+    "test_result = stats.wilcoxon(differences, zero_method=\"zsplit\")\n",
+    "confidence = 1.0 - float(test_result.pvalue)\n",
+    "print(f\"{test_result=}\")\n",
+    "print(f\"{confidence=:.1%}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We got such a high confidence that we can say for sure that these differences are not due to chance.\n",
+    "\n",
+    "So we can say that model A is _consistently_ better than model B -- even though some counter examples exist as we saw in the image by image comparison."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cite Us\n",
+    "\n",
+    "AUPIMO was developed during [Google Summer of Code 2023 (GSoC 2023)](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd) with the `anomalib` team from Intel's OpenVINO Toolkit.\n",
+    "\n",
+    "arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n",
+    "\n",
+    "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n",
+    "\n",
+    "```bibtex\n",
+    "@misc{bertoldo2024aupimo,\n",
+    "      author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n",
+    "      title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n",
+    "      year={2024},\n",
+    "      url={https://arxiv.org/abs/2401.01984}, \n",
+    "}\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Utils\n",
+    "\n",
+    "Some utility functions to expand what this notebook shows."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Save AUPIMO scores\n",
+    "\n",
+    "At the begin of the notebook we defined a function `load_aupimo_result_from_json_dict()` that deserializes `AUPIMOResult` objects.\n",
+    "\n",
+    "Let's define the opposite operator so you can save and publish your AUPIMO scores."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "payload.keys()=dict_keys(['fpr_lower_bound', 'fpr_upper_bound', 'num_thresholds', 'thresh_lower_bound', 'thresh_upper_bound', 'aupimos'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "def save_aupimo_result_to_json_dict(\n",
+    "    aupimo_result: AUPIMOResult,\n",
+    "    paths: list[str | Path] | None = None,\n",
+    ") -> dict[str, str | float | int | list[str]]:\n",
+    "    \"\"\"Convert the AUPIMOResult dataclass to a JSON payload.\"\"\"\n",
+    "    payload = {\n",
+    "        \"fpr_lower_bound\": aupimo_result.fpr_lower_bound,\n",
+    "        \"fpr_upper_bound\": aupimo_result.fpr_upper_bound,\n",
+    "        \"num_thresholds\": aupimo_result.num_thresholds,\n",
+    "        \"thresh_lower_bound\": aupimo_result.thresh_lower_bound,\n",
+    "        \"thresh_upper_bound\": aupimo_result.thresh_upper_bound,\n",
+    "        \"aupimos\": aupimo_result.aupimos.tolist(),\n",
+    "    }\n",
+    "    if paths is not None:\n",
+    "        if len(paths) != aupimo_result.aupimos.shape[0]:\n",
+    "            msg = (\n",
+    "                \"Invalid paths. It must have the same length as the AUPIMO scores. \"\n",
+    "                f\"Got {len(paths)} paths and {aupimo_result.aupimos.shape[0]} scores.\"\n",
+    "            )\n",
+    "            raise ValueError(msg)\n",
+    "        # make sure the paths are strings, not pathlib.Path objects\n",
+    "        payload[\"paths\"] = [str(p) for p in paths]\n",
+    "    return payload\n",
+    "\n",
+    "\n",
+    "payload = save_aupimo_result_to_json_dict(aupimo_result_model_a)\n",
+    "print(f\"{payload.keys()=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "payload.keys()=dict_keys(['fpr_lower_bound', 'fpr_upper_bound', 'num_thresholds', 'thresh_lower_bound', 'thresh_upper_bound', 'aupimos'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "payload = save_aupimo_result_to_json_dict(aupimo_result_model_a)\n",
+    "print(f\"{payload.keys()=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "payload.keys()=dict_keys(['fpr_lower_bound', 'fpr_upper_bound', 'num_thresholds', 'thresh_lower_bound', 'thresh_upper_bound', 'aupimos', 'paths'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# you can optionally save the paths to the images\n",
+    "# where the AUPIMO scores were computed from\n",
+    "payload = save_aupimo_result_to_json_dict(aupimo_result_model_a, paths)\n",
+    "print(f\"{payload.keys()=}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8,0K\t/tmp/tmpsuauy_de/aupimo_result.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "# let's check that it can be saved to a file and loaded back\n",
+    "\n",
+    "from tempfile import TemporaryDirectory\n",
+    "\n",
+    "with TemporaryDirectory() as tmpdir:\n",
+    "    cache_dir = Path(tmpdir)\n",
+    "\n",
+    "    with (cache_dir / \"aupimo_result.json\").open(\"w\") as file:\n",
+    "        json.dump(payload, file)\n",
+    "\n",
+    "    !du -sh {cache_dir / \"aupimo_result.json\"}\n",
+    "\n",
+    "    with (cache_dir / \"aupimo_result.json\").open(\"r\") as file:\n",
+    "        payload_reloaded = json.load(file)\n",
+    "\n",
+    "aupimo_result_reloaded = load_aupimo_result_from_json_dict(payload_reloaded)\n",
+    "assert torch.allclose(aupimo_result_model_a.aupimos, aupimo_result_reloaded.aupimos, equal_nan=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pairwise statistical tests (multiple models)\n",
+    "\n",
+    "What if you have multiple models to compare?\n",
+    "\n",
+    "Here we define a functions that will return all the pairwise comparisons between the models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import itertools\n",
+    "from typing import Any, Literal\n",
+    "\n",
+    "import numpy as np\n",
+    "from numpy import ndarray\n",
+    "from scipy import stats\n",
+    "from torch import Tensor\n",
+    "\n",
+    "\n",
+    "def _validate_models(models: dict[str, Tensor | ndarray]) -> dict[str, ndarray]:\n",
+    "    \"\"\"Make sure the input `models` is valid and convert all the dict's values to `ndarray`.\n",
+    "\n",
+    "    Args:\n",
+    "        models (dict[str, Tensor | ndarray]): {\"model name\": sequence of shape (num_images,)}.\n",
+    "    Validations:\n",
+    "        - keys are strings (model names)\n",
+    "        - there are at least two models\n",
+    "        - values are sequences of floats in [0, 1] or `nan`\n",
+    "        - all sequences have the same shape\n",
+    "        - all `nan` values are at the positions\n",
+    "    Returns:\n",
+    "        dict[str, ndarray]: {\"model name\": array (num_images,)}.\n",
+    "    \"\"\"\n",
+    "    if not isinstance(models, dict):\n",
+    "        msg = f\"Expected argument `models` to be a dict, but got {type(models)}.\"\n",
+    "        raise TypeError(msg)\n",
+    "\n",
+    "    if len(models) < 2:\n",
+    "        msg = \"Expected argument `models` to have at least one key, but got none.\"\n",
+    "        raise ValueError(msg)\n",
+    "\n",
+    "    ref_num_samples = None\n",
+    "    ref_nans = None\n",
+    "    for key in models:\n",
+    "        if not isinstance(key, str):\n",
+    "            msg = f\"Expected argument `models` to have all keys of type str. Found {type(key)}.\"\n",
+    "            raise TypeError(msg)\n",
+    "\n",
+    "        value = models[key]\n",
+    "\n",
+    "        if not isinstance(value, Tensor | ndarray):\n",
+    "            msg = (\n",
+    "                \"Expected argument `models` to have all values of type Tensor or ndarray. \"\n",
+    "                f\"Found {type(value)} on {key=}.\"\n",
+    "            )\n",
+    "            raise TypeError(msg)\n",
+    "\n",
+    "        if isinstance(value, Tensor):\n",
+    "            models[key] = value = value.numpy()\n",
+    "\n",
+    "        if not np.issubdtype(value.dtype, np.floating):\n",
+    "            msg = f\"Expected argument `models` to have all values of floating type. Found {value.dtype} on {key=}.\"\n",
+    "            raise ValueError(msg)\n",
+    "\n",
+    "        if value.ndim != 1:\n",
+    "            msg = f\"Expected argument `models` to have all values of 1D arrays. Found {value.ndim} on {key=}.\"\n",
+    "            raise ValueError(msg)\n",
+    "\n",
+    "        if ref_num_samples is None:\n",
+    "            ref_num_samples = num_samples = value.shape[0]\n",
+    "            ref_nans = nans = np.isnan(value)\n",
+    "\n",
+    "        if num_samples != ref_num_samples:\n",
+    "            msg = \"Argument `models` has inconsistent number of samples.\"\n",
+    "            raise ValueError(msg)\n",
+    "\n",
+    "        if (nans != ref_nans).any():\n",
+    "            msg = \"Argument `models` has inconsistent `nan` values (in different positions).\"\n",
+    "            raise ValueError(msg)\n",
+    "\n",
+    "        if (value[~nans] < 0).any() or (value[~nans] > 1).any():\n",
+    "            msg = (\n",
+    "                \"Expected argument `models` to have all sequences of floats \\\\in [0, 1]. \"\n",
+    "                f\"Key {key} has values outside this range.\"\n",
+    "            )\n",
+    "            raise ValueError(msg)\n",
+    "\n",
+    "    return models\n",
+    "\n",
+    "\n",
+    "def test_pairwise(\n",
+    "    models: dict[str, Tensor | ndarray],\n",
+    "    *,\n",
+    "    test: Literal[\"ttest_rel\", \"wilcoxon\"],\n",
+    "    min_abs_diff: float | None = None,\n",
+    ") -> list[dict[str, Any]]:\n",
+    "    \"\"\"Compare all pairs of models using statistical tests.\n",
+    "\n",
+    "    Scores are assumed to be *higher is better*.\n",
+    "\n",
+    "    General hypothesis in the tests:\n",
+    "        - Null hypothesis: two models are equivalent on average.\n",
+    "        - Alternative hypothesis: one model is better than the other (two-sided test).\n",
+    "\n",
+    "    Args:\n",
+    "        models (dict[str, Tensor | ndarray]): {\"model name\": sequence of shape (num_images,)}.\n",
+    "        test (Literal[\"ttest_rel\", \"wilcoxon\"]): The statistical test to use.\n",
+    "            - \"ttest_rel\": Paired Student's t-test (parametric).\n",
+    "            - \"wilcoxon\": Wilcoxon signed-rank test (non-parametric).\n",
+    "        min_abs_diff (float | None): Minimum absolute difference to consider in the Wilcoxon test. If `None`, all\n",
+    "            differences are considered. Default is `None`. Ignored in the t-test.\n",
+    "    \"\"\"\n",
+    "    models = _validate_models(models)\n",
+    "    if test not in {\"ttest_rel\", \"wilcoxon\"}:\n",
+    "        msg = f\"Expected argument `test` to be 'ttest_rel' or 'wilcoxon', but got '{test}'.\"\n",
+    "        raise ValueError(msg)\n",
+    "    # remove nan values\n",
+    "    models = {k: v[~np.isnan(v)] for k, v in models.items()}\n",
+    "    models_names = sorted(models.keys())\n",
+    "    num_models = len(models)\n",
+    "    comparisons = list(itertools.combinations(range(num_models), 2))\n",
+    "\n",
+    "    # for each comparison, compute the test and confidence (1 - p-value)\n",
+    "    test_results = []\n",
+    "    for modela_idx, modelb_idx in comparisons:  # indices of the sorted model names\n",
+    "        modela = models_names[modela_idx]\n",
+    "        modelb = models_names[modelb_idx]\n",
+    "        modela_scores = models[modela]\n",
+    "        modelb_scores = models[modelb]\n",
+    "        if test == \"ttest_rel\":\n",
+    "            test_result = stats.ttest_rel(modela_scores, modelb_scores, alternative=\"two-sided\")\n",
+    "        else:  # test == \"wilcoxon\"\n",
+    "            differences = modela_scores - modelb_scores\n",
+    "            if min_abs_diff is not None:\n",
+    "                differences[np.abs(differences) < min_abs_diff] = 0.0\n",
+    "            # extreme case\n",
+    "            if (differences == 0).all():\n",
+    "                test_result = stats._morestats.WilcoxonResult(np.nan, 1.0)  # noqa: SLF001\n",
+    "            else:\n",
+    "                test_result = stats.wilcoxon(differences, zero_method=\"zsplit\", alternative=\"two-sided\")\n",
+    "        test_results.append({\n",
+    "            \"modela\": modela,\n",
+    "            \"modelb\": modelb,\n",
+    "            \"confidence\": 1 - test_result.pvalue,\n",
+    "            \"pvalue\": test_result.pvalue,\n",
+    "            \"statistic\": test_result.statistic,\n",
+    "        })\n",
+    "\n",
+    "    return test_results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's first test it with the same two models we used before."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
modelamodelbconfidencepvaluestatistic
0AB0.9950.0052.872
\n",
+       "
"
+      ],
+      "text/plain": [
+       "  modela modelb  confidence  pvalue  statistic\n",
+       "0      A      B       0.995   0.005      2.872"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# parametric test\n",
+    "pd.DataFrame.from_records(test_pairwise({\"A\": modela, \"B\": modelb}, test=\"ttest_rel\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
modelamodelbconfidencepvaluestatistic
0AB0.9980.0021965.500
\n",
+       "
"
+      ],
+      "text/plain": [
+       "  modela modelb  confidence  pvalue  statistic\n",
+       "0      A      B       0.998   0.002   1965.500"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# non-parametric test\n",
+    "pd.DataFrame.from_records(test_pairwise({\"A\": modela, \"B\": modelb}, test=\"wilcoxon\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "
\n",
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
modelamodelbconfidencepvaluestatistic
0AB1.0000.0001823.000
\n",
+       "
"
+      ],
+      "text/plain": [
+       "  modela modelb  confidence  pvalue  statistic\n",
+       "0      A      B       1.000   0.000   1823.000"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# non-parametric test with a minimum absolute difference\n",
+    "pd.DataFrame.from_records(test_pairwise({\"A\": modela, \"B\": modelb}, test=\"wilcoxon\", min_abs_diff=0.05))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's get the best models from the benchmark in our paper and compare them two by two.\n",
+    "\n",
+    "We'll look at the dataset `cashew` from `VisA`.\n",
+    "\n",
+    "> More details in the paper (see the last cell)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "\n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "  \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "    \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "      \n",
+       "    \n",
+       "  \n",
+       "
 modelamodelbconfidencepvaluestatistic
0efficientad_wr101_s_extpatchcore_wr1010.9994020.0005981580.000000
1efficientad_wr101_s_extrd++_wr50_ext0.7736590.2263412193.500000
2efficientad_wr101_s_extsimplenet_wr50_ext1.0000000.000000690.500000
3efficientad_wr101_s_extuflow_ext0.9994470.0005531550.500000
4patchcore_wr101rd++_wr50_ext0.9999800.0000201333.000000
5patchcore_wr101simplenet_wr50_ext1.0000000.000000351.500000
6patchcore_wr101uflow_ext0.7318750.2681252213.000000
7rd++_wr50_extsimplenet_wr50_ext1.0000000.000000967.000000
8rd++_wr50_extuflow_ext0.9999450.0000551383.000000
9simplenet_wr50_extuflow_ext1.0000000.000000318.500000
\n"
+      ],
+      "text/plain": [
+       ""
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "models = {\n",
+    "    model_name: get_benchmark_aupimo_scores(model_name, \"visa/cashew\", verbose=False)[1].aupimos.numpy()\n",
+    "    for model_name in [\n",
+    "        \"efficientad_wr101_s_ext\",\n",
+    "        \"patchcore_wr101\",\n",
+    "        \"rd++_wr50_ext\",\n",
+    "        \"simplenet_wr50_ext\",\n",
+    "        \"uflow_ext\",\n",
+    "    ]\n",
+    "}\n",
+    "models = test_pairwise(models, test=\"wilcoxon\", min_abs_diff=0.1)\n",
+    "pd.DataFrame.from_records(models).style.background_gradient(cmap=\"jet\", vmin=0, vmax=1, subset=[\"confidence\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Compare to the benchmark (coming up)\n",
+    "\n",
+    "Compare your freshly trained models to the benchmark datasets in our paper."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO(jpcbertoldo): implement utility function to load and compare to the results from the benchmark  # noqa: TD003"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cite Us\n",
+    "\n",
+    "AUPIMO was developed during [Google Summer of Code 2023 (GSoC 2023)](https://summerofcode.withgoogle.com/archive/2023/projects/SPMopugd) with the `anomalib` team from Intel's OpenVINO Toolkit.\n",
+    "\n",
+    "arXiv: [arxiv.org/abs/2401.01984](https://arxiv.org/abs/2401.01984) (accepted to BMVC 2024)\n",
+    "\n",
+    "Official repository: [github.com/jpcbertoldo/aupimo](https://github.com/jpcbertoldo/aupimo) (numpy-only API and numba-accelerated versions available)\n",
+    "\n",
+    "```bibtex\n",
+    "@misc{bertoldo2024aupimo,\n",
+    "      author={Joao P. C. Bertoldo and Dick Ameln and Ashwin Vaidya and Samet Akçay},\n",
+    "      title={{AUPIMO: Redefining Visual Anomaly Detection Benchmarks with High Speed and Low Tolerance}}, \n",
+    "      year={2024},\n",
+    "      url={https://arxiv.org/abs/2401.01984}, \n",
+    "}\n",
+    "```"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "anomalib-dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/README.md b/notebooks/README.md
index 15935b93cf..de33e5b7e9 100644
--- a/notebooks/README.md
+++ b/notebooks/README.md
@@ -60,3 +60,4 @@ To install Python, Git and other required tools, [OpenVINO Notebooks](https://gi
 | AUPIMO representative samples and visualization | [701b_aupimo_advanced_i](/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb)     | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb)   |
 | PIMO curve and integration bounds               | [701c_aupimo_advanced_ii](/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb)  |
 | (AU)PIMO of a random model                      | [701d_aupimo_advanced_iii](/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb) |
+| AUPIMO load/save, statistical comparison        | [701e_aupimo_advanced_iv](/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb)  |
diff --git a/pyproject.toml b/pyproject.toml
index 2893ad20c4..e47f7e55d8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -34,6 +34,7 @@ dependencies = [
     "jsonargparse[signatures]>=4.27.7",
     "docstring_parser",     # CLI help-formatter
     "rich_argparse",        # CLI help-formatter
+    "lightning-utilities",
 ]
 
 [project.optional-dependencies]
@@ -56,6 +57,7 @@ core = [
     "open-clip-torch>=2.23.0,<2.26.1",
 ]
 openvino = ["openvino>=2024.0", "nncf>=2.10.0", "onnx>=1.16.0"]
+vlm = ["ollama", "openai", "python-dotenv","transformers"]
 loggers = [
     "comet-ml>=3.31.7",
     "gradio>=4",
@@ -84,7 +86,7 @@ test = [
     "coverage[toml]",
     "tox",
 ]
-full = ["anomalib[core,openvino,loggers,notebooks]"]
+full = ["anomalib[core,openvino,loggers,notebooks, vlm]"]
 dev = ["anomalib[full,docs,test]"]
 
 [project.scripts]
@@ -292,11 +294,15 @@ pythonpath = "src"
 # COVERAGE CONFIGURATION                                                      #
 [tool.coverage.report]
 exclude_lines = [
-    "except ImportError",
+    "pragma: no cover",
+    "def __repr__",
+    "raise NotImplementedError",
+    "if TYPE_CHECKING:",
+    "@abstractmethod",
+    "pass",
     "raise ImportError",
-    "except ApiException",
-    "raise ApiException",
     "raise ValueError",
+    "except ImportError:",
 ]
 
 [tool.coverage.paths]
diff --git a/src/anomalib/__init__.py b/src/anomalib/__init__.py
index cd82b638b9..281e5df759 100644
--- a/src/anomalib/__init__.py
+++ b/src/anomalib/__init__.py
@@ -5,7 +5,7 @@
 
 from enum import Enum
 
-__version__ = "1.2.0dev"
+__version__ = "2.0.0dev"
 
 
 class LearningType(str, Enum):
diff --git a/src/anomalib/cli/pipelines.py b/src/anomalib/cli/pipelines.py
index 8cfb04fd2e..ba6030491b 100644
--- a/src/anomalib/cli/pipelines.py
+++ b/src/anomalib/cli/pipelines.py
@@ -6,13 +6,13 @@
 import logging
 
 from jsonargparse import Namespace
-from lightning_utilities.core.imports import package_available
+from lightning_utilities.core.imports import module_available
 
 from anomalib.cli.utils.help_formatter import get_short_docstring
 
 logger = logging.getLogger(__name__)
 
-if package_available("anomalib.pipelines"):
+if module_available("anomalib.pipelines"):
     from anomalib.pipelines import Benchmark
     from anomalib.pipelines.components.base import Pipeline
 
diff --git a/src/anomalib/cli/utils/openvino.py b/src/anomalib/cli/utils/openvino.py
index ee54bf09b2..50a894c304 100644
--- a/src/anomalib/cli/utils/openvino.py
+++ b/src/anomalib/cli/utils/openvino.py
@@ -6,12 +6,12 @@
 import logging
 
 from jsonargparse import ArgumentParser
-from lightning_utilities.core.imports import package_available
+from lightning_utilities.core.imports import module_available
 
 logger = logging.getLogger(__name__)
 
 
-if package_available("openvino"):
+if module_available("openvino"):
     from openvino.tools.ovc.cli_parser import get_common_cli_parser
 else:
     get_common_cli_parser = None
diff --git a/src/anomalib/data/__init__.py b/src/anomalib/data/__init__.py
index e5ee6bae4c..9c9be7eb5b 100644
--- a/src/anomalib/data/__init__.py
+++ b/src/anomalib/data/__init__.py
@@ -32,16 +32,15 @@
 # Datamodules
 from .datamodules.base import AnomalibDataModule
 from .datamodules.depth import DepthDataFormat, Folder3D, MVTec3D
-from .datamodules.image import BTech, Folder, ImageDataFormat, Kolektor, MVTec, Visa
+from .datamodules.image import BTech, Datumaro, Folder, ImageDataFormat, Kolektor, MVTec, Visa
 from .datamodules.video import Avenue, ShanghaiTech, UCSDped, VideoDataFormat
 
 # Datasets
 from .datasets import AnomalibDataset
 from .datasets.depth import Folder3DDataset, MVTec3DDataset
-from .datasets.image import BTechDataset, FolderDataset, KolektorDataset, MVTecDataset, VisaDataset
+from .datasets.image import BTechDataset, DatumaroDataset, FolderDataset, KolektorDataset, MVTecDataset, VisaDataset
 from .datasets.video import AvenueDataset, ShanghaiTechDataset, UCSDpedDataset
 from .predict import PredictDataset
-from .utils import LabelName
 
 logger = logging.getLogger(__name__)
 
@@ -106,6 +105,7 @@ def get_datamodule(config: DictConfig | ListConfig | dict) -> AnomalibDataModule
     "Folder3DDataset",
     "MVTec3DDataset",
     "BTechDataset",
+    "DatumaroDataset",
     "FolderDataset",
     "KolektorDataset",
     "MVTecDataset",
@@ -121,6 +121,7 @@ def get_datamodule(config: DictConfig | ListConfig | dict) -> AnomalibDataModule
     "VideoDataFormat",
     "get_datamodule",
     "BTech",
+    "Datumaro",
     "Folder",
     "Folder3D",
     "Kolektor",
@@ -131,4 +132,5 @@ def get_datamodule(config: DictConfig | ListConfig | dict) -> AnomalibDataModule
     "ShanghaiTech",
     "Visa",
     "LabelName",
+    "PredictDataset",
 ]
diff --git a/src/anomalib/data/dataclasses/generic.py b/src/anomalib/data/dataclasses/generic.py
index 3244fce6cf..5f9dca9dc9 100644
--- a/src/anomalib/data/dataclasses/generic.py
+++ b/src/anomalib/data/dataclasses/generic.py
@@ -343,7 +343,7 @@ def validate_depth_path(depth_path: PathT) -> PathT | None:
 
 
 @dataclass
-class _OutputFields(Generic[T, MaskT], ABC):
+class _OutputFields(Generic[T, MaskT, PathT], ABC):
     """Generic dataclass that defines the standard output fields for Anomalib.
 
     This class defines the standard output fields used in Anomalib, including
@@ -390,6 +390,7 @@ class _OutputFields(Generic[T, MaskT], ABC):
     pred_score: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_pred_score")
     pred_mask: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="validate_pred_mask")
     pred_label: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_pred_label")
+    explanation: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="validate_explanation")
 
     @staticmethod
     @abstractmethod
@@ -415,6 +416,12 @@ def validate_pred_label(pred_label: T) -> T | None:
         """Validate the predicted label."""
         raise NotImplementedError
 
+    @staticmethod
+    @abstractmethod
+    def validate_explanation(explanation: PathT) -> PathT | None:
+        """Validate the explanation."""
+        raise NotImplementedError
+
 
 @dataclass
 class UpdateMixin:
@@ -471,7 +478,7 @@ def update(self, in_place: bool = True, **changes) -> Any:  # noqa: ANN401
 class _GenericItem(
     UpdateMixin,
     Generic[T, ImageT, MaskT, PathT],
-    _OutputFields[T, MaskT],
+    _OutputFields[T, MaskT, PathT],
     _InputFields[T, ImageT, MaskT, PathT],
 ):
     """Generic dataclass for a single item in Anomalib datasets.
@@ -520,7 +527,7 @@ class _GenericItem(
 class _GenericBatch(
     UpdateMixin,
     Generic[T, ImageT, MaskT, PathT],
-    _OutputFields[T, MaskT],
+    _OutputFields[T, MaskT, PathT],
     _InputFields[T, ImageT, MaskT, PathT],
 ):
     """Generic dataclass for a batch of items in Anomalib datasets.
diff --git a/src/anomalib/data/datamodules/__init__.py b/src/anomalib/data/datamodules/__init__.py
index c81666db5e..4072428384 100644
--- a/src/anomalib/data/datamodules/__init__.py
+++ b/src/anomalib/data/datamodules/__init__.py
@@ -4,13 +4,14 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from .depth import Folder3D, MVTec3D
-from .image import BTech, Folder, Kolektor, MVTec, Visa
+from .image import BTech, Datumaro, Folder, Kolektor, MVTec, Visa
 from .video import Avenue, ShanghaiTech, UCSDped
 
 __all__ = [
     "Folder3D",
     "MVTec3D",
     "BTech",
+    "Datumaro",
     "Folder",
     "Kolektor",
     "MVTec",
diff --git a/src/anomalib/data/datamodules/image/__init__.py b/src/anomalib/data/datamodules/image/__init__.py
index ca57cf6868..69221f863c 100644
--- a/src/anomalib/data/datamodules/image/__init__.py
+++ b/src/anomalib/data/datamodules/image/__init__.py
@@ -6,6 +6,7 @@
 from enum import Enum
 
 from .btech import BTech
+from .datumaro import Datumaro
 from .folder import Folder
 from .kolektor import Kolektor
 from .mvtec import MVTec
@@ -15,13 +16,14 @@
 class ImageDataFormat(str, Enum):
     """Supported Image Dataset Types."""
 
-    MVTEC = "mvtec"
-    MVTEC_3D = "mvtec_3d"
     BTECH = "btech"
-    KOLEKTOR = "kolektor"
+    DATUMARO = "datumaro"
     FOLDER = "folder"
     FOLDER_3D = "folder_3d"
+    KOLEKTOR = "kolektor"
+    MVTEC = "mvtec"
+    MVTEC_3D = "mvtec_3d"
     VISA = "visa"
 
 
-__all__ = ["BTech", "Folder", "Kolektor", "MVTec", "Visa"]
+__all__ = ["BTech", "Datumaro", "Folder", "Kolektor", "MVTec", "Visa"]
diff --git a/src/anomalib/data/datamodules/image/datumaro.py b/src/anomalib/data/datamodules/image/datumaro.py
new file mode 100644
index 0000000000..f7496982da
--- /dev/null
+++ b/src/anomalib/data/datamodules/image/datumaro.py
@@ -0,0 +1,104 @@
+"""DataModule for Datumaro format.
+
+Note: This currently only works for annotations exported from Intel Geti™.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+from anomalib import TaskType
+from anomalib.data.datamodules.base import AnomalibDataModule
+from anomalib.data.datasets.image.datumaro import DatumaroDataset
+from anomalib.data.utils import Split, TestSplitMode, ValSplitMode
+
+
+class Datumaro(AnomalibDataModule):
+    """Datumaro datamodule.
+
+    Args:
+        root (str | Path): Path to the dataset root directory.
+        train_batch_size (int): Batch size for training dataloader.
+            Defaults to ``32``.
+        eval_batch_size (int): Batch size for evaluation dataloader.
+            Defaults to ``32``.
+        num_workers (int): Number of workers for dataloaders.
+            Defaults to ``8``.
+        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
+            Defaults to ``TaskType.CLASSIFICATION``. Currently only supports classification.
+        image_size (tuple[int, int], optional): Size to which input images should be resized.
+            Defaults to ``None``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
+            Defaults to ``None``.
+        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
+            Defaults to ``None``.
+        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+            Defaults to ``TestSplitMode.FROM_DIR``.
+        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+            Defaults to ``0.2``.
+        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+            Defaults to ``ValSplitMode.SAME_AS_TEST``.
+        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+            Defaults to ``0.5``.
+        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+            Defualts to ``None``.
+
+    Examples:
+        To create a Datumaro datamodule
+
+        >>> from pathlib import Path
+        >>> from torchvision.transforms.v2 import Resize
+        >>> root = Path("path/to/dataset")
+        >>> datamodule = Datumaro(root, transform=Resize((256, 256)))
+        >>> datamodule.setup()
+        >>> i, data = next(enumerate(datamodule.train_dataloader()))
+        >>> data.keys()
+        dict_keys(['image_path', 'label', 'image'])
+
+        >>> data["image"].shape
+        torch.Size([32, 3, 256, 256])
+    """
+
+    def __init__(
+        self,
+        root: str | Path,
+        train_batch_size: int = 32,
+        eval_batch_size: int = 32,
+        num_workers: int = 8,
+        task: TaskType = TaskType.CLASSIFICATION,
+        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
+        test_split_ratio: float = 0.5,
+        val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
+        val_split_ratio: float = 0.5,
+        seed: int | None = None,
+    ) -> None:
+        if task != TaskType.CLASSIFICATION:
+            msg = "Datumaro dataloader currently only supports classification task."
+            raise ValueError(msg)
+        super().__init__(
+            train_batch_size=train_batch_size,
+            eval_batch_size=eval_batch_size,
+            num_workers=num_workers,
+            val_split_mode=val_split_mode,
+            val_split_ratio=val_split_ratio,
+            test_split_mode=test_split_mode,
+            test_split_ratio=test_split_ratio,
+            seed=seed,
+        )
+        self.root = root
+        self.task = task
+
+    def _setup(self, _stage: str | None = None) -> None:
+        self.train_data = DatumaroDataset(
+            task=self.task,
+            root=self.root,
+            split=Split.TRAIN,
+        )
+        self.test_data = DatumaroDataset(
+            task=self.task,
+            root=self.root,
+            split=Split.TEST,
+        )
diff --git a/src/anomalib/data/datasets/__init__.py b/src/anomalib/data/datasets/__init__.py
index 3208bda54a..32e3995ea5 100644
--- a/src/anomalib/data/datasets/__init__.py
+++ b/src/anomalib/data/datasets/__init__.py
@@ -5,7 +5,7 @@
 
 from .base import AnomalibDataset, AnomalibDepthDataset, AnomalibVideoDataset
 from .depth import Folder3DDataset, MVTec3DDataset
-from .image import BTechDataset, FolderDataset, KolektorDataset, MVTecDataset, VisaDataset
+from .image import BTechDataset, DatumaroDataset, FolderDataset, KolektorDataset, MVTecDataset, VisaDataset
 from .video import AvenueDataset, ShanghaiTechDataset, UCSDpedDataset
 
 __all__ = [
@@ -18,6 +18,7 @@
     "MVTec3DDataset",
     # Image
     "BTechDataset",
+    "DatumaroDataset",
     "FolderDataset",
     "KolektorDataset",
     "MVTecDataset",
diff --git a/src/anomalib/data/datasets/image/__init__.py b/src/anomalib/data/datasets/image/__init__.py
index c3b5c41dc7..b7749dad18 100644
--- a/src/anomalib/data/datasets/image/__init__.py
+++ b/src/anomalib/data/datasets/image/__init__.py
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from .btech import BTechDataset
+from .datumaro import DatumaroDataset
 from .folder import FolderDataset
 from .kolektor import KolektorDataset
 from .mvtec import MVTecDataset
@@ -11,6 +12,7 @@
 
 __all__ = [
     "BTechDataset",
+    "DatumaroDataset",
     "FolderDataset",
     "KolektorDataset",
     "MVTecDataset",
diff --git a/src/anomalib/data/datasets/image/datumaro.py b/src/anomalib/data/datasets/image/datumaro.py
new file mode 100644
index 0000000000..6c67c61359
--- /dev/null
+++ b/src/anomalib/data/datasets/image/datumaro.py
@@ -0,0 +1,126 @@
+"""Dataloader for Datumaro format.
+
+Note: This currently only works for annotations exported from Intel Geti™.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from pathlib import Path
+
+import pandas as pd
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.datasets.base import AnomalibDataset
+from anomalib.data.utils import LabelName, Split
+
+
+def make_datumaro_dataset(root: str | Path, split: str | Split | None = None) -> pd.DataFrame:
+    """Make Datumaro Dataset.
+
+    Assumes the following directory structure:
+
+    dataset
+    ├── annotations
+    │    └── default.json
+    └── images
+        └── default
+                ├── image1.jpg
+                ├── image2.jpg
+                └── ...
+
+    Args:
+        root (str | Path): Path to the dataset root directory.
+        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST.
+            Defaults to ``None``.
+
+    Examples:
+        >>> root = Path("path/to/dataset")
+        >>> samples = make_datumaro_dataset(root)
+        >>> samples.head()
+            image_path	label	label_index	split	mask_path
+        0	path/to/dataset...	Normal	0	Split.TRAIN
+        1	path/to/dataset...	Normal	0	Split.TRAIN
+        2	path/to/dataset...	Normal	0	Split.TRAIN
+        3	path/to/dataset...	Normal	0	Split.TRAIN
+        4	path/to/dataset...	Normal	0	Split.TRAIN
+
+
+    Returns:
+        DataFrame: an output dataframe containing samples for the requested split (ie., train or test).
+    """
+    annotation_file = Path(root) / "annotations" / "default.json"
+    with annotation_file.open() as f:
+        annotations = json.load(f)
+
+    categories = annotations["categories"]
+    categories = {idx: label["name"] for idx, label in enumerate(categories["label"]["labels"])}
+
+    samples = []
+    for item in annotations["items"]:
+        image_path = Path(root) / "images" / "default" / item["image"]["path"]
+        label_index = item["annotations"][0]["label_id"]
+        label = categories[label_index]
+        samples.append({
+            "image_path": str(image_path),
+            "label": label,
+            "label_index": label_index,
+            "split": None,
+            "mask_path": "",  # mask is provided in the annotation file and is not on disk.
+        })
+    samples_df = pd.DataFrame(
+        samples,
+        columns=["image_path", "label", "label_index", "split", "mask_path"],
+        index=range(len(samples)),
+    )
+    # Create test/train split
+    # By default assign all "Normal" samples to train and all "Anomalous" samples to test
+    samples_df.loc[samples_df["label_index"] == LabelName.NORMAL, "split"] = Split.TRAIN
+    samples_df.loc[samples_df["label_index"] == LabelName.ABNORMAL, "split"] = Split.TEST
+
+    # Get the data frame for the split.
+    if split:
+        samples_df = samples_df[samples_df.split == split].reset_index(drop=True)
+
+    return samples_df
+
+
+class DatumaroDataset(AnomalibDataset):
+    """Datumaro dataset class.
+
+    Args:
+        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
+        root (str | Path): Path to the dataset root directory.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+            Defaults to ``None``.
+
+
+    Examples:
+        .. code-block:: python
+
+            from anomalib.data.image.datumaro import DatumaroDataset
+            from torchvision.transforms.v2 import Resize
+
+            dataset = DatumaroDataset(root=root,
+                task="classification",
+                transform=Resize((256, 256)),
+            )
+            print(dataset[0].keys())
+            # Output: dict_keys(['dm_format_version', 'infos', 'categories', 'items'])
+
+    """
+
+    def __init__(
+        self,
+        task: TaskType,
+        root: str | Path,
+        transform: Transform | None = None,
+        split: str | Split | None = None,
+    ) -> None:
+        super().__init__(task, transform)
+        self.split = split
+        self.samples = make_datumaro_dataset(root, split)
diff --git a/src/anomalib/data/image/datumaro.py b/src/anomalib/data/image/datumaro.py
new file mode 100644
index 0000000000..b4836990ec
--- /dev/null
+++ b/src/anomalib/data/image/datumaro.py
@@ -0,0 +1,226 @@
+"""Dataloader for Datumaro format.
+
+Note: This currently only works for annotations exported from Intel Geti™.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from pathlib import Path
+
+import pandas as pd
+from torchvision.transforms.v2 import Transform
+
+from anomalib import TaskType
+from anomalib.data.base import AnomalibDataModule, AnomalibDataset
+from anomalib.data.utils import LabelName, Split, TestSplitMode, ValSplitMode
+
+
+def make_datumaro_dataset(root: str | Path, split: str | Split | None = None) -> pd.DataFrame:
+    """Make Datumaro Dataset.
+
+    Assumes the following directory structure:
+
+    dataset
+    ├── annotations
+    │    └── default.json
+    └── images
+        └── default
+                ├── image1.jpg
+                ├── image2.jpg
+                └── ...
+
+    Args:
+        root (str | Path): Path to the dataset root directory.
+        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST.
+            Defaults to ``None``.
+
+    Examples:
+        >>> root = Path("path/to/dataset")
+        >>> samples = make_datumaro_dataset(root)
+        >>> samples.head()
+            image_path	label	label_index	split	mask_path
+        0	path/to/dataset...	Normal	0	Split.TRAIN
+        1	path/to/dataset...	Normal	0	Split.TRAIN
+        2	path/to/dataset...	Normal	0	Split.TRAIN
+        3	path/to/dataset...	Normal	0	Split.TRAIN
+        4	path/to/dataset...	Normal	0	Split.TRAIN
+
+
+    Returns:
+        DataFrame: an output dataframe containing samples for the requested split (ie., train or test).
+    """
+    annotation_file = Path(root) / "annotations" / "default.json"
+    with annotation_file.open() as f:
+        annotations = json.load(f)
+
+    categories = annotations["categories"]
+    categories = {idx: label["name"] for idx, label in enumerate(categories["label"]["labels"])}
+
+    samples = []
+    for item in annotations["items"]:
+        image_path = Path(root) / "images" / "default" / item["image"]["path"]
+        label_index = item["annotations"][0]["label_id"]
+        label = categories[label_index]
+        samples.append({
+            "image_path": str(image_path),
+            "label": label,
+            "label_index": label_index,
+            "split": None,
+            "mask_path": "",  # mask is provided in the annotation file and is not on disk.
+        })
+    samples_df = pd.DataFrame(
+        samples,
+        columns=["image_path", "label", "label_index", "split", "mask_path"],
+        index=range(len(samples)),
+    )
+    # Create test/train split
+    # By default assign all "Normal" samples to train and all "Anomalous" samples to test
+    samples_df.loc[samples_df["label_index"] == LabelName.NORMAL, "split"] = Split.TRAIN
+    samples_df.loc[samples_df["label_index"] == LabelName.ABNORMAL, "split"] = Split.TEST
+
+    # Get the data frame for the split.
+    if split:
+        samples_df = samples_df[samples_df.split == split].reset_index(drop=True)
+
+    return samples_df
+
+
+class DatumaroDataset(AnomalibDataset):
+    """Datumaro dataset class.
+
+    Args:
+        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
+        root (str | Path): Path to the dataset root directory.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+            Defaults to ``None``.
+
+
+    Examples:
+        .. code-block:: python
+
+            from anomalib.data.image.datumaro import DatumaroDataset
+            from torchvision.transforms.v2 import Resize
+
+            dataset = DatumaroDataset(root=root,
+                task="classification",
+                transform=Resize((256, 256)),
+            )
+            print(dataset[0].keys())
+            # Output: dict_keys(['dm_format_version', 'infos', 'categories', 'items'])
+
+    """
+
+    def __init__(
+        self,
+        task: TaskType,
+        root: str | Path,
+        transform: Transform | None = None,
+        split: str | Split | None = None,
+    ) -> None:
+        super().__init__(task, transform)
+        self.split = split
+        self.samples = make_datumaro_dataset(root, split)
+
+
+class Datumaro(AnomalibDataModule):
+    """Datumaro datamodule.
+
+    Args:
+        root (str | Path): Path to the dataset root directory.
+        train_batch_size (int): Batch size for training dataloader.
+            Defaults to ``32``.
+        eval_batch_size (int): Batch size for evaluation dataloader.
+            Defaults to ``32``.
+        num_workers (int): Number of workers for dataloaders.
+            Defaults to ``8``.
+        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
+            Defaults to ``TaskType.CLASSIFICATION``. Currently only supports classification.
+        image_size (tuple[int, int], optional): Size to which input images should be resized.
+            Defaults to ``None``.
+        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``None``.
+        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
+            Defaults to ``None``.
+        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
+            Defaults to ``None``.
+        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+            Defaults to ``TestSplitMode.FROM_DIR``.
+        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+            Defaults to ``0.2``.
+        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+            Defaults to ``ValSplitMode.SAME_AS_TEST``.
+        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+            Defaults to ``0.5``.
+        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+            Defualts to ``None``.
+
+    Examples:
+        To create a Datumaro datamodule
+
+        >>> from pathlib import Path
+        >>> from torchvision.transforms.v2 import Resize
+        >>> root = Path("path/to/dataset")
+        >>> datamodule = Datumaro(root, transform=Resize((256, 256)))
+        >>> datamodule.setup()
+        >>> i, data = next(enumerate(datamodule.train_dataloader()))
+        >>> data.keys()
+        dict_keys(['image_path', 'label', 'image'])
+
+        >>> data["image"].shape
+        torch.Size([32, 3, 256, 256])
+    """
+
+    def __init__(
+        self,
+        root: str | Path,
+        train_batch_size: int = 32,
+        eval_batch_size: int = 32,
+        num_workers: int = 8,
+        task: TaskType = TaskType.CLASSIFICATION,
+        image_size: tuple[int, int] | None = None,
+        transform: Transform | None = None,
+        train_transform: Transform | None = None,
+        eval_transform: Transform | None = None,
+        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
+        test_split_ratio: float = 0.5,
+        val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
+        val_split_ratio: float = 0.5,
+        seed: int | None = None,
+    ) -> None:
+        if task != TaskType.CLASSIFICATION:
+            msg = "Datumaro dataloader currently only supports classification task."
+            raise ValueError(msg)
+        super().__init__(
+            train_batch_size=train_batch_size,
+            eval_batch_size=eval_batch_size,
+            num_workers=num_workers,
+            val_split_mode=val_split_mode,
+            val_split_ratio=val_split_ratio,
+            test_split_mode=test_split_mode,
+            test_split_ratio=test_split_ratio,
+            image_size=image_size,
+            transform=transform,
+            train_transform=train_transform,
+            eval_transform=eval_transform,
+            seed=seed,
+        )
+        self.root = root
+        self.task = task
+
+    def _setup(self, _stage: str | None = None) -> None:
+        self.train_data = DatumaroDataset(
+            task=self.task,
+            root=self.root,
+            transform=self.train_transform,
+            split=Split.TRAIN,
+        )
+        self.test_data = DatumaroDataset(
+            task=self.task,
+            root=self.root,
+            transform=self.eval_transform,
+            split=Split.TEST,
+        )
diff --git a/src/anomalib/data/utils/tiler.py b/src/anomalib/data/utils/tiler.py
index 089aeaae91..2c1e949e45 100644
--- a/src/anomalib/data/utils/tiler.py
+++ b/src/anomalib/data/utils/tiler.py
@@ -162,11 +162,11 @@ def __init__(
         remove_border_count: int = 0,
         mode: ImageUpscaleMode = ImageUpscaleMode.PADDING,
     ) -> None:
-        self.tile_size_h, self.tile_size_w = self.__validate_size_type(tile_size)
+        self.tile_size_h, self.tile_size_w = self.validate_size_type(tile_size)
         self.random_tile_count = 4
 
         if stride is not None:
-            self.stride_h, self.stride_w = self.__validate_size_type(stride)
+            self.stride_h, self.stride_w = self.validate_size_type(stride)
 
         self.remove_border_count = remove_border_count
         self.overlapping = not (self.stride_h == self.tile_size_h and self.stride_w == self.tile_size_w)
@@ -201,7 +201,15 @@ def __init__(
         self.num_patches_w: int
 
     @staticmethod
-    def __validate_size_type(parameter: int | Sequence) -> tuple[int, ...]:
+    def validate_size_type(parameter: int | Sequence) -> tuple[int, ...]:
+        """Validate size type and return tuple of form [tile_h, tile_w].
+
+        Args:
+            parameter (int | Sequence): input tile size parameter.
+
+        Returns:
+            tuple[int, ...]: Validated tile size in tuple form.
+        """
         if isinstance(parameter, int):
             output = (parameter, parameter)
         elif isinstance(parameter, Sequence):
diff --git a/src/anomalib/data/validators/numpy/depth.py b/src/anomalib/data/validators/numpy/depth.py
index d43c1e1750..89d7726182 100644
--- a/src/anomalib/data/validators/numpy/depth.py
+++ b/src/anomalib/data/validators/numpy/depth.py
@@ -82,6 +82,11 @@ def validate_depth_path(depth_path: str | None) -> str | None:
         """Validate the depth path."""
         return validate_path(depth_path) if depth_path else None
 
+    @staticmethod
+    def validate_explanation(explanation: str | None) -> str | None:
+        """Validate the explanation."""
+        return NumpyImageValidator.validate_explanation(explanation)
+
 
 class NumpyDepthBatchValidator:
     """Validate numpy.ndarray data for batches of depth images."""
@@ -156,3 +161,8 @@ def validate_depth_path(depth_path: list[str] | None) -> list[str] | None:
             msg = f"Depth path must be a list of strings, got {type(depth_path)}."
             raise TypeError(msg)
         return [validate_path(path) for path in depth_path]
+
+    @staticmethod
+    def validate_explanation(explanation: list[str] | None) -> list[str] | None:
+        """Validate the explanations for a batch."""
+        return NumpyImageBatchValidator.validate_explanation(explanation)
diff --git a/src/anomalib/data/validators/numpy/image.py b/src/anomalib/data/validators/numpy/image.py
index b560bd5f20..455ecde2b0 100644
--- a/src/anomalib/data/validators/numpy/image.py
+++ b/src/anomalib/data/validators/numpy/image.py
@@ -315,6 +315,30 @@ def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
             raise ValueError(msg)
         return pred_label.astype(bool)
 
+    @staticmethod
+    def validate_explanation(explanation: str | None) -> str | None:
+        """Validate the explanation.
+
+        Args:
+            explanation (str | None): Input explanation.
+
+        Returns:
+            str | None: Validated explanation, or None.
+
+        Examples:
+            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> explanation = "The image has a crack on the wall."
+            >>> validated_explanation = ImageValidator.validate_explanation(explanation)
+            >>> validated_explanation == explanation
+            True
+        """
+        if explanation is None:
+            return None
+        if not isinstance(explanation, str):
+            msg = f"Explanation must be a string, got {type(explanation)}."
+            raise TypeError(msg)
+        return explanation
+
 
 class NumpyImageBatchValidator:
     """Validate numpy.ndarray data for batches of images."""
@@ -677,3 +701,30 @@ def validate_image_path(image_path: list[str] | None) -> list[str] | None:
             msg = f"Image path must be a list of strings, got {type(image_path)}."
             raise TypeError(msg)
         return [str(path) for path in image_path]
+
+    @staticmethod
+    def validate_explanation(explanation: list[str] | None) -> list[str] | None:
+        """Validate the explanations for a batch.
+
+        Args:
+            explanation (list[str] | None): Input list of explanations.
+
+        Returns:
+            list[str] | None: Validated list of explanations, or None.
+
+        Raises:
+            TypeError: If the input is not a list of strings.
+
+        Examples:
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> explanations = ["The image has a crack on the wall.", "The image has a dent on the car."]
+            >>> validated_explanations = ImageBatchValidator.validate_explanation(explanations)
+            >>> print(validated_explanations)
+            ['The image has a crack on the wall.', 'The image has a dent on the car.']
+        """
+        if explanation is None:
+            return None
+        if not isinstance(explanation, list):
+            msg = f"Explanation must be a list of strings, got {type(explanation)}."
+            raise TypeError(msg)
+        return [str(exp) for exp in explanation]
diff --git a/src/anomalib/data/validators/numpy/video.py b/src/anomalib/data/validators/numpy/video.py
index a75f17d546..e12682881b 100644
--- a/src/anomalib/data/validators/numpy/video.py
+++ b/src/anomalib/data/validators/numpy/video.py
@@ -6,6 +6,7 @@
 from collections.abc import Sequence
 
 import numpy as np
+from anomalib.data.validators.numpy.image import NumpyImageBatchValidator, NumpyImageValidator
 from anomalib.data.validators.path import validate_batch_path, validate_path
 
 
@@ -350,6 +351,11 @@ def validate_target_frame(target_frame: int | None) -> int | None:
             raise ValueError(msg)
         return target_frame
 
+    @staticmethod
+    def validate_explanation(explanation: str | None) -> str | None:
+        """Validate the explanation string."""
+        return NumpyImageValidator.validate_explanation(explanation)
+
 
 class NumpyVideoBatchValidator:
     """Validate numpy.ndarray data for batches of videos."""
@@ -692,3 +698,8 @@ def validate_target_frame(target_frame: np.ndarray | None) -> np.ndarray | None:
             msg = "Target frame indices must be non-negative."
             raise ValueError(msg)
         return target_frame
+
+    @staticmethod
+    def validate_explanation(explanation: list[str] | None) -> list[str] | None:
+        """Validate the explanation string."""
+        return NumpyImageBatchValidator.validate_explanation(explanation)
diff --git a/src/anomalib/data/validators/torch/depth.py b/src/anomalib/data/validators/torch/depth.py
index a91e3f69ee..6869769ad6 100644
--- a/src/anomalib/data/validators/torch/depth.py
+++ b/src/anomalib/data/validators/torch/depth.py
@@ -228,6 +228,11 @@ def validate_mask_path(mask_path: str | None) -> str | None:
         """Validate the mask path."""
         return ImageValidator.validate_mask_path(mask_path)
 
+    @staticmethod
+    def validate_explanation(explanation: str | None) -> str | None:
+        """Validate the explanation."""
+        return ImageValidator.validate_explanation(explanation)
+
 
 class DepthBatchValidator:
     """Validate torch.Tensor data for batches of depth images."""
@@ -441,3 +446,8 @@ def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
     def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
         """Validate the prediction label for a batch."""
         return ImageBatchValidator.validate_pred_label(pred_label)
+
+    @staticmethod
+    def validate_explanation(explanation: list[str] | None) -> list[str] | None:
+        """Validate the explanations for a batch."""
+        return ImageBatchValidator.validate_explanation(explanation)
diff --git a/src/anomalib/data/validators/torch/image.py b/src/anomalib/data/validators/torch/image.py
index f001180a1d..c9a8ac07cb 100644
--- a/src/anomalib/data/validators/torch/image.py
+++ b/src/anomalib/data/validators/torch/image.py
@@ -309,6 +309,30 @@ def validate_pred_label(pred_label: torch.Tensor | np.ndarray | float | None) ->
             raise ValueError(msg)
         return pred_label.to(torch.bool)
 
+    @staticmethod
+    def validate_explanation(explanation: str | None) -> str | None:
+        """Validate the explanation.
+
+        Args:
+            explanation (str | None): Input explanation.
+
+        Returns:
+            str | None: Validated explanation, or None.
+
+        Examples:
+            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> explanation = "The image has a crack on the wall."
+            >>> validated_explanation = ImageValidator.validate_explanation(explanation)
+            >>> validated_explanation == explanation
+            True
+        """
+        if explanation is None:
+            return None
+        if not isinstance(explanation, str):
+            msg = f"Explanation must be a string, got {type(explanation)}."
+            raise TypeError(msg)
+        return explanation
+
 
 class ImageBatchValidator:
     """Validate torch.Tensor data for batches of images."""
@@ -623,3 +647,30 @@ def validate_image_path(image_path: list[str] | None) -> list[str] | None:
             msg = f"Image path must be a list of strings, got {type(image_path)}."
             raise TypeError(msg)
         return [str(path) for path in image_path]
+
+    @staticmethod
+    def validate_explanation(explanation: list[str] | None) -> list[str] | None:
+        """Validate the explanations for a batch.
+
+        Args:
+            explanation (list[str] | None): Input list of explanations.
+
+        Returns:
+            list[str] | None: Validated list of explanations, or None.
+
+        Raises:
+            TypeError: If the input is not a list of strings.
+
+        Examples:
+            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
+            >>> explanations = ["The image has a crack on the wall.", "The image has a dent on the car."]
+            >>> validated_explanations = ImageBatchValidator.validate_explanation(explanations)
+            >>> print(validated_explanations)
+            ['The image has a crack on the wall.', 'The image has a dent on the car.']
+        """
+        if explanation is None:
+            return None
+        if not isinstance(explanation, list):
+            msg = f"Explanation must be a list of strings, got {type(explanation)}."
+            raise TypeError(msg)
+        return [str(exp) for exp in explanation]
diff --git a/src/anomalib/data/validators/torch/video.py b/src/anomalib/data/validators/torch/video.py
index 0719eb46f2..b7ca50c943 100644
--- a/src/anomalib/data/validators/torch/video.py
+++ b/src/anomalib/data/validators/torch/video.py
@@ -8,6 +8,7 @@
 
 import torch
 from anomalib.data.validators.path import validate_batch_path, validate_path
+from anomalib.data.validators.torch.image import ImageBatchValidator, ImageValidator
 
 
 class VideoValidator:
@@ -487,6 +488,11 @@ def validate_last_frame(last_frame: torch.Tensor | int | float | None) -> torch.
         msg = f"Last frame must be an int, float, or a torch.Tensor, got {type(last_frame)}."
         raise TypeError(msg)
 
+    @staticmethod
+    def validate_explanation(explanation: str | None) -> str | None:
+        """Validate the explanation string."""
+        return ImageValidator.validate_explanation(explanation)
+
 
 class VideoBatchValidator:
     """Validate torch.Tensor data for video batches."""
@@ -935,3 +941,8 @@ def validate_last_frame(last_frame: torch.Tensor | None) -> torch.Tensor | None:
             msg = "Last frame indices must be non-negative."
             raise ValueError(msg)
         return last_frame
+
+    @staticmethod
+    def validate_explanation(explanation: list[str] | None) -> list[str] | None:
+        """Validate the explanation string."""
+        return ImageBatchValidator.validate_explanation(explanation)
diff --git a/src/anomalib/deploy/inferencers/openvino_inferencer.py b/src/anomalib/deploy/inferencers/openvino_inferencer.py
index 08ce792042..61b4a3d0ee 100644
--- a/src/anomalib/deploy/inferencers/openvino_inferencer.py
+++ b/src/anomalib/deploy/inferencers/openvino_inferencer.py
@@ -4,11 +4,11 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
-from importlib.util import find_spec
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import numpy as np
+from lightning_utilities.core.imports import module_available
 from openvino.runtime.utils.data_helpers.wrappers import OVDict
 
 from anomalib.data import NumpyImageBatch
@@ -17,15 +17,6 @@
 logger = logging.getLogger("anomalib")
 
 
-if find_spec("openvino") is not None:
-    import openvino as ov
-
-    if TYPE_CHECKING:
-        from openvino import CompiledModel
-else:
-    logger.warning("OpenVINO is not installed. Please install OpenVINO to use OpenVINOInferencer.")
-
-
 class OpenVINOInferencer:
     """OpenVINO implementation for the inference.
 
@@ -96,12 +87,16 @@ def __init__(
         device: str | None = "AUTO",
         config: dict | None = None,
     ) -> None:
+        if not module_available("openvino"):
+            msg = "OpenVINO is not installed. Please install OpenVINO to use OpenVINOInferencer."
+            raise ImportError(msg)
+
         self.device = device
 
         self.config = config
         self.input_blob, self.output_blob, self.model = self.load_model(path)
 
-    def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any, "CompiledModel"]:
+    def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any, Any]:
         """Load the OpenVINO model.
 
         Args:
@@ -112,6 +107,8 @@ def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any,
             [tuple[str, str, ExecutableNetwork]]: Input and Output blob names
                 together with the Executable network.
         """
+        import openvino as ov
+
         core = ov.Core()
         # If tuple of bytes is passed
         if isinstance(path, tuple):
diff --git a/src/anomalib/loggers/wandb.py b/src/anomalib/loggers/wandb.py
index 55e65e6d54..ff41a0949e 100644
--- a/src/anomalib/loggers/wandb.py
+++ b/src/anomalib/loggers/wandb.py
@@ -9,12 +9,12 @@
 from lightning.fabric.utilities.types import _PATH
 from lightning.pytorch.loggers.wandb import WandbLogger
 from lightning.pytorch.utilities import rank_zero_only
-from lightning_utilities.core.imports import package_available
+from lightning_utilities.core.imports import module_available
 from matplotlib.figure import Figure
 
 from .base import ImageLoggerBase
 
-if package_available("wandb"):
+if module_available("wandb"):
     import wandb
 
 if TYPE_CHECKING:
diff --git a/src/anomalib/metrics/pimo/dataclasses.py b/src/anomalib/metrics/pimo/dataclasses.py
index 0c5aeb025d..3eaa04cd12 100644
--- a/src/anomalib/metrics/pimo/dataclasses.py
+++ b/src/anomalib/metrics/pimo/dataclasses.py
@@ -120,7 +120,7 @@ class AUPIMOResult:
     # metadata
     fpr_lower_bound: float
     fpr_upper_bound: float
-    num_thresholds: int
+    num_thresholds: int | None
 
     # data
     thresh_lower_bound: float = field(repr=False)
@@ -169,7 +169,8 @@ def __post_init__(self) -> None:
         try:
             _validate.is_rate_range((self.fpr_lower_bound, self.fpr_upper_bound))
             # TODO(jpcbertoldo): warn when it's too low (use parameters from the numpy code)  # noqa: TD003
-            _validate.is_num_thresholds_gte2(self.num_thresholds)
+            if self.num_thresholds is not None:
+                _validate.is_num_thresholds_gte2(self.num_thresholds)
             _validate.is_rates(self.aupimos, nan_allowed=True)  # validate is_aupimos
 
             _validate.validate_threshold_bounds((self.thresh_lower_bound, self.thresh_upper_bound))
@@ -194,7 +195,6 @@ def from_pimo_result(
             num_thresholds_auc: number of thresholds used to effectively compute AUPIMO;
                          NOT the number of thresholds used to compute the PIMO curve!
             aupimos: AUPIMO scores
-            paths: paths to the source images to which the AUPIMO scores correspond.
         """
         if pimo_result.per_image_tprs.shape[0] != aupimos.shape[0]:
             msg = (
diff --git a/src/anomalib/models/__init__.py b/src/anomalib/models/__init__.py
index b4bb36a875..3b32c83367 100644
--- a/src/anomalib/models/__init__.py
+++ b/src/anomalib/models/__init__.py
@@ -30,6 +30,7 @@
     Rkde,
     Stfpm,
     Uflow,
+    VlmAd,
     WinClip,
 )
 from .video import AiVad
@@ -57,8 +58,9 @@ class UnknownModelError(ModuleNotFoundError):
     "Rkde",
     "Stfpm",
     "Uflow",
-    "AiVad",
+    "VlmAd",
     "WinClip",
+    "AiVad",
 ]
 
 logger = logging.getLogger(__name__)
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py
index ff12db0cec..336877f17a 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomaly_module.py
@@ -213,7 +213,7 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
             ]),
         )
 
-    def default_post_processor(self) -> PostProcessor:
+    def default_post_processor(self) -> PostProcessor | None:
         """Default post processor.
 
         Override in subclass for model-specific post-processing behaviour.
diff --git a/src/anomalib/models/components/base/export_mixin.py b/src/anomalib/models/components/base/export_mixin.py
index a0f84d1510..0e455332bd 100644
--- a/src/anomalib/models/components/base/export_mixin.py
+++ b/src/anomalib/models/components/base/export_mixin.py
@@ -11,7 +11,7 @@
 
 import torch
 from lightning.pytorch import LightningModule
-from lightning_utilities.core.imports import package_available
+from lightning_utilities.core.imports import module_available
 from torch import nn
 from torchmetrics import Metric
 
@@ -234,7 +234,7 @@ def to_openvino(
             ...     task="segmentation",
             ... )
         """
-        if not package_available("openvino"):
+        if not module_available("openvino"):
             logger.exception("Could not find OpenVINO. Please check OpenVINO installation.")
             raise ModuleNotFoundError
 
@@ -282,7 +282,7 @@ def _compress_ov_model(
         Returns:
             model (CompiledModel): Model in the OpenVINO format compressed with NNCF quantization.
         """
-        if not package_available("nncf"):
+        if not module_available("nncf"):
             logger.exception("Could not find NCCF. Please check NNCF installation.")
             raise ModuleNotFoundError
 
diff --git a/src/anomalib/models/image/__init__.py b/src/anomalib/models/image/__init__.py
index f3a5435038..b09da8b07b 100644
--- a/src/anomalib/models/image/__init__.py
+++ b/src/anomalib/models/image/__init__.py
@@ -20,6 +20,7 @@
 from .rkde import Rkde
 from .stfpm import Stfpm
 from .uflow import Uflow
+from .vlm_ad import VlmAd
 from .winclip import WinClip
 
 __all__ = [
@@ -40,5 +41,6 @@
     "Rkde",
     "Stfpm",
     "Uflow",
+    "VlmAd",
     "WinClip",
 ]
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index a4ed2df231..a5a6071868 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -208,4 +208,8 @@ def learning_type(self) -> LearningType:
     def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
         """Default transform for DSR. Normalization is not needed as the images are scaled to [0, 1] in Dataset."""
         image_size = image_size or (256, 256)
-        return Compose([Resize(image_size, antialias=True)])
+        return Compose(
+            [
+                Resize(image_size, antialias=True),
+            ],
+        )
diff --git a/src/anomalib/models/image/vlm_ad/__init__.py b/src/anomalib/models/image/vlm_ad/__init__.py
new file mode 100644
index 0000000000..46ab8e0fee
--- /dev/null
+++ b/src/anomalib/models/image/vlm_ad/__init__.py
@@ -0,0 +1,8 @@
+"""Visual Anomaly Model."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .lightning_model import VlmAd
+
+__all__ = ["VlmAd"]
diff --git a/src/anomalib/models/image/vlm_ad/backends/__init__.py b/src/anomalib/models/image/vlm_ad/backends/__init__.py
new file mode 100644
index 0000000000..44009f8f83
--- /dev/null
+++ b/src/anomalib/models/image/vlm_ad/backends/__init__.py
@@ -0,0 +1,11 @@
+"""VLM backends."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from .base import Backend
+from .chat_gpt import ChatGPT
+from .huggingface import Huggingface
+from .ollama import Ollama
+
+__all__ = ["Backend", "ChatGPT", "Huggingface", "Ollama"]
diff --git a/src/anomalib/models/image/vlm_ad/backends/base.py b/src/anomalib/models/image/vlm_ad/backends/base.py
new file mode 100644
index 0000000000..b4aadf9a22
--- /dev/null
+++ b/src/anomalib/models/image/vlm_ad/backends/base.py
@@ -0,0 +1,30 @@
+"""Base backend."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from anomalib.models.image.vlm_ad.utils import Prompt
+
+
+class Backend(ABC):
+    """Base backend."""
+
+    @abstractmethod
+    def __init__(self, model_name: str) -> None:
+        """Initialize the backend."""
+
+    @abstractmethod
+    def add_reference_images(self, image: str | Path) -> None:
+        """Add reference images for k-shot."""
+
+    @abstractmethod
+    def predict(self, image: str | Path, prompt: Prompt) -> str:
+        """Predict the anomaly label."""
+
+    @property
+    @abstractmethod
+    def num_reference_images(self) -> int:
+        """Get the number of reference images."""
diff --git a/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py b/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py
new file mode 100644
index 0000000000..53648e688a
--- /dev/null
+++ b/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py
@@ -0,0 +1,109 @@
+"""ChatGPT backend."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import base64
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from dotenv import load_dotenv
+from lightning_utilities.core.imports import module_available
+
+from anomalib.models.image.vlm_ad.utils import Prompt
+
+from .base import Backend
+
+if module_available("openai"):
+    from openai import OpenAI
+else:
+    OpenAI = None
+
+if TYPE_CHECKING:
+    from openai.types.chat import ChatCompletion
+
+logger = logging.getLogger(__name__)
+
+
+class ChatGPT(Backend):
+    """ChatGPT backend."""
+
+    def __init__(self, model_name: str, api_key: str | None = None) -> None:
+        """Initialize the ChatGPT backend."""
+        self._ref_images_encoded: list[str] = []
+        self.model_name: str = model_name
+        self._client: OpenAI | None = None
+        self.api_key = self._get_api_key(api_key)
+
+    @property
+    def client(self) -> OpenAI:
+        """Get the OpenAI client."""
+        if OpenAI is None:
+            msg = "OpenAI is not installed. Please install it to use ChatGPT backend."
+            raise ImportError(msg)
+        if self._client is None:
+            self._client = OpenAI(api_key=self.api_key)
+        return self._client
+
+    def add_reference_images(self, image: str | Path) -> None:
+        """Add reference images for k-shot."""
+        self._ref_images_encoded.append(self._encode_image_to_url(image))
+
+    @property
+    def num_reference_images(self) -> int:
+        """Get the number of reference images."""
+        return len(self._ref_images_encoded)
+
+    def predict(self, image: str | Path, prompt: Prompt) -> str:
+        """Predict the anomaly label."""
+        image_encoded = self._encode_image_to_url(image)
+        messages = []
+
+        # few-shot
+        if len(self._ref_images_encoded) > 0:
+            messages.append(self._generate_message(content=prompt.few_shot, images=self._ref_images_encoded))
+
+        messages.append(self._generate_message(content=prompt.predict, images=[image_encoded]))
+
+        response: ChatCompletion = self.client.chat.completions.create(messages=messages, model=self.model_name)
+        return response.choices[0].message.content
+
+    @staticmethod
+    def _generate_message(content: str, images: list[str] | None) -> dict:
+        """Generate a message."""
+        message: dict[str, list[dict] | str] = {"role": "user"}
+        if images is not None:
+            _content: list[dict[str, str | dict]] = [{"type": "text", "text": content}]
+            _content.extend([{"type": "image_url", "image_url": {"url": image}} for image in images])
+            message["content"] = _content
+        else:
+            message["content"] = content
+        return message
+
+    def _encode_image_to_url(self, image: str | Path) -> str:
+        """Encode the image to base64 and embed in url string."""
+        image_path = Path(image)
+        extension = image_path.suffix
+        base64_encoded = self._encode_image_to_base_64(image_path)
+        return f"data:image/{extension};base64,{base64_encoded}"
+
+    @staticmethod
+    def _encode_image_to_base_64(image: str | Path) -> str:
+        """Encode the image to base64."""
+        image = Path(image)
+        return base64.b64encode(image.read_bytes()).decode("utf-8")
+
+    def _get_api_key(self, api_key: str | None = None) -> str:
+        if api_key is None:
+            load_dotenv()
+            api_key = os.getenv("OPENAI_API_KEY")
+        if api_key is None:
+            msg = (
+                f"OpenAI API key must be provided to use {self.model_name}."
+                " Please provide the API key in the constructor, or set the OPENAI_API_KEY environment variable"
+                " or in a `.env` file."
+            )
+            raise ValueError(msg)
+        return api_key
diff --git a/src/anomalib/models/image/vlm_ad/backends/huggingface.py b/src/anomalib/models/image/vlm_ad/backends/huggingface.py
new file mode 100644
index 0000000000..e8d3c1e84b
--- /dev/null
+++ b/src/anomalib/models/image/vlm_ad/backends/huggingface.py
@@ -0,0 +1,98 @@
+"""Huggingface backend."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from lightning_utilities.core.imports import module_available
+from PIL import Image
+
+from anomalib.models.image.vlm_ad.utils import Prompt
+
+from .base import Backend
+
+if TYPE_CHECKING:
+    from transformers.modeling_utils import PreTrainedModel
+    from transformers.processing_utils import ProcessorMixin
+
+if module_available("transformers"):
+    import transformers
+else:
+    transformers = None
+
+
+logger = logging.getLogger(__name__)
+
+
+class Huggingface(Backend):
+    """Huggingface backend."""
+
+    def __init__(
+        self,
+        model_name: str,
+    ) -> None:
+        """Initialize the Huggingface backend."""
+        self.model_name: str = model_name
+        self._ref_images: list[str] = []
+        self._processor: ProcessorMixin | None = None
+        self._model: PreTrainedModel | None = None
+
+    @property
+    def processor(self) -> "ProcessorMixin":
+        """Get the Huggingface processor."""
+        if self._processor is None:
+            if transformers is None:
+                msg = "transformers is not installed."
+                raise ValueError(msg)
+            self._processor = transformers.LlavaNextProcessor.from_pretrained(self.model_name)
+        return self._processor
+
+    @property
+    def model(self) -> "PreTrainedModel":
+        """Get the Huggingface model."""
+        if self._model is None:
+            if transformers is None:
+                msg = "transformers is not installed."
+                raise ValueError(msg)
+            self._model = transformers.LlavaNextForConditionalGeneration.from_pretrained(self.model_name)
+        return self._model
+
+    @staticmethod
+    def _generate_message(content: str, images: list[str] | None) -> dict:
+        """Generate a message."""
+        message: dict[str, str | list[dict]] = {"role": "user"}
+        _content: list[dict[str, str]] = [{"type": "text", "text": content}]
+        if images is not None:
+            _content.extend([{"type": "image"} for _ in images])
+        message["content"] = _content
+        return message
+
+    def add_reference_images(self, image: str | Path) -> None:
+        """Add reference images for k-shot."""
+        self._ref_images.append(Image.open(image))
+
+    @property
+    def num_reference_images(self) -> int:
+        """Get the number of reference images."""
+        return len(self._ref_images)
+
+    def predict(self, image_path: str | Path, prompt: Prompt) -> str:
+        """Predict the anomaly label."""
+        image = Image.open(image_path)
+        messages: list[dict] = []
+
+        if len(self._ref_images) > 0:
+            messages.append(self._generate_message(content=prompt.few_shot, images=self._ref_images))
+
+        messages.append(self._generate_message(content=prompt.predict, images=[image]))
+        processed_prompt = [self.processor.apply_chat_template(messages, add_generation_prompt=True)]
+
+        images = [*self._ref_images, image]
+        inputs = self.processor(images, processed_prompt, return_tensors="pt", padding=True).to(self.model.device)
+        outputs = self.model.generate(**inputs, max_new_tokens=100)
+        result = self.processor.decode(outputs[0], skip_special_tokens=True)
+        print(result)
+        return result
diff --git a/src/anomalib/models/image/vlm_ad/backends/ollama.py b/src/anomalib/models/image/vlm_ad/backends/ollama.py
new file mode 100644
index 0000000000..ff680bee3b
--- /dev/null
+++ b/src/anomalib/models/image/vlm_ad/backends/ollama.py
@@ -0,0 +1,73 @@
+"""Ollama backend.
+
+Assumes that the Ollama service is running in the background.
+See: https://github.com/ollama/ollama
+Ensure that ollama is running. On linux: `ollama serve`
+On Mac and Windows ensure that the ollama service is running by launching from the application list.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from pathlib import Path
+
+from lightning_utilities.core.imports import module_available
+
+from anomalib.models.image.vlm_ad.utils import Prompt
+
+from .base import Backend
+
+if module_available("ollama"):
+    from ollama import chat
+    from ollama._client import _encode_image
+else:
+    chat = None
+
+logger = logging.getLogger(__name__)
+
+
+class Ollama(Backend):
+    """Ollama backend."""
+
+    def __init__(self, model_name: str) -> None:
+        """Initialize the Ollama backend."""
+        self.model_name: str = model_name
+        self._ref_images_encoded: list[str] = []
+
+    def add_reference_images(self, image: str | Path) -> None:
+        """Encode the image to base64."""
+        self._ref_images_encoded.append(_encode_image(image))
+
+    @property
+    def num_reference_images(self) -> int:
+        """Get the number of reference images."""
+        return len(self._ref_images_encoded)
+
+    @staticmethod
+    def _generate_message(content: str, images: list[str] | None) -> dict:
+        """Generate a message."""
+        message: dict[str, str | list[str]] = {"role": "user", "content": content}
+        if images:
+            message["images"] = images
+        return message
+
+    def predict(self, image: str | Path, prompt: Prompt) -> str:
+        """Predict the anomaly label."""
+        if not chat:
+            msg = "Ollama is not installed. Please install it using `pip install ollama`."
+            raise ImportError(msg)
+        image_encoded = _encode_image(image)
+        messages = []
+
+        # few-shot
+        if len(self._ref_images_encoded) > 0:
+            messages.append(self._generate_message(content=prompt.few_shot, images=self._ref_images_encoded))
+
+        messages.append(self._generate_message(content=prompt.predict, images=[image_encoded]))
+
+        response = chat(
+            model=self.model_name,
+            messages=messages,
+        )
+        return response["message"]["content"].strip()
diff --git a/src/anomalib/models/image/vlm_ad/lightning_model.py b/src/anomalib/models/image/vlm_ad/lightning_model.py
new file mode 100644
index 0000000000..0c072f1330
--- /dev/null
+++ b/src/anomalib/models/image/vlm_ad/lightning_model.py
@@ -0,0 +1,132 @@
+"""Visual Anomaly Model for Zero/Few-Shot Anomaly Classification."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+import torch
+from torch.utils.data import DataLoader
+
+from anomalib import LearningType
+from anomalib.data import ImageBatch
+from anomalib.metrics import Evaluator, F1Score
+from anomalib.models import AnomalyModule
+from anomalib.post_processing import PostProcessor
+
+from .backends import Backend, ChatGPT, Huggingface, Ollama
+from .utils import ModelName, Prompt
+
+logger = logging.getLogger(__name__)
+
+
+class VlmAd(AnomalyModule):
+    """Visual anomaly model."""
+
+    def __init__(
+        self,
+        model: ModelName | str = ModelName.LLAMA_OLLAMA,
+        api_key: str | None = None,
+        k_shot: int = 0,
+    ) -> None:
+        super().__init__()
+        self.k_shot = k_shot
+        model = ModelName(model)
+        self.vlm_backend: Backend = self._setup_vlm_backend(model, api_key)
+
+    @staticmethod
+    def _setup_vlm_backend(model_name: ModelName, api_key: str | None) -> Backend:
+        if model_name == ModelName.LLAMA_OLLAMA:
+            return Ollama(model_name=model_name.value)
+        if model_name == ModelName.GPT_4O_MINI:
+            return ChatGPT(api_key=api_key, model_name=model_name.value)
+        if model_name in {ModelName.VICUNA_7B_HF, ModelName.VICUNA_13B_HF, ModelName.MISTRAL_7B_HF}:
+            return Huggingface(model_name=model_name.value)
+
+        msg = f"Unsupported VLM model: {model_name}"
+        raise ValueError(msg)
+
+    def _setup(self) -> None:
+        if self.k_shot > 0 and self.vlm_backend.num_reference_images != self.k_shot:
+            logger.info("Collecting reference images from training dataset.")
+            dataloader = self.trainer.datamodule.train_dataloader()
+            self.collect_reference_images(dataloader)
+
+    def collect_reference_images(self, dataloader: DataLoader) -> None:
+        """Collect reference images for few-shot inference."""
+        for batch in dataloader:
+            for img_path in batch.image_path:
+                self.vlm_backend.add_reference_images(img_path)
+                if self.vlm_backend.num_reference_images == self.k_shot:
+                    return
+
+    @property
+    def prompt(self) -> Prompt:
+        """Get the prompt."""
+        return Prompt(
+            predict=(
+                "You are given an image. It is either normal or anomalous."
+                " First say 'YES' if the image is anomalous, or 'NO' if it is normal.\n"
+                "Then give the reason for your decision.\n"
+                "For example, 'YES: The image has a crack on the wall.'"
+            ),
+            few_shot=(
+                "These are a few examples of normal picture without any anomalies."
+                " You have to use these to determine if the image I provide in the next"
+                " chat is normal or anomalous."
+            ),
+        )
+
+    def validation_step(self, batch: ImageBatch, *args, **kwargs) -> ImageBatch:
+        """Validation step."""
+        del args, kwargs  # These variables are not used.
+        assert batch.image_path is not None
+        responses = [(self.vlm_backend.predict(img_path, self.prompt)) for img_path in batch.image_path]
+        batch.explanation = responses
+        batch.pred_label = torch.tensor([1.0 if r.startswith("Y") else 0.0 for r in responses], device=self.device)
+        return batch
+
+    @property
+    def learning_type(self) -> LearningType:
+        """The learning type of the model."""
+        return LearningType.ZERO_SHOT if self.k_shot == 0 else LearningType.FEW_SHOT
+
+    @property
+    def trainer_arguments(self) -> dict[str, int | float]:
+        """Doesn't need training."""
+        return {}
+
+    @staticmethod
+    def configure_transforms(image_size: tuple[int, int] | None = None) -> None:
+        """This modes does not require any transforms."""
+        if image_size is not None:
+            logger.warning("Ignoring image_size argument as each backend has its own transforms.")
+
+    def default_post_processor(self) -> PostProcessor | None:  # noqa: PLR6301
+        """Post processing is not required for this model."""
+        return None
+
+    @staticmethod
+    def configure_evaluator() -> Evaluator:
+        """Default evaluator.
+
+        Override in subclass for model-specific evaluator behaviour.
+        """
+        image_f1score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
+        return Evaluator(test_metrics=image_f1score)
+
+    @staticmethod
+    def _export_not_supported_message() -> None:
+        logging.warning("Exporting the model is not supported for VLM-AD model. Skipping...")
+
+    def to_torch(self, *_, **__) -> None:  # type: ignore[override]
+        """Skip export to torch."""
+        return self._export_not_supported_message()
+
+    def to_onnx(self, *_, **__) -> None:  # type: ignore[override]
+        """Skip export to onnx."""
+        return self._export_not_supported_message()
+
+    def to_openvino(self, *_, **__) -> None:  # type: ignore[override]
+        """Skip export to openvino."""
+        return self._export_not_supported_message()
diff --git a/src/anomalib/models/image/vlm_ad/utils.py b/src/anomalib/models/image/vlm_ad/utils.py
new file mode 100644
index 0000000000..ce9b9067ac
--- /dev/null
+++ b/src/anomalib/models/image/vlm_ad/utils.py
@@ -0,0 +1,25 @@
+"""Dataclasses."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+@dataclass
+class Prompt:
+    """Prompt."""
+
+    few_shot: str
+    predict: str
+
+
+class ModelName(Enum):
+    """List of supported models."""
+
+    LLAMA_OLLAMA = "llava"
+    GPT_4O_MINI = "gpt-4o-mini"
+    VICUNA_7B_HF = "llava-hf/llava-v1.6-vicuna-7b-hf"
+    VICUNA_13B_HF = "llava-hf/llava-v1.6-vicuna-13b-hf"
+    MISTRAL_7B_HF = "llava-hf/llava-v1.6-mistral-7b-hf"
diff --git a/src/anomalib/pipelines/benchmark/generator.py b/src/anomalib/pipelines/benchmark/generator.py
index 922dfa06cb..988e0111b7 100644
--- a/src/anomalib/pipelines/benchmark/generator.py
+++ b/src/anomalib/pipelines/benchmark/generator.py
@@ -10,6 +10,7 @@
 from anomalib.pipelines.components import JobGenerator
 from anomalib.pipelines.components.utils import get_iterator_from_grid_dict
 from anomalib.pipelines.types import PREV_STAGE_RESULT
+from anomalib.utils.config import flatten_dict
 from anomalib.utils.logging import hide_output
 
 from .job import BenchmarkJob
@@ -39,9 +40,12 @@ def generate_jobs(
         """Return iterator based on the arguments."""
         del previous_stage_result  # Not needed for this job
         for _container in get_iterator_from_grid_dict(args):
+            # Pass experimental configs as a flatten dictionary to the job runner.
+            flat_cfg = flatten_dict(_container)
             yield BenchmarkJob(
                 accelerator=self.accelerator,
                 seed=_container["seed"],
                 model=get_model(_container["model"]),
                 datamodule=get_datamodule(_container["data"]),
+                flat_cfg=flat_cfg,
             )
diff --git a/src/anomalib/pipelines/benchmark/job.py b/src/anomalib/pipelines/benchmark/job.py
index ab443cfa8a..f56899ac5d 100644
--- a/src/anomalib/pipelines/benchmark/job.py
+++ b/src/anomalib/pipelines/benchmark/job.py
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+import time
 from datetime import datetime
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -31,16 +32,25 @@ class BenchmarkJob(Job):
         model (AnomalyModule): The model to use.
         datamodule (AnomalibDataModule): The data module to use.
         seed (int): The seed to use.
+        flat_cfg (dict): The flat dictionary of configs with dotted keys.
     """
 
     name = "benchmark"
 
-    def __init__(self, accelerator: str, model: AnomalyModule, datamodule: AnomalibDataModule, seed: int) -> None:
+    def __init__(
+        self,
+        accelerator: str,
+        model: AnomalyModule,
+        datamodule: AnomalibDataModule,
+        seed: int,
+        flat_cfg: dict,
+    ) -> None:
         super().__init__()
         self.accelerator = accelerator
         self.model = model
         self.datamodule = datamodule
         self.seed = seed
+        self.flat_cfg = flat_cfg
 
     @hide_output
     def run(
@@ -48,6 +58,7 @@ def run(
         task_id: int | None = None,
     ) -> dict[str, Any]:
         """Run the benchmark."""
+        job_start_time = time.time()
         devices: str | list[int] = "auto"
         if task_id is not None:
             devices = [task_id]
@@ -59,16 +70,22 @@ def run(
                 devices=devices,
                 default_root_dir=temp_dir,
             )
+            fit_start_time = time.time()
             engine.fit(self.model, self.datamodule)
+            test_start_time = time.time()
             test_results = engine.test(self.model, self.datamodule)
+        job_end_time = time.time()
+        durations = {
+            "job_duration": job_end_time - job_start_time,
+            "fit_duration": test_start_time - fit_start_time,
+            "test_duration": job_end_time - test_start_time,
+        }
         # TODO(ashwinvaidya17): Restore throughput
         # https://github.com/openvinotoolkit/anomalib/issues/2054
         output = {
-            "seed": self.seed,
             "accelerator": self.accelerator,
-            "model": self.model.__class__.__name__,
-            "data": self.datamodule.__class__.__name__,
-            "category": self.datamodule.category,
+            **durations,
+            **self.flat_cfg,
             **test_results[0],
         }
         logger.info(f"Completed with result {output}")
diff --git a/src/anomalib/pipelines/benchmark/pipeline.py b/src/anomalib/pipelines/benchmark/pipeline.py
index 730b3ecccc..3b27caeec1 100644
--- a/src/anomalib/pipelines/benchmark/pipeline.py
+++ b/src/anomalib/pipelines/benchmark/pipeline.py
@@ -20,11 +20,12 @@ def _setup_runners(args: dict) -> list[Runner]:
         accelerators = args["accelerator"] if isinstance(args["accelerator"], list) else [args["accelerator"]]
         runners: list[Runner] = []
         for accelerator in accelerators:
-            if accelerator == "cpu":
-                runners.append(SerialRunner(BenchmarkJobGenerator("cpu")))
-            elif accelerator == "cuda":
-                runners.append(ParallelRunner(BenchmarkJobGenerator("cuda"), n_jobs=torch.cuda.device_count()))
-            else:
+            if accelerator not in {"cpu", "cuda"}:
                 msg = f"Unsupported accelerator: {accelerator}"
                 raise ValueError(msg)
+            device_count = torch.cuda.device_count()
+            if device_count <= 1 or accelerator == "cpu":
+                runners.append(SerialRunner(BenchmarkJobGenerator(accelerator)))
+            else:
+                runners.append(ParallelRunner(BenchmarkJobGenerator(accelerator), n_jobs=device_count))
         return runners
diff --git a/src/anomalib/utils/exceptions/imports.py b/src/anomalib/utils/exceptions/imports.py
index dac22ba056..6ef8dbd89d 100644
--- a/src/anomalib/utils/exceptions/imports.py
+++ b/src/anomalib/utils/exceptions/imports.py
@@ -22,7 +22,7 @@ def try_import(import_path: str) -> bool:
 
     warnings.warn(
         "The 'try_import' function is deprecated and will be removed in v2.0.0. "
-        "Use 'package_available' from lightning-utilities instead.",
+        "Use 'module_available' from lightning-utilities instead.",
         DeprecationWarning,
         stacklevel=2,
     )
diff --git a/src/anomalib/utils/logging.py b/src/anomalib/utils/logging.py
index 21f7994fbf..d73ef440c4 100644
--- a/src/anomalib/utils/logging.py
+++ b/src/anomalib/utils/logging.py
@@ -74,10 +74,8 @@ def redirect_logs(log_file: str) -> None:
     """
     Path(log_file).parent.mkdir(exist_ok=True, parents=True)
     logger_file_handler = logging.FileHandler(log_file)
-    root_logger = logging.getLogger()
-    root_logger.setLevel(logging.DEBUG)
     format_string = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    logging.basicConfig(format=format_string, level=logging.DEBUG, handlers=[logger_file_handler])
+    logging.basicConfig(format=format_string, handlers=[logger_file_handler])
     logging.captureWarnings(capture=True)
     # remove other handlers from all loggers
     loggers = [logging.getLogger(name) for name in logging.root.manager.loggerDict]
diff --git a/src/anomalib/utils/visualization/__init__.py b/src/anomalib/utils/visualization/__init__.py
index f68036ed78..404036dfad 100644
--- a/src/anomalib/utils/visualization/__init__.py
+++ b/src/anomalib/utils/visualization/__init__.py
@@ -4,11 +4,13 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from .base import BaseVisualizer, GeneratorResult, VisualizationStep
+from .explanation import ExplanationVisualizer
 from .image import ImageResult, ImageVisualizer
 from .metrics import MetricsVisualizer
 
 __all__ = [
     "BaseVisualizer",
+    "ExplanationVisualizer",
     "ImageResult",
     "ImageVisualizer",
     "GeneratorResult",
diff --git a/src/anomalib/utils/visualization/explanation.py b/src/anomalib/utils/visualization/explanation.py
new file mode 100644
index 0000000000..10904161e3
--- /dev/null
+++ b/src/anomalib/utils/visualization/explanation.py
@@ -0,0 +1,106 @@
+"""Explanation visualization generator.
+
+Note: This is a temporary visualizer, and will be replaced with the new visualizer in the future.
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Iterator
+from pathlib import Path
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+from .base import BaseVisualizer, GeneratorResult, VisualizationStep
+
+
+class ExplanationVisualizer(BaseVisualizer):
+    """Explanation visualization generator."""
+
+    def __init__(self) -> None:
+        super().__init__(visualize_on=VisualizationStep.BATCH)
+        self.padding = 3
+        self.font = ImageFont.load_default(size=16)
+
+    def generate(self, **kwargs) -> Iterator[GeneratorResult]:
+        """Generate images and return them as an iterator."""
+        outputs = kwargs.get("outputs", None)
+        if outputs is None:
+            msg = "Outputs must be provided to generate images."
+            raise ValueError(msg)
+        return self._visualize_batch(outputs)
+
+    def _visualize_batch(self, batch: dict) -> Iterator[GeneratorResult]:
+        """Visualize batch of images."""
+        batch_size = batch["image"].shape[0]
+        height, width = batch["image"].shape[-2:]
+        for i in range(batch_size):
+            image = batch["image"][i]
+            explanation = batch["explanation"][i]
+            file_name = Path(batch["image_path"][i])
+            image = Image.open(file_name)
+            image = image.resize((width, height))
+            image = self._draw_image(width, height, image=image, explanation=explanation)
+            yield GeneratorResult(image=image, file_name=file_name)
+
+    def _draw_image(self, width: int, height: int, image: Image, explanation: str) -> np.ndarray:
+        text_canvas: Image = self._get_explanation_image(width, height, image, explanation)
+        label_canvas: Image = self._get_label_image(explanation)
+
+        final_width = max(text_canvas.size[0], width)
+        final_height = height + text_canvas.size[1]
+        combined_image = Image.new("RGB", (final_width, final_height), (255, 255, 255))
+        combined_image.paste(image, (self.padding, 0))
+        combined_image.paste(label_canvas, (10, 10))
+        combined_image.paste(text_canvas, (0, height))
+        return np.array(combined_image)
+
+    def _get_label_image(self, explanation: str) -> Image:
+        # Draw label
+        # Can't use  pred_labels as it is computed from the pred_scores using image_threshold. It gives incorrect value.
+        # So, using explanation. This will probably change with the new design.
+        label = "Anomalous" if explanation.startswith("Y") else "Normal"
+        label_color = "red" if label == "Anomalous" else "green"
+        label_canvas = Image.new("RGB", (100, 20), color=label_color)
+        draw = ImageDraw.Draw(label_canvas)
+        draw.text((0, 0), label, font=self.font, fill="white", align="center")
+        return label_canvas
+
+    def _get_explanation_image(self, width: int, height: int, image: Image, explanation: str) -> Image:
+        # compute wrap width
+        text_canvas = Image.new("RGB", (width, height), color="white")
+        dummy_image = ImageDraw.Draw(image)
+        text_bbox = dummy_image.textbbox((0, 0), explanation, font=self.font, align="center")
+        text_canvas_width = text_bbox[2] - text_bbox[0] + self.padding
+
+        # split lines based on the width
+        lines = list(explanation.split("\n"))
+        line_with_max_len = max(lines, key=len)
+        new_width = int(width * len(line_with_max_len) // text_canvas_width)
+
+        # wrap text based on the new width
+        lines = []
+        current_line: list[str] = []
+        for word in explanation.split(" "):
+            test_line = " ".join([*current_line, word])
+            if len(test_line) <= new_width:
+                current_line.append(word)
+            else:
+                lines.append(" ".join(current_line))
+                current_line = [word]
+        lines.append(" ".join(current_line))
+        wrapped_lines = "\n".join(lines)
+
+        # recompute height
+        dummy_image = Image.new("RGB", (new_width, height), color="white")
+        draw = ImageDraw.Draw(dummy_image)
+        text_bbox = draw.textbbox((0, 0), wrapped_lines, font=self.font, align="center")
+        new_width = int(text_bbox[2] - text_bbox[0] + self.padding)
+        new_height = int(text_bbox[3] - text_bbox[1] + self.padding)
+
+        # Final text image
+        text_canvas = Image.new("RGB", (new_width, new_height), color="white")
+        draw = ImageDraw.Draw(text_canvas)
+        draw.text((self.padding // 2, 0), wrapped_lines, font=self.font, fill="black", align="center")
+        return text_canvas
diff --git a/tests/helpers/data.py b/tests/helpers/data.py
index 0ad699fb2f..60433df9eb 100644
--- a/tests/helpers/data.py
+++ b/tests/helpers/data.py
@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import json
 import shutil
 from contextlib import ContextDecorator
 from pathlib import Path
@@ -319,6 +320,43 @@ def __init__(
         self.min_size = min_size
         self.image_generator = DummyImageGenerator(image_shape=image_shape, rng=self.rng)
 
+    def _generate_dummy_datumaro_dataset(self) -> None:
+        """Generates dummy Datumaro dataset in a temporary directory."""
+        # generate images
+        image_root = self.dataset_root / "images" / "default"
+        image_root.mkdir(parents=True, exist_ok=True)
+
+        file_names: list[str] = []
+
+        # Create normal images
+        for i in range(self.num_train + self.num_test):
+            label = LabelName.NORMAL
+            image_filename = image_root / f"normal_{i:03}.png"
+            file_names.append(image_filename)
+            self.image_generator.generate_image(label, image_filename)
+
+        # Create abnormal images
+        for i in range(self.num_test):
+            label = LabelName.ABNORMAL
+            image_filename = image_root / f"abnormal_{i:03}.png"
+            file_names.append(image_filename)
+            self.image_generator.generate_image(label, image_filename)
+
+        # create annotation file
+        annotation_file = self.dataset_root / "annotations" / "default.json"
+        annotation_file.parent.mkdir(parents=True, exist_ok=True)
+        annotations = {
+            "categories": {"label": {"labels": [{"name": "Normal"}, {"name": "Anomalous"}]}},
+            "items": [],
+        }
+        for file_name in file_names:
+            annotations["items"].append({
+                "annotations": [{"label_id": 1 if "abnormal" in str(file_name) else 0}],
+                "image": {"path": file_name.name},
+            })
+        with annotation_file.open("w") as f:
+            json.dump(annotations, f)
+
     def _generate_dummy_mvtec_dataset(
         self,
         normal_dir: str = "good",
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index 2ffd2188f4..9c9c203d45 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -7,6 +7,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from pathlib import Path
+from unittest.mock import MagicMock
 
 import pytest
 
@@ -202,6 +203,11 @@ def _get_objects(
             )
 
         model = get_model(model_name, **extra_args)
+
+        if model_name == "vlm_ad":
+            model.vlm_backend = MagicMock()
+            model.vlm_backend.predict.return_value = "YES: Because reasons..."
+
         engine = Engine(
             logger=False,
             default_root_dir=project_path,
diff --git a/tests/unit/data/datamodule/image/test_datumaro.py b/tests/unit/data/datamodule/image/test_datumaro.py
new file mode 100644
index 0000000000..789d4571c0
--- /dev/null
+++ b/tests/unit/data/datamodule/image/test_datumaro.py
@@ -0,0 +1,39 @@
+"""Unit tests - Datumaro Datamodule."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+import pytest
+
+from anomalib import TaskType
+from anomalib.data import Datumaro
+from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
+
+
+class TestDatumaro(_TestAnomalibImageDatamodule):
+    """Datumaro Datamodule Unit Tests."""
+
+    @pytest.fixture()
+    @staticmethod
+    def datamodule(dataset_path: Path, task_type: TaskType) -> Datumaro:
+        """Create and return a Datumaro datamodule."""
+        if task_type != TaskType.CLASSIFICATION:
+            pytest.skip("Datumaro only supports classification tasks.")
+
+        _datamodule = Datumaro(
+            root=dataset_path / "datumaro",
+            task=task_type,
+            train_batch_size=4,
+            eval_batch_size=4,
+        )
+        _datamodule.setup()
+
+        return _datamodule
+
+    @pytest.fixture()
+    @staticmethod
+    def fxt_data_config_path() -> str:
+        """Return the path to the test data config."""
+        return "configs/data/datumaro.yaml"
diff --git a/tests/unit/pipelines/__init__.py b/tests/unit/pipelines/__init__.py
new file mode 100644
index 0000000000..46de40af76
--- /dev/null
+++ b/tests/unit/pipelines/__init__.py
@@ -0,0 +1,4 @@
+"""Pipeline unit tests."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
diff --git a/tools/tiled_ensemble/ens_config.yaml b/tools/tiled_ensemble/ens_config.yaml
new file mode 100644
index 0000000000..2490b22e9a
--- /dev/null
+++ b/tools/tiled_ensemble/ens_config.yaml
@@ -0,0 +1,43 @@
+seed: 42
+accelerator: "gpu"
+default_root_dir: "results"
+
+tiling:
+  tile_size: [128, 128]
+  stride: 128
+
+normalization_stage: image # on what level we normalize, options: [tile, image, none]
+thresholding:
+  method: F1AdaptiveThreshold # refer to documentation for thresholding methods
+  stage: image # stage at which we apply threshold, options: [tile, image]
+
+data:
+  class_path: anomalib.data.MVTec
+  init_args:
+    root: ./datasets/MVTec
+    category: bottle
+    train_batch_size: 32
+    eval_batch_size: 32
+    num_workers: 8
+    task: segmentation
+    transform: null
+    train_transform: null
+    eval_transform: null
+    test_split_mode: from_dir
+    test_split_ratio: 0.2
+    val_split_mode: same_as_test
+    val_split_ratio: 0.5
+    image_size: [256, 256]
+
+SeamSmoothing:
+  apply: True # if this is applied, area around tile seams are is smoothed
+  sigma: 2 # sigma of gaussian filter used to smooth this area
+  width: 0.1 # width factor, multiplied by tile dimension gives the region width around seam which will be smoothed
+
+TrainModels:
+  model:
+    class_path: Padim
+
+  metrics:
+    pixel: AUROC
+    image: AUROC
diff --git a/tools/tiled_ensemble/eval.py b/tools/tiled_ensemble/eval.py
new file mode 100644
index 0000000000..58be27c25c
--- /dev/null
+++ b/tools/tiled_ensemble/eval.py
@@ -0,0 +1,28 @@
+"""Run tiled ensemble prediction."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+from jsonargparse import ArgumentParser
+
+from anomalib.pipelines.tiled_ensemble import EvalTiledEnsemble
+
+
+def get_parser() -> ArgumentParser:
+    """Create a new parser if none is provided."""
+    parser = ArgumentParser()
+    parser.add_argument("--config", type=str | Path, help="Configuration file path.", required=True)
+    parser.add_argument("--root", type=str | Path, help="Weights file path.", required=True)
+
+    return parser
+
+
+if __name__ == "__main__":
+    args = get_parser().parse_args()
+
+    print("Running tiled ensemble test pipeline.")
+    # pass the path to root dir with checkpoints
+    test_pipeline = EvalTiledEnsemble(args.root)
+    test_pipeline.run(args)
diff --git a/tools/tiled_ensemble/train.py b/tools/tiled_ensemble/train.py
new file mode 100644
index 0000000000..8aed47ea0d
--- /dev/null
+++ b/tools/tiled_ensemble/train.py
@@ -0,0 +1,17 @@
+"""Run tiled ensemble training."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from anomalib.pipelines.tiled_ensemble import EvalTiledEnsemble, TrainTiledEnsemble
+
+if __name__ == "__main__":
+    print("Running tiled ensemble train pipeline")
+    train_pipeline = TrainTiledEnsemble()
+    # run training
+    train_pipeline.run()
+
+    print("Running tiled ensemble test pipeline.")
+    # pass the root dir from train run to load checkpoints
+    test_pipeline = EvalTiledEnsemble(train_pipeline.root_dir)
+    test_pipeline.run()

From c16f51ed5b118b753e7b3dd95e6ba45e3b2388a8 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Fri, 22 Nov 2024 10:44:55 +0000
Subject: [PATCH 13/45] Rename `AnomalyModule` to `AnomalibModule` (#2423)

* Rename AnomalyModule to AnomalibModule

Signed-off-by: Samet Akcay 

* Ignore AnomalyModule from the tests

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 
---
 docs/source/markdown/guides/developer/sdd.md  |  2 +-
 src/anomalib/callbacks/model_loader.py        |  4 +-
 src/anomalib/callbacks/tiler_configuration.py |  4 +-
 src/anomalib/callbacks/visualizer.py          | 14 ++---
 src/anomalib/cli/cli.py                       | 10 ++--
 src/anomalib/engine/engine.py                 | 56 +++++++++----------
 src/anomalib/metrics/evaluator.py             |  6 +-
 src/anomalib/models/__init__.py               | 22 +++++---
 src/anomalib/models/components/__init__.py    |  4 +-
 .../models/components/base/__init__.py        |  4 +-
 .../models/components/base/anomaly_module.py  | 37 ++++++++----
 .../models/image/cfa/lightning_model.py       |  4 +-
 .../models/image/cflow/lightning_model.py     |  4 +-
 .../models/image/csflow/lightning_model.py    |  4 +-
 .../models/image/dfkde/lightning_model.py     |  4 +-
 .../models/image/dfm/lightning_model.py       |  4 +-
 .../models/image/draem/lightning_model.py     |  4 +-
 .../models/image/dsr/lightning_model.py       |  4 +-
 .../image/efficient_ad/lightning_model.py     |  4 +-
 .../models/image/fastflow/lightning_model.py  |  4 +-
 .../models/image/fre/lightning_model.py       |  4 +-
 .../models/image/ganomaly/lightning_model.py  |  4 +-
 .../models/image/padim/lightning_model.py     |  4 +-
 .../models/image/patchcore/lightning_model.py |  4 +-
 .../reverse_distillation/lightning_model.py   |  4 +-
 .../models/image/rkde/lightning_model.py      |  4 +-
 .../models/image/stfpm/lightning_model.py     |  4 +-
 .../models/image/uflow/lightning_model.py     |  4 +-
 .../models/image/vlm_ad/lightning_model.py    |  4 +-
 .../models/image/winclip/lightning_model.py   |  4 +-
 .../models/video/ai_vad/lightning_model.py    |  4 +-
 src/anomalib/pipelines/benchmark/job.py       |  6 +-
 src/anomalib/utils/visualization/metrics.py   |  4 +-
 .../visualization/image/visualizer.py         |  6 +-
 tests/integration/model/test_models.py        |  6 +-
 .../components/base/test_anomaly_module.py    | 20 +++----
 .../dummy_lightning_model.py                  |  4 +-
 tools/inference/lightning_inference.py        |  4 +-
 38 files changed, 155 insertions(+), 138 deletions(-)

diff --git a/docs/source/markdown/guides/developer/sdd.md b/docs/source/markdown/guides/developer/sdd.md
index 19bb90b4a3..41088669e7 100644
--- a/docs/source/markdown/guides/developer/sdd.md
+++ b/docs/source/markdown/guides/developer/sdd.md
@@ -201,7 +201,7 @@ and depth data.
 
 Anomalib provides a collection of anomaly models within the image and video
 domains. The models are implemented sub-classing PyTorch Lightning's
-`LightningModule` class, which is called `AnomalyModule`, which provides a set
+`LightningModule` class, which is called `AnomalibModule`, which provides a set
 of APIs for defining the model architecture, loss function, and optimization
 algorithm. The models are designed to be modular and extensible, allowing users
 to easily modify the model architecture and training workflow based on their
diff --git a/src/anomalib/callbacks/model_loader.py b/src/anomalib/callbacks/model_loader.py
index bbdebfce0e..8c688b3127 100644
--- a/src/anomalib/callbacks/model_loader.py
+++ b/src/anomalib/callbacks/model_loader.py
@@ -8,7 +8,7 @@
 import torch
 from lightning.pytorch import Callback, Trainer
 
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 
 logger = logging.getLogger(__name__)
 
@@ -27,7 +27,7 @@ class LoadModelCallback(Callback):
     def __init__(self, weights_path: str) -> None:
         self.weights_path = weights_path
 
-    def setup(self, trainer: Trainer, pl_module: AnomalyModule, stage: str | None = None) -> None:
+    def setup(self, trainer: Trainer, pl_module: AnomalibModule, stage: str | None = None) -> None:
         """Call when inference begins.
 
         Loads the model weights from ``weights_path`` into the PyTorch module.
diff --git a/src/anomalib/callbacks/tiler_configuration.py b/src/anomalib/callbacks/tiler_configuration.py
index a3018bd42b..f44a4d679f 100644
--- a/src/anomalib/callbacks/tiler_configuration.py
+++ b/src/anomalib/callbacks/tiler_configuration.py
@@ -9,7 +9,7 @@
 from lightning.pytorch.callbacks import Callback
 
 from anomalib.data.utils.tiler import ImageUpscaleMode, Tiler
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 
 __all__ = ["TilerConfigurationCallback"]
 
@@ -61,7 +61,7 @@ def setup(self, trainer: pl.Trainer, pl_module: pl.LightningModule, stage: str |
         del trainer, stage  # These variables are not used.
 
         if self.enable:
-            if isinstance(pl_module, AnomalyModule) and hasattr(pl_module.model, "tiler"):
+            if isinstance(pl_module, AnomalibModule) and hasattr(pl_module.model, "tiler"):
                 pl_module.model.tiler = Tiler(
                     tile_size=self.tile_size,
                     stride=self.stride,
diff --git a/src/anomalib/callbacks/visualizer.py b/src/anomalib/callbacks/visualizer.py
index 41d56a7ebd..9b0b78dfa0 100644
--- a/src/anomalib/callbacks/visualizer.py
+++ b/src/anomalib/callbacks/visualizer.py
@@ -16,7 +16,7 @@
 from anomalib.data.utils.image import save_image, show_image
 from anomalib.loggers import AnomalibWandbLogger
 from anomalib.loggers.base import ImageLoggerBase
-from anomalib.models import AnomalyModule
+from anomalib.models import AnomalibModule
 from anomalib.utils.visualization import (
     BaseVisualizer,
     GeneratorResult,
@@ -77,7 +77,7 @@ def __init__(
     def on_test_batch_end(
         self,
         trainer: Trainer,
-        pl_module: AnomalyModule,
+        pl_module: AnomalibModule,
         outputs: STEP_OUTPUT | None,
         batch: Any,  # noqa: ANN401
         batch_idx: int,
@@ -114,7 +114,7 @@ def on_test_batch_end(
                     if self.log:
                         self._add_to_logger(result, pl_module, trainer)
 
-    def on_test_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
+    def on_test_end(self, trainer: Trainer, pl_module: AnomalibModule) -> None:
         for generator in self.generators:
             if generator.visualize_on == VisualizationStep.STAGE_END:
                 for result in generator(trainer=trainer, pl_module=pl_module):
@@ -135,7 +135,7 @@ def on_test_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
     def on_predict_batch_end(
         self,
         trainer: Trainer,
-        pl_module: AnomalyModule,
+        pl_module: AnomalibModule,
         outputs: STEP_OUTPUT | None,
         batch: Any,  # noqa: ANN401
         batch_idx: int,
@@ -143,20 +143,20 @@ def on_predict_batch_end(
     ) -> None:
         return self.on_test_batch_end(trainer, pl_module, outputs, batch, batch_idx, dataloader_idx)
 
-    def on_predict_end(self, trainer: Trainer, pl_module: AnomalyModule) -> None:
+    def on_predict_end(self, trainer: Trainer, pl_module: AnomalibModule) -> None:
         return self.on_test_end(trainer, pl_module)
 
     @staticmethod
     def _add_to_logger(
         result: GeneratorResult,
-        module: AnomalyModule,
+        module: AnomalibModule,
         trainer: Trainer,
     ) -> None:
         """Add image to logger.
 
         Args:
             result (GeneratorResult): Output from the generators.
-            module (AnomalyModule): LightningModule from which the global step is extracted.
+            module (AnomalibModule): LightningModule from which the global step is extracted.
             trainer (Trainer): Trainer object.
         """
         # Store names of logger and the logger in a dict
diff --git a/src/anomalib/cli/cli.py b/src/anomalib/cli/cli.py
index b272fdc81b..87492ac3f3 100644
--- a/src/anomalib/cli/cli.py
+++ b/src/anomalib/cli/cli.py
@@ -30,7 +30,7 @@
 
     from anomalib.data import AnomalibDataModule
     from anomalib.engine import Engine
-    from anomalib.models import AnomalyModule
+    from anomalib.models import AnomalibModule
     from anomalib.utils.config import update_config
 
 except ImportError:
@@ -166,7 +166,7 @@ def add_trainer_arguments(self, parser: ArgumentParser, subcommand: str) -> None
         self._add_default_arguments_to_parser(parser)
         self._add_trainer_arguments_to_parser(parser, add_optimizer=True, add_scheduler=True)
         parser.add_subclass_arguments(
-            AnomalyModule,
+            AnomalibModule,
             "model",
             fail_untyped=False,
             required=True,
@@ -186,7 +186,7 @@ def add_train_arguments(self, parser: ArgumentParser) -> None:
         self._add_default_arguments_to_parser(parser)
         self._add_trainer_arguments_to_parser(parser, add_optimizer=True, add_scheduler=True)
         parser.add_subclass_arguments(
-            AnomalyModule,
+            AnomalibModule,
             "model",
             fail_untyped=False,
             required=True,
@@ -205,7 +205,7 @@ def add_predict_arguments(self, parser: ArgumentParser) -> None:
         self._add_default_arguments_to_parser(parser)
         self._add_trainer_arguments_to_parser(parser)
         parser.add_subclass_arguments(
-            AnomalyModule,
+            AnomalibModule,
             "model",
             fail_untyped=False,
             required=True,
@@ -228,7 +228,7 @@ def add_export_arguments(self, parser: ArgumentParser) -> None:
         self._add_default_arguments_to_parser(parser)
         self._add_trainer_arguments_to_parser(parser)
         parser.add_subclass_arguments(
-            AnomalyModule,
+            AnomalibModule,
             "model",
             fail_untyped=False,
             required=True,
diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index 36bfcc3bf4..017e20bb93 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -20,7 +20,7 @@
 from anomalib.callbacks.timer import TimerCallback
 from anomalib.data import AnomalibDataModule, AnomalibDataset, PredictDataset
 from anomalib.deploy import CompressionType, ExportType
-from anomalib.models import AnomalyModule
+from anomalib.models import AnomalibModule
 from anomalib.utils.path import create_versioned_dir
 from anomalib.visualization import ImageVisualizer
 
@@ -64,11 +64,11 @@ class _TrainerArgumentsCache:
     def __init__(self, **kwargs) -> None:
         self._cached_args = {**kwargs}
 
-    def update(self, model: AnomalyModule) -> None:
+    def update(self, model: AnomalibModule) -> None:
         """Replace cached arguments with arguments retrieved from the model.
 
         Args:
-            model (AnomalyModule): The model used for training
+            model (AnomalibModule): The model used for training
         """
         for key, value in model.trainer_arguments.items():
             if key in self._cached_args and self._cached_args[key] != value:
@@ -77,7 +77,7 @@ def update(self, model: AnomalyModule) -> None:
                 )
             self._cached_args[key] = value
 
-    def requires_update(self, model: AnomalyModule) -> bool:
+    def requires_update(self, model: AnomalibModule) -> bool:
         return any(self._cached_args.get(key, None) != value for key, value in model.trainer_arguments.items())
 
     @property
@@ -152,14 +152,14 @@ def trainer(self) -> Trainer:
         return self._trainer
 
     @property
-    def model(self) -> AnomalyModule:
+    def model(self) -> AnomalibModule:
         """Property to get the model.
 
         Raises:
             UnassignedError: When the model is not assigned yet.
 
         Returns:
-            AnomalyModule: Anomaly model.
+            AnomalibModule: Anomaly model.
         """
         if not self.trainer.lightning_module:
             msg = "Trainer does not have a model assigned yet."
@@ -190,7 +190,7 @@ def best_model_path(self) -> str | None:
 
     def _setup_workspace(
         self,
-        model: AnomalyModule,
+        model: AnomalibModule,
         train_dataloaders: TRAIN_DATALOADERS | None = None,
         val_dataloaders: EVAL_DATALOADERS | None = None,
         test_dataloaders: EVAL_DATALOADERS | None = None,
@@ -205,7 +205,7 @@ def _setup_workspace(
         other artifacts will be saved in this directory.
 
         Args:
-            model (AnomalyModule): Input model.
+            model (AnomalibModule): Input model.
             train_dataloaders (TRAIN_DATALOADERS | None, optional): Train dataloaders.
                 Defaults to ``None``.
             val_dataloaders (EVAL_DATALOADERS | None, optional): Validation dataloaders.
@@ -255,7 +255,7 @@ def _setup_workspace(
         root_dir = Path(self._cache.args["default_root_dir"]) / model.name / dataset_name / category
         self._cache.args["default_root_dir"] = create_versioned_dir(root_dir) if versioned_dir else root_dir / "latest"
 
-    def _setup_trainer(self, model: AnomalyModule) -> None:
+    def _setup_trainer(self, model: AnomalibModule) -> None:
         """Instantiate the trainer based on the model parameters."""
         # Check if the cache requires an update
         if self._cache.requires_update(model):
@@ -291,7 +291,7 @@ def _setup_dataset_task(
                             )
                             data.task = self.task
 
-    def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None:
+    def _setup_anomalib_callbacks(self, model: AnomalibModule) -> None:
         """Set up callbacks for the trainer."""
         _callbacks: list[Callback] = []
 
@@ -325,7 +325,7 @@ def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None:
 
     @staticmethod
     def _should_run_validation(
-        model: AnomalyModule,
+        model: AnomalibModule,
         ckpt_path: str | Path | None,
     ) -> bool:
         """Check if we need to run validation to collect normalization statistics and thresholds.
@@ -341,7 +341,7 @@ def _should_run_validation(
         are available. If neither is available, we can't run validation.
 
         Args:
-            model (AnomalyModule): Model passed to the entrypoint.
+            model (AnomalibModule): Model passed to the entrypoint.
             dataloaders (EVAL_DATALOADERS | None): Dataloaders passed to the entrypoint.
             datamodule (AnomalibDataModule | None): Lightning datamodule passed to the entrypoint.
             ckpt_path (str | Path | None): Checkpoint path passed to the entrypoint.
@@ -357,7 +357,7 @@ def _should_run_validation(
 
     def fit(
         self,
-        model: AnomalyModule,
+        model: AnomalibModule,
         train_dataloaders: TRAIN_DATALOADERS | None = None,
         val_dataloaders: EVAL_DATALOADERS | None = None,
         datamodule: AnomalibDataModule | None = None,
@@ -366,7 +366,7 @@ def fit(
         """Fit the model using the trainer.
 
         Args:
-            model (AnomalyModule): Model to be trained.
+            model (AnomalibModule): Model to be trained.
             train_dataloaders (TRAIN_DATALOADERS | None, optional): Train dataloaders.
                 Defaults to None.
             val_dataloaders (EVAL_DATALOADERS | None, optional): Validation dataloaders.
@@ -411,7 +411,7 @@ def fit(
 
     def validate(
         self,
-        model: AnomalyModule | None = None,
+        model: AnomalibModule | None = None,
         dataloaders: EVAL_DATALOADERS | None = None,
         ckpt_path: str | Path | None = None,
         verbose: bool = True,
@@ -420,7 +420,7 @@ def validate(
         """Validate the model using the trainer.
 
         Args:
-            model (AnomalyModule | None, optional): Model to be validated.
+            model (AnomalibModule | None, optional): Model to be validated.
                 Defaults to None.
             dataloaders (EVAL_DATALOADERS | None, optional): Dataloaders to be used for
                 validation.
@@ -460,7 +460,7 @@ def validate(
 
     def test(
         self,
-        model: AnomalyModule | None = None,
+        model: AnomalibModule | None = None,
         dataloaders: EVAL_DATALOADERS | None = None,
         ckpt_path: str | Path | None = None,
         verbose: bool = True,
@@ -472,7 +472,7 @@ def test(
         finally tests the model.
 
         Args:
-            model (AnomalyModule | None, optional):
+            model (AnomalibModule | None, optional):
                 The model to be tested.
                 Defaults to None.
             dataloaders (EVAL_DATALOADERS | None, optional):
@@ -545,7 +545,7 @@ def test(
         if model:
             self._setup_trainer(model)
         elif not self.model:
-            msg = "`Engine.test()` requires an `AnomalyModule` when it hasn't been passed in a previous run."
+            msg = "`Engine.test()` requires an `AnomalibModule` when it hasn't been passed in a previous run."
             raise RuntimeError(msg)
 
         self._setup_dataset_task(dataloaders)
@@ -556,7 +556,7 @@ def test(
 
     def predict(
         self,
-        model: AnomalyModule | None = None,
+        model: AnomalibModule | None = None,
         dataloaders: EVAL_DATALOADERS | None = None,
         datamodule: AnomalibDataModule | None = None,
         dataset: Dataset | PredictDataset | None = None,
@@ -570,7 +570,7 @@ def predict(
         validation dataloader is available. Finally, predicts using the model.
 
         Args:
-            model (AnomalyModule | None, optional):
+            model (AnomalibModule | None, optional):
                 Model to be used for prediction.
                 Defaults to None.
             dataloaders (EVAL_DATALOADERS | None, optional):
@@ -623,7 +623,7 @@ def predict(
                 ```
         """
         if not (model or self.model):
-            msg = "`Engine.predict()` requires an `AnomalyModule` when it hasn't been passed in a previous run."
+            msg = "`Engine.predict()` requires an `AnomalibModule` when it hasn't been passed in a previous run."
             raise ValueError(msg)
 
         if ckpt_path:
@@ -668,7 +668,7 @@ def predict(
 
     def train(
         self,
-        model: AnomalyModule,
+        model: AnomalibModule,
         train_dataloaders: TRAIN_DATALOADERS | None = None,
         val_dataloaders: EVAL_DATALOADERS | None = None,
         test_dataloaders: EVAL_DATALOADERS | None = None,
@@ -678,7 +678,7 @@ def train(
         """Fits the model and then calls test on it.
 
         Args:
-            model (AnomalyModule): Model to be trained.
+            model (AnomalibModule): Model to be trained.
             train_dataloaders (TRAIN_DATALOADERS | None, optional): Train dataloaders.
                 Defaults to None.
             val_dataloaders (EVAL_DATALOADERS | None, optional): Validation dataloaders.
@@ -731,7 +731,7 @@ def train(
 
     def export(
         self,
-        model: AnomalyModule,
+        model: AnomalibModule,
         export_type: ExportType | str,
         export_root: str | Path | None = None,
         input_size: tuple[int, int] | None = None,
@@ -744,7 +744,7 @@ def export(
         r"""Export the model in PyTorch, ONNX or OpenVINO format.
 
         Args:
-            model (AnomalyModule): Trained model.
+            model (AnomalibModule): Trained model.
             export_type (ExportType): Export type.
             export_root (str | Path | None, optional): Path to the output directory. If it is not set, the model is
                 exported to trainer.default_root_dir. Defaults to None.
@@ -832,7 +832,7 @@ def from_config(
         cls: type["Engine"],
         config_path: str | Path,
         **kwargs,
-    ) -> tuple["Engine", AnomalyModule, AnomalibDataModule]:
+    ) -> tuple["Engine", AnomalibModule, AnomalibDataModule]:
         """Create an Engine instance from a configuration file.
 
         Args:
@@ -840,7 +840,7 @@ def from_config(
             **kwargs (dict): Additional keyword arguments.
 
         Returns:
-            tuple[Engine, AnomalyModule, AnomalibDataModule]: Engine instance.
+            tuple[Engine, AnomalibModule, AnomalibDataModule]: Engine instance.
 
         Example:
             The following example shows training with full configuration file:
diff --git a/src/anomalib/metrics/evaluator.py b/src/anomalib/metrics/evaluator.py
index 91ef47aa6d..53f05af3b2 100644
--- a/src/anomalib/metrics/evaluator.py
+++ b/src/anomalib/metrics/evaluator.py
@@ -19,10 +19,10 @@ class Evaluator(nn.Module, Callback):
     """Evaluator module for LightningModule.
 
     The Evaluator module is a PyTorch module that computes and logs metrics during
-    validation and test steps. Each AnomalyModule should have an Evaluator module as
+    validation and test steps. Each AnomalibModule should have an Evaluator module as
     a submodule to compute and log metrics during validation and test steps. An Evaluation
-    module can be passed to the AnomalyModule as a parameter during initialization. When
-    no Evaluator module is provided, the AnomalyModule will use a default Evaluator module
+    module can be passed to the AnomalibModule as a parameter during initialization. When
+    no Evaluator module is provided, the AnomalibModule will use a default Evaluator module
     that logs a default set of metrics.
 
     Args:
diff --git a/src/anomalib/models/__init__.py b/src/anomalib/models/__init__.py
index 3b32c83367..26f8695ab6 100644
--- a/src/anomalib/models/__init__.py
+++ b/src/anomalib/models/__init__.py
@@ -9,7 +9,7 @@
 from jsonargparse import Namespace
 from omegaconf import DictConfig, OmegaConf
 
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.utils.path import convert_to_snake_case
 
 from .image import (
@@ -95,10 +95,14 @@ def get_available_models() -> set[str]:
         >>> get_available_models()
         ['ai_vad', 'cfa', 'cflow', 'csflow', 'dfkde', 'dfm', 'draem', 'efficient_ad', 'fastflow', ...]
     """
-    return {convert_to_snake_case(cls.__name__) for cls in AnomalyModule.__subclasses__()}
+    return {
+        convert_to_snake_case(cls.__name__)
+        for cls in AnomalibModule.__subclasses__()
+        if cls.__name__ != "AnomalyModule"
+    }
 
 
-def _get_model_class_by_name(name: str) -> type[AnomalyModule]:
+def _get_model_class_by_name(name: str) -> type[AnomalibModule]:
     """Retrieves an anomaly model based on its name.
 
     Args:
@@ -108,13 +112,13 @@ def _get_model_class_by_name(name: str) -> type[AnomalyModule]:
         UnknownModelError: If the model is not found.
 
     Returns:
-        type[AnomalyModule]: Anomaly Model
+        type[AnomalibModule]: Anomaly Model
     """
     logger.info("Loading the model.")
-    model_class: type[AnomalyModule] | None = None
+    model_class: type[AnomalibModule] | None = None
 
     name = convert_snake_to_pascal_case(name).lower()
-    for model in AnomalyModule.__subclasses__():
+    for model in AnomalibModule.__subclasses__():
         if name == model.__name__.lower():
             model_class = model
     if model_class is None:
@@ -124,7 +128,7 @@ def _get_model_class_by_name(name: str) -> type[AnomalyModule]:
     return model_class
 
 
-def get_model(model: DictConfig | str | dict | Namespace, *args, **kwdargs) -> AnomalyModule:
+def get_model(model: DictConfig | str | dict | Namespace, *args, **kwdargs) -> AnomalibModule:
     """Get Anomaly Model.
 
     Args:
@@ -145,9 +149,9 @@ def get_model(model: DictConfig | str | dict | Namespace, *args, **kwdargs) -> A
         TypeError: If unsupported type is passed.
 
     Returns:
-        AnomalyModule: Anomaly Model
+        AnomalibModule: Anomaly Model
     """
-    _model: AnomalyModule
+    _model: AnomalibModule
     if isinstance(model, str):
         _model_class = _get_model_class_by_name(model)
         _model = _model_class(*args, **kwdargs)
diff --git a/src/anomalib/models/components/__init__.py b/src/anomalib/models/components/__init__.py
index b37daafefe..762345a93d 100644
--- a/src/anomalib/models/components/__init__.py
+++ b/src/anomalib/models/components/__init__.py
@@ -3,7 +3,7 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from .base import AnomalyModule, BufferListMixin, DynamicBufferMixin, MemoryBankMixin
+from .base import AnomalibModule, BufferListMixin, DynamicBufferMixin, MemoryBankMixin
 from .dimensionality_reduction import PCA, SparseRandomProjection
 from .feature_extractors import TimmFeatureExtractor, TorchFXFeatureExtractor
 from .filters import GaussianBlur2d
@@ -11,7 +11,7 @@
 from .stats import GaussianKDE, MultiVariateGaussian
 
 __all__ = [
-    "AnomalyModule",
+    "AnomalibModule",
     "BufferListMixin",
     "DynamicBufferMixin",
     "MemoryBankMixin",
diff --git a/src/anomalib/models/components/base/__init__.py b/src/anomalib/models/components/base/__init__.py
index b535c910cb..5214f966dc 100644
--- a/src/anomalib/models/components/base/__init__.py
+++ b/src/anomalib/models/components/base/__init__.py
@@ -3,9 +3,9 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from .anomaly_module import AnomalyModule
+from .anomaly_module import AnomalibModule
 from .buffer_list import BufferListMixin
 from .dynamic_buffer import DynamicBufferMixin
 from .memory_bank_module import MemoryBankMixin
 
-__all__ = ["AnomalyModule", "BufferListMixin", "DynamicBufferMixin", "MemoryBankMixin"]
+__all__ = ["AnomalibModule", "BufferListMixin", "DynamicBufferMixin", "MemoryBankMixin"]
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py
index 336877f17a..6509351cfb 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomaly_module.py
@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from pathlib import Path
@@ -30,8 +31,8 @@
 logger = logging.getLogger(__name__)
 
 
-class AnomalyModule(ExportMixin, pl.LightningModule, ABC):
-    """AnomalyModule to train, validate, predict and test images.
+class AnomalibModule(ExportMixin, pl.LightningModule, ABC):
+    """AnomalibModule to train, validate, predict and test images.
 
     Acts as a base class for all the Anomaly Modules in the library.
     """
@@ -98,7 +99,7 @@ def _resolve_pre_processor(self, pre_processor: PreProcessor | bool) -> PreProce
         raise TypeError(msg)
 
     def configure_callbacks(self) -> Sequence[Callback] | Callback:
-        """Configure default callbacks for AnomalyModule."""
+        """Configure default callbacks for AnomalibModule."""
         return [self.pre_processor] if self.pre_processor else []
 
     def forward(self, batch: torch.Tensor, *args, **kwargs) -> InferenceBatch:
@@ -187,7 +188,7 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
         Examples:
             Get default pre-processor with custom image size:
 
-            >>> preprocessor = AnomalyModule.configure_pre_processor(image_size=(512, 512))
+            >>> preprocessor = AnomalibModule.configure_pre_processor(image_size=(512, 512))
 
             Create model with custom pre-processor:
 
@@ -266,10 +267,10 @@ def input_size(self) -> tuple[int, int] | None:
 
     @classmethod
     def from_config(
-        cls: type["AnomalyModule"],
+        cls: type["AnomalibModule"],
         config_path: str | Path,
         **kwargs,
-    ) -> "AnomalyModule":
+    ) -> "AnomalibModule":
         """Create a model instance from the configuration.
 
         Args:
@@ -277,20 +278,20 @@ def from_config(
             **kwargs (dict): Additional keyword arguments.
 
         Returns:
-            AnomalyModule: model instance.
+            AnomalibModule: model instance.
 
         Example:
             The following example shows how to get model from patchcore.yaml:
 
             .. code-block:: python
                 >>> model_config = "configs/model/patchcore.yaml"
-                >>> model = AnomalyModule.from_config(config_path=model_config)
+                >>> model = AnomalibModule.from_config(config_path=model_config)
 
             The following example shows overriding the configuration file with additional keyword arguments:
 
             .. code-block:: python
                 >>> override_kwargs = {"model.pre_trained": False}
-                >>> model = AnomalyModule.from_config(config_path=model_config, **override_kwargs)
+                >>> model = AnomalibModule.from_config(config_path=model_config, **override_kwargs)
         """
         from jsonargparse import ActionConfigFile, ArgumentParser
         from lightning.pytorch import Trainer
@@ -308,7 +309,7 @@ def from_config(
             action=ActionConfigFile,
             help="Path to a configuration file in json or yaml format.",
         )
-        model_parser.add_subclass_arguments(AnomalyModule, "model", required=False, fail_untyped=False)
+        model_parser.add_subclass_arguments(AnomalibModule, "model", required=False, fail_untyped=False)
         model_parser.add_argument("--task", type=TaskType | str, default=TaskType.SEGMENTATION)
         model_parser.add_argument("--metrics.image", type=list[str] | str | None, default=["F1Score", "AUROC"])
         model_parser.add_argument("--metrics.pixel", type=list[str] | str | None, default=None, required=False)
@@ -320,8 +321,20 @@ def from_config(
         config = model_parser.parse_args(args=args)
         instantiated_classes = model_parser.instantiate_classes(config)
         model = instantiated_classes.get("model")
-        if isinstance(model, AnomalyModule):
+        if isinstance(model, AnomalibModule):
             return model
 
-        msg = f"Model is not an instance of AnomalyModule: {model}"
+        msg = f"Model is not an instance of AnomalibModule: {model}"
         raise ValueError(msg)
+
+
+class AnomalyModule(AnomalibModule):
+    """Deprecated AnomalyModule class. Use AnomalibModule instead."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        warnings.warn(
+            "AnomalyModule is deprecated and will be removed in a future release. Use AnomalibModule instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(*args, **kwargs)
diff --git a/src/anomalib/models/image/cfa/lightning_model.py b/src/anomalib/models/image/cfa/lightning_model.py
index 154ea4e3e8..ea4bf3a2bd 100644
--- a/src/anomalib/models/image/cfa/lightning_model.py
+++ b/src/anomalib/models/image/cfa/lightning_model.py
@@ -17,7 +17,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -29,7 +29,7 @@
 __all__ = ["Cfa"]
 
 
-class Cfa(AnomalyModule):
+class Cfa(AnomalibModule):
     """CFA: Coupled-hypersphere-based Feature Adaptation for Target-Oriented Anomaly Localization.
 
     Args:
diff --git a/src/anomalib/models/image/cflow/lightning_model.py b/src/anomalib/models/image/cflow/lightning_model.py
index b6118d8e4e..d6b39751d0 100644
--- a/src/anomalib/models/image/cflow/lightning_model.py
+++ b/src/anomalib/models/image/cflow/lightning_model.py
@@ -24,7 +24,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -32,7 +32,7 @@
 from .utils import get_logp, positional_encoding_2d
 
 
-class Cflow(AnomalyModule):
+class Cflow(AnomalibModule):
     """PL Lightning Module for the CFLOW algorithm.
 
     Args:
diff --git a/src/anomalib/models/image/csflow/lightning_model.py b/src/anomalib/models/image/csflow/lightning_model.py
index 0ae381c65b..3be936cc90 100644
--- a/src/anomalib/models/image/csflow/lightning_model.py
+++ b/src/anomalib/models/image/csflow/lightning_model.py
@@ -15,7 +15,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -27,7 +27,7 @@
 __all__ = ["Csflow"]
 
 
-class Csflow(AnomalyModule):
+class Csflow(AnomalibModule):
     """Fully Convolutional Cross-Scale-Flows for Image-based Defect Detection.
 
     Args:
diff --git a/src/anomalib/models/image/dfkde/lightning_model.py b/src/anomalib/models/image/dfkde/lightning_model.py
index 9bd8388d49..d1b1fba497 100644
--- a/src/anomalib/models/image/dfkde/lightning_model.py
+++ b/src/anomalib/models/image/dfkde/lightning_model.py
@@ -13,7 +13,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import AUROC, Evaluator, F1Score
-from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.models.components import AnomalibModule, MemoryBankMixin
 from anomalib.models.components.classification import FeatureScalingMethod
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
@@ -23,7 +23,7 @@
 logger = logging.getLogger(__name__)
 
 
-class Dfkde(MemoryBankMixin, AnomalyModule):
+class Dfkde(MemoryBankMixin, AnomalibModule):
     """DFKDE: Deep Feature Kernel Density Estimation.
 
     Args:
diff --git a/src/anomalib/models/image/dfm/lightning_model.py b/src/anomalib/models/image/dfm/lightning_model.py
index b0449d1e69..cc39b4e398 100644
--- a/src/anomalib/models/image/dfm/lightning_model.py
+++ b/src/anomalib/models/image/dfm/lightning_model.py
@@ -15,7 +15,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.models.components import AnomalibModule, MemoryBankMixin
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -24,7 +24,7 @@
 logger = logging.getLogger(__name__)
 
 
-class Dfm(MemoryBankMixin, AnomalyModule):
+class Dfm(MemoryBankMixin, AnomalibModule):
     """DFM: Deep Featured Kernel Density Estimation.
 
     Args:
diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py
index a072bcae0f..dd02fd168a 100644
--- a/src/anomalib/models/image/draem/lightning_model.py
+++ b/src/anomalib/models/image/draem/lightning_model.py
@@ -18,7 +18,7 @@
 from anomalib.data import Batch
 from anomalib.data.utils import Augmenter
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -28,7 +28,7 @@
 __all__ = ["Draem"]
 
 
-class Draem(AnomalyModule):
+class Draem(AnomalibModule):
     """DRÆM: A discriminatively trained reconstruction embedding for surface anomaly detection.
 
     Args:
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index a5a6071868..23daa6b95d 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -19,7 +19,7 @@
 from anomalib.data.utils import DownloadInfo, download_and_extract
 from anomalib.data.utils.augmenter import Augmenter
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.models.image.dsr.anomaly_generator import DsrAnomalyGenerator
 from anomalib.models.image.dsr.loss import DsrSecondStageLoss, DsrThirdStageLoss
 from anomalib.models.image.dsr.torch_model import DsrModel
@@ -37,7 +37,7 @@
 )
 
 
-class Dsr(AnomalyModule):
+class Dsr(AnomalibModule):
     """DSR: A Dual Subspace Re-Projection Network for Surface Anomaly Detection.
 
     Args:
diff --git a/src/anomalib/models/image/efficient_ad/lightning_model.py b/src/anomalib/models/image/efficient_ad/lightning_model.py
index 88b29f7215..47ace2a073 100644
--- a/src/anomalib/models/image/efficient_ad/lightning_model.py
+++ b/src/anomalib/models/image/efficient_ad/lightning_model.py
@@ -21,7 +21,7 @@
 from anomalib.data import Batch
 from anomalib.data.utils import DownloadInfo, download_and_extract
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -42,7 +42,7 @@
 )
 
 
-class EfficientAd(AnomalyModule):
+class EfficientAd(AnomalibModule):
     """PL Lightning Module for the EfficientAd algorithm.
 
     Args:
diff --git a/src/anomalib/models/image/fastflow/lightning_model.py b/src/anomalib/models/image/fastflow/lightning_model.py
index 935df8468d..35a5f8dddb 100644
--- a/src/anomalib/models/image/fastflow/lightning_model.py
+++ b/src/anomalib/models/image/fastflow/lightning_model.py
@@ -15,7 +15,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import AUROC, Evaluator, F1Score
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -23,7 +23,7 @@
 from .torch_model import FastflowModel
 
 
-class Fastflow(AnomalyModule):
+class Fastflow(AnomalibModule):
     """PL Lightning Module for the FastFlow algorithm.
 
     Args:
diff --git a/src/anomalib/models/image/fre/lightning_model.py b/src/anomalib/models/image/fre/lightning_model.py
index f3de232667..505beb7f1b 100755
--- a/src/anomalib/models/image/fre/lightning_model.py
+++ b/src/anomalib/models/image/fre/lightning_model.py
@@ -16,7 +16,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -25,7 +25,7 @@
 logger = logging.getLogger(__name__)
 
 
-class Fre(AnomalyModule):
+class Fre(AnomalibModule):
     """FRE: Feature-reconstruction error using Tied AutoEncoder.
 
     Args:
diff --git a/src/anomalib/models/image/ganomaly/lightning_model.py b/src/anomalib/models/image/ganomaly/lightning_model.py
index de3a479aa8..982bd93d33 100644
--- a/src/anomalib/models/image/ganomaly/lightning_model.py
+++ b/src/anomalib/models/image/ganomaly/lightning_model.py
@@ -16,7 +16,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import AUROC, Evaluator, F1Score
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -26,7 +26,7 @@
 logger = logging.getLogger(__name__)
 
 
-class Ganomaly(AnomalyModule):
+class Ganomaly(AnomalibModule):
     """PL Lightning Module for the GANomaly Algorithm.
 
     Args:
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index aed2163def..28d59fc9eb 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -14,7 +14,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.models.components import AnomalibModule, MemoryBankMixin
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -25,7 +25,7 @@
 __all__ = ["Padim"]
 
 
-class Padim(MemoryBankMixin, AnomalyModule):
+class Padim(MemoryBankMixin, AnomalibModule):
     """PaDiM: a Patch Distribution Modeling Framework for Anomaly Detection and Localization.
 
     Args:
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index f855a61d8e..d22a97d891 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -17,7 +17,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.models.components import AnomalibModule, MemoryBankMixin
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -26,7 +26,7 @@
 logger = logging.getLogger(__name__)
 
 
-class Patchcore(MemoryBankMixin, AnomalyModule):
+class Patchcore(MemoryBankMixin, AnomalibModule):
     """PatchcoreLightning Module to train PatchCore algorithm.
 
     Args:
diff --git a/src/anomalib/models/image/reverse_distillation/lightning_model.py b/src/anomalib/models/image/reverse_distillation/lightning_model.py
index a0cd8521f9..e052c864cb 100644
--- a/src/anomalib/models/image/reverse_distillation/lightning_model.py
+++ b/src/anomalib/models/image/reverse_distillation/lightning_model.py
@@ -15,7 +15,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -24,7 +24,7 @@
 from .torch_model import ReverseDistillationModel
 
 
-class ReverseDistillation(AnomalyModule):
+class ReverseDistillation(AnomalibModule):
     """PL Lightning Module for Reverse Distillation Algorithm.
 
     Args:
diff --git a/src/anomalib/models/image/rkde/lightning_model.py b/src/anomalib/models/image/rkde/lightning_model.py
index 8d618127c0..20a18496fc 100644
--- a/src/anomalib/models/image/rkde/lightning_model.py
+++ b/src/anomalib/models/image/rkde/lightning_model.py
@@ -15,7 +15,7 @@
 
 from anomalib import LearningType
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.models.components import AnomalibModule, MemoryBankMixin
 from anomalib.models.components.classification import FeatureScalingMethod
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
@@ -26,7 +26,7 @@
 logger = logging.getLogger(__name__)
 
 
-class Rkde(MemoryBankMixin, AnomalyModule):
+class Rkde(MemoryBankMixin, AnomalibModule):
     """Region Based Anomaly Detection With Real-Time Training and Analysis.
 
     Args:
diff --git a/src/anomalib/models/image/stfpm/lightning_model.py b/src/anomalib/models/image/stfpm/lightning_model.py
index 32cace71f1..9f37e46239 100644
--- a/src/anomalib/models/image/stfpm/lightning_model.py
+++ b/src/anomalib/models/image/stfpm/lightning_model.py
@@ -16,7 +16,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -26,7 +26,7 @@
 __all__ = ["Stfpm"]
 
 
-class Stfpm(AnomalyModule):
+class Stfpm(AnomalibModule):
     """PL Lightning Module for the STFPM algorithm.
 
     Args:
diff --git a/src/anomalib/models/image/uflow/lightning_model.py b/src/anomalib/models/image/uflow/lightning_model.py
index ce88d4ae2e..60e7a26752 100644
--- a/src/anomalib/models/image/uflow/lightning_model.py
+++ b/src/anomalib/models/image/uflow/lightning_model.py
@@ -18,7 +18,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -30,7 +30,7 @@
 __all__ = ["Uflow"]
 
 
-class Uflow(AnomalyModule):
+class Uflow(AnomalibModule):
     """Uflow model.
 
     Args:
diff --git a/src/anomalib/models/image/vlm_ad/lightning_model.py b/src/anomalib/models/image/vlm_ad/lightning_model.py
index 0c072f1330..6e47e58027 100644
--- a/src/anomalib/models/image/vlm_ad/lightning_model.py
+++ b/src/anomalib/models/image/vlm_ad/lightning_model.py
@@ -11,7 +11,7 @@
 from anomalib import LearningType
 from anomalib.data import ImageBatch
 from anomalib.metrics import Evaluator, F1Score
-from anomalib.models import AnomalyModule
+from anomalib.models import AnomalibModule
 from anomalib.post_processing import PostProcessor
 
 from .backends import Backend, ChatGPT, Huggingface, Ollama
@@ -20,7 +20,7 @@
 logger = logging.getLogger(__name__)
 
 
-class VlmAd(AnomalyModule):
+class VlmAd(AnomalibModule):
     """Visual anomaly model."""
 
     def __init__(
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index 3ce35f46f4..d3f7481df7 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -19,7 +19,7 @@
 from anomalib.data import Batch
 from anomalib.data.predict import PredictDataset
 from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -30,7 +30,7 @@
 __all__ = ["WinClip"]
 
 
-class WinClip(AnomalyModule):
+class WinClip(AnomalibModule):
     """WinCLIP Lightning model.
 
     Args:
diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py
index 9625f4b565..750746f259 100644
--- a/src/anomalib/models/video/ai_vad/lightning_model.py
+++ b/src/anomalib/models/video/ai_vad/lightning_model.py
@@ -14,7 +14,7 @@
 
 from anomalib import LearningType
 from anomalib.data import VideoBatch
-from anomalib.models.components import AnomalyModule, MemoryBankMixin
+from anomalib.models.components import AnomalibModule, MemoryBankMixin
 from anomalib.post_processing.one_class import OneClassPostProcessor, PostProcessor
 from anomalib.pre_processing import PreProcessor
 
@@ -25,7 +25,7 @@
 __all__ = ["AiVad"]
 
 
-class AiVad(MemoryBankMixin, AnomalyModule):
+class AiVad(MemoryBankMixin, AnomalibModule):
     """AI-VAD: Attribute-based Representations for Accurate and Interpretable Video Anomaly Detection.
 
     Args:
diff --git a/src/anomalib/pipelines/benchmark/job.py b/src/anomalib/pipelines/benchmark/job.py
index f56899ac5d..d98b689304 100644
--- a/src/anomalib/pipelines/benchmark/job.py
+++ b/src/anomalib/pipelines/benchmark/job.py
@@ -17,7 +17,7 @@
 
 from anomalib.data import AnomalibDataModule
 from anomalib.engine import Engine
-from anomalib.models import AnomalyModule
+from anomalib.models import AnomalibModule
 from anomalib.pipelines.components import Job
 from anomalib.utils.logging import hide_output
 
@@ -29,7 +29,7 @@ class BenchmarkJob(Job):
 
     Args:
         accelerator (str): The accelerator to use.
-        model (AnomalyModule): The model to use.
+        model (AnomalibModule): The model to use.
         datamodule (AnomalibDataModule): The data module to use.
         seed (int): The seed to use.
         flat_cfg (dict): The flat dictionary of configs with dotted keys.
@@ -40,7 +40,7 @@ class BenchmarkJob(Job):
     def __init__(
         self,
         accelerator: str,
-        model: AnomalyModule,
+        model: AnomalibModule,
         datamodule: AnomalibDataModule,
         seed: int,
         flat_cfg: dict,
diff --git a/src/anomalib/utils/visualization/metrics.py b/src/anomalib/utils/visualization/metrics.py
index 48f426ea11..36f4948405 100644
--- a/src/anomalib/utils/visualization/metrics.py
+++ b/src/anomalib/utils/visualization/metrics.py
@@ -9,7 +9,7 @@
 from .base import BaseVisualizer, GeneratorResult, VisualizationStep
 
 if TYPE_CHECKING:
-    from anomalib.models import AnomalyModule
+    from anomalib.models import AnomalibModule
 
 
 class MetricsVisualizer(BaseVisualizer):
@@ -21,7 +21,7 @@ def __init__(self) -> None:
     @staticmethod
     def generate(**kwargs) -> Iterator[GeneratorResult]:
         """Generate metric plots and return them as an iterator."""
-        pl_module: AnomalyModule = kwargs.get("pl_module", None)
+        pl_module: AnomalibModule = kwargs.get("pl_module", None)
         if pl_module is None:
             msg = "`pl_module` must be provided"
             raise ValueError(msg)
diff --git a/src/anomalib/visualization/image/visualizer.py b/src/anomalib/visualization/image/visualizer.py
index 7c83446ae5..c8eafc8ae8 100644
--- a/src/anomalib/visualization/image/visualizer.py
+++ b/src/anomalib/visualization/image/visualizer.py
@@ -9,7 +9,7 @@
 from lightning.pytorch import Callback, Trainer
 
 from anomalib.data import ImageBatch
-from anomalib.models import AnomalyModule
+from anomalib.models import AnomalibModule
 from anomalib.utils.path import generate_output_filename
 
 from .item_visualizer import (
@@ -138,7 +138,7 @@ def __init__(
     def on_test_batch_end(
         self,
         trainer: Trainer,
-        pl_module: AnomalyModule,
+        pl_module: AnomalibModule,
         outputs: ImageBatch,
         batch: ImageBatch,
         batch_idx: int,
@@ -176,7 +176,7 @@ def on_test_batch_end(
     def on_predict_batch_end(
         self,
         trainer: Trainer,
-        pl_module: AnomalyModule,
+        pl_module: AnomalibModule,
         outputs: ImageBatch,
         batch: ImageBatch,
         batch_idx: int,
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index 9c9c203d45..464c2cb1da 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -15,7 +15,7 @@
 from anomalib.data import AnomalibDataModule, MVTec
 from anomalib.deploy import ExportType
 from anomalib.engine import Engine
-from anomalib.models import AnomalyModule, get_available_models, get_model
+from anomalib.models import AnomalibModule, get_available_models, get_model
 
 
 def models() -> set[str]:
@@ -165,7 +165,7 @@ def _get_objects(
         model_name: str,
         dataset_path: Path,
         project_path: Path,
-    ) -> tuple[AnomalyModule, AnomalibDataModule, Engine]:
+    ) -> tuple[AnomalibModule, AnomalibDataModule, Engine]:
         """Return model, dataset, and engine objects.
 
         Args:
@@ -174,7 +174,7 @@ def _get_objects(
             project_path (Path): path to the temporary project folder
 
         Returns:
-            tuple[AnomalyModule, AnomalibDataModule, Engine]: Returns the created objects for model, dataset,
+            tuple[AnomalibModule, AnomalibDataModule, Engine]: Returns the created objects for model, dataset,
                 and engine
         """
         # select task type
diff --git a/tests/unit/models/components/base/test_anomaly_module.py b/tests/unit/models/components/base/test_anomaly_module.py
index c77ab7c212..92e37af5b4 100644
--- a/tests/unit/models/components/base/test_anomaly_module.py
+++ b/tests/unit/models/components/base/test_anomaly_module.py
@@ -1,4 +1,4 @@
-"""Test AnomalyModule module."""
+"""Test AnomalibModule module."""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -7,7 +7,7 @@
 
 import pytest
 
-from anomalib.models.components.base import AnomalyModule
+from anomalib.models.components.base import AnomalibModule
 
 
 @pytest.fixture(scope="class")
@@ -16,19 +16,19 @@ def model_config_folder_path() -> str:
     return "configs/model"
 
 
-class TestAnomalyModule:
-    """Test AnomalyModule."""
+class TestAnomalibModule:
+    """Test AnomalibModule."""
 
     @pytest.fixture(autouse=True)
     def setup(self, model_config_folder_path: str) -> None:
-        """Setup test AnomalyModule."""
+        """Setup test AnomalibModule."""
         self.model_config_folder_path = model_config_folder_path
 
     @staticmethod
     def test_from_config_with_wrong_config_path() -> None:
-        """Test AnomalyModule.from_config with wrong model name."""
+        """Test AnomalibModule.from_config with wrong model name."""
         with pytest.raises(FileNotFoundError):
-            AnomalyModule.from_config(config_path="wrong_configs.yaml")
+            AnomalibModule.from_config(config_path="wrong_configs.yaml")
 
     @pytest.mark.parametrize(
         "model_name",
@@ -53,8 +53,8 @@ def test_from_config_with_wrong_config_path() -> None:
         ],
     )
     def test_from_config(self, model_name: str) -> None:
-        """Test AnomalyModule.from_config."""
+        """Test AnomalibModule.from_config."""
         config_path = Path(self.model_config_folder_path) / f"{model_name}.yaml"
-        model = AnomalyModule.from_config(config_path=config_path)
+        model = AnomalibModule.from_config(config_path=config_path)
         assert model is not None
-        assert isinstance(model, AnomalyModule)
+        assert isinstance(model, AnomalibModule)
diff --git a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
index 33a215f56f..dc9c31e8db 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
@@ -11,7 +11,7 @@
 
 from anomalib import LearningType
 from anomalib.data import ImageBatch, InferenceBatch
-from anomalib.models.components import AnomalyModule
+from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 
 
@@ -27,7 +27,7 @@ def forward(batch: InferenceBatch) -> InferenceBatch:
         return batch
 
 
-class DummyModule(AnomalyModule):
+class DummyModule(AnomalibModule):
     """A dummy model which calls visualizer callback on fake images and masks.
 
     TODO(ashwinvaidya17): Remove this when the DummyModels have been refactored.
diff --git a/tools/inference/lightning_inference.py b/tools/inference/lightning_inference.py
index 400b46ae00..e06c87c281 100644
--- a/tools/inference/lightning_inference.py
+++ b/tools/inference/lightning_inference.py
@@ -10,7 +10,7 @@
 
 from anomalib.data import PredictDataset
 from anomalib.engine import Engine
-from anomalib.models import AnomalyModule, get_model
+from anomalib.models import AnomalibModule, get_model
 
 
 def get_parser() -> LightningArgumentParser:
@@ -20,7 +20,7 @@ def get_parser() -> LightningArgumentParser:
         LightningArgumentParser: The parser object.
     """
     parser = LightningArgumentParser(description="Inference on Anomaly models in Lightning format.")
-    parser.add_lightning_class_args(AnomalyModule, "model", subclass_mode=True)
+    parser.add_lightning_class_args(AnomalibModule, "model", subclass_mode=True)
     parser.add_lightning_class_args(Callback, "--callbacks", subclass_mode=True, required=False)
     parser.add_argument("--ckpt_path", type=str, required=True, help="Path to model weights")
     parser.add_class_arguments(PredictDataset, "--data", instantiate=False)

From 2f3d6169833717e6ccb0f5c1d0b5c4abd853de32 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 27 Nov 2024 16:49:09 +0000
Subject: [PATCH 14/45] =?UTF-8?q?=F0=9F=94=A8=20Replace=20`imgaug`=20with?=
 =?UTF-8?q?=20Native=20PyTorch=20Transforms=20(#2436)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Add multi random choice transform

* Add DRAEMAugmenter class and Perlin noise generation to new_perlin.py

- Introduced DRAEMAugmenter for advanced image augmentations using torchvision v2.
- Implemented various augmentation techniques including ColorJitter, RandomAdjustSharpness, and custom transformations.
- Added functionality for comparing augmentation methods and visualizing results.
- Included utility functions for metrics computation and image processing.
- Established logging for better traceability of operations.

This commit enhances the image processing capabilities within the Anomalib framework, facilitating more robust anomaly detection workflows.

* Add the new perlin noise

Signed-off-by: Samet Akcay 

* Add the new perlin noise

Signed-off-by: Samet Akcay 

* add generate_perlin_noise relative import

Signed-off-by: Samet Akcay 

* add tiffile as a dependency

Signed-off-by: Samet Akcay 

* Remove upper bound from wandb

Signed-off-by: Samet Akcay 

* Added skimage

Signed-off-by: Samet Akcay 

* add scikit-learn as a dependency

Signed-off-by: Samet Akcay 

* limit ollama to < 0.4.0 as it has breaking changes

Signed-off-by: Samet Akcay 

* Fix data generators in test helpers

Signed-off-by: Samet Akcay 

* Update the perlin augmenters

Signed-off-by: Samet Akcay 

* Fix numpy validator tests caused by numpy upgrade

Signed-off-by: Samet Akcay 

* Fix CS-Flow tests

Signed-off-by: Samet Akcay 

* Fix the tests

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 
---
 pyproject.toml                                |   7 +-
 src/anomalib/data/transforms/__init__.py      |   3 +-
 .../data/transforms/multi_random_choice.py    |  82 ++++
 src/anomalib/data/utils/__init__.py           |   6 +-
 src/anomalib/data/utils/augmenter.py          | 171 --------
 .../data/utils/generators/__init__.py         |   4 +-
 src/anomalib/data/utils/generators/perlin.py  | 401 ++++++++++++------
 src/anomalib/data/utils/synthetic.py          |   7 +-
 .../models/image/draem/lightning_model.py     |   6 +-
 .../models/image/dsr/anomaly_generator.py     |  29 +-
 .../models/image/dsr/lightning_model.py       |   6 +-
 tests/helpers/data.py                         |   7 +-
 tests/integration/model/test_models.py        |  27 +-
 .../unit/data/validators/numpy/test_image.py  |   9 +-
 .../unit/data/validators/numpy/test_video.py  |  24 +-
 tests/unit/metrics/test_pro.py                |   6 +-
 16 files changed, 453 insertions(+), 342 deletions(-)
 create mode 100644 src/anomalib/data/transforms/multi_random_choice.py
 delete mode 100644 src/anomalib/data/utils/augmenter.py

diff --git a/pyproject.toml b/pyproject.toml
index e47f7e55d8..805795da40 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -42,11 +42,12 @@ core = [
     "av>=10.0.0",
     "einops>=0.3.2",
     "freia>=0.2",
-    "imgaug==0.4.0",
     "kornia>=0.6.6",
     "matplotlib>=3.4.3",
     "opencv-python>=4.5.3.56",
     "pandas>=1.1.0",
+    "scikit-image",  # NOTE: skimage should be removed as part of dependency cleanup
+    "tifffile",
     "timm",
     "lightning>=2.2",
     "torch>=2",
@@ -57,12 +58,12 @@ core = [
     "open-clip-torch>=2.23.0,<2.26.1",
 ]
 openvino = ["openvino>=2024.0", "nncf>=2.10.0", "onnx>=1.16.0"]
-vlm = ["ollama", "openai", "python-dotenv","transformers"]
+vlm = ["ollama<0.4.0", "openai", "python-dotenv","transformers"]
 loggers = [
     "comet-ml>=3.31.7",
     "gradio>=4",
     "tensorboard",
-    "wandb>=0.12.17,<=0.15.9",
+    "wandb",
     "mlflow >=1.0.0",
 ]
 notebooks = ["gitpython", "ipykernel", "ipywidgets", "notebook"]
diff --git a/src/anomalib/data/transforms/__init__.py b/src/anomalib/data/transforms/__init__.py
index 146fb19e15..89a5c673d2 100644
--- a/src/anomalib/data/transforms/__init__.py
+++ b/src/anomalib/data/transforms/__init__.py
@@ -4,5 +4,6 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from .center_crop import ExportableCenterCrop
+from .multi_random_choice import MultiRandomChoice
 
-__all__ = ["ExportableCenterCrop"]
+__all__ = ["ExportableCenterCrop", "MultiRandomChoice"]
diff --git a/src/anomalib/data/transforms/multi_random_choice.py b/src/anomalib/data/transforms/multi_random_choice.py
new file mode 100644
index 0000000000..1d507c17a2
--- /dev/null
+++ b/src/anomalib/data/transforms/multi_random_choice.py
@@ -0,0 +1,82 @@
+"""Multi random choice transform."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Callable, Sequence
+
+import torch
+from torchvision.transforms import v2
+
+
+class MultiRandomChoice(v2.Transform):
+    """Apply multiple transforms randomly picked from a list.
+
+    This transform does not support torchscript.
+
+    Args:
+        transforms (sequence or torch.nn.Module): List of transformations to choose from.
+        probabilities (list[float] | None, optional): Probability of each transform being picked.
+            If None (default), all transforms have equal probability. If provided, probabilities
+            will be normalized to sum to 1.
+        num_transforms (int): Maximum number of transforms to apply at once.
+            Defaults to ``1``.
+        fixed_num_transforms (bool): If ``True``, always applies exactly ``num_transforms`` transforms.
+            If ``False``, randomly picks between 1 and ``num_transforms``.
+            Defaults to ``False``.
+
+    Examples:
+        >>> import torchvision.transforms.v2 as v2
+        >>> transforms = [
+        ...     v2.RandomHorizontalFlip(p=1.0),
+        ...     v2.ColorJitter(brightness=0.5),
+        ...     v2.RandomRotation(10),
+        ... ]
+        >>> # Apply 1-2 random transforms with equal probability
+        >>> transform = MultiRandomChoice(transforms, num_transforms=2)
+
+        >>> # Always apply exactly 2 transforms with custom probabilities
+        >>> transform = MultiRandomChoice(
+        ...     transforms,
+        ...     probabilities=[0.5, 0.3, 0.2],
+        ...     num_transforms=2,
+        ...     fixed_num_transforms=True
+        ... )
+    """
+
+    def __init__(
+        self,
+        transforms: Sequence[Callable],
+        probabilities: list[float] | None = None,
+        num_transforms: int = 1,
+        fixed_num_transforms: bool = False,
+    ) -> None:
+        if not isinstance(transforms, Sequence):
+            msg = "Argument transforms should be a sequence of callables"
+            raise TypeError(msg)
+
+        if probabilities is None:
+            probabilities = [1.0] * len(transforms)
+        elif len(probabilities) != len(transforms):
+            msg = f"Length of p doesn't match the number of transforms: {len(probabilities)} != {len(transforms)}"
+            raise ValueError(msg)
+
+        super().__init__()
+
+        self.transforms = transforms
+        total = sum(probabilities)
+        self.probabilities = [probability / total for probability in probabilities]
+
+        self.num_transforms = num_transforms
+        self.fixed_num_transforms = fixed_num_transforms
+
+    def forward(self, *inputs: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, ...]:
+        """Apply randomly selected transforms to the input."""
+        # First determine number of transforms to apply
+        num_transforms = (
+            self.num_transforms if self.fixed_num_transforms else int(torch.randint(self.num_transforms, (1,)) + 1)
+        )
+        # Get transforms
+        idx = torch.multinomial(torch.tensor(self.probabilities), num_transforms).tolist()
+        transform = v2.Compose([self.transforms[i] for i in idx])
+        return transform(*inputs)
diff --git a/src/anomalib/data/utils/__init__.py b/src/anomalib/data/utils/__init__.py
index e75ba5bf49..570c45af4a 100644
--- a/src/anomalib/data/utils/__init__.py
+++ b/src/anomalib/data/utils/__init__.py
@@ -3,10 +3,9 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from .augmenter import Augmenter
 from .boxes import boxes_to_anomaly_maps, boxes_to_masks, masks_to_boxes
 from .download import DownloadInfo, download_and_extract
-from .generators import random_2d_perlin
+from .generators import generate_perlin_noise
 from .image import (
     generate_output_image_filename,
     get_image_filenames,
@@ -30,7 +29,7 @@
     "generate_output_image_filename",
     "get_image_filenames",
     "get_image_height_and_width",
-    "random_2d_perlin",
+    "generate_perlin_noise",
     "read_image",
     "read_mask",
     "read_depth_image",
@@ -42,7 +41,6 @@
     "TestSplitMode",
     "LabelName",
     "DirType",
-    "Augmenter",
     "masks_to_boxes",
     "boxes_to_masks",
     "boxes_to_anomaly_maps",
diff --git a/src/anomalib/data/utils/augmenter.py b/src/anomalib/data/utils/augmenter.py
deleted file mode 100644
index aa35434773..0000000000
--- a/src/anomalib/data/utils/augmenter.py
+++ /dev/null
@@ -1,171 +0,0 @@
-"""Augmenter module to generates out-of-distribution samples for the DRAEM implementation."""
-
-# Original Code
-# Copyright (c) 2021 VitjanZ
-# https://github.com/VitjanZ/DRAEM.
-# SPDX-License-Identifier: MIT
-#
-# Modified
-# Copyright (C) 2022-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import math
-import random
-from pathlib import Path
-
-import cv2
-import imgaug.augmenters as iaa
-import numpy as np
-import torch
-from PIL import Image
-from torchvision.datasets.folder import IMG_EXTENSIONS
-
-from anomalib.data.utils.generators.perlin import random_2d_perlin
-
-
-def nextpow2(value: int) -> int:
-    """Return the smallest power of 2 greater than or equal to the input value."""
-    return 2 ** (math.ceil(math.log(value, 2)))
-
-
-class Augmenter:
-    """Class that generates noisy augmentations of input images.
-
-    Args:
-        anomaly_source_path (str | None): Path to a folder of images that will be used as source of the anomalous
-        noise. If not specified, random noise will be used instead.
-        p_anomalous (float): Probability that the anomalous perturbation will be applied to a given image.
-        beta (float): Parameter that determines the opacity of the noise mask.
-    """
-
-    def __init__(
-        self,
-        anomaly_source_path: str | None = None,
-        p_anomalous: float = 0.5,
-        beta: float | tuple[float, float] = (0.2, 1.0),
-    ) -> None:
-        self.p_anomalous = p_anomalous
-        self.beta = beta
-
-        self.anomaly_source_paths: list[Path] = []
-        if anomaly_source_path is not None:
-            for img_ext in IMG_EXTENSIONS:
-                self.anomaly_source_paths.extend(Path(anomaly_source_path).rglob("*" + img_ext))
-
-        self.augmenters = [
-            iaa.GammaContrast((0.5, 2.0), per_channel=True),
-            iaa.MultiplyAndAddToBrightness(mul=(0.8, 1.2), add=(-30, 30)),
-            iaa.pillike.EnhanceSharpness(),
-            iaa.AddToHueAndSaturation((-50, 50), per_channel=True),
-            iaa.Solarize(0.5, threshold=(32, 128)),
-            iaa.Posterize(),
-            iaa.Invert(),
-            iaa.pillike.Autocontrast(),
-            iaa.pillike.Equalize(),
-            iaa.Affine(rotate=(-45, 45)),
-        ]
-        self.rot = iaa.Sequential([iaa.Affine(rotate=(-90, 90))])
-
-    def rand_augmenter(self) -> iaa.Sequential:
-        """Select 3 random transforms that will be applied to the anomaly source images.
-
-        Returns:
-            A selection of 3 transforms.
-        """
-        aug_ind = np.random.default_rng().choice(np.arange(len(self.augmenters)), 3, replace=False)
-        return iaa.Sequential([self.augmenters[aug_ind[0]], self.augmenters[aug_ind[1]], self.augmenters[aug_ind[2]]])
-
-    def generate_perturbation(
-        self,
-        height: int,
-        width: int,
-        anomaly_source_path: Path | str | None = None,
-    ) -> tuple[np.ndarray, np.ndarray]:
-        """Generate an image containing a random anomalous perturbation using a source image.
-
-        Args:
-            height (int): height of the generated image.
-            width: (int): width of the generated image.
-            anomaly_source_path (Path | str | None): Path to an image file. If not provided, random noise will be used
-            instead.
-
-        Returns:
-            Image containing a random anomalous perturbation, and the corresponding ground truth anomaly mask.
-        """
-        # Generate random perlin noise
-        perlin_scale = 6
-        min_perlin_scale = 0
-
-        perlin_scalex = 2 ** np.random.default_rng().integers(min_perlin_scale, perlin_scale)
-        perlin_scaley = 2 ** np.random.default_rng().integers(min_perlin_scale, perlin_scale)
-
-        perlin_noise = random_2d_perlin((nextpow2(height), nextpow2(width)), (perlin_scalex, perlin_scaley))[
-            :height,
-            :width,
-        ]
-        perlin_noise = self.rot(image=perlin_noise)
-
-        # Create mask from perlin noise
-        mask = np.where(perlin_noise > 0.5, np.ones_like(perlin_noise), np.zeros_like(perlin_noise))
-        mask = np.expand_dims(mask, axis=2).astype(np.float32)
-
-        # Load anomaly source image
-        if anomaly_source_path:
-            anomaly_source_img = np.array(Image.open(anomaly_source_path))
-            anomaly_source_img = cv2.resize(anomaly_source_img, dsize=(width, height))
-        else:  # if no anomaly source is specified, we use the perlin noise as anomalous source
-            anomaly_source_img = np.expand_dims(perlin_noise, 2).repeat(3, 2)
-            anomaly_source_img = (anomaly_source_img * 255).astype(np.uint8)
-
-        # Augment anomaly source image
-        aug = self.rand_augmenter()
-        anomaly_img_augmented = aug(image=anomaly_source_img)
-
-        # Create anomalous perturbation that we will apply to the image
-        perturbation = anomaly_img_augmented.astype(np.float32) * mask / 255.0
-
-        return perturbation, mask
-
-    def augment_batch(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        """Generate anomalous augmentations for a batch of input images.
-
-        Args:
-            batch (torch.Tensor): Batch of input images
-
-        Returns:
-            - Augmented image to which anomalous perturbations have been added.
-            - Ground truth masks corresponding to the anomalous perturbations.
-        """
-        batch_size, channels, height, width = batch.shape
-
-        # Collect perturbations
-        perturbations_list = []
-        masks_list = []
-        for _ in range(batch_size):
-            if torch.rand(1) > self.p_anomalous:  # include normal samples
-                perturbations_list.append(torch.zeros((channels, height, width)))
-                masks_list.append(torch.zeros((1, height, width)))
-            else:
-                anomaly_source_path = (
-                    random.sample(self.anomaly_source_paths, 1)[0] if len(self.anomaly_source_paths) > 0 else None
-                )
-                perturbation, mask = self.generate_perturbation(height, width, anomaly_source_path)
-                perturbations_list.append(torch.Tensor(perturbation).permute((2, 0, 1)))
-                masks_list.append(torch.Tensor(mask).permute((2, 0, 1)))
-
-        perturbations = torch.stack(perturbations_list).to(batch.device)
-        masks = torch.stack(masks_list).to(batch.device)
-
-        # Apply perturbations batch wise
-        if isinstance(self.beta, float):
-            beta = self.beta
-        elif isinstance(self.beta, tuple):
-            beta = torch.rand(batch_size) * (self.beta[1] - self.beta[0]) + self.beta[0]
-            beta = beta.view(batch_size, 1, 1, 1).expand_as(batch).to(batch.device)  # type: ignore[attr-defined]
-        else:
-            msg = "Beta must be either float or tuple of floats"
-            raise TypeError(msg)
-
-        augmented_batch = batch * (1 - masks) + (beta) * perturbations + (1 - beta) * batch * (masks)
-
-        return augmented_batch, masks
diff --git a/src/anomalib/data/utils/generators/__init__.py b/src/anomalib/data/utils/generators/__init__.py
index a79bad9770..c46f30d08e 100644
--- a/src/anomalib/data/utils/generators/__init__.py
+++ b/src/anomalib/data/utils/generators/__init__.py
@@ -3,6 +3,6 @@
 # Copyright (C) 2022 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from .perlin import random_2d_perlin
+from .perlin import PerlinAnomalyGenerator, generate_perlin_noise
 
-__all__ = ["random_2d_perlin"]
+__all__ = ["PerlinAnomalyGenerator", "generate_perlin_noise"]
diff --git a/src/anomalib/data/utils/generators/perlin.py b/src/anomalib/data/utils/generators/perlin.py
index fa683d7546..052d565121 100644
--- a/src/anomalib/data/utils/generators/perlin.py
+++ b/src/anomalib/data/utils/generators/perlin.py
@@ -1,160 +1,317 @@
-"""Helper functions for generating Perlin noise."""
-
-# Original Code
-# Copyright (c) 2021 VitjanZ
-# https://github.com/VitjanZ/DRAEM.
-# SPDX-License-Identifier: MIT
-#
-# Modified
+"""Perlin noise-based synthetic anomaly generator."""
+
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-# ruff: noqa
-
-import math
+from pathlib import Path
 
-import numpy as np
 import torch
+from torchvision import io
+from torchvision.datasets.folder import IMG_EXTENSIONS
+from torchvision.transforms import v2
 
+from anomalib.data.transforms import MultiRandomChoice
 
-def lerp_np(x, y, w):
-    """Helper function."""
-    return (y - x) * w + x
-
-
-def rand_perlin_2d_octaves_np(shape, res, octaves=1, persistence=0.5):
-    """Generate Perlin noise parameterized by the octaves method. Numpy version."""
-    noise = np.zeros(shape)
-    frequency = 1
-    amplitude = 1
-    for _ in range(octaves):
-        noise += amplitude * generate_perlin_noise_2d(shape, (frequency * res[0], frequency * res[1]))
-        frequency *= 2
-        amplitude *= persistence
-    return noise
 
+def generate_perlin_noise(
+    height: int,
+    width: int,
+    scale: tuple[int, int] | None = None,
+    device: torch.device | None = None,
+) -> torch.Tensor:
+    """Generate a Perlin noise pattern.
 
-def generate_perlin_noise_2d(shape, res):
-    """Fractal perlin noise."""
-
-    def f(t):
-        return 6 * t**5 - 15 * t**4 + 10 * t**3
-
-    delta = (res[0] / shape[0], res[1] / shape[1])
-    d = (shape[0] // res[0], shape[1] // res[1])
-    grid = np.mgrid[0 : res[0] : delta[0], 0 : res[1] : delta[1]].transpose(1, 2, 0) % 1
-    # Gradients
-    angles = 2 * np.pi * np.random.default_rng().random(res[0] + 1, res[1] + 1)
-    gradients = np.dstack((np.cos(angles), np.sin(angles)))
-    g00 = gradients[0:-1, 0:-1].repeat(d[0], 0).repeat(d[1], 1)
-    g10 = gradients[1:, 0:-1].repeat(d[0], 0).repeat(d[1], 1)
-    g01 = gradients[0:-1, 1:].repeat(d[0], 0).repeat(d[1], 1)
-    g11 = gradients[1:, 1:].repeat(d[0], 0).repeat(d[1], 1)
-    # Ramps
-    n00 = np.sum(grid * g00, 2)
-    n10 = np.sum(np.dstack((grid[:, :, 0] - 1, grid[:, :, 1])) * g10, 2)
-    n01 = np.sum(np.dstack((grid[:, :, 0], grid[:, :, 1] - 1)) * g01, 2)
-    n11 = np.sum(np.dstack((grid[:, :, 0] - 1, grid[:, :, 1] - 1)) * g11, 2)
-    # Interpolation
-    t = f(grid)
-    n0 = n00 * (1 - t[:, :, 0]) + t[:, :, 0] * n10
-    n1 = n01 * (1 - t[:, :, 0]) + t[:, :, 0] * n11
-    return np.sqrt(2) * ((1 - t[:, :, 1]) * n0 + t[:, :, 1] * n1)
-
-
-def random_2d_perlin(
-    shape: tuple,
-    res: tuple[int | torch.Tensor, int | torch.Tensor],
-    fade=lambda t: 6 * t**5 - 15 * t**4 + 10 * t**3,
-) -> np.ndarray | torch.Tensor:
-    """Returns a random 2d perlin noise array.
+    This function generates a Perlin noise pattern using a grid-based gradient noise approach.
+    The noise is generated by interpolating between randomly generated gradient vectors at grid vertices.
+    The interpolation uses a quintic curve for smooth transitions.
 
     Args:
-        shape (tuple): Shape of the 2d map.
-        res (tuple[int | torch.Tensor, int | torch.Tensor]): Tuple of scales for perlin noise for height and width dimension.
-        fade (_type_, optional): Function used for fading the resulting 2d map.
-            Defaults to equation 6*t**5-15*t**4+10*t**3.
+        height: Desired height of the noise pattern
+        width: Desired width of the noise pattern
+        scale: Tuple of (scale_x, scale_y) for noise granularity. If None, random scales will be used.
+               Larger scales produce coarser noise patterns, while smaller scales produce finer patterns.
+        device: Device to generate the noise on. If None, uses current default device
 
     Returns:
-        np.ndarray | torch.Tensor: Random 2d-array/tensor generated using perlin noise.
-    """
-    if isinstance(res[0], int | np.integer):
-        result = _rand_perlin_2d_np(shape, res, fade)
-    elif isinstance(res[0], torch.Tensor):
-        result = _rand_perlin_2d(shape, res, fade)
-    else:
-        msg = f"got scales of type {type(res[0])}"
-        raise TypeError(msg)
-    return result
+        Tensor of shape [height, width] containing the noise pattern, with values roughly in [-1, 1] range
 
+    Examples:
+        >>> # Generate 256x256 noise with default random scale
+        >>> noise = generate_perlin_noise(256, 256)
+        >>> print(noise.shape)
+        torch.Size([256, 256])
 
-def _rand_perlin_2d_np(shape, res, fade=lambda t: 6 * t**5 - 15 * t**4 + 10 * t**3):
-    """Generate a random image containing Perlin noise. Numpy version."""
-    delta = (res[0] / shape[0], res[1] / shape[1])
-    d = (shape[0] // res[0], shape[1] // res[1])
-    grid = np.mgrid[0 : res[0] : delta[0], 0 : res[1] : delta[1]].transpose(1, 2, 0) % 1
+        >>> # Generate 512x512 noise with fixed scale
+        >>> noise = generate_perlin_noise(512, 512, scale=(8, 8))
+        >>> print(noise.shape)
+        torch.Size([512, 512])
 
-    angles = 2 * math.pi * np.random.default_rng().random((res[0] + 1, res[1] + 1))
-    gradients = np.stack((np.cos(angles), np.sin(angles)), axis=-1)
+        >>> # Generate noise on GPU if available
+        >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        >>> noise = generate_perlin_noise(128, 128, device=device)
+    """
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-    def tile_grads(slice1, slice2):
-        return np.repeat(np.repeat(gradients[slice1[0] : slice1[1], slice2[0] : slice2[1]], d[0], axis=0), d[1], axis=1)
+    # Handle scale parameter
+    if scale is None:
+        min_scale, max_scale = 0, 6
+        scalex = 2 ** torch.randint(min_scale, max_scale, (1,), device=device).item()
+        scaley = 2 ** torch.randint(min_scale, max_scale, (1,), device=device).item()
+    else:
+        scalex, scaley = scale
 
-    def dot(grad, shift):
-        return (
-            np.stack((grid[: shape[0], : shape[1], 0] + shift[0], grid[: shape[0], : shape[1], 1] + shift[1]), axis=-1)
-            * grad[: shape[0], : shape[1]]
-        ).sum(axis=-1)
+    # Ensure dimensions are powers of 2 for proper noise generation
+    def nextpow2(value: int) -> int:
+        return int(2 ** torch.ceil(torch.log2(torch.tensor(value))).int().item())
 
-    n00 = dot(tile_grads([0, -1], [0, -1]), [0, 0])
-    n10 = dot(tile_grads([1, None], [0, -1]), [-1, 0])
-    n01 = dot(tile_grads([0, -1], [1, None]), [0, -1])
-    n11 = dot(tile_grads([1, None], [1, None]), [-1, -1])
-    t = fade(grid[: shape[0], : shape[1]])
-    return math.sqrt(2) * lerp_np(lerp_np(n00, n10, t[..., 0]), lerp_np(n01, n11, t[..., 0]), t[..., 1])
+    pad_h = nextpow2(height)
+    pad_w = nextpow2(width)
 
+    # Generate base grid
+    delta = (scalex / pad_h, scaley / pad_w)
+    d = (pad_h // scalex, pad_w // scaley)
 
-def _rand_perlin_2d(shape, res, fade=lambda t: 6 * t**5 - 15 * t**4 + 10 * t**3):
-    """Generate a random image containing Perlin noise. PyTorch version."""
-    delta = (res[0] / shape[0], res[1] / shape[1])
-    d = (shape[0] // res[0], shape[1] // res[1])
+    grid = (
+        torch.stack(
+            torch.meshgrid(
+                torch.arange(0, scalex, delta[0], device=device),
+                torch.arange(0, scaley, delta[1], device=device),
+                indexing="ij",
+            ),
+            dim=-1,
+        )
+        % 1
+    )
 
-    grid = torch.stack(torch.meshgrid(torch.arange(0, res[0], delta[0]), torch.arange(0, res[1], delta[1])), dim=-1) % 1
-    angles = 2 * math.pi * torch.rand(res[0] + 1, res[1] + 1)
+    # Generate random gradients
+    angles = 2 * torch.pi * torch.rand(int(scalex) + 1, int(scaley) + 1, device=device)
     gradients = torch.stack((torch.cos(angles), torch.sin(angles)), dim=-1)
 
-    def tile_grads(slice1, slice2):
+    def tile_grads(slice1: list[int | None], slice2: list[int | None]) -> torch.Tensor:
         return (
             gradients[slice1[0] : slice1[1], slice2[0] : slice2[1]]
-            .repeat_interleave(d[0], 0)
-            .repeat_interleave(d[1], 1)
+            .repeat_interleave(int(d[0]), 0)
+            .repeat_interleave(int(d[1]), 1)
         )
 
-    def dot(grad, shift):
+    def dot(grad: torch.Tensor, shift: list[float]) -> torch.Tensor:
         return (
             torch.stack(
-                (grid[: shape[0], : shape[1], 0] + shift[0], grid[: shape[0], : shape[1], 1] + shift[1]),
+                (grid[:pad_h, :pad_w, 0] + shift[0], grid[:pad_h, :pad_w, 1] + shift[1]),
                 dim=-1,
             )
-            * grad[: shape[0], : shape[1]]
+            * grad[:pad_h, :pad_w]
         ).sum(dim=-1)
 
+    # Calculate noise values at grid points
     n00 = dot(tile_grads([0, -1], [0, -1]), [0, 0])
-
     n10 = dot(tile_grads([1, None], [0, -1]), [-1, 0])
     n01 = dot(tile_grads([0, -1], [1, None]), [0, -1])
     n11 = dot(tile_grads([1, None], [1, None]), [-1, -1])
-    t = fade(grid[: shape[0], : shape[1]])
-    return math.sqrt(2) * torch.lerp(torch.lerp(n00, n10, t[..., 0]), torch.lerp(n01, n11, t[..., 0]), t[..., 1])
-
-
-def rand_perlin_2d_octaves(shape, res, octaves=1, persistence=0.5):
-    """Generate Perlin noise parameterized by the octaves method. PyTorch version."""
-    noise = torch.zeros(shape)
-    frequency = 1
-    amplitude = 1
-    for _ in range(octaves):
-        noise += amplitude * _rand_perlin_2d(shape, (frequency * res[0], frequency * res[1]))
-        frequency *= 2
-        amplitude *= persistence
-    return noise
+
+    # Interpolate between grid points using quintic curve
+    def fade(t: torch.Tensor) -> torch.Tensor:
+        return 6 * t**5 - 15 * t**4 + 10 * t**3
+
+    t = fade(grid[:pad_h, :pad_w])
+    noise = torch.sqrt(torch.tensor(2.0, device=device)) * torch.lerp(
+        torch.lerp(n00, n10, t[..., 0]),
+        torch.lerp(n01, n11, t[..., 0]),
+        t[..., 1],
+    )
+
+    # Crop to desired dimensions
+    return noise[:height, :width]
+
+
+class PerlinAnomalyGenerator(v2.Transform):
+    """Perlin noise-based synthetic anomaly generator.
+
+    Examples:
+        >>> # Single image usage with default parameters
+        >>> transform = PerlinAnomalyGenerator()
+        >>> image = torch.randn(3, 256, 256)  # [C, H, W]
+        >>> augmented_image, anomaly_mask = transform(image)
+        >>> print(augmented_image.shape)  # [C, H, W]
+        >>> print(anomaly_mask.shape)  # [1, H, W]
+
+        >>> # Batch usage with custom parameters
+        >>> transform = PerlinAnomalyGenerator(
+        ...     probability=0.8,
+        ...     blend_factor=0.5
+        ... )
+        >>> batch = torch.randn(4, 3, 256, 256)  # [B, C, H, W]
+        >>> augmented_batch, anomaly_masks = transform(batch)
+        >>> print(augmented_batch.shape)  # [B, C, H, W]
+        >>> print(anomaly_masks.shape)  # [B, 1, H, W]
+
+        >>> # Using anomaly source images
+        >>> transform = PerlinAnomalyGenerator(
+        ...     anomaly_source_path='path/to/anomaly/images',
+        ...     probability=0.7,
+        ...     blend_factor=(0.3, 0.9),
+        ...     rotation_range=(-45, 45)
+        ... )
+        >>> augmented_image, anomaly_mask = transform(image)
+    """
+
+    def __init__(
+        self,
+        anomaly_source_path: str | None = None,
+        probability: float = 0.5,
+        blend_factor: float | tuple[float, float] = (0.2, 1.0),
+        rotation_range: tuple[float, float] = (-90, 90),
+    ) -> None:
+        super().__init__()
+        self.probability = probability
+        self.blend_factor = blend_factor
+
+        # Load anomaly source paths
+        self.anomaly_source_paths: list[Path] = []
+        if anomaly_source_path is not None:
+            for img_ext in IMG_EXTENSIONS:
+                self.anomaly_source_paths.extend(Path(anomaly_source_path).rglob("*" + img_ext))
+
+        # Initialize perlin rotation transform
+        self.perlin_rotation_transform = v2.RandomAffine(
+            degrees=rotation_range,
+            interpolation=v2.InterpolationMode.BILINEAR,
+            fill=0,
+        )
+
+        # Initialize augmenters
+        self.augmenters = MultiRandomChoice(
+            transforms=[
+                v2.ColorJitter(contrast=(0.5, 2.0)),
+                v2.RandomPhotometricDistort(
+                    brightness=(0.8, 1.2),
+                    contrast=(1.0, 1.0),  # No contrast change
+                    saturation=(1.0, 1.0),  # No saturation change
+                    hue=(0.0, 0.0),  # No hue change
+                    p=1.0,
+                ),
+                v2.RandomAdjustSharpness(sharpness_factor=2.0, p=1.0),
+                v2.ColorJitter(hue=[-50 / 360, 50 / 360], saturation=[0.5, 1.5]),
+                v2.RandomSolarize(threshold=torch.empty(1).uniform_(32 / 255, 128 / 255).item(), p=1.0),
+                v2.RandomPosterize(bits=4, p=1.0),
+                v2.RandomInvert(p=1.0),
+                v2.AutoAugment(),
+                v2.RandomEqualize(p=1.0),
+                v2.RandomAffine(degrees=(-45, 45), interpolation=v2.InterpolationMode.BILINEAR, fill=0),
+            ],
+            probabilities=None,
+            num_transforms=3,
+            fixed_num_transforms=True,
+        )
+
+    def generate_perturbation(
+        self,
+        height: int,
+        width: int,
+        device: torch.device | None = None,
+        anomaly_source_path: Path | str | None = None,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Generate perturbed image and mask.
+
+        Args:
+            height: Height of the output image
+            width: Width of the output image
+            device: Device to generate the perturbation on
+            anomaly_source_path: Optional path to source image for anomaly
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: Perturbation and mask tensors
+        """
+        # Generate perlin noise
+        perlin_noise = generate_perlin_noise(height, width, device=device)
+
+        # Create rotated noise pattern
+        perlin_noise = perlin_noise.unsqueeze(0)  # [1, H, W]
+        perlin_noise = self.perlin_rotation_transform(perlin_noise).squeeze(0)  # [H, W]
+
+        # Generate binary mask from perlin noise
+        mask = torch.where(
+            perlin_noise > 0.5,
+            torch.ones_like(perlin_noise, device=device),
+            torch.zeros_like(perlin_noise, device=device),
+        ).unsqueeze(-1)  # [H, W, 1]
+
+        # Generate anomaly source image
+        if anomaly_source_path:
+            anomaly_source_img = (
+                io.read_image(str(anomaly_source_path), mode=io.ImageReadMode.RGB).float().to(device) / 255.0
+            )
+            if anomaly_source_img.shape[-2:] != (height, width):
+                anomaly_source_img = v2.functional.resize(anomaly_source_img, [height, width], antialias=True)
+            anomaly_source_img = anomaly_source_img.permute(1, 2, 0)  # [H, W, C]
+        else:
+            anomaly_source_img = perlin_noise.unsqueeze(-1).repeat(1, 1, 3)  # [H, W, C]
+            anomaly_source_img = (anomaly_source_img * 0.5) + 0.25  # Adjust intensity range
+
+        # Apply augmentations to source image
+        anomaly_augmented = self.augmenters(anomaly_source_img.permute(2, 0, 1))  # [C, H, W]
+        anomaly_augmented = anomaly_augmented.permute(1, 2, 0)  # [H, W, C]
+
+        # Create final perturbation by applying mask
+        perturbation = anomaly_augmented * mask
+
+        return perturbation, mask
+
+    def _transform_image(
+        self,
+        img: torch.Tensor,
+        h: int,
+        w: int,
+        device: torch.device,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Transform a single image."""
+        if torch.rand(1, device=device) > self.probability:
+            return img, torch.zeros((1, h, w), device=device)
+
+        anomaly_source_path = (
+            list(self.anomaly_source_paths)[int(torch.randint(len(self.anomaly_source_paths), (1,)).item())]
+            if self.anomaly_source_paths
+            else None
+        )
+
+        perturbation, mask = self.generate_perturbation(h, w, device, anomaly_source_path)
+        perturbation = perturbation.permute(2, 0, 1)
+        mask = mask.permute(2, 0, 1)
+
+        beta = (
+            self.blend_factor
+            if isinstance(self.blend_factor, float)
+            else torch.rand(1, device=device) * (self.blend_factor[1] - self.blend_factor[0]) + self.blend_factor[0]
+            if isinstance(self.blend_factor, tuple)
+            # Add type guard
+            else torch.tensor(0.5, device=device)  # Fallback value
+        )
+
+        if not isinstance(beta, float):
+            beta = beta.view(-1, 1, 1).expand_as(img)
+
+        augmented_img = img * (1 - mask) + beta * perturbation + (1 - beta) * img * mask
+        return augmented_img, mask
+
+    def forward(self, img: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        """Apply augmentation using the mask for single image or batch."""
+        device = img.device
+        is_batch = len(img.shape) == 4
+
+        if is_batch:
+            batch, _, height, width = img.shape
+            # Initialize batch outputs
+            batch_augmented = []
+            batch_masks = []
+
+            for i in range(batch):
+                # Apply transform to each image in batch
+                augmented, mask = self._transform_image(img[i], height, width, device)
+                batch_augmented.append(augmented)
+                batch_masks.append(mask)
+
+            return torch.stack(batch_augmented), torch.stack(batch_masks)
+
+        # Handle single image
+        return self._transform_image(img, img.shape[1], img.shape[2], device)
diff --git a/src/anomalib/data/utils/synthetic.py b/src/anomalib/data/utils/synthetic.py
index 16aa20d83d..7d2b340e33 100644
--- a/src/anomalib/data/utils/synthetic.py
+++ b/src/anomalib/data/utils/synthetic.py
@@ -20,7 +20,8 @@
 
 from anomalib import TaskType
 from anomalib.data.datasets.base.image import AnomalibDataset
-from anomalib.data.utils import Augmenter, Split, read_image
+from anomalib.data.utils import Split, read_image
+from anomalib.data.utils.generators.perlin import PerlinAnomalyGenerator
 
 logger = logging.getLogger(__name__)
 
@@ -66,7 +67,7 @@ def make_synthetic_dataset(
     anomalous_samples = anomalous_samples.reset_index(drop=True)
 
     # initialize augmenter
-    augmenter = Augmenter("./datasets/dtd", p_anomalous=1.0, beta=(0.01, 0.2))
+    augmenter = PerlinAnomalyGenerator(anomaly_source_path="./datasets/dtd", probability=1.0, blend_factor=(0.01, 0.2))
 
     def augment(sample: Series) -> Series:
         """Apply synthetic anomalous augmentation to a sample from a dataframe.
@@ -83,7 +84,7 @@ def augment(sample: Series) -> Series:
         # read and transform image
         image = read_image(sample.image_path, as_tensor=True)
         # apply anomalous perturbation
-        aug_im, mask = augmenter.augment_batch(image.unsqueeze(0))
+        aug_im, mask = augmenter(image)
         # target file name with leading zeros
         file_name = f"{str(sample.name).zfill(int(math.log10(n_anomalous)) + 1)}.png"
         # write image
diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py
index dd02fd168a..66e87a904b 100644
--- a/src/anomalib/models/image/draem/lightning_model.py
+++ b/src/anomalib/models/image/draem/lightning_model.py
@@ -16,7 +16,7 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
-from anomalib.data.utils import Augmenter
+from anomalib.data.utils.generators.perlin import PerlinAnomalyGenerator
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
@@ -56,7 +56,7 @@ def __init__(
     ) -> None:
         super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
 
-        self.augmenter = Augmenter(anomaly_source_path, beta=beta)
+        self.augmenter = PerlinAnomalyGenerator(anomaly_source_path=anomaly_source_path, blend_factor=beta)
         self.model = DraemModel(sspcab=enable_sspcab)
         self.loss = DraemLoss()
         self.sspcab = enable_sspcab
@@ -110,7 +110,7 @@ def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
         input_image = batch.image
         # Apply corruption to input image
-        augmented_image, anomaly_mask = self.augmenter.augment_batch(input_image)
+        augmented_image, anomaly_mask = self.augmenter(input_image)
         # Generate model prediction
         reconstruction, prediction = self.model(augmented_image)
         # Compute loss
diff --git a/src/anomalib/models/image/dsr/anomaly_generator.py b/src/anomalib/models/image/dsr/anomaly_generator.py
index 396019de39..9bb262500c 100644
--- a/src/anomalib/models/image/dsr/anomaly_generator.py
+++ b/src/anomalib/models/image/dsr/anomaly_generator.py
@@ -3,12 +3,11 @@
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import imgaug.augmenters as iaa
-import numpy as np
 import torch
 from torch import Tensor, nn
+from torchvision.transforms import v2
 
-from anomalib.data.utils.generators.perlin import _rand_perlin_2d_np
+from anomalib.data.utils.generators.perlin import generate_perlin_noise
 
 
 class DsrAnomalyGenerator(nn.Module):
@@ -29,7 +28,8 @@ def __init__(
         super().__init__()
 
         self.p_anomalous = p_anomalous
-        self.rot = iaa.Sequential([iaa.Affine(rotate=(-90, 90))])
+        # Replace imgaug with torchvision transform
+        self.rot = v2.RandomAffine(degrees=(-90, 90))
 
     def generate_anomaly(self, height: int, width: int) -> Tensor:
         """Generate an anomalous mask.
@@ -43,15 +43,20 @@ def generate_anomaly(self, height: int, width: int) -> Tensor:
         """
         min_perlin_scale = 0
         perlin_scale = 6
-        perlin_scalex = 2 ** (torch.randint(min_perlin_scale, perlin_scale, (1,)).numpy()[0])
-        perlin_scaley = 2 ** (torch.randint(min_perlin_scale, perlin_scale, (1,)).numpy()[0])
+        perlin_scalex = int(2 ** torch.randint(min_perlin_scale, perlin_scale, (1,)).item())
+        perlin_scaley = int(2 ** torch.randint(min_perlin_scale, perlin_scale, (1,)).item())
         threshold = 0.5
-        perlin_noise_np = _rand_perlin_2d_np((height, width), (perlin_scalex, perlin_scaley))
-        perlin_noise_np = self.rot(image=perlin_noise_np)
-        mask = np.where(perlin_noise_np > threshold, np.ones_like(perlin_noise_np), np.zeros_like(perlin_noise_np))
-        mask = np.expand_dims(mask, axis=2).astype(np.float32)
 
-        return torch.from_numpy(mask)
+        # Generate perlin noise using the new function
+        perlin_noise = generate_perlin_noise(height, width, scale=(perlin_scalex, perlin_scaley))
+
+        # Apply random rotation
+        perlin_noise = perlin_noise.unsqueeze(0)  # Add channel dimension for transform
+        perlin_noise = self.rot(perlin_noise).squeeze(0)  # Remove channel dimension
+
+        # Create binary mask
+        mask = (perlin_noise > threshold).float()
+        return mask.unsqueeze(0)  # Add channel dimension [1, H, W]
 
     def augment_batch(self, batch: Tensor) -> Tensor:
         """Generate anomalous augmentations for a batch of input images.
@@ -71,6 +76,6 @@ def augment_batch(self, batch: Tensor) -> Tensor:
                 masks_list.append(torch.zeros((1, height, width)))
             else:
                 mask = self.generate_anomaly(height, width)
-                masks_list.append(mask.permute((2, 0, 1)))
+                masks_list.append(mask)
 
         return torch.stack(masks_list).to(batch.device)
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index 23daa6b95d..8aa3de08e2 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -17,7 +17,7 @@
 from anomalib import LearningType
 from anomalib.data import Batch
 from anomalib.data.utils import DownloadInfo, download_and_extract
-from anomalib.data.utils.augmenter import Augmenter
+from anomalib.data.utils.generators.perlin import PerlinAnomalyGenerator
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalibModule
 from anomalib.models.image.dsr.anomaly_generator import DsrAnomalyGenerator
@@ -62,7 +62,7 @@ def __init__(
         self.upsampling_train_ratio = upsampling_train_ratio
 
         self.quantized_anomaly_generator = DsrAnomalyGenerator()
-        self.perlin_generator = Augmenter()
+        self.perlin_generator = PerlinAnomalyGenerator()
         self.model = DsrModel(latent_anomaly_strength)
         self.second_stage_loss = DsrSecondStageLoss()
         self.third_stage_loss = DsrThirdStageLoss()
@@ -158,7 +158,7 @@ def training_step(self, batch: Batch) -> STEP_OUTPUT:
             # we are training the upsampling module
             input_image = batch.image
             # Generate anomalies
-            input_image, anomaly_maps = self.perlin_generator.augment_batch(input_image)
+            input_image, anomaly_maps = self.perlin_generator(input_image)
             # Get model prediction
             model_outputs = self.model(input_image)
             # Calculate loss
diff --git a/tests/helpers/data.py b/tests/helpers/data.py
index 60433df9eb..e1efccc1b1 100644
--- a/tests/helpers/data.py
+++ b/tests/helpers/data.py
@@ -18,7 +18,8 @@
 from skimage.io import imsave
 
 from anomalib.data import DataFormat
-from anomalib.data.utils import Augmenter, LabelName
+from anomalib.data.utils import LabelName
+from anomalib.data.utils.generators.perlin import PerlinAnomalyGenerator
 
 
 class DummyImageGenerator:
@@ -47,7 +48,7 @@ class DummyImageGenerator:
 
     def __init__(self, image_shape: tuple[int, int] = (256, 256), rng: np.random.Generator | None = None) -> None:
         self.image_shape = image_shape
-        self.augmenter = Augmenter()
+        self.augmenter = PerlinAnomalyGenerator()
         self.rng = rng if rng else np.random.default_rng()
 
     def generate_normal_image(self) -> tuple[np.ndarray, np.ndarray]:
@@ -72,6 +73,8 @@ def generate_abnormal_image(self, beta: float = 0.2) -> tuple[np.ndarray, np.nda
 
         # Generate perturbation.
         perturbation, mask = self.augmenter.generate_perturbation(height=self.image_shape[0], width=self.image_shape[1])
+        perturbation = perturbation.cpu().numpy()
+        mask = mask.cpu().numpy()
 
         # Superimpose perturbation on image ``img``.
         abnormal_image = (image * (1 - mask) + (beta) * perturbation + (1 - beta) * image * (mask)).astype(np.uint8)
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index 464c2cb1da..e78ad19fe0 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -6,6 +6,9 @@
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+import contextlib
+import sys
+from collections.abc import Generator
 from pathlib import Path
 from unittest.mock import MagicMock
 
@@ -28,6 +31,17 @@ def export_types() -> list[ExportType]:
     return list(ExportType)
 
 
+@contextlib.contextmanager
+def increased_recursion_limit(limit: int = 10000) -> Generator[None, None, None]:
+    """Temporarily increase the recursion limit."""
+    old_limit = sys.getrecursionlimit()
+    try:
+        sys.setrecursionlimit(limit)
+        yield
+    finally:
+        sys.setrecursionlimit(old_limit)
+
+
 class TestAPI:
     """Do sanity check on all models."""
 
@@ -154,11 +168,14 @@ def test_export(
             dataset_path=dataset_path,
             project_path=project_path,
         )
-        engine.export(
-            model=model,
-            ckpt_path=f"{project_path}/{model.name}/{dataset.name}/dummy/v0/weights/lightning/model.ckpt",
-            export_type=export_type,
-        )
+
+        # Use context manager only for CSFlow
+        with increased_recursion_limit() if model_name == "csflow" else contextlib.nullcontext():
+            engine.export(
+                model=model,
+                ckpt_path=f"{project_path}/{model.name}/{dataset.name}/dummy/v0/weights/lightning/model.ckpt",
+                export_type=export_type,
+            )
 
     @staticmethod
     def _get_objects(
diff --git a/tests/unit/data/validators/numpy/test_image.py b/tests/unit/data/validators/numpy/test_image.py
index 008bc4dff6..e81793aeb7 100644
--- a/tests/unit/data/validators/numpy/test_image.py
+++ b/tests/unit/data/validators/numpy/test_image.py
@@ -180,12 +180,13 @@ def test_validate_gt_label_none(self) -> None:
         """Test validation of None ground truth labels."""
         assert self.validator.validate_gt_label(None) is None
 
-    def test_validate_gt_label_valid_string_input(self) -> None:
-        """Test validation of ground truth labels with string input."""
-        validated_labels = self.validator.validate_gt_label(["0", "1"])
+    def test_validate_gt_label_valid_sequence(self) -> None:
+        """Test validation of ground truth labels with sequence input."""
+        # Test with binary labels (0: normal, 1: anomaly)
+        validated_labels = self.validator.validate_gt_label([0, 1, 1, 0])
         assert isinstance(validated_labels, np.ndarray)
         assert validated_labels.dtype == bool
-        assert np.array_equal(validated_labels, np.array([False, True]))
+        assert np.array_equal(validated_labels, np.array([False, True, True, False]))
 
     def test_validate_gt_label_invalid_dimensions(self) -> None:
         """Test validation of ground truth labels with invalid dimensions."""
diff --git a/tests/unit/data/validators/numpy/test_video.py b/tests/unit/data/validators/numpy/test_video.py
index abf29d31d9..675a462630 100644
--- a/tests/unit/data/validators/numpy/test_video.py
+++ b/tests/unit/data/validators/numpy/test_video.py
@@ -76,6 +76,15 @@ def test_validate_target_frame_negative(self) -> None:
         with pytest.raises(ValueError, match="Target frame index must be non-negative"):
             self.validator.validate_target_frame(-1)
 
+    def test_validate_gt_label_valid(self) -> None:
+        """Test validation of a valid ground truth label."""
+        # Test with binary label (0: normal, 1: anomaly)
+        label = 1
+        validated_label = self.validator.validate_gt_label(label)
+        assert isinstance(validated_label, np.ndarray)
+        assert validated_label.dtype == bool
+        assert validated_label.item() is True
+
 
 class TestNumpyVideoBatchValidator:
     """Test NumpyVideoBatchValidator."""
@@ -141,14 +150,21 @@ def test_validate_gt_label_none(self) -> None:
         """Test validation of None ground truth labels."""
         assert self.validator.validate_gt_label(None) is None
 
-    def test_validate_gt_label_invalid_type(self) -> None:
-        """Test validation of ground truth labels with invalid type."""
-        validated_labels = self.validator.validate_gt_label(["0", "1"])
-        assert validated_labels is not None
+    def test_validate_gt_label_valid_sequence(self) -> None:
+        """Test validation of ground truth labels with sequence input."""
+        # Test with binary labels (0: normal, 1: anomaly)
+        labels = [0, 1]
+        validated_labels = self.validator.validate_gt_label(labels)
         assert isinstance(validated_labels, np.ndarray)
         assert validated_labels.dtype == bool
         assert np.array_equal(validated_labels, np.array([False, True]))
 
+    def test_validate_gt_label_invalid_type(self) -> None:
+        """Test validation of ground truth labels with invalid type."""
+        # Test with a non-sequence, non-array type
+        with pytest.raises(TypeError, match="Ground truth label batch must be a numpy.ndarray"):
+            self.validator.validate_gt_label(3.14)
+
     def test_validate_gt_label_invalid_dimensions(self) -> None:
         """Test validation of ground truth labels with invalid dimensions."""
         with pytest.raises(ValueError, match="Ground truth label batch must be 1-dimensional, got shape \\(2, 2\\)"):
diff --git a/tests/unit/metrics/test_pro.py b/tests/unit/metrics/test_pro.py
index 21f26c3349..fe6e149cb1 100644
--- a/tests/unit/metrics/test_pro.py
+++ b/tests/unit/metrics/test_pro.py
@@ -6,7 +6,7 @@
 import torch
 from torchvision.transforms import RandomAffine
 
-from anomalib.data.utils import random_2d_perlin
+from anomalib.data.utils.generators.perlin import generate_perlin_noise
 from anomalib.metrics.pro import _PRO as PRO
 from anomalib.metrics.pro import connected_components_cpu, connected_components_gpu
 
@@ -50,7 +50,7 @@ def test_device_consistency() -> None:
 
     batch = torch.zeros((32, 256, 256))
     for i in range(batch.shape[0]):
-        batch[i, ...] = random_2d_perlin((256, 256), (torch.tensor(4), torch.tensor(4))) > 0.5
+        batch[i, ...] = generate_perlin_noise(256, 256, scale=(4, 4)) > 0.5
     # ground truth mask is int type
     batch = batch.type(torch.int32)
 
@@ -70,7 +70,7 @@ def test_connected_component_labeling() -> None:
     # generate batch of random binary images using perlin noise
     batch = torch.zeros((32, 1, 256, 256))
     for i in range(batch.shape[0]):
-        batch[i, ...] = random_2d_perlin((256, 256), (torch.tensor(4), torch.tensor(4))) > 0.5
+        batch[i, ...] = generate_perlin_noise(256, 256, scale=(4, 4)) > 0.5
 
     # get connected component results on both cpu and gpu
     cc_cpu = connected_components_cpu(batch.cpu())

From 00b01b1f1a58cf8fb141446e0f7fc7e06e18c37e Mon Sep 17 00:00:00 2001
From: Dick Ameln 
Date: Thu, 5 Dec 2024 14:26:01 +0100
Subject: [PATCH 15/45] [V2]: Remove task type (#2450)

* remove task type

* remove task type

* fix unit tests

* fix integration tests

* update getting started notebook

* remove task type from data notebooks

* remove task type from model notebooks

* remove task type from logger notebooks

* remove task type from metric notebooks
---
 configs/data/folder.yaml                      |   1 -
 configs/data/mvtec.yaml                       |   1 -
 configs/model/ai_vad.yaml                     |   2 -
 configs/model/dfkde.yaml                      |   2 -
 configs/model/ganomaly.yaml                   |   2 -
 configs/model/rkde.yaml                       |   2 -
 .../001_getting_started.ipynb                 | 459 ++----------------
 notebooks/100_datamodules/101_btech.ipynb     |  96 +---
 notebooks/100_datamodules/102_mvtec.ipynb     |  91 +---
 notebooks/100_datamodules/103_folder.ipynb    |  94 ++--
 notebooks/200_models/201_fastflow.ipynb       |  26 +-
 .../600_loggers/601_mlflow_logging.ipynb      |   6 +-
 notebooks/700_metrics/701a_aupimo.ipynb       |  11 +-
 .../700_metrics/701b_aupimo_advanced_i.ipynb  |  15 +-
 .../700_metrics/701c_aupimo_advanced_ii.ipynb |   3 -
 src/anomalib/cli/cli.py                       |   9 +-
 src/anomalib/data/datamodules/base/image.py   |  13 +
 .../data/datamodules/depth/folder_3d.py       |   7 -
 .../data/datamodules/depth/mvtec_3d.py        |   7 -
 src/anomalib/data/datamodules/image/btech.py  |   7 -
 .../data/datamodules/image/datumaro.py        |  10 -
 src/anomalib/data/datamodules/image/folder.py |  17 -
 .../data/datamodules/image/kolektor.py        |   7 -
 src/anomalib/data/datamodules/image/mvtec.py  |   7 -
 src/anomalib/data/datamodules/image/visa.py   |   7 -
 src/anomalib/data/datamodules/video/avenue.py |  11 +-
 .../data/datamodules/video/shanghaitech.py    |   6 -
 .../data/datamodules/video/ucsd_ped.py        |   6 -
 src/anomalib/data/datasets/base/depth.py      |   5 +-
 src/anomalib/data/datasets/base/image.py      |  21 +-
 src/anomalib/data/datasets/base/video.py      |   5 +-
 src/anomalib/data/datasets/depth/folder_3d.py |  12 +-
 src/anomalib/data/datasets/depth/mvtec_3d.py  |   8 +-
 src/anomalib/data/datasets/image/btech.py     |  10 +-
 src/anomalib/data/datasets/image/datumaro.py  |   7 +-
 src/anomalib/data/datasets/image/folder.py    |  13 +-
 src/anomalib/data/datasets/image/kolektor.py  |   7 +-
 src/anomalib/data/datasets/image/mvtec.py     |   8 +-
 src/anomalib/data/datasets/image/visa.py      |  31 +-
 src/anomalib/data/datasets/video/avenue.py    |  32 +-
 .../data/datasets/video/shanghaitech.py       |   7 +-
 src/anomalib/data/datasets/video/ucsd_ped.py  |   7 +-
 src/anomalib/data/utils/synthetic.py          |   8 +-
 src/anomalib/engine/engine.py                 |  44 +-
 .../models/components/base/anomaly_module.py  |   3 -
 .../models/components/base/export_mixin.py    |  11 +-
 tests/integration/cli/test_cli.py             |   2 -
 tests/integration/model/test_models.py        |   7 -
 .../tools/upgrade/expected_draem_v1.yaml      |   2 -
 .../data/datamodule/depth/test_folder_3d.py   |   4 +-
 .../data/datamodule/depth/test_mvtec_3d.py    |   4 +-
 .../unit/data/datamodule/image/test_btech.py  |   4 +-
 .../data/datamodule/image/test_datumaro.py    |   7 +-
 .../unit/data/datamodule/image/test_folder.py |   7 +-
 .../data/datamodule/image/test_kolektor.py    |   4 +-
 .../unit/data/datamodule/image/test_mvtec.py  |   4 +-
 tests/unit/data/datamodule/image/test_visa.py |   4 +-
 .../unit/data/datamodule/video/test_avenue.py |   4 +-
 .../datamodule/video/test_shanghaitech.py     |   4 +-
 .../data/datamodule/video/test_ucsdped.py     |   4 +-
 tests/unit/data/utils/test_synthetic.py       |   3 -
 tests/unit/deploy/test_inferencer.py          |  24 +-
 tests/unit/engine/test_engine.py              |   7 +-
 .../visualizer_callback/test_visualizer.py    |   7 +-
 tests/unit/utils/test_visualizer.py           |   7 +-
 tools/upgrade/config.py                       |   5 -
 66 files changed, 215 insertions(+), 1063 deletions(-)

diff --git a/configs/data/folder.yaml b/configs/data/folder.yaml
index 76be1382a7..705d83051f 100644
--- a/configs/data/folder.yaml
+++ b/configs/data/folder.yaml
@@ -11,7 +11,6 @@ init_args:
   train_batch_size: 32
   eval_batch_size: 32
   num_workers: 8
-  task: segmentation
   test_split_mode: from_dir
   test_split_ratio: 0.2
   val_split_mode: same_as_test
diff --git a/configs/data/mvtec.yaml b/configs/data/mvtec.yaml
index 5fb206e144..78c8a5c01c 100644
--- a/configs/data/mvtec.yaml
+++ b/configs/data/mvtec.yaml
@@ -5,7 +5,6 @@ init_args:
   train_batch_size: 32
   eval_batch_size: 32
   num_workers: 8
-  task: segmentation
   test_split_mode: from_dir
   test_split_ratio: 0.2
   val_split_mode: same_as_test
diff --git a/configs/model/ai_vad.yaml b/configs/model/ai_vad.yaml
index b799299330..79803a366a 100644
--- a/configs/model/ai_vad.yaml
+++ b/configs/model/ai_vad.yaml
@@ -17,5 +17,3 @@ model:
     n_components_velocity: 2
     n_neighbors_pose: 1
     n_neighbors_deep: 1
-
-task: detection
diff --git a/configs/model/dfkde.yaml b/configs/model/dfkde.yaml
index a241bd55cc..29716d0327 100644
--- a/configs/model/dfkde.yaml
+++ b/configs/model/dfkde.yaml
@@ -8,5 +8,3 @@ model:
     n_pca_components: 16
     feature_scaling_method: SCALE
     max_training_points: 40000
-
-task: CLASSIFICATION
diff --git a/configs/model/ganomaly.yaml b/configs/model/ganomaly.yaml
index 0b84d9b960..4bc9c730bc 100644
--- a/configs/model/ganomaly.yaml
+++ b/configs/model/ganomaly.yaml
@@ -13,8 +13,6 @@ model:
     beta1: 0.5
     beta2: 0.999
 
-task: CLASSIFICATION
-
 trainer:
   max_epochs: 100
   callbacks:
diff --git a/configs/model/rkde.yaml b/configs/model/rkde.yaml
index b421ffed7d..36ca63c261 100644
--- a/configs/model/rkde.yaml
+++ b/configs/model/rkde.yaml
@@ -9,5 +9,3 @@ model:
     n_pca_components: 16
     feature_scaling_method: SCALE
     max_training_points: 40000
-
-task: detection
diff --git a/notebooks/000_getting_started/001_getting_started.ipynb b/notebooks/000_getting_started/001_getting_started.ipynb
index a13261e2ff..664aaa2116 100644
--- a/notebooks/000_getting_started/001_getting_started.ipynb
+++ b/notebooks/000_getting_started/001_getting_started.ipynb
@@ -45,7 +45,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:18:56.096138098Z",
@@ -80,7 +80,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:18:56.101357180Z",
@@ -106,7 +106,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:18:56.112607883Z",
@@ -149,7 +149,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:18:56.112848196Z",
@@ -165,7 +165,6 @@
     "from PIL import Image\n",
     "from torchvision.transforms import ToPILImage\n",
     "\n",
-    "from anomalib import TaskType\n",
     "from anomalib.data import MVTec\n",
     "from anomalib.data.utils import read_image\n",
     "from anomalib.deploy import ExportType, OpenVINOInferencer\n",
@@ -214,22 +213,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:18:57.203133970Z",
      "start_time": "2024-01-26T12:18:56.111365813Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "datamodule = MVTec(num_workers=0)\n",
     "datamodule.prepare_data()  # Downloads the dataset if it's not in the specified `root` directory\n",
@@ -249,22 +240,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:18:57.203997320Z",
      "start_time": "2024-01-26T12:18:57.202960908Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "torch.Size([32, 3, 900, 900]) torch.Size([32, 900, 900])\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(data.image.shape, data.gt_mask.shape)"
    ]
@@ -279,27 +262,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:18:57.312944404Z",
      "start_time": "2024-01-26T12:18:57.203237964Z"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "def show_image_and_mask(sample: dict[str, Any], index: int) -> Image:\n",
     "    \"\"\"Show an image with a mask.\n",
@@ -340,7 +310,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:18:57.633634551Z",
@@ -356,147 +326,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:03.278278808Z",
      "start_time": "2024-01-26T12:18:57.635288644Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Trainer already configured with model summary callbacks: []. Skipping setting a default `ModelSummary` callback.\n",
-      "GPU available: True (cuda), used: True\n",
-      "TPU available: False, using: 0 TPU cores\n",
-      "HPU available: False, using: 0 HPUs\n",
-      "`Trainer(val_check_interval=1.0)` was configured so validation will run at the end of the training epoch..\n",
-      "You are using a CUDA device ('NVIDIA GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n",
-      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n",
-      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/lightning/pytorch/core/optimizer.py:182: `LightningModule.configure_optimizers` returned `None`, this fit will run with no optimizer\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
┏━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┓\n",
-       "┃   ┃ Name           ┃ Type                     ┃ Params ┃ Mode  ┃\n",
-       "┡━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━┩\n",
-       "│ 0 │ post_processor │ OneClassPostProcessor    │      0 │ train │\n",
-       "│ 1 │ model          │ PadimModel               │  2.8 M │ train │\n",
-       "│ 2 │ _transform     │ Compose                  │      0 │ train │\n",
-       "│ 3 │ image_metrics  │ AnomalibMetricCollection │      0 │ train │\n",
-       "│ 4 │ pixel_metrics  │ AnomalibMetricCollection │      0 │ train │\n",
-       "└───┴────────────────┴──────────────────────────┴────────┴───────┘\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "┏━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━┓\n",
-       "┃\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mName          \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mType                    \u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mParams\u001b[0m\u001b[1;35m \u001b[0m┃\u001b[1;35m \u001b[0m\u001b[1;35mMode \u001b[0m\u001b[1;35m \u001b[0m┃\n",
-       "┡━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━┩\n",
-       "│\u001b[2m \u001b[0m\u001b[2m0\u001b[0m\u001b[2m \u001b[0m│ post_processor │ OneClassPostProcessor    │      0 │ train │\n",
-       "│\u001b[2m \u001b[0m\u001b[2m1\u001b[0m\u001b[2m \u001b[0m│ model          │ PadimModel               │  2.8 M │ train │\n",
-       "│\u001b[2m \u001b[0m\u001b[2m2\u001b[0m\u001b[2m \u001b[0m│ _transform     │ Compose                  │      0 │ train │\n",
-       "│\u001b[2m \u001b[0m\u001b[2m3\u001b[0m\u001b[2m \u001b[0m│ image_metrics  │ AnomalibMetricCollection │      0 │ train │\n",
-       "│\u001b[2m \u001b[0m\u001b[2m4\u001b[0m\u001b[2m \u001b[0m│ pixel_metrics  │ AnomalibMetricCollection │      0 │ train │\n",
-       "└───┴────────────────┴──────────────────────────┴────────┴───────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
Trainable params: 2.8 M                                                                                            \n",
-       "Non-trainable params: 0                                                                                            \n",
-       "Total params: 2.8 M                                                                                                \n",
-       "Total estimated model params size (MB): 11                                                                         \n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\u001b[1mTrainable params\u001b[0m: 2.8 M                                                                                            \n",
-       "\u001b[1mNon-trainable params\u001b[0m: 0                                                                                            \n",
-       "\u001b[1mTotal params\u001b[0m: 2.8 M                                                                                                \n",
-       "\u001b[1mTotal estimated model params size (MB)\u001b[0m: 11                                                                         \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "37c9772db61c4235b4295039e632ce64",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Output()"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:424: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=35` in the `DataLoader` to improve performance.\n",
-      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:424: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=35` in the `DataLoader` to improve performance.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
/home/djameln/anomalib/.venv/lib/python3.10/site-packages/lightning/pytorch/loops/optimization/automatic.py:132: \n",
-       "`training_step` returned `None`. If this was on purpose, ignore this warning...\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/lightning/pytorch/loops/optimization/automatic.py:132: \n",
-       "`training_step` returned `None`. If this was on purpose, ignore this warning...\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "`Trainer.fit` stopped: `max_epochs=1` reached.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# start training\n",
-    "engine = Engine(task=TaskType.SEGMENTATION)\n",
+    "engine = Engine()\n",
     "engine.fit(model=model, datamodule=datamodule)"
    ]
   },
@@ -510,95 +350,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:05.567521337Z",
      "start_time": "2024-01-26T12:19:03.280992538Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Restoring states from the checkpoint path at /home/djameln/anomalib/results/Padim/MVTec/bottle/v5/weights/lightning/model.ckpt\n",
-      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n",
-      "Loaded model weights from the checkpoint at /home/djameln/anomalib/results/Padim/MVTec/bottle/v5/weights/lightning/model.ckpt\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "29cc1011024b4ee39e6ffb0339ec307c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Output()"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:424: The 'test_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=35` in the `DataLoader` to improve performance.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃        Test metric        ┃       DataLoader 0        ┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│        image_AUROC        │     0.997619092464447     │\n",
-       "│        image_F1Max        │         0.984375          │\n",
-       "│        pixel_AUROC        │    0.9841534495353699     │\n",
-       "│        pixel_F1Max        │    0.7346382737159729     │\n",
-       "└───────────────────────────┴───────────────────────────┘\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       image_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m    0.997619092464447    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       image_F1Max       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m        0.984375         \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       pixel_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.9841534495353699    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       pixel_F1Max       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m   0.7346382737159729    \u001b[0m\u001b[35m \u001b[0m│\n",
-       "└───────────────────────────┴───────────────────────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# load best model from checkpoint before evaluating\n",
     "test_results = engine.test(\n",
@@ -610,17 +369,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[{'pixel_AUROC': 0.9841534495353699, 'pixel_F1Max': 0.7346382737159729, 'image_AUROC': 0.997619092464447, 'image_F1Max': 0.984375}]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(test_results)"
    ]
@@ -644,43 +395,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:06.645604243Z",
      "start_time": "2024-01-26T12:19:05.569089932Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/torch/onnx/utils.py:2078: UserWarning: Provided key output for dynamic axes is not a valid input/output name\n",
-      "  warnings.warn(\n",
-      "/home/djameln/anomalib/src/anomalib/post_processing/one_class.py:151: TracerWarning: torch.tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n",
-      "  preds = torch.minimum(preds, torch.tensor(1))\n",
-      "/home/djameln/anomalib/src/anomalib/post_processing/one_class.py:152: TracerWarning: torch.tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n",
-      "  return torch.maximum(preds, torch.tensor(0))\n",
-      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/torch/onnx/_internal/jit_utils.py:307: UserWarning: Constant folding - Only steps=1 can be constant folded for opset >= 10 onnx::Slice op. Constant folding not applied. (Triggered internally at ../torch/csrc/jit/passes/onnx/constant_fold.cpp:179.)\n",
-      "  _C._jit_pass_onnx_node_shape_type_inference(node, params_dict, opset_version)\n",
-      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/torch/onnx/utils.py:702: UserWarning: Constant folding - Only steps=1 can be constant folded for opset >= 10 onnx::Slice op. Constant folding not applied. (Triggered internally at ../torch/csrc/jit/passes/onnx/constant_fold.cpp:179.)\n",
-      "  _C._jit_pass_onnx_graph_shape_type_inference(\n",
-      "/home/djameln/anomalib/.venv/lib/python3.10/site-packages/torch/onnx/utils.py:1209: UserWarning: Constant folding - Only steps=1 can be constant folded for opset >= 10 onnx::Slice op. Constant folding not applied. (Triggered internally at ../torch/csrc/jit/passes/onnx/constant_fold.cpp:179.)\n",
-      "  _C._jit_pass_onnx_graph_shape_type_inference(\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "PosixPath('/home/djameln/anomalib/results/Padim/MVTec/bottle/latest/weights/openvino/model.xml')"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "engine.export(\n",
     "    model=model,\n",
@@ -700,25 +422,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:06.867644218Z",
      "start_time": "2024-01-26T12:19:06.646217079Z"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "image_path = root_directory / \"datasets/MVTec/bottle/test/broken_large/000.png\"\n",
     "image = read_image(path=\"./datasets/MVTec/bottle/test/broken_large/000.png\")\n",
@@ -737,22 +448,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:06.869599561Z",
      "start_time": "2024-01-26T12:19:06.866628785Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/home/djameln/anomalib/results/Padim/MVTec/bottle/latest\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "output_path = Path(engine.trainer.default_root_dir)\n",
     "print(output_path)"
@@ -760,22 +463,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:06.880794392Z",
      "start_time": "2024-01-26T12:19:06.868965582Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "True\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "openvino_model_path = output_path / \"weights\" / \"openvino\" / \"model.bin\"\n",
     "print(openvino_model_path.exists())"
@@ -783,7 +478,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.127278601Z",
@@ -810,7 +505,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.221219176Z",
@@ -828,7 +523,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "where `predictions` contain any relevant information regarding the task type. For example, predictions for a segmentation model could contain image, anomaly maps, predicted scores, labels or masks.\n"
+    "where `predictions` contain any inputs and outputs of the model, such as image, anomaly maps, predicted scores, labels or masks.\n"
    ]
   },
   {
@@ -841,47 +536,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.222396309Z",
      "start_time": "2024-01-26T12:19:07.214650568Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.7244761 [ True]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(predictions.pred_score, predictions.pred_label)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.347717385Z",
      "start_time": "2024-01-26T12:19:07.214884777Z"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Visualize the original image\n",
     "plt.imshow(predictions.image)"
@@ -889,25 +565,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.471919621Z",
      "start_time": "2024-01-26T12:19:07.346789142Z"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Visualize the raw anomaly maps predicted by the model.\n",
     "plt.imshow(predictions.anomaly_map)"
@@ -915,25 +580,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.644440308Z",
      "start_time": "2024-01-26T12:19:07.479955777Z"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Visualize the heatmaps, on which raw anomaly map is overlayed on the original image.\n",
     "plt.imshow(predictions.heat_map)"
@@ -941,25 +595,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.759913041Z",
      "start_time": "2024-01-26T12:19:07.644757570Z"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Visualize the segmentation mask.\n",
     "plt.imshow(predictions.pred_mask)"
@@ -967,25 +610,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2024-01-26T12:19:07.925019564Z",
      "start_time": "2024-01-26T12:19:07.762215888Z"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Visualize the segmentation mask with the original image.\n",
     "plt.imshow(predictions.segmentations)"
@@ -1002,7 +634,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "anomalib",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -1018,12 +650,7 @@
    "pygments_lexer": "ipython3",
    "version": "3.10.14"
   },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "ae223df28f60859a2f400fae8b3a1034248e0a469f5599fd9a89c32908ed7a84"
-   }
-  }
+  "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 2
diff --git a/notebooks/100_datamodules/101_btech.ipynb b/notebooks/100_datamodules/101_btech.ipynb
index 2b87763ff0..cd980fc56e 100644
--- a/notebooks/100_datamodules/101_btech.ipynb
+++ b/notebooks/100_datamodules/101_btech.ipynb
@@ -109,7 +109,6 @@
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=0,\n",
-    "    task=TaskType.SEGMENTATION,\n",
     ")"
    ]
   },
@@ -228,7 +227,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Classification Task\n"
+    "Now let's create the dataset, we'll start with the training subset."
    ]
   },
   {
@@ -238,49 +237,14 @@
    "outputs": [],
    "source": [
     "# BTechDataset Classification Train Set\n",
-    "btech_dataset_classification_train = BTechDataset(\n",
+    "btech_dataset_train = BTechDataset(\n",
     "    root=dataset_root,\n",
     "    category=\"01\",\n",
     "    transform=transform,\n",
     "    split=\"train\",\n",
-    "    task=TaskType.CLASSIFICATION,\n",
     ")\n",
-    "btech_dataset_classification_train.samples.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sample = btech_dataset_classification_train[0]\n",
-    "print(sample.image.shape)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As can be seen above, when we choose `classification` task and `train` split, the dataset only returns `image`. This is mainly because training only requires normal images and no labels. Now let's try `test` split for the `classification` task\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# BTech Classification Test Set\n",
-    "btech_dataset_classification_test = BTechDataset(\n",
-    "    root=dataset_root,\n",
-    "    category=\"01\",\n",
-    "    transform=transform,\n",
-    "    split=\"test\",\n",
-    "    task=TaskType.CLASSIFICATION,\n",
-    ")\n",
-    "sample = btech_dataset_classification_test[0]\n",
+    "print(len(btech_dataset_train))\n",
+    "sample = btech_dataset_train[0]\n",
     "print(sample.image.shape, sample.image_path, sample.gt_label)"
    ]
   },
@@ -289,36 +253,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "where a classification test sample returns `image`, `image_path` and `label`. `image_path` is used to extract the filename when saving images.\n",
+    "As can be seen above, when we choose `train` split, the dataset contains 400 samples. These are the normal training samples from the \"01\" category, which have a corresponding ground truth label of `False`, indicating that the image does not contain an anomaly. \n",
     "\n",
-    "#### Segmentation Task\n",
-    "\n",
-    "It is also possible to configure the BTech dataset for the segmentation task, where the dataset object returns image and ground-truth mask.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# BTech Segmentation Train Set\n",
-    "btech_dataset_segmentation_train = BTechDataset(\n",
-    "    root=dataset_root,\n",
-    "    category=\"01\",\n",
-    "    transform=transform,\n",
-    "    split=\"train\",\n",
-    "    task=TaskType.SEGMENTATION,\n",
-    ")\n",
-    "btech_dataset_segmentation_train.samples.head()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The above dataframe stores all the necessary information regarding the dataset. `__getitem__` method returns the corresponding information depending on the task type or train/test split.\n"
+    "Now let's have a look at the test set:"
    ]
   },
   {
@@ -327,16 +264,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# BTech Segmentation Test Set\n",
-    "btech_dataset_segmentation_test = BTechDataset(\n",
+    "# BTech Classification Test Set\n",
+    "btech_dataset_test = BTechDataset(\n",
     "    root=dataset_root,\n",
     "    category=\"01\",\n",
     "    transform=transform,\n",
     "    split=\"test\",\n",
-    "    task=TaskType.SEGMENTATION,\n",
     ")\n",
-    "sample = btech_dataset_segmentation_test[20]\n",
-    "print(sample.image.shape, sample.gt_mask.shape)"
+    "print(len(btech_dataset_test))\n",
+    "sample = btech_dataset_test[0]\n",
+    "print(sample.image.shape, sample.image_path, sample.gt_label)"
    ]
   },
   {
@@ -363,7 +300,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "anomalib",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -377,14 +314,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.10.14"
   },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "ae223df28f60859a2f400fae8b3a1034248e0a469f5599fd9a89c32908ed7a84"
-   }
-  }
+  "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 2
diff --git a/notebooks/100_datamodules/102_mvtec.ipynb b/notebooks/100_datamodules/102_mvtec.ipynb
index 9081f256ae..cbc62f51dd 100644
--- a/notebooks/100_datamodules/102_mvtec.ipynb
+++ b/notebooks/100_datamodules/102_mvtec.ipynb
@@ -33,8 +33,7 @@
     "from torchvision.transforms.v2 import Resize\n",
     "from torchvision.transforms.v2.functional import to_pil_image\n",
     "\n",
-    "from anomalib.data import MVTec, MVTecDataset\n",
-    "from anomalib import TaskType"
+    "from anomalib.data import MVTec, MVTecDataset"
    ]
   },
   {
@@ -87,7 +86,6 @@
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=0,\n",
-    "    task=TaskType.SEGMENTATION,\n",
     ")"
    ]
   },
@@ -206,7 +204,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Classification Task\n"
+    "Now let's create the dataset, we'll start with the training subset."
    ]
   },
   {
@@ -215,50 +213,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# MVTec Classification Train Set\n",
-    "mvtec_dataset_classification_train = MVTecDataset(\n",
+    "# MVTec dataset\n",
+    "mvtec_dataset_train = MVTecDataset(\n",
     "    root=dataset_root,\n",
     "    category=\"bottle\",\n",
     "    transform=transform,\n",
     "    split=\"train\",\n",
-    "    task=\"classification\",\n",
     ")\n",
-    "mvtec_dataset_classification_train.samples.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sample = mvtec_dataset_classification_train[0]\n",
-    "print(sample.image.shape)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As can be seen above, when we choose `classification` task and `train` split, the dataset only returns `image`. This is mainly because training only requires normal images and no labels. Now let's try `test` split for the `classification` task\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# MVTec Classification Test Set\n",
-    "mvtec_dataset_classification_test = MVTecDataset(\n",
-    "    root=dataset_root,\n",
-    "    category=\"bottle\",\n",
-    "    transform=transform,\n",
-    "    split=\"test\",\n",
-    "    task=\"classification\",\n",
-    ")\n",
-    "sample = mvtec_dataset_classification_test[0]\n",
+    "print(len(mvtec_dataset_train))\n",
+    "sample = mvtec_dataset_train[0]\n",
     "print(sample.image.shape, sample.image_path, sample.gt_label)"
    ]
   },
@@ -267,26 +230,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Segmentation Task\n",
+    "As can be seen above, when we choose `train` split, the dataset contains 209 samples. These are the normal training samples from the MVTec bottle category, which have a corresponding ground truth label of `False`, indicating that the image does not contain an anomaly. \n",
     "\n",
-    "It is also possible to configure the MVTec dataset for the segmentation task, where the dataset object returns image and ground-truth mask.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# MVTec Segmentation Train Set\n",
-    "mvtec_dataset_segmentation_train = MVTecDataset(\n",
-    "    root=dataset_root,\n",
-    "    category=\"bottle\",\n",
-    "    transform=transform,\n",
-    "    split=\"train\",\n",
-    "    task=\"segmentation\",\n",
-    ")\n",
-    "mvtec_dataset_segmentation_train.samples.head()"
+    "Now let's have a look at the test set:\n"
    ]
   },
   {
@@ -295,16 +241,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# MVTec Segmentation Test Set\n",
-    "mvtec_dataset_segmentation_test = MVTecDataset(\n",
+    "# MVTec Classification Test Set\n",
+    "mvtec_dataset_test = MVTecDataset(\n",
     "    root=dataset_root,\n",
     "    category=\"bottle\",\n",
     "    transform=transform,\n",
     "    split=\"test\",\n",
-    "    task=\"segmentation\",\n",
     ")\n",
-    "sample = mvtec_dataset_segmentation_test[20]\n",
-    "print(sample.image.shape, sample.gt_mask.shape)"
+    "print(len(mvtec_dataset_test))\n",
+    "sample = mvtec_dataset_test[0]\n",
+    "print(sample.image.shape, sample.image_path, sample.gt_label)"
    ]
   },
   {
@@ -330,7 +276,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "anomalib",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -344,14 +290,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.10.14"
   },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "ae223df28f60859a2f400fae8b3a1034248e0a469f5599fd9a89c32908ed7a84"
-   }
-  }
+  "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 2
diff --git a/notebooks/100_datamodules/103_folder.ipynb b/notebooks/100_datamodules/103_folder.ipynb
index 328a069652..e40b68a858 100644
--- a/notebooks/100_datamodules/103_folder.ipynb
+++ b/notebooks/100_datamodules/103_folder.ipynb
@@ -33,7 +33,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -63,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -73,8 +73,7 @@
     "from torchvision.transforms.v2 import Resize\n",
     "from torchvision.transforms.v2.functional import to_pil_image\n",
     "\n",
-    "from anomalib.data import Folder, FolderDataset\n",
-    "from anomalib import TaskType"
+    "from anomalib.data import Folder, FolderDataset"
    ]
   },
   {
@@ -91,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -100,7 +99,6 @@
     "    root=dataset_root,\n",
     "    normal_dir=\"good\",\n",
     "    abnormal_dir=\"crack\",\n",
-    "    task=TaskType.SEGMENTATION,\n",
     "    mask_dir=dataset_root / \"mask\" / \"crack\",\n",
     ")\n",
     "folder_datamodule.setup()"
@@ -186,7 +184,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -199,7 +197,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Classification Task\n"
+    "Now let's create the dataset, we'll start with the training subset."
    ]
   },
   {
@@ -208,33 +206,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "folder_dataset_classification_train = FolderDataset(\n",
+    "folder_dataset_train = FolderDataset(\n",
     "    name=\"hazelnut_toy\",\n",
     "    normal_dir=dataset_root / \"good\",\n",
     "    abnormal_dir=dataset_root / \"crack\",\n",
     "    split=\"train\",\n",
     "    transform=transform,\n",
-    "    task=TaskType.CLASSIFICATION,\n",
     ")\n",
-    "folder_dataset_classification_train.samples.head()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's look at the first sample in the dataset.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = folder_dataset_classification_train[0]\n",
-    "print(data.image.shape)"
+    "print(len(folder_dataset_train))\n",
+    "sample = folder_dataset_train[0]\n",
+    "print(sample.image.shape, sample.image_path, sample.gt_label)"
    ]
   },
   {
@@ -242,7 +223,10 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As can be seen above, when we choose `classification` task and `train` split, the dataset only returns `image`. This is mainly because training only requires normal images and no labels. Now let's try `test` split for the `classification` task\n"
+    "As can be seen above, when we choose `train` split, the dataset contains 34 samples. These are the normal images that have been assigned to the training set, which have a corresponding ground truth label of `False`, indicating that the image does not contain an anomaly. \n",
+    "\n",
+    "Now let's have a look at the test set:\n",
+    "\n"
    ]
   },
   {
@@ -252,25 +236,16 @@
    "outputs": [],
    "source": [
     "# Folder Classification Test Set\n",
-    "folder_dataset_classification_test = FolderDataset(\n",
+    "folder_dataset_test = FolderDataset(\n",
     "    name=\"hazelnut_toy\",\n",
     "    normal_dir=dataset_root / \"good\",\n",
     "    abnormal_dir=dataset_root / \"crack\",\n",
     "    split=\"test\",\n",
     "    transform=transform,\n",
-    "    task=TaskType.CLASSIFICATION,\n",
     ")\n",
-    "folder_dataset_classification_test.samples.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = folder_dataset_classification_test[0]\n",
-    "print(data.image.shape, data.image_path, data.gt_label)"
+    "print(len(folder_dataset_test))\n",
+    "sample = folder_dataset_test[0]\n",
+    "print(sample.image.shape, sample.image_path, sample.gt_label)"
    ]
   },
   {
@@ -280,7 +255,7 @@
    "source": [
     "#### Segmentation Task\n",
     "\n",
-    "It is also possible to configure the Folder dataset for the segmentation task, where the dataset object returns image and ground-truth mask.\n"
+    "It is also possible to configure the Folder dataset for the segmentation task, where the dataset object returns image and ground-truth mask. To achieve this, we need to pass a folder of ground truth masks to the dataset. The mask folder should contain a ground truth pixel mask for every anomalous image in the dataset.\n"
    ]
   },
   {
@@ -297,9 +272,10 @@
     "    split=\"train\",\n",
     "    transform=transform,\n",
     "    mask_dir=dataset_root / \"mask\" / \"crack\",\n",
-    "    task=TaskType.SEGMENTATION,\n",
     ")\n",
-    "folder_dataset_segmentation_train.samples.head()"
+    "print(len(folder_dataset_segmentation_train))\n",
+    "sample = folder_dataset_segmentation_train[0]\n",
+    "print(sample.image.shape, sample.gt_mask.shape, sample.image_path, sample.gt_label)"
    ]
   },
   {
@@ -316,19 +292,10 @@
     "    split=\"test\",\n",
     "    transform=transform,\n",
     "    mask_dir=dataset_root / \"mask\" / \"crack\",\n",
-    "    task=TaskType.SEGMENTATION,\n",
     ")\n",
-    "folder_dataset_segmentation_test.samples.head(10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data = folder_dataset_segmentation_test[3]\n",
-    "print(data.image.shape, data.gt_mask.shape)"
+    "print(len(folder_dataset_segmentation_test))\n",
+    "sample = folder_dataset_segmentation_test[0]\n",
+    "print(sample.image.shape, sample.gt_mask.shape, sample.image_path, sample.gt_label)"
    ]
   },
   {
@@ -354,7 +321,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "anomalib",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -368,14 +335,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.10.14"
   },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "ae223df28f60859a2f400fae8b3a1034248e0a469f5599fd9a89c32908ed7a84"
-   }
-  }
+  "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 2
diff --git a/notebooks/200_models/201_fastflow.ipynb b/notebooks/200_models/201_fastflow.ipynb
index 492655f010..2e5872db60 100644
--- a/notebooks/200_models/201_fastflow.ipynb
+++ b/notebooks/200_models/201_fastflow.ipynb
@@ -75,7 +75,6 @@
     "from PIL import Image\n",
     "from torch.utils.data import DataLoader\n",
     "\n",
-    "from anomalib import TaskType\n",
     "from anomalib.data import MVTec, PredictDataset\n",
     "from anomalib.engine import Engine\n",
     "from anomalib.models import Fastflow\n",
@@ -93,18 +92,7 @@
    "source": [
     "## Data Module\n",
     "\n",
-    "To train the model end-to-end, we do need to have a dataset. In our [previous notebooks](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules), we demonstrate how to initialize benchmark- and custom datasets. In this tutorial, we will use MVTec AD DataModule. We assume that `datasets` directory is created in the `anomalib` root directory and `MVTec` dataset is located in `datasets` directory.\n",
-    "\n",
-    "Before creating the dataset, let's define the task type that we will be working on. In this notebook, we will be working on a segmentation task. Therefore the `task` variable would be:\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "task = TaskType.SEGMENTATION"
+    "To train the model end-to-end, we do need to have a dataset. In our [previous notebooks](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules), we demonstrate how to initialize benchmark- and custom datasets. In this tutorial, we will use MVTec AD DataModule. We assume that `datasets` directory is created in the `anomalib` root directory and `MVTec` dataset is located in `datasets` directory.\n"
    ]
   },
   {
@@ -123,7 +111,6 @@
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=0,\n",
-    "    task=task,\n",
     ")"
    ]
   },
@@ -541,7 +528,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "anomalib",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -555,14 +542,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.10.14"
   },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "f26beec5b578f06009232863ae217b956681fd13da2e828fa5a0ecf8cf2ccd29"
-   }
-  }
+  "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 2
diff --git a/notebooks/600_loggers/601_mlflow_logging.ipynb b/notebooks/600_loggers/601_mlflow_logging.ipynb
index c3f37de763..c3cbe0fdb5 100644
--- a/notebooks/600_loggers/601_mlflow_logging.ipynb
+++ b/notebooks/600_loggers/601_mlflow_logging.ipynb
@@ -155,7 +155,6 @@
     "\n",
     "from lightning.pytorch.callbacks import EarlyStopping\n",
     "\n",
-    "from anomalib import TaskType\n",
     "from anomalib.callbacks.checkpoint import ModelCheckpoint\n",
     "from anomalib.data import MVTec\n",
     "from anomalib.engine import Engine\n",
@@ -200,7 +199,6 @@
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=24,\n",
-    "    task=TaskType.SEGMENTATION,\n",
     ")"
    ]
   },
@@ -405,7 +403,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -419,7 +417,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.10.14"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/700_metrics/701a_aupimo.ipynb b/notebooks/700_metrics/701a_aupimo.ipynb
index 10e198fef9..18c82caa2e 100644
--- a/notebooks/700_metrics/701a_aupimo.ipynb
+++ b/notebooks/700_metrics/701a_aupimo.ipynb
@@ -71,7 +71,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -102,7 +102,6 @@
     "from matplotlib.ticker import MaxNLocator, PercentFormatter\n",
     "from scipy import stats\n",
     "\n",
-    "from anomalib import TaskType\n",
     "from anomalib.data import MVTec\n",
     "from anomalib.engine import Engine\n",
     "from anomalib.metrics import AUPIMO, Evaluator\n",
@@ -111,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -132,18 +131,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "task = TaskType.SEGMENTATION\n",
     "datamodule = MVTec(\n",
     "    root=dataset_root,\n",
     "    category=\"leather\",\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=8,\n",
-    "    task=task,\n",
     ")"
    ]
   },
@@ -279,7 +276,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
index 70f0968520..9646e81868 100644
--- a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
+++ b/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -98,7 +98,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -111,7 +111,6 @@
     "from matplotlib.ticker import PercentFormatter\n",
     "from scipy import stats\n",
     "\n",
-    "from anomalib import TaskType\n",
     "from anomalib.data import MVTec\n",
     "from anomalib.data.utils import read_image\n",
     "from anomalib.engine import Engine\n",
@@ -121,7 +120,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -130,7 +129,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -160,14 +159,12 @@
    "outputs": [],
    "source": [
     "# train the model\n",
-    "task = TaskType.SEGMENTATION\n",
     "datamodule = MVTec(\n",
     "    root=dataset_root,\n",
     "    category=\"leather\",\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=8,\n",
-    "    task=task,\n",
     ")\n",
     "evaluator = Evaluator(test_metrics=AUPIMO())\n",
     "model = Padim(\n",
@@ -379,7 +376,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -752,7 +749,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
index 1d64e9ec44..6c76c411e8 100644
--- a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
+++ b/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
@@ -114,7 +114,6 @@
     "from scipy import stats\n",
     "from torch import Tensor\n",
     "\n",
-    "from anomalib import TaskType\n",
     "from anomalib.data import MVTec\n",
     "from anomalib.data.utils import read_image\n",
     "from anomalib.engine import Engine\n",
@@ -154,14 +153,12 @@
    "outputs": [],
    "source": [
     "# train the model\n",
-    "task = TaskType.SEGMENTATION\n",
     "datamodule = MVTec(\n",
     "    root=dataset_root,\n",
     "    category=\"leather\",\n",
     "    train_batch_size=32,\n",
     "    eval_batch_size=32,\n",
     "    num_workers=8,\n",
-    "    task=task,\n",
     ")\n",
     "evaluator = Evaluator(test_metrics=AUPIMO())\n",
     "model = Padim(\n",
diff --git a/src/anomalib/cli/cli.py b/src/anomalib/cli/cli.py
index 87492ac3f3..2bb61d7af5 100644
--- a/src/anomalib/cli/cli.py
+++ b/src/anomalib/cli/cli.py
@@ -14,7 +14,7 @@
 from jsonargparse._actions import _ActionSubCommands
 from rich import traceback
 
-from anomalib import TaskType, __version__
+from anomalib import __version__
 from anomalib.cli.pipelines import PIPELINE_REGISTRY, pipeline_subcommands, run_pipeline
 from anomalib.cli.utils.help_formatter import CustomHelpFormatter, get_short_docstring
 from anomalib.cli.utils.openvino import add_openvino_export_arguments
@@ -147,10 +147,7 @@ def add_arguments_to_parser(parser: ArgumentParser) -> None:
             Since ``Engine`` parameters are manually added, any change to the
             ``Engine`` class should be reflected manually.
         """
-        parser.add_argument("--task", type=TaskType | str, default=TaskType.SEGMENTATION)
         parser.add_argument("--logging.log_graph", type=bool, help="Log the model to the logger", default=False)
-        if hasattr(parser, "subcommand") and parser.subcommand not in {"export", "predict"}:
-            parser.link_arguments("task", "data.init_args.task")
         parser.add_argument(
             "--default_root_dir",
             type=Path,
@@ -319,9 +316,7 @@ def instantiate_engine(self) -> None:
 
         from anomalib.callbacks import get_callbacks
 
-        engine_args = {
-            "task": self._get(self.config_init, "task"),
-        }
+        engine_args: dict[str, Any] = {}
         trainer_config = {**self._get(self.config_init, "trainer", default={}), **engine_args}
         key = "callbacks"
         if key in trainer_config:
diff --git a/src/anomalib/data/datamodules/base/image.py b/src/anomalib/data/datamodules/base/image.py
index 8476bf5eeb..5c28cd4557 100644
--- a/src/anomalib/data/datamodules/base/image.py
+++ b/src/anomalib/data/datamodules/base/image.py
@@ -13,6 +13,7 @@
 from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
 from torch.utils.data.dataloader import DataLoader
 
+from anomalib import TaskType
 from anomalib.data.utils import TestSplitMode, ValSplitMode, random_split, split_by_label
 from anomalib.data.utils.synthetic import SyntheticAnomalyDataset
 
@@ -119,6 +120,18 @@ def category(self, category: str) -> None:
         """Set the category of the datamodule."""
         self._category = category
 
+    @property
+    def task(self) -> TaskType:
+        """Get the task type of the datamodule."""
+        if hasattr(self, "train_data"):
+            return self.train_data.task
+        if hasattr(self, "val_data"):
+            return self.val_data.task
+        if hasattr(self, "test_data"):
+            return self.test_data.task
+        msg = "This datamodule does not have any datasets. Did you call setup?"
+        raise AttributeError(msg)
+
     def _create_test_split(self) -> None:
         """Obtain the test set based on the settings in the config."""
         if self.test_data.has_normal:
diff --git a/src/anomalib/data/datamodules/depth/folder_3d.py b/src/anomalib/data/datamodules/depth/folder_3d.py
index 2e2930be26..f475c26bd8 100644
--- a/src/anomalib/data/datamodules/depth/folder_3d.py
+++ b/src/anomalib/data/datamodules/depth/folder_3d.py
@@ -8,7 +8,6 @@
 
 from pathlib import Path
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.depth.folder_3d import Folder3DDataset
 from anomalib.data.utils import Split, TestSplitMode, ValSplitMode
@@ -47,8 +46,6 @@ class Folder3D(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        task (TaskType, optional): Task type. Could be ``classification``, ``detection`` or ``segmentation``.
-            Defaults to ``TaskType.SEGMENTATION``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -76,7 +73,6 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
@@ -94,7 +90,6 @@ def __init__(
             seed=seed,
         )
         self._name = name
-        self.task = TaskType(task)
         self.root = Path(root)
         self.normal_dir = normal_dir
         self.abnormal_dir = abnormal_dir
@@ -108,7 +103,6 @@ def __init__(
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = Folder3DDataset(
             name=self.name,
-            task=self.task,
             split=Split.TRAIN,
             root=self.root,
             normal_dir=self.normal_dir,
@@ -123,7 +117,6 @@ def _setup(self, _stage: str | None = None) -> None:
 
         self.test_data = Folder3DDataset(
             name=self.name,
-            task=self.task,
             split=Split.TEST,
             root=self.root,
             normal_dir=self.normal_dir,
diff --git a/src/anomalib/data/datamodules/depth/mvtec_3d.py b/src/anomalib/data/datamodules/depth/mvtec_3d.py
index 6a497ec952..400b1d3139 100644
--- a/src/anomalib/data/datamodules/depth/mvtec_3d.py
+++ b/src/anomalib/data/datamodules/depth/mvtec_3d.py
@@ -22,7 +22,6 @@
 import logging
 from pathlib import Path
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.depth.mvtec_3d import MVTec3DDataset
 from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
@@ -52,8 +51,6 @@ class MVTec3D(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
-            Defaults to ``TaskType.SEGMENTATION``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -73,7 +70,6 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -91,19 +87,16 @@ def __init__(
             seed=seed,
         )
 
-        self.task = TaskType(task)
         self.root = Path(root)
         self.category = category
 
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = MVTec3DDataset(
-            task=self.task,
             split=Split.TRAIN,
             root=self.root,
             category=self.category,
         )
         self.test_data = MVTec3DDataset(
-            task=self.task,
             split=Split.TEST,
             root=self.root,
             category=self.category,
diff --git a/src/anomalib/data/datamodules/image/btech.py b/src/anomalib/data/datamodules/image/btech.py
index 818c9d71b5..4ec0527f16 100644
--- a/src/anomalib/data/datamodules/image/btech.py
+++ b/src/anomalib/data/datamodules/image/btech.py
@@ -16,7 +16,6 @@
 import cv2
 from tqdm import tqdm
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.btech import BTechDataset
 from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
@@ -44,8 +43,6 @@ class BTech(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        task (TaskType, optional): Task type.
-            Defaults to ``TaskType.SEGMENTATION``.
         test_split_mode (TestSplitMode, optional): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float, optional): Fraction of images from the train set that will be reserved for testing.
@@ -102,7 +99,6 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -122,17 +118,14 @@ def __init__(
 
         self.root = Path(root)
         self.category = category
-        self.task = TaskType(task)
 
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = BTechDataset(
-            task=self.task,
             split=Split.TRAIN,
             root=self.root,
             category=self.category,
         )
         self.test_data = BTechDataset(
-            task=self.task,
             split=Split.TEST,
             root=self.root,
             category=self.category,
diff --git a/src/anomalib/data/datamodules/image/datumaro.py b/src/anomalib/data/datamodules/image/datumaro.py
index f7496982da..fb37bc7ee7 100644
--- a/src/anomalib/data/datamodules/image/datumaro.py
+++ b/src/anomalib/data/datamodules/image/datumaro.py
@@ -8,7 +8,6 @@
 
 from pathlib import Path
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base import AnomalibDataModule
 from anomalib.data.datasets.image.datumaro import DatumaroDataset
 from anomalib.data.utils import Split, TestSplitMode, ValSplitMode
@@ -25,8 +24,6 @@ class Datumaro(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int): Number of workers for dataloaders.
             Defaults to ``8``.
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
-            Defaults to ``TaskType.CLASSIFICATION``. Currently only supports classification.
         image_size (tuple[int, int], optional): Size to which input images should be resized.
             Defaults to ``None``.
         transform (Transform, optional): Transforms that should be applied to the input images.
@@ -68,16 +65,12 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
-        task: TaskType = TaskType.CLASSIFICATION,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.5,
         val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
         val_split_ratio: float = 0.5,
         seed: int | None = None,
     ) -> None:
-        if task != TaskType.CLASSIFICATION:
-            msg = "Datumaro dataloader currently only supports classification task."
-            raise ValueError(msg)
         super().__init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
@@ -89,16 +82,13 @@ def __init__(
             seed=seed,
         )
         self.root = root
-        self.task = task
 
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = DatumaroDataset(
-            task=self.task,
             root=self.root,
             split=Split.TRAIN,
         )
         self.test_data = DatumaroDataset(
-            task=self.task,
             root=self.root,
             split=Split.TEST,
         )
diff --git a/src/anomalib/data/datamodules/image/folder.py b/src/anomalib/data/datamodules/image/folder.py
index 7fe51c32a0..bd3c3fedd0 100644
--- a/src/anomalib/data/datamodules/image/folder.py
+++ b/src/anomalib/data/datamodules/image/folder.py
@@ -9,7 +9,6 @@
 from collections.abc import Sequence
 from pathlib import Path
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.folder import FolderDataset
 from anomalib.data.utils import Split, TestSplitMode, ValSplitMode
@@ -43,8 +42,6 @@ class Folder(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        task (TaskType, optional): Task type. Could be ``classification``, ``detection`` or ``segmentation``.
-            Defaults to ``segmentation``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -90,7 +87,6 @@ class Folder(AnomalibDataModule):
                 root=dataset_root,
                 normal_dir="good",
                 abnormal_dir="crack",
-                task=TaskType.SEGMENTATION,
                 mask_dir=dataset_root / "mask" / "crack",
             )
             folder_datamodule.setup()
@@ -123,7 +119,6 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
@@ -136,7 +131,6 @@ def __init__(
         self.abnormal_dir = abnormal_dir
         self.normal_test_dir = normal_test_dir
         self.mask_dir = mask_dir
-        self.task = TaskType(task)
         self.extensions = extensions
         test_split_mode = TestSplitMode(test_split_mode)
         val_split_mode = ValSplitMode(val_split_mode)
@@ -151,21 +145,11 @@ def __init__(
             seed=seed,
         )
 
-        if task == TaskType.SEGMENTATION and test_split_mode == TestSplitMode.FROM_DIR and mask_dir is None:
-            msg = (
-                f"Segmentation task requires mask directory if test_split_mode is {test_split_mode}. "
-                "You could set test_split_mode to {TestSplitMode.NONE} or provide a mask directory."
-            )
-            raise ValueError(
-                msg,
-            )
-
         self.normal_split_ratio = normal_split_ratio
 
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = FolderDataset(
             name=self.name,
-            task=self.task,
             split=Split.TRAIN,
             root=self.root,
             normal_dir=self.normal_dir,
@@ -177,7 +161,6 @@ def _setup(self, _stage: str | None = None) -> None:
 
         self.test_data = FolderDataset(
             name=self.name,
-            task=self.task,
             split=Split.TEST,
             root=self.root,
             normal_dir=self.normal_dir,
diff --git a/src/anomalib/data/datamodules/image/kolektor.py b/src/anomalib/data/datamodules/image/kolektor.py
index c962e4fba7..fe767c3a94 100644
--- a/src/anomalib/data/datamodules/image/kolektor.py
+++ b/src/anomalib/data/datamodules/image/kolektor.py
@@ -20,7 +20,6 @@
 import logging
 from pathlib import Path
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.kolektor import KolektorDataset
 from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
@@ -46,8 +45,6 @@ class Kolektor(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        task TaskType): Task type, 'classification', 'detection' or 'segmentation'
-            Defaults to ``TaskType.SEGMENTATION``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -66,7 +63,6 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -84,17 +80,14 @@ def __init__(
             seed=seed,
         )
 
-        self.task = TaskType(task)
         self.root = Path(root)
 
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = KolektorDataset(
-            task=self.task,
             split=Split.TRAIN,
             root=self.root,
         )
         self.test_data = KolektorDataset(
-            task=self.task,
             split=Split.TEST,
             root=self.root,
         )
diff --git a/src/anomalib/data/datamodules/image/mvtec.py b/src/anomalib/data/datamodules/image/mvtec.py
index a465ef52c1..9e7b2fce89 100644
--- a/src/anomalib/data/datamodules/image/mvtec.py
+++ b/src/anomalib/data/datamodules/image/mvtec.py
@@ -28,7 +28,6 @@
 import logging
 from pathlib import Path
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.mvtec import MVTecDataset
 from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
@@ -58,8 +57,6 @@ class MVTec(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        task TaskType): Task type, 'classification', 'detection' or 'segmentation'
-            Defaults to ``TaskType.SEGMENTATION``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -108,7 +105,6 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -126,7 +122,6 @@ def __init__(
             seed=seed,
         )
 
-        self.task = TaskType(task)
         self.root = Path(root)
         self.category = category
 
@@ -143,13 +138,11 @@ def _setup(self, _stage: str | None = None) -> None:
 
         """
         self.train_data = MVTecDataset(
-            task=self.task,
             split=Split.TRAIN,
             root=self.root,
             category=self.category,
         )
         self.test_data = MVTecDataset(
-            task=self.task,
             split=Split.TEST,
             root=self.root,
             category=self.category,
diff --git a/src/anomalib/data/datamodules/image/visa.py b/src/anomalib/data/datamodules/image/visa.py
index a445349702..553d0dcc03 100644
--- a/src/anomalib/data/datamodules/image/visa.py
+++ b/src/anomalib/data/datamodules/image/visa.py
@@ -29,7 +29,6 @@
 
 import cv2
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.visa import VisaDataset
 from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
@@ -57,8 +56,6 @@ class Visa(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
-            Defaults to ``TaskType.SEGMENTATION``.
         test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
@@ -78,7 +75,6 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
-        task: TaskType | str = TaskType.SEGMENTATION,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -96,20 +92,17 @@ def __init__(
             seed=seed,
         )
 
-        self.task = TaskType(task)
         self.root = Path(root)
         self.split_root = self.root / "visa_pytorch"
         self.category = category
 
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = VisaDataset(
-            task=self.task,
             split=Split.TRAIN,
             root=self.split_root,
             category=self.category,
         )
         self.test_data = VisaDataset(
-            task=self.task,
             split=Split.TEST,
             root=self.split_root,
             category=self.category,
diff --git a/src/anomalib/data/datamodules/video/avenue.py b/src/anomalib/data/datamodules/video/avenue.py
index 86d068e761..446b4b6c37 100644
--- a/src/anomalib/data/datamodules/video/avenue.py
+++ b/src/anomalib/data/datamodules/video/avenue.py
@@ -22,7 +22,6 @@
 import cv2
 import scipy.io
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
 from anomalib.data.datasets.base.video import VideoTargetFrame
 from anomalib.data.datasets.video.avenue import AvenueDataset
@@ -56,8 +55,6 @@ class Avenue(AnomalibVideoDataModule):
             Defaults to ``1``.
         target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
             Defaults to ``VideoTargetFrame.LAST``.
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
-            Defaults to ``TaskType.SEGMENTATION``.
         train_batch_size (int, optional): Training batch size.
             Defaults to ``32``.
         eval_batch_size (int, optional): Test batch size.
@@ -90,8 +87,7 @@ class Avenue(AnomalibVideoDataModule):
             data["image"].shape
             # Output: torch.Size([32, 2, 3, 256, 256])
 
-        Note that the default task type is segmentation and the dataloader returns a mask in addition to the input.
-        Also, it is important to note that the dataloader returns a batch of clips, where each clip is a sequence of
+        Note that it is important to note that the dataloader returns a batch of clips, where each clip is a sequence of
         frames. The number of frames in each clip is determined by the ``clip_length_in_frames`` parameter. The
         ``frames_between_clips`` parameter determines the number of frames between each consecutive clip. The
         ``target_frame`` parameter determines which frame in the clip is used for ground truth retrieval. For example,
@@ -103,7 +99,6 @@ class Avenue(AnomalibVideoDataModule):
         .. code-block:: python
 
             datamodule = Avenue(
-                task="classification",
                 clip_length_in_frames=2,
                 frames_between_clips=1,
                 target_frame=VideoTargetFrame.LAST
@@ -126,7 +121,6 @@ def __init__(
         clip_length_in_frames: int = 2,
         frames_between_clips: int = 1,
         target_frame: VideoTargetFrame | str = VideoTargetFrame.LAST,
-        task: TaskType | str = TaskType.SEGMENTATION,
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
@@ -143,7 +137,6 @@ def __init__(
             seed=seed,
         )
 
-        self.task = TaskType(task)
         self.root = Path(root)
         self.gt_dir = Path(gt_dir)
         self.clip_length_in_frames = clip_length_in_frames
@@ -152,7 +145,6 @@ def __init__(
 
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = AvenueDataset(
-            task=self.task,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
@@ -162,7 +154,6 @@ def _setup(self, _stage: str | None = None) -> None:
         )
 
         self.test_data = AvenueDataset(
-            task=self.task,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
diff --git a/src/anomalib/data/datamodules/video/shanghaitech.py b/src/anomalib/data/datamodules/video/shanghaitech.py
index 2b5c6f428c..f5e5cd0036 100644
--- a/src/anomalib/data/datamodules/video/shanghaitech.py
+++ b/src/anomalib/data/datamodules/video/shanghaitech.py
@@ -20,7 +20,6 @@
 from pathlib import Path
 from shutil import move
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
 from anomalib.data.datasets.base.video import VideoTargetFrame
 from anomalib.data.datasets.video.shanghaitech import ShanghaiTechDataset
@@ -45,7 +44,6 @@ class ShanghaiTech(AnomalibVideoDataModule):
         clip_length_in_frames (int, optional): Number of video frames in each clip.
         frames_between_clips (int, optional): Number of frames between each consecutive video clip.
         target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
-        task TaskType): Task type, 'classification', 'detection' or 'segmentation'
         train_batch_size (int, optional): Training batch size. Defaults to 32.
         eval_batch_size (int, optional): Test batch size. Defaults to 32.
         num_workers (int, optional): Number of workers. Defaults to 8.
@@ -61,7 +59,6 @@ def __init__(
         clip_length_in_frames: int = 2,
         frames_between_clips: int = 1,
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
-        task: TaskType | str = TaskType.SEGMENTATION,
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
@@ -78,7 +75,6 @@ def __init__(
             seed=seed,
         )
 
-        self.task = TaskType(task)
         self.root = Path(root)
         self.scene = scene
 
@@ -88,7 +84,6 @@ def __init__(
 
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = ShanghaiTechDataset(
-            task=self.task,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
@@ -98,7 +93,6 @@ def _setup(self, _stage: str | None = None) -> None:
         )
 
         self.test_data = ShanghaiTechDataset(
-            task=self.task,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
diff --git a/src/anomalib/data/datamodules/video/ucsd_ped.py b/src/anomalib/data/datamodules/video/ucsd_ped.py
index 4743d17044..e08bfd1ca6 100644
--- a/src/anomalib/data/datamodules/video/ucsd_ped.py
+++ b/src/anomalib/data/datamodules/video/ucsd_ped.py
@@ -7,7 +7,6 @@
 from pathlib import Path
 from shutil import move
 
-from anomalib import TaskType
 from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
 from anomalib.data.datasets.base.video import VideoTargetFrame
 from anomalib.data.datasets.video.ucsd_ped import UCSDpedDataset
@@ -31,7 +30,6 @@ class UCSDped(AnomalibVideoDataModule):
         clip_length_in_frames (int, optional): Number of video frames in each clip.
         frames_between_clips (int, optional): Number of frames between each consecutive video clip.
         target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
         train_batch_size (int, optional): Training batch size. Defaults to 32.
         eval_batch_size (int, optional): Test batch size. Defaults to 32.
         num_workers (int, optional): Number of workers. Defaults to 8.
@@ -47,7 +45,6 @@ def __init__(
         clip_length_in_frames: int = 2,
         frames_between_clips: int = 10,
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
-        task: TaskType | str = TaskType.SEGMENTATION,
         train_batch_size: int = 8,
         eval_batch_size: int = 8,
         num_workers: int = 8,
@@ -64,7 +61,6 @@ def __init__(
             seed=seed,
         )
 
-        self.task = TaskType(task)
         self.root = Path(root)
         self.category = category
 
@@ -74,7 +70,6 @@ def __init__(
 
     def _setup(self, _stage: str | None = None) -> None:
         self.train_data = UCSDpedDataset(
-            task=self.task,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
@@ -84,7 +79,6 @@ def _setup(self, _stage: str | None = None) -> None:
         )
 
         self.test_data = UCSDpedDataset(
-            task=self.task,
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
             target_frame=self.target_frame,
diff --git a/src/anomalib/data/datasets/base/depth.py b/src/anomalib/data/datasets/base/depth.py
index 56460b3a6a..5dd4683b6c 100644
--- a/src/anomalib/data/datasets/base/depth.py
+++ b/src/anomalib/data/datasets/base/depth.py
@@ -23,13 +23,12 @@ class AnomalibDepthDataset(AnomalibDataset, ABC):
     """Base depth anomalib dataset class.
 
     Args:
-        task (str): Task type, either 'classification' or 'segmentation'
         transform (Transform, optional): Transforms that should be applied to the input images.
             Defaults to ``None``.
     """
 
-    def __init__(self, task: TaskType, transform: Transform | None = None) -> None:
-        super().__init__(task, transform)
+    def __init__(self, transform: Transform | None = None) -> None:
+        super().__init__(transform)
 
         self.transform = transform
 
diff --git a/src/anomalib/data/datasets/base/image.py b/src/anomalib/data/datasets/base/image.py
index 5aaabc8fe4..9bc8c45e74 100644
--- a/src/anomalib/data/datasets/base/image.py
+++ b/src/anomalib/data/datasets/base/image.py
@@ -20,13 +20,7 @@
 from anomalib.data.dataclasses import DatasetItem, ImageBatch, ImageItem
 from anomalib.data.utils import LabelName, read_image, read_mask
 
-_EXPECTED_COLUMNS_CLASSIFICATION = ["image_path", "split"]
-_EXPECTED_COLUMNS_SEGMENTATION = [*_EXPECTED_COLUMNS_CLASSIFICATION, "mask_path"]
-_EXPECTED_COLUMNS_PERTASK = {
-    "classification": _EXPECTED_COLUMNS_CLASSIFICATION,
-    "segmentation": _EXPECTED_COLUMNS_SEGMENTATION,
-    "detection": _EXPECTED_COLUMNS_SEGMENTATION,
-}
+_EXPECTED_COLUMNS = ["image_path", "split"]
 
 logger = logging.getLogger(__name__)
 
@@ -62,9 +56,8 @@ class AnomalibDataset(Dataset, ABC):
             Defaults to ``None``.
     """
 
-    def __init__(self, task: TaskType | str, transform: Transform | None = None) -> None:
+    def __init__(self, transform: Transform | None = None) -> None:
         super().__init__()
-        self.task = TaskType(task)
         self.transform = transform
         self._samples: DataFrame | None = None
         self._category: str | None = None
@@ -122,9 +115,8 @@ def samples(self, samples: DataFrame) -> None:
             msg = f"samples must be a pandas.DataFrame, found {type(samples)}"
             raise TypeError(msg)
 
-        expected_columns = _EXPECTED_COLUMNS_PERTASK[self.task]
-        if not all(col in samples.columns for col in expected_columns):
-            msg = f"samples must have (at least) columns {expected_columns}, found {samples.columns}"
+        if not all(col in samples.columns for col in _EXPECTED_COLUMNS):
+            msg = f"samples must have (at least) columns {_EXPECTED_COLUMNS}, found {samples.columns}"
             raise ValueError(msg)
 
         if not samples["image_path"].apply(lambda p: Path(p).exists()).all():
@@ -153,6 +145,11 @@ def has_anomalous(self) -> bool:
         """Check if the dataset contains any anomalous samples."""
         return LabelName.ABNORMAL in list(self.samples.label_index)
 
+    @property
+    def task(self) -> TaskType:
+        """Infer the task type from the dataset."""
+        return TaskType(self.samples.attrs["task"])
+
     def __getitem__(self, index: int) -> DatasetItem:
         """Get dataset item for the index ``index``.
 
diff --git a/src/anomalib/data/datasets/base/video.py b/src/anomalib/data/datasets/base/video.py
index 3ba8f2fd83..4b8366aae4 100644
--- a/src/anomalib/data/datasets/base/video.py
+++ b/src/anomalib/data/datasets/base/video.py
@@ -13,7 +13,6 @@
 from torchvision.transforms.v2.functional import to_dtype, to_dtype_video
 from torchvision.tv_tensors import Mask
 
-from anomalib import TaskType
 from anomalib.data.dataclasses import VideoBatch, VideoItem
 from anomalib.data.utils.video import ClipsIndexer
 
@@ -36,7 +35,6 @@ class AnomalibVideoDataset(AnomalibDataset, ABC):
     """Base video anomalib dataset class.
 
     Args:
-        task (str): Task type, either 'classification' or 'segmentation'
         clip_length_in_frames (int): Number of video frames in each clip.
         frames_between_clips (int): Number of frames between each consecutive video clip.
         transform (Transform, optional): Transforms that should be applied to the input clips.
@@ -47,13 +45,12 @@ class AnomalibVideoDataset(AnomalibDataset, ABC):
 
     def __init__(
         self,
-        task: TaskType,
         clip_length_in_frames: int,
         frames_between_clips: int,
         transform: Transform | None = None,
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
     ) -> None:
-        super().__init__(task, transform)
+        super().__init__(transform)
 
         self.clip_length_in_frames = clip_length_in_frames
         self.frames_between_clips = frames_between_clips
diff --git a/src/anomalib/data/datasets/depth/folder_3d.py b/src/anomalib/data/datasets/depth/folder_3d.py
index a176674ff0..0e5247c7bc 100644
--- a/src/anomalib/data/datasets/depth/folder_3d.py
+++ b/src/anomalib/data/datasets/depth/folder_3d.py
@@ -11,7 +11,6 @@
 from pandas import DataFrame, isna
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets.base.depth import AnomalibDepthDataset
 from anomalib.data.errors import MisMatchError
 from anomalib.data.utils import DirType, LabelName, Split
@@ -23,7 +22,6 @@ class Folder3DDataset(AnomalibDepthDataset):
 
     Args:
         name (str): Name of the dataset.
-        task (TaskType): Task type. (``classification``, ``detection`` or ``segmentation``).
         transform (Transform): Transforms that should be applied to the input images.
         normal_dir (str | Path): Path to the directory containing normal images.
         root (str | Path | None): Root folder of the dataset.
@@ -52,16 +50,11 @@ class Folder3DDataset(AnomalibDepthDataset):
             Defaults to ``None``.
         extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
             Defaults to ``None``.
-
-    Raises:
-        ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is
-            provided, `task` should be set to `segmentation`.
     """
 
     def __init__(
         self,
         name: str,
-        task: TaskType,
         normal_dir: str | Path,
         root: str | Path | None = None,
         abnormal_dir: str | Path | None = None,
@@ -74,7 +67,7 @@ def __init__(
         split: str | Split | None = None,
         extensions: tuple[str, ...] | None = None,
     ) -> None:
-        super().__init__(task, transform)
+        super().__init__(transform)
 
         self._name = name
         self.split = split
@@ -263,6 +256,9 @@ def make_folder3d_dataset(
     samples.loc[(samples.label == DirType.NORMAL), "split"] = Split.TRAIN
     samples.loc[(samples.label == DirType.ABNORMAL) | (samples.label == DirType.NORMAL_TEST), "split"] = Split.TEST
 
+    # infer the task type
+    samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
+
     # Get the data frame for the split.
     if split:
         samples = samples[samples.split == split]
diff --git a/src/anomalib/data/datasets/depth/mvtec_3d.py b/src/anomalib/data/datasets/depth/mvtec_3d.py
index de6d326a4a..6dd8ed3752 100644
--- a/src/anomalib/data/datasets/depth/mvtec_3d.py
+++ b/src/anomalib/data/datasets/depth/mvtec_3d.py
@@ -25,7 +25,6 @@
 from pandas import DataFrame
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets.base.depth import AnomalibDepthDataset
 from anomalib.data.errors import MisMatchError
 from anomalib.data.utils import LabelName, Split, validate_path
@@ -38,7 +37,6 @@ class MVTec3DDataset(AnomalibDepthDataset):
     """MVTec 3D dataset class.
 
     Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``
         root (Path | str): Path to the root of the dataset
             Defaults to ``"./datasets/MVTec3D"``.
         category (str): Sub-category of the dataset, e.g. 'bagel'
@@ -51,13 +49,12 @@ class MVTec3DDataset(AnomalibDepthDataset):
 
     def __init__(
         self,
-        task: TaskType,
         root: Path | str = "./datasets/MVTec3D",
         category: str = "bagel",
         transform: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(task=task, transform=transform)
+        super().__init__(transform=transform)
 
         self.root_category = Path(root) / Path(category)
         self.split = split
@@ -178,6 +175,9 @@ def make_mvtec_3d_dataset(
           (e.g. image: '000.png', depth: '000.tiff')."""
         raise MisMatchError(msg)
 
+    # infer the task type
+    samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
+
     if split:
         samples = samples[samples.split == split].reset_index(drop=True)
 
diff --git a/src/anomalib/data/datasets/image/btech.py b/src/anomalib/data/datasets/image/btech.py
index 412097c912..3078c99e12 100644
--- a/src/anomalib/data/datasets/image/btech.py
+++ b/src/anomalib/data/datasets/image/btech.py
@@ -15,7 +15,6 @@
 from pandas.core.frame import DataFrame
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets.base.image import AnomalibDataset
 from anomalib.data.utils import LabelName, Split, validate_path
 
@@ -31,7 +30,6 @@ class BTechDataset(AnomalibDataset):
         transform (Transform, optional): Transforms that should be applied to the input images.
             Defaults to ``None``.
         split: 'train', 'val' or 'test'
-        task: ``classification``, ``detection`` or ``segmentation``
         create_validation_set: Create a validation subset in addition to the train and test subsets
 
     Examples:
@@ -39,7 +37,6 @@ class BTechDataset(AnomalibDataset):
         >>> from anomalib.data.utils.transforms import get_transforms
         >>> transform = get_transforms(image_size=256)
         >>> dataset = BTechDataset(
-        ...     task="classification",
         ...     transform=transform,
         ...     root='./datasets/BTech',
         ...     category='01',
@@ -52,7 +49,6 @@ class BTechDataset(AnomalibDataset):
         >>> dataset[0].keys()
         dict_keys(['image', 'image_path', 'label'])
 
-        >>> dataset.task = "segmentation"
         >>> dataset.split = "train"
         >>> dataset[0].keys()
         dict_keys(['image'])
@@ -71,9 +67,8 @@ def __init__(
         category: str,
         transform: Transform | None = None,
         split: str | Split | None = None,
-        task: TaskType | str = TaskType.SEGMENTATION,
     ) -> None:
-        super().__init__(task, transform)
+        super().__init__(transform)
 
         self.root_category = Path(root) / category
         self.split = split
@@ -150,6 +145,9 @@ def make_btech_dataset(path: Path, split: str | Split | None = None) -> DataFram
     samples.loc[(samples.label != "ok"), "label_index"] = LabelName.ABNORMAL
     samples.label_index = samples.label_index.astype(int)
 
+    # infer the task type
+    samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
+
     # Get the data frame for the split.
     if split:
         samples = samples[samples.split == split]
diff --git a/src/anomalib/data/datasets/image/datumaro.py b/src/anomalib/data/datasets/image/datumaro.py
index 6c67c61359..9335f0a4b4 100644
--- a/src/anomalib/data/datasets/image/datumaro.py
+++ b/src/anomalib/data/datasets/image/datumaro.py
@@ -12,7 +12,6 @@
 import pandas as pd
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets.base import AnomalibDataset
 from anomalib.data.utils import LabelName, Split
 
@@ -80,6 +79,9 @@ def make_datumaro_dataset(root: str | Path, split: str | Split | None = None) ->
     samples_df.loc[samples_df["label_index"] == LabelName.NORMAL, "split"] = Split.TRAIN
     samples_df.loc[samples_df["label_index"] == LabelName.ABNORMAL, "split"] = Split.TEST
 
+    # datumaro only supports classification
+    samples_df.attrs["task"] = "classification"
+
     # Get the data frame for the split.
     if split:
         samples_df = samples_df[samples_df.split == split].reset_index(drop=True)
@@ -116,11 +118,10 @@ class DatumaroDataset(AnomalibDataset):
 
     def __init__(
         self,
-        task: TaskType,
         root: str | Path,
         transform: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(task, transform)
+        super().__init__(transform)
         self.split = split
         self.samples = make_datumaro_dataset(root, split)
diff --git a/src/anomalib/data/datasets/image/folder.py b/src/anomalib/data/datasets/image/folder.py
index 48415c0867..08e01d85c2 100644
--- a/src/anomalib/data/datasets/image/folder.py
+++ b/src/anomalib/data/datasets/image/folder.py
@@ -12,7 +12,6 @@
 from pandas import DataFrame
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets.base.image import AnomalibDataset
 from anomalib.data.errors import MisMatchError
 from anomalib.data.utils import DirType, LabelName, Split
@@ -26,7 +25,6 @@ class FolderDataset(AnomalibDataset):
 
     Args:
         name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
-        task (TaskType): Task type. (``classification``, ``detection`` or ``segmentation``).
         transform (Transform, optional): Transforms that should be applied to the input images.
             Defaults to ``None``.
         normal_dir (str | Path | Sequence): Path to the directory containing normal images.
@@ -46,10 +44,6 @@ class FolderDataset(AnomalibDataset):
         extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
             Defaults to ``None``.
 
-    Raises:
-        ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is
-            provided, `task` should be set to `segmentation`.
-
     Examples:
         Assume that we would like to use this ``FolderDataset`` to create a dataset from a folder for a classification
         task. We could first create the transforms,
@@ -66,7 +60,6 @@ class FolderDataset(AnomalibDataset):
                 abnormal_dir=dataset_root / "crack",
                 split="train",
                 transform=transform,
-                task=TaskType.CLASSIFICATION,
             )
 
     """
@@ -74,7 +67,6 @@ class FolderDataset(AnomalibDataset):
     def __init__(
         self,
         name: str,
-        task: TaskType,
         normal_dir: str | Path | Sequence[str | Path],
         transform: Transform | None = None,
         root: str | Path | None = None,
@@ -84,7 +76,7 @@ def __init__(
         split: str | Split | None = None,
         extensions: tuple[str, ...] | None = None,
     ) -> None:
-        super().__init__(task, transform)
+        super().__init__(transform)
 
         self._name = name
         self.split = split
@@ -263,6 +255,9 @@ def _resolve_path_and_convert_to_list(path: str | Path | Sequence[str | Path] |
     samples.loc[(samples.label == DirType.NORMAL), "split"] = Split.TRAIN
     samples.loc[(samples.label == DirType.ABNORMAL) | (samples.label == DirType.NORMAL_TEST), "split"] = Split.TEST
 
+    # infer the task type
+    samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
+
     # Get the data frame for the split.
     if split:
         samples = samples[samples.split == split]
diff --git a/src/anomalib/data/datasets/image/kolektor.py b/src/anomalib/data/datasets/image/kolektor.py
index 39e9380a03..410d2191cf 100644
--- a/src/anomalib/data/datasets/image/kolektor.py
+++ b/src/anomalib/data/datasets/image/kolektor.py
@@ -25,7 +25,6 @@
 from sklearn.model_selection import train_test_split
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets import AnomalibDataset
 from anomalib.data.errors import MisMatchError
 from anomalib.data.utils import Split, validate_path
@@ -46,12 +45,11 @@ class KolektorDataset(AnomalibDataset):
 
     def __init__(
         self,
-        task: TaskType,
         root: Path | str = "./datasets/kolektor",
         transform: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(task=task, transform=transform)
+        super().__init__(transform=transform)
 
         self.root = root
         self.split = split
@@ -160,6 +158,9 @@ def make_kolektor_dataset(
         (e.g. image: 'Part0.jpg', mask: 'Part0_label.bmp')."""
         raise MisMatchError(msg)
 
+    # infer the task type
+    samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
+
     # Get the dataframe for the required split
     if split:
         samples = samples[samples.split == split].reset_index(drop=True)
diff --git a/src/anomalib/data/datasets/image/mvtec.py b/src/anomalib/data/datasets/image/mvtec.py
index bb6fdf9e41..c07cdf34e4 100644
--- a/src/anomalib/data/datasets/image/mvtec.py
+++ b/src/anomalib/data/datasets/image/mvtec.py
@@ -31,7 +31,6 @@
 from pandas import DataFrame
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets.base import AnomalibDataset
 from anomalib.data.errors import MisMatchError
 from anomalib.data.utils import LabelName, Split, validate_path
@@ -60,7 +59,6 @@ class MVTecDataset(AnomalibDataset):
     """MVTec dataset class.
 
     Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
         root (Path | str): Path to the root of the dataset.
             Defaults to ``./datasets/MVTec``.
         category (str): Sub-category of the dataset, e.g. 'bottle'
@@ -107,13 +105,12 @@ class MVTecDataset(AnomalibDataset):
 
     def __init__(
         self,
-        task: TaskType,
         root: Path | str = "./datasets/MVTec",
         category: str = "bottle",
         transform: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(task=task, transform=transform)
+        super().__init__(transform=transform)
 
         self.root_category = Path(root) / Path(category)
         self.category = category
@@ -209,6 +206,9 @@ def make_mvtec_dataset(
         anomalous images in the dataset (e.g. image: '000.png', mask: '000.png' or '000_mask.png')."""
         raise MisMatchError(msg)
 
+    # infer the task type
+    samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
+
     if split:
         samples = samples[samples.split == split].reset_index(drop=True)
 
diff --git a/src/anomalib/data/datasets/image/visa.py b/src/anomalib/data/datasets/image/visa.py
index 9c5336ab05..70ee5352aa 100644
--- a/src/anomalib/data/datasets/image/visa.py
+++ b/src/anomalib/data/datasets/image/visa.py
@@ -23,7 +23,6 @@
 
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets import AnomalibDataset
 from anomalib.data.datasets.image.mvtec import make_mvtec_dataset
 from anomalib.data.utils import Split
@@ -49,7 +48,6 @@ class VisaDataset(AnomalibDataset):
     """VisA dataset class.
 
     Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``
         root (str | Path): Path to the root of the dataset
         category (str): Sub-category of the dataset, e.g. 'candle'
         transform (Transform, optional): Transforms that should be applied to the input images.
@@ -67,7 +65,6 @@ class VisaDataset(AnomalibDataset):
 
             transform = get_transforms(image_size=256)
             dataset = VisaDataset(
-                task="classification",
                 transform=transform,
                 split="train",
                 root="./datasets/visa/visa_pytorch/",
@@ -77,42 +74,18 @@ class VisaDataset(AnomalibDataset):
             dataset[0].keys()
 
             # Output
-            dict_keys(['image_path', 'label', 'image'])
-
-        If you want to use the dataset for segmentation, you can use the same
-        code as above, with the task set to ``segmentation``. The dataset will
-        then have a ``mask`` key in the output dictionary.
-
-        .. code-block:: python
-
-            from anomalib.data.image.visa import VisaDataset
-            from anomalib.data.utils.transforms import get_transforms
-
-            transform = get_transforms(image_size=256)
-            dataset = VisaDataset(
-                task="segmentation",
-                transform=transform,
-                split="train",
-                root="./datasets/visa/visa_pytorch/",
-                category="candle",
-            )
-            dataset.setup()
-            dataset[0].keys()
-
-            # Output
-            dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask'])
+            dict_keys(['image_path', 'label', 'image', 'mask'])
 
     """
 
     def __init__(
         self,
-        task: TaskType,
         root: str | Path,
         category: str,
         transform: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(task=task, transform=transform)
+        super().__init__(transform=transform)
 
         self.root_category = Path(root) / category
         self.split = split
diff --git a/src/anomalib/data/datasets/video/avenue.py b/src/anomalib/data/datasets/video/avenue.py
index 0d3bd741bf..03c07404a5 100644
--- a/src/anomalib/data/datasets/video/avenue.py
+++ b/src/anomalib/data/datasets/video/avenue.py
@@ -22,7 +22,6 @@
 from pandas import DataFrame
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets.base.video import AnomalibVideoDataset, VideoTargetFrame
 from anomalib.data.utils import Split, read_mask, validate_path
 from anomalib.data.utils.video import ClipsIndexer
@@ -35,7 +34,6 @@ class AvenueDataset(AnomalibVideoDataset):
     """Avenue Dataset class.
 
     Args:
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
         split (Split): Split of the dataset, usually Split.TRAIN or Split.TEST
         root (Path | str): Path to the root of the dataset
             Defaults to ``./datasets/avenue``.
@@ -51,29 +49,11 @@ class AvenueDataset(AnomalibVideoDataset):
             Defaults to ``None``.
 
     Examples:
-        To create an Avenue dataset to train a classification model:
+        To create an Avenue dataset to train a model:
 
         .. code-block:: python
 
-            transform = A.Compose([A.Resize(256, 256), A.pytorch.ToTensorV2()])
             dataset = AvenueDataset(
-                task="classification",
-                transform=transform,
-                split="train",
-                root="./datasets/avenue/",
-            )
-
-            dataset.setup()
-            dataset[0].keys()
-
-            # Output: dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image'])
-
-        If you would like to test a segmentation model, you can use the following code:
-
-        .. code-block:: python
-
-            dataset = AvenueDataset(
-                task="segmentation",
                 transform=transform,
                 split="test",
                 root="./datasets/avenue/",
@@ -85,13 +65,12 @@ class AvenueDataset(AnomalibVideoDataset):
             # Output: dict_keys(['image', 'mask', 'video_path', 'frames', 'last_frame', 'original_image', 'label'])
 
         Avenue video dataset can also be used as an image dataset if you set the clip length to 1. This means that each
-        video frame will be treated as a separate sample. This is useful for training a classification model on the
-        Avenue dataset. The following code shows how to create an image dataset for classification:
+        video frame will be treated as a separate sample. This is useful for training an image model on the
+        Avenue dataset. The following code shows how to create an image dataset:
 
         .. code-block:: python
 
             dataset = AvenueDataset(
-                task="classification",
                 transform=transform,
                 split="test",
                 root="./datasets/avenue/",
@@ -108,7 +87,6 @@ class AvenueDataset(AnomalibVideoDataset):
 
     def __init__(
         self,
-        task: TaskType,
         split: Split,
         root: Path | str = "./datasets/avenue",
         gt_dir: Path | str = "./datasets/avenue/ground_truth_demo",
@@ -118,7 +96,6 @@ def __init__(
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
     ) -> None:
         super().__init__(
-            task=task,
             clip_length_in_frames=clip_length_in_frames,
             frames_between_clips=frames_between_clips,
             target_frame=target_frame,
@@ -178,6 +155,9 @@ def make_avenue_dataset(root: Path, gt_dir: Path, split: Split | str | None = No
     samples.loc[samples.folder == "training_videos", "split"] = "train"
     samples.loc[samples.folder == "testing_videos", "split"] = "test"
 
+    # infer the task type
+    samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
+
     if split:
         samples = samples[samples.split == split]
         samples = samples.reset_index(drop=True)
diff --git a/src/anomalib/data/datasets/video/shanghaitech.py b/src/anomalib/data/datasets/video/shanghaitech.py
index e90dbae482..424a13e9e6 100644
--- a/src/anomalib/data/datasets/video/shanghaitech.py
+++ b/src/anomalib/data/datasets/video/shanghaitech.py
@@ -25,7 +25,6 @@
 from pandas import DataFrame
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets.base.video import AnomalibVideoDataset, VideoTargetFrame
 from anomalib.data.utils import Split, read_image, validate_path
 from anomalib.data.utils.video import ClipsIndexer
@@ -35,7 +34,6 @@ class ShanghaiTechDataset(AnomalibVideoDataset):
     """ShanghaiTech Dataset class.
 
     Args:
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
         split (Split): Split of the dataset, usually Split.TRAIN or Split.TEST
         root (Path | str): Path to the root of the dataset
         scene (int): Index of the dataset scene (category) in range [1, 13]
@@ -48,7 +46,6 @@ class ShanghaiTechDataset(AnomalibVideoDataset):
 
     def __init__(
         self,
-        task: TaskType,
         split: Split,
         root: Path | str = "./datasets/shanghaitech",
         scene: int = 1,
@@ -58,7 +55,6 @@ def __init__(
         transform: Transform | None = None,
     ) -> None:
         super().__init__(
-            task=task,
             clip_length_in_frames=clip_length_in_frames,
             frames_between_clips=frames_between_clips,
             target_frame=target_frame,
@@ -194,6 +190,9 @@ def make_shanghaitech_dataset(root: Path, scene: int, split: Split | str | None
 
     samples["image_path"] = samples.root + "/" + samples.image_path
 
+    # infer the task type
+    samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
+
     if split:
         samples = samples[samples.split == split]
         samples = samples.reset_index(drop=True)
diff --git a/src/anomalib/data/datasets/video/ucsd_ped.py b/src/anomalib/data/datasets/video/ucsd_ped.py
index 960218e79e..5a619be3f1 100644
--- a/src/anomalib/data/datasets/video/ucsd_ped.py
+++ b/src/anomalib/data/datasets/video/ucsd_ped.py
@@ -11,7 +11,6 @@
 from pandas import DataFrame
 from torchvision.transforms.v2 import Transform
 
-from anomalib import TaskType
 from anomalib.data.datasets.base.video import AnomalibVideoDataset, VideoTargetFrame
 from anomalib.data.utils import Split, read_image, read_mask, validate_path
 from anomalib.data.utils.video import ClipsIndexer
@@ -26,7 +25,6 @@ class UCSDpedDataset(AnomalibVideoDataset):
     """UCSDped Dataset class.
 
     Args:
-        task (TaskType): Task type, 'classification', 'detection' or 'segmentation'
         root (Path | str): Path to the root of the dataset
         category (str): Sub-category of the dataset, e.g. "UCSDped1" or "UCSDped2"
         split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
@@ -39,7 +37,6 @@ class UCSDpedDataset(AnomalibVideoDataset):
 
     def __init__(
         self,
-        task: TaskType,
         root: str | Path,
         category: str,
         split: Split,
@@ -49,7 +46,6 @@ def __init__(
         transform: Transform | None = None,
     ) -> None:
         super().__init__(
-            task=task,
             clip_length_in_frames=clip_length_in_frames,
             frames_between_clips=frames_between_clips,
             target_frame=target_frame,
@@ -160,6 +156,9 @@ def make_ucsd_dataset(path: Path, split: str | Split | None = None) -> DataFrame
     samples.loc[samples.folder == "Train", "split"] = "train"
     samples.loc[samples.folder == "Test", "split"] = "test"
 
+    # infer the task type
+    samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
+
     if split:
         samples = samples[samples.split == split]
         samples = samples.reset_index(drop=True)
diff --git a/src/anomalib/data/utils/synthetic.py b/src/anomalib/data/utils/synthetic.py
index 7d2b340e33..c4b52d5b35 100644
--- a/src/anomalib/data/utils/synthetic.py
+++ b/src/anomalib/data/utils/synthetic.py
@@ -18,7 +18,6 @@
 from pandas import DataFrame, Series
 from torchvision.transforms.v2 import Compose
 
-from anomalib import TaskType
 from anomalib.data.datasets.base.image import AnomalibDataset
 from anomalib.data.utils import Split, read_image
 from anomalib.data.utils.generators.perlin import PerlinAnomalyGenerator
@@ -114,13 +113,12 @@ class SyntheticAnomalyDataset(AnomalibDataset):
     """Dataset which reads synthetically generated anomalous images from a temporary folder.
 
     Args:
-        task (str): Task type, either "classification" or "segmentation".
         transform (A.Compose): Transform object describing the transforms that are applied to the inputs.
         source_samples (DataFrame): Normal samples to which the anomalous augmentations will be applied.
     """
 
-    def __init__(self, task: TaskType, transform: Compose, source_samples: DataFrame) -> None:
-        super().__init__(task, transform)
+    def __init__(self, transform: Compose, source_samples: DataFrame) -> None:
+        super().__init__(transform)
 
         self.source_samples = source_samples
 
@@ -147,7 +145,7 @@ def from_dataset(cls: type["SyntheticAnomalyDataset"], dataset: AnomalibDataset)
             dataset (AnomalibDataset): Dataset consisting of only normal images that will be converrted to a synthetic
                 anomalous dataset with a 50/50 normal anomalous split.
         """
-        return cls(task=dataset.task, transform=dataset.transform, source_samples=dataset.samples)
+        return cls(transform=dataset.transform, source_samples=dataset.samples)
 
     def __copy__(self) -> "SyntheticAnomalyDataset":
         """Return a shallow copy of the dataset object and prevents cleanup when original object is deleted."""
diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index 017e20bb93..fe823f3729 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -15,7 +15,7 @@
 from torch.utils.data import DataLoader, Dataset
 from torchmetrics import Metric
 
-from anomalib import LearningType, TaskType
+from anomalib import LearningType
 from anomalib.callbacks.checkpoint import ModelCheckpoint
 from anomalib.callbacks.timer import TimerCallback
 from anomalib.data import AnomalibDataModule, AnomalibDataset, PredictDataset
@@ -99,7 +99,6 @@ class Engine:
             Defaults to NormalizationMethod.MIN_MAX.
         threshold (THRESHOLD):
             Thresholding method. Defaults to "F1AdaptiveThreshold".
-        task (TaskType, optional): Task type. Defaults to TaskType.SEGMENTATION.
         image_metrics (list[str] | str | dict[str, dict[str, Any]] | None, optional): Image metrics to be used for
             evaluation. Defaults to None.
         pixel_metrics (list[str] | str | dict[str, dict[str, Any]] | None, optional): Pixel metrics to be used for
@@ -113,7 +112,6 @@ class Engine:
     def __init__(
         self,
         callbacks: list[Callback] | None = None,
-        task: TaskType | str = TaskType.SEGMENTATION,
         logger: Logger | Iterable[Logger] | bool | None = None,
         default_root_dir: str | Path = "results",
         **kwargs,
@@ -132,8 +130,6 @@ def __init__(
             **kwargs,
         )
 
-        self.task = TaskType(task)
-
         self._trainer: Trainer | None = None
 
     @property
@@ -271,26 +267,6 @@ def _setup_trainer(self, model: AnomalibModule) -> None:
         if self._trainer is None:
             self._trainer = Trainer(**self._cache.args)
 
-    def _setup_dataset_task(
-        self,
-        *dataloaders: EVAL_DATALOADERS | TRAIN_DATALOADERS | AnomalibDataModule | None,
-    ) -> None:
-        """Override the dataloader task with the task passed to the Engine.
-
-        Args:
-            dataloaders (TRAIN_DATALOADERS | EVAL_DATALOADERS): Dataloaders to be used for training or evaluation.
-        """
-        for dataloader in dataloaders:
-            if dataloader is not None and isinstance(dataloader, AnomalibDataModule):
-                for attribute in ("train_data", "val_data", "test_data"):
-                    if hasattr(dataloader, attribute):
-                        data: AnomalibDataset = getattr(dataloader, attribute)
-                        if data.task != self.task:
-                            logger.info(
-                                f"Overriding task from {data.task} with {self.task} for {dataloader.__class__}",
-                            )
-                            data.task = self.task
-
     def _setup_anomalib_callbacks(self, model: AnomalibModule) -> None:
         """Set up callbacks for the trainer."""
         _callbacks: list[Callback] = []
@@ -402,7 +378,6 @@ def fit(
             versioned_dir=True,
         )
         self._setup_trainer(model)
-        self._setup_dataset_task(train_dataloaders, val_dataloaders, datamodule)
         if model.learning_type in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}:
             # if the model is zero-shot or few-shot, we only need to run validate for normalization and thresholding
             self.trainer.validate(model, val_dataloaders, datamodule=datamodule, ckpt_path=ckpt_path)
@@ -455,7 +430,6 @@ def validate(
             ckpt_path = Path(ckpt_path).resolve()
         if model:
             self._setup_trainer(model)
-        self._setup_dataset_task(dataloaders)
         return self.trainer.validate(model, dataloaders, ckpt_path, verbose, datamodule)
 
     def test(
@@ -468,8 +442,7 @@ def test(
     ) -> _EVALUATE_OUTPUT:
         """Test the model using the trainer.
 
-        Sets up the trainer and the dataset task if not already set up. Then validates the model if needed and
-        finally tests the model.
+        Then validates the model if needed and then tests the model.
 
         Args:
             model (AnomalibModule | None, optional):
@@ -548,7 +521,6 @@ def test(
             msg = "`Engine.test()` requires an `AnomalibModule` when it hasn't been passed in a previous run."
             raise RuntimeError(msg)
 
-        self._setup_dataset_task(dataloaders)
         if self._should_run_validation(model or self.model, ckpt_path):
             logger.info("Running validation before testing to collect normalization metrics and/or thresholds.")
             self.trainer.validate(model, dataloaders, None, verbose=False, datamodule=datamodule)
@@ -566,8 +538,7 @@ def predict(
     ) -> _PREDICT_OUTPUT | None:
         """Predict using the model using the trainer.
 
-        Sets up the trainer and the dataset task if not already set up. Then validates the model if needed and a
-        validation dataloader is available. Finally, predicts using the model.
+        Validates the model if needed and if a validation dataloader is available. Then predicts using the model.
 
         Args:
             model (AnomalibModule | None, optional):
@@ -652,8 +623,6 @@ def predict(
             dataloaders.append(DataLoader(dataset, collate_fn=dataset.collate_fn))
         dataloaders = dataloaders or None
 
-        self._setup_dataset_task(dataloaders, datamodule)
-
         if self._should_run_validation(model or self.model, ckpt_path):
             logger.info("Running validation before predicting to collect normalization metrics and/or thresholds.")
             self.trainer.validate(
@@ -716,12 +685,6 @@ def train(
             versioned_dir=True,
         )
         self._setup_trainer(model)
-        self._setup_dataset_task(
-            train_dataloaders,
-            val_dataloaders,
-            test_dataloaders,
-            datamodule,
-        )
         if model.learning_type in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}:
             # if the model is zero-shot or few-shot, we only need to run validate for normalization and thresholding
             self.trainer.validate(model, val_dataloaders, None, verbose=False, datamodule=datamodule)
@@ -814,7 +777,6 @@ def export(
             exported_model_path = model.to_openvino(
                 export_root=export_root,
                 input_size=input_size,
-                task=self.task,
                 compression_type=compression_type,
                 datamodule=datamodule,
                 metric=metric,
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomaly_module.py
index 6509351cfb..408200231a 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomaly_module.py
@@ -296,8 +296,6 @@ def from_config(
         from jsonargparse import ActionConfigFile, ArgumentParser
         from lightning.pytorch import Trainer
 
-        from anomalib import TaskType
-
         if not Path(config_path).exists():
             msg = f"Configuration file not found: {config_path}"
             raise FileNotFoundError(msg)
@@ -310,7 +308,6 @@ def from_config(
             help="Path to a configuration file in json or yaml format.",
         )
         model_parser.add_subclass_arguments(AnomalibModule, "model", required=False, fail_untyped=False)
-        model_parser.add_argument("--task", type=TaskType | str, default=TaskType.SEGMENTATION)
         model_parser.add_argument("--metrics.image", type=list[str] | str | None, default=["F1Score", "AUROC"])
         model_parser.add_argument("--metrics.pixel", type=list[str] | str | None, default=None, required=False)
         model_parser.add_argument("--metrics.threshold", type=Threshold | str, default="F1AdaptiveThreshold")
diff --git a/src/anomalib/models/components/base/export_mixin.py b/src/anomalib/models/components/base/export_mixin.py
index 0e455332bd..dbcd6166de 100644
--- a/src/anomalib/models/components/base/export_mixin.py
+++ b/src/anomalib/models/components/base/export_mixin.py
@@ -47,8 +47,6 @@ def to_torch(
                 Defaults to ``None``.
             post_processor (nn.Module, optional): Post-processing module to apply to the model output.
                 Defaults to ``None``.
-            task (TaskType | None): Task type.
-                Defaults to ``None``.
 
         Returns:
             Path: Path to the exported pytorch model.
@@ -70,7 +68,6 @@ def to_torch(
 
             >>> model.to_torch(
             ...     export_root="path/to/export",
-            ...     task=datamodule.test_data.task,
             ... )
         """
         export_root = _create_export_root(export_root, ExportType.TORCH)
@@ -97,8 +94,6 @@ def to_onnx(
                 Defaults to ``None``.
             post_processor (nn.Module, optional): Post-processing module to apply to the model output.
                 Defaults to ``None``.
-            task (TaskType | None): Task type.
-                Defaults to ``None``.
 
         Returns:
             Path: Path to the exported onnx model.
@@ -115,7 +110,6 @@ def to_onnx(
             >>> model.to_onnx(
             ...     export_root="path/to/export",
             ...     transform=datamodule.test_data.transform,
-            ...     task=datamodule.test_data.task
             ... )
 
             Using Custom Transforms:
@@ -123,7 +117,6 @@ def to_onnx(
 
             >>> model.to_onnx(
             ...     export_root="path/to/export",
-            ...     task="segmentation",
             ... )
         """
         export_root = _create_export_root(export_root, ExportType.ONNX)
@@ -293,7 +286,6 @@ def _compress_ov_model(
         elif compression_type == CompressionType.INT8_PTQ:
             model = self._post_training_quantization_ov(model, datamodule)
         elif compression_type == CompressionType.INT8_ACQ:
-            assert task is not None, "Task must be provided for OpenVINO accuracy aware compression"
             model = self._accuracy_control_quantization_ov(model, datamodule, metric, task)
         else:
             msg = f"Unrecognized compression type: {compression_type}"
@@ -367,6 +359,9 @@ def _accuracy_control_quantization_ov(
             raise ValueError(msg)
         datamodule.setup("fit")
 
+        # if task is not provided, use the task from the datamodule
+        task = task or datamodule.task
+
         if metric is None:
             msg = "Metric must be provided for OpenVINO INT8_ACQ compression"
             raise ValueError(msg)
diff --git a/tests/integration/cli/test_cli.py b/tests/integration/cli/test_cli.py
index 3a9b001903..1385d756c7 100644
--- a/tests/integration/cli/test_cli.py
+++ b/tests/integration/cli/test_cli.py
@@ -209,8 +209,6 @@ def _get_common_cli_args(dataset_path: Path | None, project_path: Path) -> list[
             *data_args,
             "--default_root_dir",
             str(project_path),
-            "--task",
-            "SEGMENTATION",
             "--trainer.max_epochs",
             "1",
         ]
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index e78ad19fe0..fee98301ea 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -14,7 +14,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import AnomalibDataModule, MVTec
 from anomalib.deploy import ExportType
 from anomalib.engine import Engine
@@ -194,10 +193,6 @@ def _get_objects(
             tuple[AnomalibModule, AnomalibDataModule, Engine]: Returns the created objects for model, dataset,
                 and engine
         """
-        # select task type
-
-        task_type = TaskType.CLASSIFICATION if model_name in {"ganomaly", "dfkde"} else TaskType.SEGMENTATION
-
         # set extra model args
         # TODO(ashwinvaidya17): Fix these Edge cases
         # https://github.com/openvinotoolkit/anomalib/issues/1478
@@ -214,7 +209,6 @@ def _get_objects(
             dataset = MVTec(
                 root=dataset_path / "mvtec",
                 category="dummy",
-                task=task_type,
                 # EfficientAd requires train batch size 1
                 train_batch_size=1 if model_name == "efficient_ad" else 2,
             )
@@ -230,7 +224,6 @@ def _get_objects(
             default_root_dir=project_path,
             max_epochs=1,
             devices=1,
-            task=task_type,
             # TODO(ashwinvaidya17): Fix these Edge cases
             # https://github.com/openvinotoolkit/anomalib/issues/1478
             max_steps=70000 if model_name == "efficient_ad" else -1,
diff --git a/tests/integration/tools/upgrade/expected_draem_v1.yaml b/tests/integration/tools/upgrade/expected_draem_v1.yaml
index 882e27b74e..438c49fd73 100644
--- a/tests/integration/tools/upgrade/expected_draem_v1.yaml
+++ b/tests/integration/tools/upgrade/expected_draem_v1.yaml
@@ -6,7 +6,6 @@ data:
     train_batch_size: 72
     eval_batch_size: 32
     num_workers: 8
-    task: segmentation
     test_split_mode: from_dir
     test_split_ratio: 0.2
     val_split_mode: same_as_test
@@ -45,7 +44,6 @@ visualization:
 logging:
   log_graph: false
 seed_everything: true
-task: segmentation
 results_dir:
   path: ./results
   unique: false
diff --git a/tests/unit/data/datamodule/depth/test_folder_3d.py b/tests/unit/data/datamodule/depth/test_folder_3d.py
index 9ebf82e3f2..71adef7b12 100644
--- a/tests/unit/data/datamodule/depth/test_folder_3d.py
+++ b/tests/unit/data/datamodule/depth/test_folder_3d.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import Folder3D
 from tests.unit.data.datamodule.base.depth import _TestAnomalibDepthDatamodule
 
@@ -17,7 +16,7 @@ class TestFolder3D(_TestAnomalibDepthDatamodule):
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType) -> Folder3D:
+    def datamodule(dataset_path: Path) -> Folder3D:
         """Create and return a Folder 3D datamodule."""
         _datamodule = Folder3D(
             name="dummy",
@@ -32,7 +31,6 @@ def datamodule(dataset_path: Path, task_type: TaskType) -> Folder3D:
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
-            task=task_type,
         )
         _datamodule.prepare_data()
         _datamodule.setup()
diff --git a/tests/unit/data/datamodule/depth/test_mvtec_3d.py b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
index 6a94f1b279..2a90822763 100644
--- a/tests/unit/data/datamodule/depth/test_mvtec_3d.py
+++ b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import MVTec3D
 from tests.unit.data.datamodule.base.depth import _TestAnomalibDepthDatamodule
 
@@ -17,12 +16,11 @@ class TestMVTec3D(_TestAnomalibDepthDatamodule):
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType) -> MVTec3D:
+    def datamodule(dataset_path: Path) -> MVTec3D:
         """Create and return a Folder 3D datamodule."""
         _datamodule = MVTec3D(
             root=dataset_path / "mvtec_3d",
             category="dummy",
-            task=task_type,
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
diff --git a/tests/unit/data/datamodule/image/test_btech.py b/tests/unit/data/datamodule/image/test_btech.py
index 2f483da7c8..fb559641c1 100644
--- a/tests/unit/data/datamodule/image/test_btech.py
+++ b/tests/unit/data/datamodule/image/test_btech.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import BTech
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
@@ -17,12 +16,11 @@ class TestBTech(_TestAnomalibImageDatamodule):
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType) -> BTech:
+    def datamodule(dataset_path: Path) -> BTech:
         """Create and return a BTech datamodule."""
         _datamodule = BTech(
             root=dataset_path / "btech",
             category="dummy",
-            task=task_type,
             train_batch_size=4,
             eval_batch_size=4,
         )
diff --git a/tests/unit/data/datamodule/image/test_datumaro.py b/tests/unit/data/datamodule/image/test_datumaro.py
index 789d4571c0..e10009a71c 100644
--- a/tests/unit/data/datamodule/image/test_datumaro.py
+++ b/tests/unit/data/datamodule/image/test_datumaro.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import Datumaro
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
@@ -17,14 +16,10 @@ class TestDatumaro(_TestAnomalibImageDatamodule):
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType) -> Datumaro:
+    def datamodule(dataset_path: Path) -> Datumaro:
         """Create and return a Datumaro datamodule."""
-        if task_type != TaskType.CLASSIFICATION:
-            pytest.skip("Datumaro only supports classification tasks.")
-
         _datamodule = Datumaro(
             root=dataset_path / "datumaro",
-            task=task_type,
             train_batch_size=4,
             eval_batch_size=4,
         )
diff --git a/tests/unit/data/datamodule/image/test_folder.py b/tests/unit/data/datamodule/image/test_folder.py
index a11cc4b725..e564b5a5e3 100644
--- a/tests/unit/data/datamodule/image/test_folder.py
+++ b/tests/unit/data/datamodule/image/test_folder.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import Folder
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
@@ -20,11 +19,10 @@ class TestFolder(_TestAnomalibImageDatamodule):
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType) -> Folder:
+    def datamodule(dataset_path: Path) -> Folder:
         """Create and return a Folder datamodule."""
-        # Make sure to use a mask directory for segmentation. Folder datamodule
         # expects a relative directory to the root.
-        mask_dir = None if task_type == TaskType.CLASSIFICATION else "ground_truth/bad"
+        mask_dir = "ground_truth/bad"
 
         # Create and prepare the dataset
         _datamodule = Folder(
@@ -37,7 +35,6 @@ def datamodule(dataset_path: Path, task_type: TaskType) -> Folder:
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
-            task=task_type,
         )
         _datamodule.setup()
 
diff --git a/tests/unit/data/datamodule/image/test_kolektor.py b/tests/unit/data/datamodule/image/test_kolektor.py
index 7fc061c09d..3d6b896d50 100644
--- a/tests/unit/data/datamodule/image/test_kolektor.py
+++ b/tests/unit/data/datamodule/image/test_kolektor.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import Kolektor
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
@@ -17,11 +16,10 @@ class TestKolektor(_TestAnomalibImageDatamodule):
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType) -> Kolektor:
+    def datamodule(dataset_path: Path) -> Kolektor:
         """Create and return a BTech datamodule."""
         _datamodule = Kolektor(
             root=dataset_path / "kolektor",
-            task=task_type,
             train_batch_size=4,
             eval_batch_size=4,
         )
diff --git a/tests/unit/data/datamodule/image/test_mvtec.py b/tests/unit/data/datamodule/image/test_mvtec.py
index 2df701a3b1..8f40c9e38a 100644
--- a/tests/unit/data/datamodule/image/test_mvtec.py
+++ b/tests/unit/data/datamodule/image/test_mvtec.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import MVTec
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
@@ -17,12 +16,11 @@ class TestMVTec(_TestAnomalibImageDatamodule):
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType) -> MVTec:
+    def datamodule(dataset_path: Path) -> MVTec:
         """Create and return a MVTec datamodule."""
         _datamodule = MVTec(
             root=dataset_path / "mvtec",
             category="dummy",
-            task=task_type,
             train_batch_size=4,
             eval_batch_size=4,
         )
diff --git a/tests/unit/data/datamodule/image/test_visa.py b/tests/unit/data/datamodule/image/test_visa.py
index 8b173f38cc..b24b1d42c0 100644
--- a/tests/unit/data/datamodule/image/test_visa.py
+++ b/tests/unit/data/datamodule/image/test_visa.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import Visa
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
 
@@ -17,7 +16,7 @@ class TestVisa(_TestAnomalibImageDatamodule):
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType) -> Visa:
+    def datamodule(dataset_path: Path) -> Visa:
         """Create and return a Avenue datamodule."""
         _datamodule = Visa(
             root=dataset_path,
@@ -25,7 +24,6 @@ def datamodule(dataset_path: Path, task_type: TaskType) -> Visa:
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
-            task=task_type,
         )
         _datamodule.prepare_data()
         _datamodule.setup()
diff --git a/tests/unit/data/datamodule/video/test_avenue.py b/tests/unit/data/datamodule/video/test_avenue.py
index 5069b93def..f63e240e15 100644
--- a/tests/unit/data/datamodule/video/test_avenue.py
+++ b/tests/unit/data/datamodule/video/test_avenue.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import Avenue
 from tests.unit.data.datamodule.base.video import _TestAnomalibVideoDatamodule
 
@@ -23,13 +22,12 @@ def clip_length_in_frames() -> int:
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: int) -> Avenue:
+    def datamodule(dataset_path: Path, clip_length_in_frames: int) -> Avenue:
         """Create and return a Avenue datamodule."""
         _datamodule = Avenue(
             root=dataset_path / "avenue",
             gt_dir=dataset_path / "avenue" / "ground_truth_demo",
             clip_length_in_frames=clip_length_in_frames,
-            task=task_type,
             num_workers=0,
             train_batch_size=4,
             eval_batch_size=4,
diff --git a/tests/unit/data/datamodule/video/test_shanghaitech.py b/tests/unit/data/datamodule/video/test_shanghaitech.py
index 4e96cfbaa7..e1dc1ba3c3 100644
--- a/tests/unit/data/datamodule/video/test_shanghaitech.py
+++ b/tests/unit/data/datamodule/video/test_shanghaitech.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import ShanghaiTech
 from tests.unit.data.datamodule.base.video import _TestAnomalibVideoDatamodule
 
@@ -23,7 +22,7 @@ def clip_length_in_frames() -> int:
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: int) -> ShanghaiTech:
+    def datamodule(dataset_path: Path, clip_length_in_frames: int) -> ShanghaiTech:
         """Create and return a Shanghai datamodule."""
         _datamodule = ShanghaiTech(
             root=dataset_path / "shanghaitech",
@@ -32,7 +31,6 @@ def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: i
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
-            task=task_type,
         )
 
         _datamodule.prepare_data()
diff --git a/tests/unit/data/datamodule/video/test_ucsdped.py b/tests/unit/data/datamodule/video/test_ucsdped.py
index 669d72278a..3da6c076d1 100644
--- a/tests/unit/data/datamodule/video/test_ucsdped.py
+++ b/tests/unit/data/datamodule/video/test_ucsdped.py
@@ -7,7 +7,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data import UCSDped
 from tests.unit.data.datamodule.base.video import _TestAnomalibVideoDatamodule
 
@@ -23,13 +22,12 @@ def clip_length_in_frames() -> int:
 
     @pytest.fixture()
     @staticmethod
-    def datamodule(dataset_path: Path, task_type: TaskType, clip_length_in_frames: int) -> UCSDped:
+    def datamodule(dataset_path: Path, clip_length_in_frames: int) -> UCSDped:
         """Create and return a UCSDped datamodule."""
         _datamodule = UCSDped(
             root=dataset_path / "ucsdped",
             category="dummy",
             clip_length_in_frames=clip_length_in_frames,
-            task=task_type,
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
diff --git a/tests/unit/data/utils/test_synthetic.py b/tests/unit/data/utils/test_synthetic.py
index 67b421c90d..09cb77e777 100644
--- a/tests/unit/data/utils/test_synthetic.py
+++ b/tests/unit/data/utils/test_synthetic.py
@@ -8,7 +8,6 @@
 
 import pytest
 
-from anomalib import TaskType
 from anomalib.data.datasets.image.folder import FolderDataset
 from anomalib.data.utils.synthetic import SyntheticAnomalyDataset
 
@@ -18,7 +17,6 @@ def folder_dataset(dataset_path: Path) -> FolderDataset:
     """Fixture that returns a FolderDataset instance."""
     return FolderDataset(
         name="dummy",
-        task=TaskType.SEGMENTATION,
         root=dataset_path / "mvtec" / "dummy",
         normal_dir="train/good",
         abnormal_dir="test/bad",
@@ -38,7 +36,6 @@ def synthetic_dataset(folder_dataset: FolderDataset) -> SyntheticAnomalyDataset:
 def synthetic_dataset_from_samples(folder_dataset: FolderDataset) -> SyntheticAnomalyDataset:
     """Fixture that returns a SyntheticAnomalyDataset instance."""
     return SyntheticAnomalyDataset(
-        task=folder_dataset.task,
         transform=folder_dataset.transform,
         source_samples=folder_dataset.samples,
     )
diff --git a/tests/unit/deploy/test_inferencer.py b/tests/unit/deploy/test_inferencer.py
index 9565cd58bc..3119866b4b 100644
--- a/tests/unit/deploy/test_inferencer.py
+++ b/tests/unit/deploy/test_inferencer.py
@@ -7,10 +7,8 @@
 from pathlib import Path
 
 import numpy as np
-import pytest
 import torch
 
-from anomalib import TaskType
 from anomalib.deploy import ExportType, OpenVINOInferencer, TorchInferencer
 from anomalib.engine import Engine
 from anomalib.models import Padim
@@ -48,14 +46,7 @@ def __call__(self) -> Iterable[np.ndarray] | Iterable[torch.Tensor]:
             yield self.image
 
 
-@pytest.mark.parametrize(
-    "task",
-    [
-        TaskType.CLASSIFICATION,
-        TaskType.SEGMENTATION,
-    ],
-)
-def test_torch_inference(task: TaskType, ckpt_path: Callable[[str], Path]) -> None:
+def test_torch_inference(ckpt_path: Callable[[str], Path]) -> None:
     """Tests Torch inference.
 
     Model is not trained as this checks that the inferencers are working.
@@ -66,7 +57,7 @@ def test_torch_inference(task: TaskType, ckpt_path: Callable[[str], Path]) -> No
         dataset_path (Path): Path to dummy dataset.
     """
     model = Padim()
-    engine = Engine(task=task)
+    engine = Engine()
     export_root = ckpt_path("Padim").parent.parent
     engine.export(
         model=model,
@@ -86,14 +77,7 @@ def test_torch_inference(task: TaskType, ckpt_path: Callable[[str], Path]) -> No
             assert 0.0 <= prediction.pred_score <= 1.0  # confirm if predicted scores are normalized
 
 
-@pytest.mark.parametrize(
-    "task",
-    [
-        TaskType.CLASSIFICATION,
-        TaskType.SEGMENTATION,
-    ],
-)
-def test_openvino_inference(task: TaskType, ckpt_path: Callable[[str], Path]) -> None:
+def test_openvino_inference(ckpt_path: Callable[[str], Path]) -> None:
     """Tests OpenVINO inference.
 
     Model is not trained as this checks that the inferencers are working.
@@ -104,7 +88,7 @@ def test_openvino_inference(task: TaskType, ckpt_path: Callable[[str], Path]) ->
         dataset_path (Path): Path to dummy dataset.
     """
     model = Padim()
-    engine = Engine(task=task)
+    engine = Engine()
     export_dir = ckpt_path("Padim").parent.parent
     exported_xml_file_path = engine.export(
         model=model,
diff --git a/tests/unit/engine/test_engine.py b/tests/unit/engine/test_engine.py
index c927733595..947fe3f843 100644
--- a/tests/unit/engine/test_engine.py
+++ b/tests/unit/engine/test_engine.py
@@ -8,7 +8,6 @@
 import pytest
 import yaml
 
-from anomalib import TaskType
 from anomalib.data import MVTec
 from anomalib.engine import Engine
 from anomalib.models import Padim
@@ -62,7 +61,6 @@ def fxt_full_config_path(tmp_path: Path) -> Path:
             plugins: null
             sync_batchnorm: false
             reload_dataloaders_every_n_epochs: 0
-        task: SEGMENTATION
         logging:
             log_graph: false
         default_root_dir: results
@@ -106,7 +104,6 @@ def test_from_config(fxt_full_config_path: Path) -> None:
         engine, model, datamodule = Engine.from_config(config_path=fxt_full_config_path)
         assert engine is not None
         assert isinstance(engine, Engine)
-        assert engine.task == TaskType.SEGMENTATION
         assert model is not None
         assert isinstance(model, Padim)
         assert datamodule is not None
@@ -114,13 +111,11 @@ def test_from_config(fxt_full_config_path: Path) -> None:
         assert datamodule.train_batch_size == 32
         assert datamodule.num_workers == 8
 
-        # Override task & batch_size & num_workers
+        # Override batch_size & num_workers
         override_kwargs = {
-            "task": "CLASSIFICATION",
             "data.train_batch_size": 1,
             "data.num_workers": 1,
         }
         engine, model, datamodule = Engine.from_config(config_path=fxt_full_config_path, **override_kwargs)
-        assert engine.task == TaskType.CLASSIFICATION
         assert datamodule.train_batch_size == 1
         assert datamodule.num_workers == 1
diff --git a/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py b/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
index 964e62415b..2bb04bbffe 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/test_visualizer.py
@@ -6,9 +6,6 @@
 import tempfile
 from pathlib import Path
 
-import pytest
-
-from anomalib import TaskType
 from anomalib.data import MVTec
 from anomalib.engine import Engine
 from anomalib.loggers import AnomalibTensorBoardLogger
@@ -16,8 +13,7 @@
 from .dummy_lightning_model import DummyModule
 
 
-@pytest.mark.parametrize("task", [TaskType.CLASSIFICATION, TaskType.SEGMENTATION])
-def test_add_images(task: TaskType, dataset_path: Path) -> None:
+def test_add_images(dataset_path: Path) -> None:
     """Tests if tensorboard logs are generated."""
     with tempfile.TemporaryDirectory() as dir_loc:
         logger = AnomalibTensorBoardLogger(name="tensorboard_logs", save_dir=dir_loc)
@@ -25,7 +21,6 @@ def test_add_images(task: TaskType, dataset_path: Path) -> None:
         engine = Engine(
             logger=logger,
             default_root_dir=dir_loc,
-            task=task,
             limit_test_batches=1,
             accelerator="cpu",
         )
diff --git a/tests/unit/utils/test_visualizer.py b/tests/unit/utils/test_visualizer.py
index be8993debb..924a0ad13a 100644
--- a/tests/unit/utils/test_visualizer.py
+++ b/tests/unit/utils/test_visualizer.py
@@ -7,11 +7,9 @@
 from pathlib import Path
 
 import numpy as np
-import pytest
 from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
 from torch.utils.data import DataLoader
 
-from anomalib import TaskType
 from anomalib.data import ImageBatch, MVTec, PredictDataset
 from anomalib.engine import Engine
 from anomalib.models import Padim
@@ -39,12 +37,10 @@ class TestVisualizer:
     """Test visualization callback for test and predict with different task types."""
 
     @staticmethod
-    @pytest.mark.parametrize("task", [TaskType.CLASSIFICATION, TaskType.SEGMENTATION])
     def test_model_visualizer_mode(
         ckpt_path: Callable[[str], Path],
         project_path: Path,
         dataset_path: Path,
-        task: TaskType,
     ) -> None:
         """Test combination of model/visualizer/mode on only 1 epoch as a sanity check before merge."""
         _ckpt_path: Path = ckpt_path("Padim")
@@ -53,9 +49,8 @@ def test_model_visualizer_mode(
             default_root_dir=project_path,
             fast_dev_run=True,
             devices=1,
-            task=task,
         )
-        datamodule = MVTec(root=dataset_path / "mvtec", category="dummy", task=task)
+        datamodule = MVTec(root=dataset_path / "mvtec", category="dummy")
         engine.test(model=model, datamodule=datamodule, ckpt_path=str(_ckpt_path))
 
         dataset = PredictDataset(path=dataset_path / "mvtec" / "dummy" / "test")
diff --git a/tools/upgrade/config.py b/tools/upgrade/config.py
index 5f1f3278e1..bd97cc0834 100644
--- a/tools/upgrade/config.py
+++ b/tools/upgrade/config.py
@@ -249,10 +249,6 @@ def add_ckpt_path_config() -> dict[str, Any]:
         """Create checkpoint path directory in v1 config."""
         return {"ckpt_path": None}
 
-    def add_task_config(self) -> dict[str, str]:
-        """Create task field in v1 config."""
-        return {"task": self.old_config["dataset"]["task"]}
-
     def upgrade_trainer_config(self) -> dict[str, Any]:
         """Upgrade Trainer config to v1 format."""
         # Get the signature of the Trainer class's __init__ method
@@ -290,7 +286,6 @@ def upgrade_all(self) -> dict[str, Any]:
         new_config.update(self.upgrade_visualization_config())
         new_config.update(self.upgrade_logging_config())
         new_config.update(self.add_seed_config())
-        new_config.update(self.add_task_config())
         new_config.update(self.add_results_dir_config())
         new_config.update(self.add_ckpt_path_config())
         new_config.update(self.upgrade_trainer_config())

From c73e411a27e9ef6b5eb97a2f7397995e994b0802 Mon Sep 17 00:00:00 2001
From: Ashwin Vaidya 
Date: Fri, 6 Dec 2024 13:52:38 +0100
Subject: [PATCH 16/45] =?UTF-8?q?=F0=9F=97=91=EF=B8=8F=20Remove=20RKDE=20(?=
 =?UTF-8?q?#2455)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* remove rkde

Signed-off-by: Ashwin Vaidya 

* update changelog

Signed-off-by: Ashwin Vaidya 

* Remove R-KDE model references and documentation

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 
---
 .github/CODEOWNERS                            |   1 -
 CHANGELOG.md                                  |   4 +
 configs/README.md                             |   1 -
 configs/model/rkde.yaml                       |  11 --
 .../guides/reference/models/image/index.md    |   8 -
 .../guides/reference/models/image/rkde.md     |  25 ---
 src/anomalib/models/__init__.py               |   2 -
 src/anomalib/models/image/__init__.py         |   2 -
 src/anomalib/models/image/rkde/README.md      |  45 -----
 src/anomalib/models/image/rkde/__init__.py    |   8 -
 .../models/image/rkde/feature_extractor.py    |  78 ---------
 .../models/image/rkde/lightning_model.py      | 165 ------------------
 .../models/image/rkde/region_extractor.py     | 145 ---------------
 src/anomalib/models/image/rkde/torch_model.py | 114 ------------
 tests/integration/model/test_models.py        |   9 +-
 .../components/base/test_anomaly_module.py    |   1 -
 16 files changed, 6 insertions(+), 613 deletions(-)
 delete mode 100644 configs/model/rkde.yaml
 delete mode 100644 docs/source/markdown/guides/reference/models/image/rkde.md
 delete mode 100644 src/anomalib/models/image/rkde/README.md
 delete mode 100644 src/anomalib/models/image/rkde/__init__.py
 delete mode 100644 src/anomalib/models/image/rkde/feature_extractor.py
 delete mode 100644 src/anomalib/models/image/rkde/lightning_model.py
 delete mode 100644 src/anomalib/models/image/rkde/region_extractor.py
 delete mode 100644 src/anomalib/models/image/rkde/torch_model.py

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index e1f032c544..2960d480a7 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -41,7 +41,6 @@
 /src/anomalib/models/padim                                  @samet-akcay
 /src/anomalib/models/patchcore                              @djdameln
 /src/anomalib/models/reverse_distillation                   @ashwinvaidya17
-/src/anomalib/models/rkde                                   @djdameln
 /src/anomalib/models/stfpm                                  @samet-akcay
 
 /src/anomalib/post_processing                               @ashwinvaidya17 @djdameln
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a18ebac732..b4e8248969 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Add `AUPIMO` tutorials notebooks in https://github.com/openvinotoolkit/anomalib/pull/2330 and https://github.com/openvinotoolkit/anomalib/pull/2336
 - Add `AUPIMO` metric by [jpcbertoldo](https://github.com/jpcbertoldo) in https://github.com/openvinotoolkit/anomalib/pull/1726 and refactored by [ashwinvaidya17](https://github.com/ashwinvaidya17) in https://github.com/openvinotoolkit/anomalib/pull/2329
 
+### Removed
+
+- Remove `RKDE` in https://github.com/openvinotoolkit/anomalib/pull/2455
+
 ### Changed
 
 ### Deprecated
diff --git a/configs/README.md b/configs/README.md
index bd3ecb618e..bb9bcf5de9 100644
--- a/configs/README.md
+++ b/configs/README.md
@@ -32,7 +32,6 @@ configs/
     ├── padim.yaml
     ├── patchcore.yaml
     ├── reverse_distillation.yaml
-    ├── rkde.yaml
     └── stfpm.yaml
 
 ```
diff --git a/configs/model/rkde.yaml b/configs/model/rkde.yaml
deleted file mode 100644
index 36ca63c261..0000000000
--- a/configs/model/rkde.yaml
+++ /dev/null
@@ -1,11 +0,0 @@
-model:
-  class_path: anomalib.models.Rkde
-  init_args:
-    roi_stage: RCNN
-    roi_score_threshold: 0.001
-    min_box_size: 25
-    iou_threshold: 0.3
-    max_detections_per_image: 100
-    n_pca_components: 16
-    feature_scaling_method: SCALE
-    max_training_points: 40000
diff --git a/docs/source/markdown/guides/reference/models/image/index.md b/docs/source/markdown/guides/reference/models/image/index.md
index 2229a3b15d..a872a2c7b2 100644
--- a/docs/source/markdown/guides/reference/models/image/index.md
+++ b/docs/source/markdown/guides/reference/models/image/index.md
@@ -95,13 +95,6 @@ Towards Total Recall in Industrial Anomaly Detection
 Anomaly Detection via Reverse Distillation from One-Class Embedding.
 :::
 
-:::{grid-item-card} {material-regular}`model_training;1.5em` R-KDE
-:link: ./rkde
-:link-type: doc
-
-Region-Based Kernel Density Estimation (RKDE)
-:::
-
 :::{grid-item-card} {material-regular}`model_training;1.5em` STFPM
 :link: ./stfpm
 :link-type: doc
@@ -141,7 +134,6 @@ WinCLIP: Zero-/Few-Shot Anomaly Classification and Segmentation
 ./padim
 ./patchcore
 ./reverse_distillation
-./rkde
 ./stfpm
 ./uflow
 ./winclip
diff --git a/docs/source/markdown/guides/reference/models/image/rkde.md b/docs/source/markdown/guides/reference/models/image/rkde.md
deleted file mode 100644
index 89126c4f77..0000000000
--- a/docs/source/markdown/guides/reference/models/image/rkde.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# R-KDE
-
-```{eval-rst}
-.. automodule:: anomalib.models.image.rkde.lightning_model
-   :members:
-   :show-inheritance:
-```
-
-```{eval-rst}
-.. automodule:: anomalib.models.image.rkde.torch_model
-   :members:
-   :show-inheritance:
-```
-
-```{eval-rst}
-.. automodule:: anomalib.models.image.rkde.feature_extractor
-   :members:
-   :show-inheritance:
-```
-
-```{eval-rst}
-.. automodule:: anomalib.models.image.rkde.region_extractor
-   :members:
-   :show-inheritance:
-```
diff --git a/src/anomalib/models/__init__.py b/src/anomalib/models/__init__.py
index 26f8695ab6..1e383530d0 100644
--- a/src/anomalib/models/__init__.py
+++ b/src/anomalib/models/__init__.py
@@ -27,7 +27,6 @@
     Padim,
     Patchcore,
     ReverseDistillation,
-    Rkde,
     Stfpm,
     Uflow,
     VlmAd,
@@ -55,7 +54,6 @@ class UnknownModelError(ModuleNotFoundError):
     "Padim",
     "Patchcore",
     "ReverseDistillation",
-    "Rkde",
     "Stfpm",
     "Uflow",
     "VlmAd",
diff --git a/src/anomalib/models/image/__init__.py b/src/anomalib/models/image/__init__.py
index b09da8b07b..c8ce0987b2 100644
--- a/src/anomalib/models/image/__init__.py
+++ b/src/anomalib/models/image/__init__.py
@@ -17,7 +17,6 @@
 from .padim import Padim
 from .patchcore import Patchcore
 from .reverse_distillation import ReverseDistillation
-from .rkde import Rkde
 from .stfpm import Stfpm
 from .uflow import Uflow
 from .vlm_ad import VlmAd
@@ -38,7 +37,6 @@
     "Padim",
     "Patchcore",
     "ReverseDistillation",
-    "Rkde",
     "Stfpm",
     "Uflow",
     "VlmAd",
diff --git a/src/anomalib/models/image/rkde/README.md b/src/anomalib/models/image/rkde/README.md
deleted file mode 100644
index 083c209208..0000000000
--- a/src/anomalib/models/image/rkde/README.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# Region-Based Kernel Density Estimation (RKDE)
-
-This is the implementation of the paper [Region Based Anomaly Detection With Real-Time
-Training and Analysis](https://ieeexplore.ieee.org/abstract/document/8999287).
-
-Model Type: Detection
-
-## Description
-
-Three-stage anomaly detection consisting of region extraction to obtain a set of region-of-interest proposals for each image, feature extraction to obtain a fixed-length feature vector for each region proposal, and density estimation to classify the region proposals as normal vs. anomalous.
-
-Both the region extractor and the feature extractor rely on pre-trained convolutional neural networks. The density estimation stage uses Kernel Density Estimation (KDE).
-
-### Region Extraction
-
-Region proposals are obtained in the form of bounding boxes by feeding the images through a Faster-RCNN object detector with a ResNet50 backbone, pretrained on MS COCO. Depending on the chosen settings, the region proposals are obtained by taking either the final bounding box predictions of the classification heads, or the region proposals of the Region Proposal Network (RPN). Any detections with the `background` label are discarded, after which the raw region proposals are post-processed by discarding small bounding boxes, applying NMS (across all class labels), and discarding regions with a low confidence score. The minimum region size, IOU threshold used during NMS, and the confidence score threshold can be configured from the config file.
-
-### Feature Extraction
-
-The feature extractor consists of a Fast-RCNN model with an AlexNet backbone, which was trained in a multi-task setting on the MS COCO and Visual Genome datasets (see paper for more details). The ROI align layer ensures that the feature maps produced by the convolutional layers are cropped to the bounding box coordinates obtained in the region extraction stage. The activations of the final shared fully connected layer are retrieved to obtain a feature embeddings for each region proposal.
-
-### Density Estimation
-
-The classification module uses Kernel Density Estimation (KDE) to estimate the probability density function of the feature space. The KDE model is fitted on the collection of features extracted from the training images. During inference, features extracted from the regions in the inference images are evaluated against the KDE model to obtain a density estimation for each region proposal. The estimates density serves as a 'normality score', which is converted to a normal/anomalous label using Anomalib's thresholding mechanism.
-
-Before fitting the KDE model, the dimensionality of the feature vectors is reduced using Principal Component Analysis (PCA). Depending on the chosen settings, the features are then scaled to unit vector length or the maximum vector length observed in the training set.
-
-## Usage and parameters
-
-`anomalib train --model Rkde --data MVTec --data.category `
-
-| Parameter                | Affects Stage      | Description                                                                                                                                                                                                | Type   | Options       |
-| :----------------------- | :----------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----- | :------------ |
-| roi_stage                | Region Extraction  | Processing stage from which the region proposals are retrieved. `rpn`: raw predictions of the region proposal network. `rcnn`: final detection outputs of the classification heads.                        | string | [rpn, rcnn]   |
-| roi_score_threshold      | Region Extraction  | Minimum class score for the region proposals. Regions with a confidence score below this value are discarded. When stage is `rcnn`, class score is used. When stage is `rpn`, objectness score is used.    | float  |               |
-| min_box_size             | Region Extraction  | Minimum size in pixels for the region proposals. Regions with a hight or width smaller than this value will be discarded.                                                                                  | int    |               |
-| iou_threshold            | Region Extraction  | Intersection-Over-Union threshold used in Non-Maximum-Suppression when post-processing detections. Regions are discarded when their IoU with a higher-confidence region is above this value.               | float  |               |
-| max_detections_per_image | Region Extraction  | Maximum number of region proposals N allowed per image. When the number of raw proposals is higher than this value, only the top N scoring proposals will be kept.                                         | int    |               |
-| n_pca_components         | Density Estimation | Number of principal components to which the features are reduced before applying KDE.                                                                                                                      | int    |               |
-| max_training_points      | Density Estimation | Maximum number of training features on which the KDE model is fitted. When more training features are available, a random selection of features will be discarded.                                         | int    |               |
-| feature_scaling_method   | Density Estimation | Determines how the features are scaled before applying KDE. `norm`: the features are normalized to unit vector length. `scale`: The features are normalized to the max vector length observed in training. | string | [norm, scale] |
-
-## Benchmark
-
-N/A
diff --git a/src/anomalib/models/image/rkde/__init__.py b/src/anomalib/models/image/rkde/__init__.py
deleted file mode 100644
index de9c6e8ce1..0000000000
--- a/src/anomalib/models/image/rkde/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-"""Region-based Anomaly Detection with Real Time Training and Analysis."""
-
-# Copyright (C) 2022-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from .lightning_model import Rkde
-
-__all__ = ["Rkde"]
diff --git a/src/anomalib/models/image/rkde/feature_extractor.py b/src/anomalib/models/image/rkde/feature_extractor.py
deleted file mode 100644
index 117cd71027..0000000000
--- a/src/anomalib/models/image/rkde/feature_extractor.py
+++ /dev/null
@@ -1,78 +0,0 @@
-"""Region-based Anomaly Detection with Real Time Training and Analysis.
-
-Feature Extractor.
-"""
-
-# Copyright (C) 2022-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import torch
-from torch import nn
-from torchvision.ops import RoIAlign
-from torchvision.transforms import Normalize, Resize
-
-from anomalib.data.utils.boxes import scale_boxes
-
-WEIGHTS_URL = "https://github.com/openvinotoolkit/anomalib/releases/download/rkde-weights/rkde_feature_extractor.pth"
-
-
-class FeatureExtractor(nn.Module):
-    """Feature Extractor module for Region-based anomaly detection."""
-
-    def __init__(self) -> None:
-        super().__init__()
-
-        self.transform = nn.Sequential(
-            Resize(size=600, max_size=1000),
-            Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-        )
-
-        self.features = nn.Sequential(
-            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(64, 192, kernel_size=5, padding=2),
-            nn.ReLU(inplace=True),
-            nn.MaxPool2d(kernel_size=3, stride=2),
-            nn.Conv2d(192, 384, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(384, 256, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-            nn.Conv2d(256, 256, kernel_size=3, padding=1),
-            nn.ReLU(inplace=True),
-        )
-
-        self.roi_align = RoIAlign(output_size=(6, 6), spatial_scale=1 / 16, sampling_ratio=0)
-
-        self.classifier = nn.Sequential(
-            nn.Linear(256 * 6 * 6, 4096),
-            nn.ReLU(inplace=True),
-            nn.Linear(4096, 4096),
-            nn.ReLU(inplace=True),
-        )
-
-        # load the pre-trained weights from url
-        self.load_state_dict(torch.hub.load_state_dict_from_url(WEIGHTS_URL, progress=False))
-
-    @torch.no_grad()
-    def forward(self, batch: torch.Tensor, rois: torch.Tensor) -> torch.Tensor:
-        """Perform a forward pass of the feature extractor.
-
-        Args:
-            batch (torch.Tensor): Batch of input images of shape [B, C, H, W].
-            rois (torch.Tensor): torch.Tensor of shape [N, 5] describing the regions-of-interest in the batch.
-
-        Returns:
-            Tensor: torch.Tensor containing a 4096-dimensional feature vector for every RoI location.
-        """
-        # Apply the feature extractor transforms
-        transformed_batch = self.transform(batch)
-
-        # Scale the RoIs to the effective input size of the feature extractor.
-        rois[:, 1:] = scale_boxes(rois[:, 1:], batch.shape[-2:], transformed_batch.shape[-2:])
-
-        # Forward pass through the backbone
-        features = self.features(transformed_batch)
-        features = self.roi_align(features, rois)
-        features = torch.flatten(features, 1)
-        return self.classifier(features)
diff --git a/src/anomalib/models/image/rkde/lightning_model.py b/src/anomalib/models/image/rkde/lightning_model.py
deleted file mode 100644
index 20a18496fc..0000000000
--- a/src/anomalib/models/image/rkde/lightning_model.py
+++ /dev/null
@@ -1,165 +0,0 @@
-"""Region Based Anomaly Detection With Real-Time Training and Analysis.
-
-https://ieeexplore.ieee.org/abstract/document/8999287
-"""
-
-# Copyright (C) 2022-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from typing import Any
-
-import torch
-from lightning.pytorch.utilities.types import STEP_OUTPUT
-from torchvision.transforms.v2 import Compose, Resize, Transform
-
-from anomalib import LearningType
-from anomalib.metrics import Evaluator
-from anomalib.models.components import AnomalibModule, MemoryBankMixin
-from anomalib.models.components.classification import FeatureScalingMethod
-from anomalib.post_processing import PostProcessor
-from anomalib.pre_processing import PreProcessor
-
-from .region_extractor import RoiStage
-from .torch_model import RkdeModel
-
-logger = logging.getLogger(__name__)
-
-
-class Rkde(MemoryBankMixin, AnomalibModule):
-    """Region Based Anomaly Detection With Real-Time Training and Analysis.
-
-    Args:
-        roi_stage (RoiStage, optional): Processing stage from which rois are extracted.
-            Defaults to ``RoiStage.RCNN``.
-        roi_score_threshold (float, optional): Mimumum confidence score for the region proposals.
-            Defaults to ``0.001``.
-        min_size (int, optional): Minimum size in pixels for the region proposals.
-            Defaults to ``25``.
-        iou_threshold (float, optional): Intersection-Over-Union threshold used during NMS.
-            Defaults to ``0.3``.
-        max_detections_per_image (int, optional): Maximum number of region proposals per image.
-            Defaults to ``100``.
-        n_pca_components (int, optional): Number of PCA components.
-            Defaults to ``16``.
-        feature_scaling_method (FeatureScalingMethod, optional): Scaling method applied to features before passing to
-            KDE. Options are `norm` (normalize to unit vector length) and `scale` (scale to max length observed in
-            training).
-            Defaults to ``FeatureScalingMethod.SCALE``.
-        max_training_points (int, optional): Maximum number of training points to fit the KDE model.
-            Defaults to ``40000``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
-    """
-
-    def __init__(
-        self,
-        roi_stage: RoiStage = RoiStage.RCNN,
-        roi_score_threshold: float = 0.001,
-        min_box_size: int = 25,
-        iou_threshold: float = 0.3,
-        max_detections_per_image: int = 100,
-        n_pca_components: int = 16,
-        feature_scaling_method: FeatureScalingMethod = FeatureScalingMethod.SCALE,
-        max_training_points: int = 40000,
-        pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
-        evaluator: Evaluator | bool = True,
-    ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
-
-        self.model: RkdeModel = RkdeModel(
-            roi_stage=roi_stage,
-            roi_score_threshold=roi_score_threshold,
-            min_box_size=min_box_size,
-            iou_threshold=iou_threshold,
-            max_detections_per_image=max_detections_per_image,
-            n_pca_components=n_pca_components,
-            feature_scaling_method=feature_scaling_method,
-            max_training_points=max_training_points,
-        )
-        self.embeddings: list[torch.Tensor] = []
-
-    @staticmethod
-    def configure_optimizers() -> None:
-        """RKDE doesn't require optimization, therefore returns no optimizers."""
-        return
-
-    def training_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> None:
-        """Perform a training Step of RKDE. For each batch, features are extracted from the CNN.
-
-        Args:
-            batch (dict[str, str | torch.Tensor]): Batch containing image filename, image, label and mask
-            args: Additional arguments.
-            kwargs: Additional keyword arguments.
-
-        Returns:
-          Deep CNN features.
-        """
-        del args, kwargs  # These variables are not used.
-
-        features = self.model(batch["image"])
-        self.embeddings.append(features)
-
-    def fit(self) -> None:
-        """Fit a KDE Model to the embedding collected from the training set."""
-        embeddings = torch.vstack(self.embeddings)
-
-        logger.info("Fitting a KDE model to the embedding collected from the training set.")
-        self.model.fit(embeddings)
-
-    def validation_step(self, batch: dict[str, str | torch.Tensor], *args, **kwargs) -> STEP_OUTPUT:
-        """Perform a validation Step of RKde.
-
-        Similar to the training step, features are extracted from the CNN for each batch.
-
-        Args:
-            batch (dict[str, str | torch.Tensor]): Batch containing image filename, image, label and mask
-            args: Additional arguments.
-            kwargs: Additional keyword arguments.
-
-        Returns:
-          Dictionary containing probability, prediction and ground truth values.
-        """
-        del args, kwargs  # These variables are not used.
-
-        # get batched model predictions
-        boxes, scores = self.model(batch["image"])
-
-        # convert batched predictions to list format
-        image: torch.Tensor = batch["image"]
-        batch_size = image.shape[0]
-        indices = boxes[:, 0]
-        batch["pred_boxes"] = [boxes[indices == i, 1:] for i in range(batch_size)]
-        batch["box_scores"] = [scores[indices == i] for i in range(batch_size)]
-
-        return batch
-
-    @property
-    def trainer_arguments(self) -> dict[str, Any]:
-        """Return R-KDE trainer arguments.
-
-        Returns:
-            dict[str, Any]: Arguments for the trainer.
-        """
-        return {"gradient_clip_val": 0, "max_epochs": 1, "num_sanity_val_steps": 0}
-
-    @property
-    def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
-
-        Returns:
-            LearningType: Learning type of the model.
-        """
-        return LearningType.ONE_CLASS
-
-    @staticmethod
-    def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
-        """Default transform for RKDE."""
-        image_size = image_size or (240, 360)
-        return Compose(
-            [
-                Resize(image_size, antialias=True),
-            ],
-        )
diff --git a/src/anomalib/models/image/rkde/region_extractor.py b/src/anomalib/models/image/rkde/region_extractor.py
deleted file mode 100644
index 8471ec4edb..0000000000
--- a/src/anomalib/models/image/rkde/region_extractor.py
+++ /dev/null
@@ -1,145 +0,0 @@
-"""Region-based Anomaly Detection with Real Time Training and Analysis.
-
-Region Extractor.
-"""
-
-# Copyright (C) 2022-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from enum import Enum
-
-import torch
-from torch import nn
-from torchvision.models.detection import fasterrcnn_resnet50_fpn
-from torchvision.ops import boxes as box_ops
-
-from anomalib.data.utils.boxes import scale_boxes
-
-
-class RoiStage(str, Enum):
-    """Processing stage from which rois are extracted."""
-
-    RCNN = "rcnn"
-    RPN = "rpn"
-
-
-class RegionExtractor(nn.Module):
-    """Extracts regions from the image.
-
-    Args:
-        stage (RoiStage, optional): Processing stage from which rois are extracted.
-            Defaults to ``RoiStage.RCNN``.
-        score_threshold (float, optional): Mimumum confidence score for the region proposals.
-            Defaults to ``0.001``.
-        min_size (int, optional): Minimum size in pixels for the region proposals.
-            Defaults to ``25``.
-        iou_threshold (float, optional): Intersection-Over-Union threshold used during NMS.
-            Defaults to ``0.3``.
-        max_detections_per_image (int, optional): Maximum number of region proposals per image.
-            Defaults to ``100``.
-    """
-
-    def __init__(
-        self,
-        stage: RoiStage = RoiStage.RCNN,
-        score_threshold: float = 0.001,
-        min_size: int = 25,
-        iou_threshold: float = 0.3,
-        max_detections_per_image: int = 100,
-    ) -> None:
-        super().__init__()
-
-        # Affects global behaviour of the region extractor
-        self.stage = stage
-        self.min_size = min_size
-        self.iou_threshold = iou_threshold
-        self.max_detections_per_image = max_detections_per_image
-
-        # Affects behaviour depending on roi stage
-        rpn_top_n = max_detections_per_image if self.stage == RoiStage.RPN else 1000
-        rpn_score_thresh = score_threshold if self.stage == RoiStage.RPN else 0.0
-
-        # Create the model
-        self.faster_rcnn = fasterrcnn_resnet50_fpn(
-            pretrained=True,
-            rpn_post_nms_top_n_test=rpn_top_n,
-            rpn_score_thresh=rpn_score_thresh,
-            box_score_thresh=score_threshold,
-            box_nms_thresh=1.0,  # this disables nms (we apply custom label-agnostic nms during post-processing)
-            box_detections_per_img=1000,  # this disables filtering top-k predictions (we apply our own after nms)
-        )
-
-    @torch.no_grad()
-    def forward(self, batch: torch.Tensor) -> torch.Tensor:
-        """Forward pass of the model.
-
-        Args:
-            batch (torch.Tensor): Batch of input images of shape [B, C, H, W].
-
-        Raises:
-            ValueError: When ``stage`` is not one of ``rcnn`` or ``rpn``.
-
-        Returns:
-            Tensor: Predicted regions, tensor of shape [N, 5] where N is the number of predicted regions in the batch,
-                 and where each row describes the index of the image in the batch and the 4 bounding box coordinates.
-        """
-        if self.training:
-            msg = "Should not be in training mode"
-            raise ValueError(msg)
-
-        if self.stage == RoiStage.RCNN:
-            # get rois from rcnn output
-            predictions = self.faster_rcnn(batch)
-            all_regions = [prediction["boxes"] for prediction in predictions]
-            all_scores = [prediction["scores"] for prediction in predictions]
-        elif self.stage == RoiStage.RPN:
-            # get rois from region proposal network
-            images, _ = self.faster_rcnn.transform(batch)
-            features = self.faster_rcnn.backbone(images.tensors)
-            proposals, _ = self.faster_rcnn.rpn(images, features)
-            # post-process raw rpn predictions
-            all_regions = [box_ops.clip_boxes_to_image(boxes, images.tensors.shape[-2:]) for boxes in proposals]
-            all_regions = [scale_boxes(boxes, images.tensors.shape[-2:], batch.shape[-2:]) for boxes in all_regions]
-            all_scores = [torch.ones(boxes.shape[0]).to(boxes.device) for boxes in all_regions]
-        else:
-            msg = f"Unknown region extractor stage: {self.stage}"
-            raise ValueError(msg)
-
-        regions = self.post_process_box_predictions(all_regions, all_scores)
-
-        # convert from list of [N, 4] tensors to single [N, 5] tensor where each row is [index-in-batch, x1, y1, x2, y2]
-        indices = torch.repeat_interleave(
-            torch.arange(len(regions)),
-            torch.Tensor([rois.shape[0] for rois in regions]).int(),
-        )
-        return torch.cat([indices.unsqueeze(1).to(batch.device), torch.cat(regions)], dim=1)
-
-    def post_process_box_predictions(self, pred_boxes: torch.Tensor, pred_scores: torch.Tensor) -> list[torch.Tensor]:
-        """Post-processes the box predictions.
-
-        The post-processing consists of removing small boxes, applying nms, and
-        keeping only the k boxes with the highest confidence score.
-
-        Args:
-            pred_boxes (torch.Tensor): Box predictions of shape (N, 4).
-            pred_scores (torch.Tensor): torch.Tensor of shape () with a confidence score for each box prediction.
-
-        Returns:
-            list[torch.Tensor]: Post-processed box predictions of shape (N, 4).
-        """
-        processed_boxes_list: list[torch.Tensor] = []
-        for boxes, scores in zip(pred_boxes, pred_scores, strict=True):
-            # remove small boxes
-            keep = box_ops.remove_small_boxes(boxes, min_size=self.min_size)
-            processed_boxes, processed_scores = boxes[keep], scores[keep]
-
-            # non-maximum suppression, all boxes together
-            keep = box_ops.nms(processed_boxes, processed_scores, self.iou_threshold)
-
-            # keep only top-k scoring predictions
-            keep = keep[: self.max_detections_per_image]
-            processed_boxes = processed_boxes[keep]
-
-            processed_boxes_list.append(processed_boxes)
-
-        return processed_boxes_list
diff --git a/src/anomalib/models/image/rkde/torch_model.py b/src/anomalib/models/image/rkde/torch_model.py
deleted file mode 100644
index ee574bf1ac..0000000000
--- a/src/anomalib/models/image/rkde/torch_model.py
+++ /dev/null
@@ -1,114 +0,0 @@
-"""Torch model for region-based anomaly detection."""
-
-# Copyright (C) 2022-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-
-import torch
-from torch import nn
-
-from anomalib.models.components.classification import FeatureScalingMethod, KDEClassifier
-
-from .feature_extractor import FeatureExtractor
-from .region_extractor import RegionExtractor, RoiStage
-
-logger = logging.getLogger(__name__)
-
-
-class RkdeModel(nn.Module):
-    """Torch Model for the Region-based Anomaly Detection Model.
-
-    Args:
-        roi_stage (RoiStage, optional): Processing stage from which rois are extracted.
-            Defaults to ``RoiStage.RCNN``.
-        roi_score_threshold (float, optional): Mimumum confidence score for the region proposals.
-            Defaults to ``0.001``.
-        min_size (int, optional): Minimum size in pixels for the region proposals.
-            Defaults to ``25``.
-        iou_threshold (float, optional): Intersection-Over-Union threshold used during NMS.
-            Defaults to ``0.3``.
-        max_detections_per_image (int, optional): Maximum number of region proposals per image.
-            Defaults to ``100``.
-        n_pca_components (int, optional): Number of PCA components.
-            Defaults to ``16``.
-        feature_scaling_method (FeatureScalingMethod, optional): Scaling method applied to features before passing to
-            KDE. Options are `norm` (normalize to unit vector length) and `scale` (scale to max length observed in
-            training).
-            Defaults to ``FeatureScalingMethod.SCALE``.
-        max_training_points (int, optional): Maximum number of training points to fit the KDE model.
-            Defaults to ``40000``.
-    """
-
-    def __init__(
-        self,
-        # roi params
-        roi_stage: RoiStage = RoiStage.RCNN,
-        roi_score_threshold: float = 0.001,
-        min_box_size: int = 25,
-        iou_threshold: float = 0.3,
-        max_detections_per_image: int = 100,
-        # kde params
-        n_pca_components: int = 16,
-        feature_scaling_method: FeatureScalingMethod = FeatureScalingMethod.SCALE,
-        max_training_points: int = 40000,
-    ) -> None:
-        super().__init__()
-
-        self.region_extractor = RegionExtractor(
-            stage=roi_stage,
-            score_threshold=roi_score_threshold,
-            min_size=min_box_size,
-            iou_threshold=iou_threshold,
-            max_detections_per_image=max_detections_per_image,
-        ).eval()
-
-        self.feature_extractor = FeatureExtractor().eval()
-
-        self.classifier = KDEClassifier(
-            n_pca_components=n_pca_components,
-            feature_scaling_method=feature_scaling_method,
-            max_training_points=max_training_points,
-        )
-
-    def fit(self, embeddings: torch.Tensor) -> bool:
-        """Fit the model using a set of collected embeddings.
-
-        Args:
-            embeddings (torch.Tensor): Input embeddings to fit the model.
-
-        Returns:
-            Boolean confirming whether the training is successful.
-        """
-        return self.classifier.fit(embeddings)
-
-    def forward(self, batch: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
-        """Prediction by normality model.
-
-        Args:
-            batch (torch.Tensor): Input images.
-
-        Returns:
-            Tensor | tuple[torch.Tensor, torch.Tensor]: The extracted features (when in training mode),
-                or the predicted rois and corresponding anomaly scores.
-        """
-        self.region_extractor.eval()
-        self.feature_extractor.eval()
-
-        # 1. apply region extraction
-        rois = self.region_extractor(batch)
-
-        # 2. apply feature extraction
-        if rois.shape[0] == 0:
-            # cannot extract features when no rois are retrieved
-            features = torch.empty((0, 4096)).to(batch.device)
-        else:
-            features = self.feature_extractor(batch, rois.clone())
-
-        if self.training:
-            return features
-
-        # 3. apply density estimation
-        scores = self.classifier(features)
-
-        return rois, scores
diff --git a/tests/integration/model/test_models.py b/tests/integration/model/test_models.py
index fee98301ea..39de61297a 100644
--- a/tests/integration/model/test_models.py
+++ b/tests/integration/model/test_models.py
@@ -22,7 +22,7 @@
 
 def models() -> set[str]:
     """Return all available models."""
-    return {model for model in get_available_models() if model != "rkde"}
+    return get_available_models()
 
 
 def export_types() -> list[ExportType]:
@@ -157,11 +157,6 @@ def test_export(
             dataset_path (Path): Root to dataset from fixture.
             project_path (Path): Path to temporary project folder from fixture.
         """
-        if model_name == "rkde":
-            # TODO(ashwinvaidya17): Restore this test after fixing the issue
-            # https://github.com/openvinotoolkit/anomalib/issues/1513
-            pytest.skip(f"{model_name} fails to convert to OpenVINO")
-
         model, dataset, engine = self._get_objects(
             model_name=model_name,
             dataset_path=dataset_path,
@@ -198,7 +193,7 @@ def _get_objects(
         # https://github.com/openvinotoolkit/anomalib/issues/1478
 
         extra_args = {}
-        if model_name in {"rkde", "dfkde"}:
+        if model_name == "dfkde":
             extra_args["n_pca_components"] = 2
 
         if model_name == "ai_vad":
diff --git a/tests/unit/models/components/base/test_anomaly_module.py b/tests/unit/models/components/base/test_anomaly_module.py
index 92e37af5b4..1578fc9e17 100644
--- a/tests/unit/models/components/base/test_anomaly_module.py
+++ b/tests/unit/models/components/base/test_anomaly_module.py
@@ -47,7 +47,6 @@ def test_from_config_with_wrong_config_path() -> None:
             "padim",
             "patchcore",
             "reverse_distillation",
-            "rkde",
             "stfpm",
             "uflow",
         ],

From 8bd06a96b3aba00875b8d1957836db499c1a02e3 Mon Sep 17 00:00:00 2001
From: Ashwin Vaidya 
Date: Tue, 10 Dec 2024 11:49:48 +0100
Subject: [PATCH 17/45] Multi-GPU fixes (#2435)

* Initial changes

Signed-off-by: Ashwin Vaidya 

* stash

Signed-off-by: Ashwin Vaidya 

* fix video mask

Signed-off-by: Ashwin Vaidya 

* fix remaining models

Signed-off-by: Ashwin Vaidya 

* Fix tests

Signed-off-by: Ashwin Vaidya 

* update docstrings

Signed-off-by: Ashwin Vaidya 

---------

Signed-off-by: Ashwin Vaidya 
Signed-off-by: Ashwin Vaidya 
---
 src/anomalib/data/validators/torch/video.py   | 21 ++++++++++---------
 src/anomalib/engine/engine.py                 |  3 ---
 src/anomalib/metrics/evaluator.py             | 14 +++++++++++--
 .../components/base/memory_bank_module.py     |  5 +++--
 .../classification/kde_classifier.py          |  5 ++++-
 .../dimensionality_reduction/pca.py           |  4 ++--
 .../models/image/dfkde/lightning_model.py     |  3 +++
 .../models/image/dfm/lightning_model.py       |  3 +++
 src/anomalib/models/image/dfm/torch_model.py  |  2 +-
 .../models/image/dsr/anomaly_generator.py     |  2 +-
 .../models/image/padim/lightning_model.py     |  5 ++++-
 .../models/image/patchcore/lightning_model.py |  2 ++
 .../models/video/ai_vad/lightning_model.py    | 13 +++++-------
 src/anomalib/utils/config.py                  |  7 -------
 .../unit/data/validators/torch/test_video.py  | 10 ++++-----
 15 files changed, 56 insertions(+), 43 deletions(-)

diff --git a/src/anomalib/data/validators/torch/video.py b/src/anomalib/data/validators/torch/video.py
index b7ca50c943..bcfca62451 100644
--- a/src/anomalib/data/validators/torch/video.py
+++ b/src/anomalib/data/validators/torch/video.py
@@ -588,10 +588,10 @@ def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoBatchValidator
-            >>> gt_masks = torch.rand(2, 10, 224, 224) > 0.5  # 2 videos, 10 frames each
+            >>> gt_masks = torch.rand(10, 224, 224) > 0.5  # 10 frames each
             >>> validated_masks = VideoBatchValidator.validate_gt_mask(gt_masks)
             >>> print(validated_masks.shape)
-            torch.Size([2, 10, 224, 224])
+            torch.Size([10, 224, 224])
             >>> single_frame_masks = torch.rand(4, 456, 256) > 0.5  # 4 single-frame images
             >>> validated_single_frame = VideoBatchValidator.validate_gt_mask(single_frame_masks)
             >>> print(validated_single_frame.shape)
@@ -600,17 +600,18 @@ def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
         if mask is None:
             return None
         if not isinstance(mask, torch.Tensor):
-            msg = f"Masks must be a torch.Tensor, got {type(mask)}."
+            msg = f"Ground truth mask must be a torch.Tensor, got {type(mask)}."
             raise TypeError(msg)
-        if mask.ndim not in {3, 4, 5}:
-            msg = f"Masks must have shape [B, H, W], [B, T, H, W] or [B, T, 1, H, W], got shape {mask.shape}."
+        if mask.ndim not in {2, 3, 4}:
+            msg = f"Ground truth mask must have shape [H, W] or [N, H, W] or [N, 1, H, W] got shape {mask.shape}."
             raise ValueError(msg)
-        if mask.ndim == 5:
-            if mask.shape[2] != 1:
-                msg = f"Masks must have 1 channel, got {mask.shape[2]}."
+        if mask.ndim == 2:
+            mask = mask.unsqueeze(0)
+        if mask.ndim == 4:
+            if mask.shape[1] != 1:
+                msg = f"Ground truth mask must have 1 channel, got {mask.shape[1]}."
                 raise ValueError(msg)
-            mask = mask.squeeze(2)
-
+            mask = mask.squeeze(1)
         return Mask(mask, dtype=torch.bool)
 
     @staticmethod
diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index fe823f3729..36f6f93828 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -260,9 +260,6 @@ def _setup_trainer(self, model: AnomalibModule) -> None:
         # Setup anomalib callbacks to be used with the trainer
         self._setup_anomalib_callbacks(model)
 
-        # Temporarily set devices to 1 to avoid issues with multiple processes
-        self._cache.args["devices"] = 1
-
         # Instantiate the trainer if it is not already instantiated
         if self._trainer is None:
             self._trainer = Trainer(**self._cache.args)
diff --git a/src/anomalib/metrics/evaluator.py b/src/anomalib/metrics/evaluator.py
index 53f05af3b2..460a2a4b0b 100644
--- a/src/anomalib/metrics/evaluator.py
+++ b/src/anomalib/metrics/evaluator.py
@@ -3,6 +3,7 @@
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+import logging
 from collections.abc import Sequence
 from typing import Any
 
@@ -14,6 +15,8 @@
 
 from anomalib.metrics import AnomalibMetric
 
+logger = logging.getLogger(__name__)
+
 
 class Evaluator(nn.Module, Callback):
     """Evaluator module for LightningModule.
@@ -53,8 +56,15 @@ def __init__(
         super().__init__()
         self.val_metrics = ModuleList(self.validate_metrics(val_metrics))
         self.test_metrics = ModuleList(self.validate_metrics(test_metrics))
-
-        if compute_on_cpu:
+        self.compute_on_cpu = compute_on_cpu
+
+    def setup(self, trainer: Trainer, pl_module: LightningModule, stage: str) -> None:
+        """Move metrics to cpu if ``num_devices == 1`` and ``compute_on_cpu`` is set to ``True``."""
+        del pl_module, stage  # Unused arguments.
+        if trainer.num_devices > 1:
+            if self.compute_on_cpu:
+                logger.warning("Number of devices is greater than 1, setting compute_on_cpu to False.")
+        elif self.compute_on_cpu:
             self.metrics_to_cpu(self.val_metrics)
             self.metrics_to_cpu(self.test_metrics)
 
diff --git a/src/anomalib/models/components/base/memory_bank_module.py b/src/anomalib/models/components/base/memory_bank_module.py
index 738dff6185..501e8dc11a 100644
--- a/src/anomalib/models/components/base/memory_bank_module.py
+++ b/src/anomalib/models/components/base/memory_bank_module.py
@@ -19,6 +19,7 @@ class MemoryBankMixin(nn.Module):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.register_buffer("_is_fitted", torch.tensor([False]))
+        self.device: torch.device  # defined in lightning module
         self._is_fitted: torch.Tensor
 
     @abstractmethod
@@ -34,10 +35,10 @@ def on_validation_start(self) -> None:
         """Ensure that the model is fitted before validation starts."""
         if not self._is_fitted:
             self.fit()
-            self._is_fitted = torch.tensor([True])
+            self._is_fitted = torch.tensor([True], device=self.device)
 
     def on_train_epoch_end(self) -> None:
         """Ensure that the model is fitted before validation starts."""
         if not self._is_fitted:
             self.fit()
-            self._is_fitted = torch.tensor([True])
+            self._is_fitted = torch.tensor([True], device=self.device)
diff --git a/src/anomalib/models/components/classification/kde_classifier.py b/src/anomalib/models/components/classification/kde_classifier.py
index 88362ff3de..d50e5cca31 100644
--- a/src/anomalib/models/components/classification/kde_classifier.py
+++ b/src/anomalib/models/components/classification/kde_classifier.py
@@ -93,7 +93,10 @@ def fit(self, embeddings: torch.Tensor) -> bool:
 
         # if max training points is non-zero and smaller than number of staged features, select random subset
         if embeddings.shape[0] > self.max_training_points:
-            selected_idx = torch.tensor(random.sample(range(embeddings.shape[0]), self.max_training_points))
+            selected_idx = torch.tensor(
+                random.sample(range(embeddings.shape[0]), self.max_training_points),
+                device=embeddings.device,
+            )
             selected_features = embeddings[selected_idx]
         else:
             selected_features = embeddings
diff --git a/src/anomalib/models/components/dimensionality_reduction/pca.py b/src/anomalib/models/components/dimensionality_reduction/pca.py
index 93c60b2b56..3e9bd4bb65 100644
--- a/src/anomalib/models/components/dimensionality_reduction/pca.py
+++ b/src/anomalib/models/components/dimensionality_reduction/pca.py
@@ -74,7 +74,7 @@ def fit(self, dataset: torch.Tensor) -> None:
         else:
             num_components = int(self.n_components)
 
-        self.num_components = torch.Tensor([num_components])
+        self.num_components = torch.tensor([num_components], device=dataset.device)
 
         self.singular_vectors = v_h.transpose(-2, -1)[:, :num_components].float()
         self.singular_values = sig[:num_components].float()
@@ -98,7 +98,7 @@ def fit_transform(self, dataset: torch.Tensor) -> torch.Tensor:
         mean = dataset.mean(dim=0)
         dataset -= mean
         num_components = int(self.n_components)
-        self.num_components = torch.Tensor([num_components])
+        self.num_components = torch.tensor([num_components], device=dataset.device)
 
         v_h = torch.linalg.svd(dataset)[-1]
         self.singular_vectors = v_h.transpose(-2, -1)[:, :num_components]
diff --git a/src/anomalib/models/image/dfkde/lightning_model.py b/src/anomalib/models/image/dfkde/lightning_model.py
index d1b1fba497..5eac9930f7 100644
--- a/src/anomalib/models/image/dfkde/lightning_model.py
+++ b/src/anomalib/models/image/dfkde/lightning_model.py
@@ -87,6 +87,9 @@ def training_step(self, batch: Batch, *args, **kwargs) -> None:
         embedding = self.model(batch.image)
         self.embeddings.append(embedding)
 
+        # Return a dummy loss tensor
+        return torch.tensor(0.0, requires_grad=True, device=self.device)
+
     def fit(self) -> None:
         """Fit a KDE Model to the embedding collected from the training set."""
         embeddings = torch.vstack(self.embeddings)
diff --git a/src/anomalib/models/image/dfm/lightning_model.py b/src/anomalib/models/image/dfm/lightning_model.py
index cc39b4e398..0ad179dd98 100644
--- a/src/anomalib/models/image/dfm/lightning_model.py
+++ b/src/anomalib/models/image/dfm/lightning_model.py
@@ -93,6 +93,9 @@ def training_step(self, batch: Batch, *args, **kwargs) -> None:
         embedding = self.model.get_features(batch.image).squeeze()
         self.embeddings.append(embedding)
 
+        # Return a dummy loss tensor
+        return torch.tensor(0.0, requires_grad=True, device=self.device)
+
     def fit(self) -> None:
         """Fit a PCA transformation and a Gaussian model to dataset."""
         logger.info("Aggregating the embedding extracted from the training set.")
diff --git a/src/anomalib/models/image/dfm/torch_model.py b/src/anomalib/models/image/dfm/torch_model.py
index ab133d045f..520cbf8196 100644
--- a/src/anomalib/models/image/dfm/torch_model.py
+++ b/src/anomalib/models/image/dfm/torch_model.py
@@ -41,7 +41,7 @@ def fit(self, dataset: torch.Tensor) -> None:
             dataset (torch.Tensor): Input dataset to fit the model.
         """
         num_samples = dataset.shape[1]
-        self.mean_vec = torch.mean(dataset, dim=1)
+        self.mean_vec = torch.mean(dataset, dim=1, device=dataset.device)
         data_centered = (dataset - self.mean_vec.reshape(-1, 1)) / math.sqrt(num_samples)
         self.u_mat, self.sigma_mat, _ = torch.linalg.svd(data_centered, full_matrices=False)
 
diff --git a/src/anomalib/models/image/dsr/anomaly_generator.py b/src/anomalib/models/image/dsr/anomaly_generator.py
index 9bb262500c..2d1d5c4a75 100644
--- a/src/anomalib/models/image/dsr/anomaly_generator.py
+++ b/src/anomalib/models/image/dsr/anomaly_generator.py
@@ -73,7 +73,7 @@ def augment_batch(self, batch: Tensor) -> Tensor:
         masks_list: list[Tensor] = []
         for _ in range(batch_size):
             if torch.rand(1) > self.p_anomalous:  # include normal samples
-                masks_list.append(torch.zeros((1, height, width)))
+                masks_list.append(torch.zeros((1, height, width), device=batch.device))
             else:
                 mask = self.generate_anomaly(height, width)
                 masks_list.append(mask)
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index 28d59fc9eb..2e246e8450 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -84,7 +84,10 @@ def training_step(self, batch: Batch, *args, **kwargs) -> None:
         del args, kwargs  # These variables are not used.
 
         embedding = self.model(batch.image)
-        self.embeddings.append(embedding.cpu())
+        self.embeddings.append(embedding)
+
+        # Return a dummy loss tensor
+        return torch.tensor(0.0, requires_grad=True, device=self.device)
 
     def fit(self) -> None:
         """Fit a Gaussian to the embedding collected from the training set."""
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index d22a97d891..748be1f443 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -111,6 +111,8 @@ def training_step(self, batch: Batch, *args, **kwargs) -> None:
 
         embedding = self.model(batch.image)
         self.embeddings.append(embedding)
+        # Return a dummy loss tensor
+        return torch.tensor(0.0, requires_grad=True, device=self.device)
 
     def fit(self) -> None:
         """Apply subsampling to the embedding collected from the training set."""
diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py
index 750746f259..fb9044518c 100644
--- a/src/anomalib/models/video/ai_vad/lightning_model.py
+++ b/src/anomalib/models/video/ai_vad/lightning_model.py
@@ -7,9 +7,9 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
-from dataclasses import replace
 from typing import Any
 
+import torch
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 
 from anomalib import LearningType
@@ -123,6 +123,9 @@ def training_step(self, batch: VideoBatch) -> None:
             self.model.density_estimator.update(features, video_path)
             self.total_detections += len(next(iter(features.values())))
 
+        # Return a dummy loss tensor
+        return torch.tensor(0.0, requires_grad=True, device=self.device)
+
     def fit(self) -> None:
         """Fit the density estimators to the extracted features from the training set."""
         if self.total_detections == 0:
@@ -146,13 +149,7 @@ def validation_step(self, batch: VideoBatch, *args, **kwargs) -> STEP_OUTPUT:
         del args, kwargs  # Unused arguments.
 
         predictions = self.model(batch.image)
-
-        return replace(
-            batch,
-            pred_score=predictions.pred_score,
-            anomaly_map=predictions.anomaly_map,
-            pred_mask=predictions.pred_mask,
-        )
+        return batch.update(pred_score=predictions.pred_score, anomaly_map=predictions.anomaly_map)
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
diff --git a/src/anomalib/utils/config.py b/src/anomalib/utils/config.py
index f41617f355..aadaa6a42b 100644
--- a/src/anomalib/utils/config.py
+++ b/src/anomalib/utils/config.py
@@ -254,10 +254,3 @@ def _show_warnings(config: DictConfig | ListConfig | Namespace) -> None:
             "Anomalib's models and visualizer are currently not compatible with video datasets with a clip length > 1. "
             "Custom changes to these modules will be needed to prevent errors and/or unpredictable behaviour.",
         )
-    if (
-        "devices" in config.trainer
-        and (config.trainer.devices is None or config.trainer.devices != 1)
-        and config.trainer.accelerator != "cpu"
-    ):
-        logger.warning("Anomalib currently does not support multi-gpu training. Setting devices to 1.")
-        config.trainer.devices = 1
diff --git a/tests/unit/data/validators/torch/test_video.py b/tests/unit/data/validators/torch/test_video.py
index 2933ddb7f4..04e3373a5a 100644
--- a/tests/unit/data/validators/torch/test_video.py
+++ b/tests/unit/data/validators/torch/test_video.py
@@ -174,10 +174,10 @@ def test_validate_gt_label_invalid_type(self) -> None:
 
     def test_validate_gt_mask_valid(self) -> None:
         """Test validation of valid ground truth masks."""
-        masks = torch.randint(0, 2, (2, 10, 224, 224))
+        masks = torch.randint(0, 2, (10, 1, 224, 224))
         validated_masks = self.validator.validate_gt_mask(masks)
         assert isinstance(validated_masks, Mask)
-        assert validated_masks.shape == (2, 10, 224, 224)
+        assert validated_masks.shape == (10, 224, 224)
         assert validated_masks.dtype == torch.bool
 
     def test_validate_gt_mask_none(self) -> None:
@@ -186,13 +186,13 @@ def test_validate_gt_mask_none(self) -> None:
 
     def test_validate_gt_mask_invalid_type(self) -> None:
         """Test validation of ground truth masks with invalid type."""
-        with pytest.raises(TypeError, match="Masks must be a torch.Tensor"):
+        with pytest.raises(TypeError, match="Ground truth mask must be a torch.Tensor"):
             self.validator.validate_gt_mask([torch.zeros(10, 224, 224)])
 
     def test_validate_gt_mask_invalid_shape(self) -> None:
         """Test validation of ground truth masks with invalid shape."""
-        with pytest.raises(ValueError, match="Masks must have 1 channel, got 2."):
-            self.validator.validate_gt_mask(torch.zeros(2, 10, 2, 224, 224))
+        with pytest.raises(ValueError, match="Ground truth mask must have 1 channel, got 2."):
+            self.validator.validate_gt_mask(torch.zeros(10, 2, 224, 224))
 
     def test_validate_anomaly_map_valid(self) -> None:
         """Test validation of a valid anomaly map batch."""

From c235ca13bbdb896e25240c9c76e2057c4571e966 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 11 Dec 2024 06:33:52 +0000
Subject: [PATCH 18/45] =?UTF-8?q?=F0=9F=94=A8=20v2=20-=20Refactor:=20Add?=
 =?UTF-8?q?=20missing=20auxiliary=20attributes=20to=20`AnomalibModule`=20(?=
 =?UTF-8?q?#2460)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Refactor post-processor to match the pre-processor and evaluator pattern

Signed-off-by: Samet Akcay 

* Add visualizer to models

Signed-off-by: Samet Akcay 

* Refactor `configure_callbacks` method in `AnomalibModule` to dynamically include available callbacks (pre-processor, post-processor, evaluator, visualizer) based on their existence. Update docstring for clarity on return values.

* Refactor callback handling in `Engine` class by removing post-processor and metrics callbacks. Simplify callback configuration to streamline the process and enhance maintainability.

* Fix circular import issue

Signed-off-by: Samet Akcay 

* Fix circular import issue

Signed-off-by: Samet Akcay 

* Convert `configure_post_processor` to a method

Signed-off-by: Samet Akcay 

* Fix upgrade tests

Signed-off-by: Samet Akcay 

* Rename anomaly_module to anomalib_module

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 
---
 src/anomalib/engine/engine.py                 |  17 +-
 .../models/components/base/__init__.py        |   2 +-
 .../{anomaly_module.py => anomalib_module.py} | 164 +++++++++++++++---
 .../models/image/cfa/lightning_model.py       |  12 +-
 .../models/image/cflow/lightning_model.py     |  11 +-
 .../models/image/csflow/lightning_model.py    |  11 +-
 .../models/image/dfkde/lightning_model.py     |  11 +-
 .../models/image/dfm/lightning_model.py       |  11 +-
 .../models/image/draem/lightning_model.py     |  11 +-
 .../models/image/dsr/lightning_model.py       |  11 +-
 .../image/efficient_ad/lightning_model.py     |  11 +-
 .../models/image/fastflow/lightning_model.py  |  11 +-
 .../models/image/fre/lightning_model.py       |  11 +-
 .../models/image/ganomaly/lightning_model.py  |  11 +-
 .../models/image/padim/lightning_model.py     |  13 +-
 .../models/image/patchcore/lightning_model.py |  13 +-
 .../reverse_distillation/lightning_model.py   |  11 +-
 .../models/image/stfpm/lightning_model.py     |  11 +-
 .../models/image/uflow/lightning_model.py     |  14 +-
 .../models/image/vlm_ad/lightning_model.py    |   3 +-
 .../models/image/winclip/lightning_model.py   |  13 +-
 .../models/video/ai_vad/lightning_model.py    |   5 +-
 src/anomalib/visualization/__init__.py        |   3 +
 src/anomalib/visualization/base.py            |  14 ++
 .../visualization/image/visualizer.py         |  31 ++--
 .../tools/upgrade/expected_draem_v1.yaml      |   3 +-
 .../dummy_lightning_model.py                  |   2 +-
 27 files changed, 343 insertions(+), 98 deletions(-)
 rename src/anomalib/models/components/base/{anomaly_module.py => anomalib_module.py} (72%)
 create mode 100644 src/anomalib/visualization/base.py

diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index 36f6f93828..a548dd23e4 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -22,7 +22,6 @@
 from anomalib.deploy import CompressionType, ExportType
 from anomalib.models import AnomalibModule
 from anomalib.utils.path import create_versioned_dir
-from anomalib.visualization import ImageVisualizer
 
 logger = logging.getLogger(__name__)
 
@@ -258,13 +257,13 @@ def _setup_trainer(self, model: AnomalibModule) -> None:
             self._cache.update(model)
 
         # Setup anomalib callbacks to be used with the trainer
-        self._setup_anomalib_callbacks(model)
+        self._setup_anomalib_callbacks()
 
         # Instantiate the trainer if it is not already instantiated
         if self._trainer is None:
             self._trainer = Trainer(**self._cache.args)
 
-    def _setup_anomalib_callbacks(self, model: AnomalibModule) -> None:
+    def _setup_anomalib_callbacks(self) -> None:
         """Set up callbacks for the trainer."""
         _callbacks: list[Callback] = []
 
@@ -279,18 +278,6 @@ def _setup_anomalib_callbacks(self, model: AnomalibModule) -> None:
                 ),
             )
 
-        # Add the post-processor callback.
-        if isinstance(model.post_processor, Callback):
-            _callbacks.append(model.post_processor)
-
-        # Add the metrics callback.
-        if isinstance(model.evaluator, Callback):
-            _callbacks.append(model.evaluator)
-
-        # Add the image visualizer callback if it is passed by the user.
-        if not any(isinstance(callback, ImageVisualizer) for callback in self._cache.args["callbacks"]):
-            _callbacks.append(ImageVisualizer())
-
         _callbacks.append(TimerCallback())
 
         # Combine the callbacks, and update the trainer callbacks.
diff --git a/src/anomalib/models/components/base/__init__.py b/src/anomalib/models/components/base/__init__.py
index 5214f966dc..250eec5045 100644
--- a/src/anomalib/models/components/base/__init__.py
+++ b/src/anomalib/models/components/base/__init__.py
@@ -3,7 +3,7 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from .anomaly_module import AnomalibModule
+from .anomalib_module import AnomalibModule
 from .buffer_list import BufferListMixin
 from .dynamic_buffer import DynamicBufferMixin
 from .memory_bank_module import MemoryBankMixin
diff --git a/src/anomalib/models/components/base/anomaly_module.py b/src/anomalib/models/components/base/anomalib_module.py
similarity index 72%
rename from src/anomalib/models/components/base/anomaly_module.py
rename to src/anomalib/models/components/base/anomalib_module.py
index 408200231a..3fd5557032 100644
--- a/src/anomalib/models/components/base/anomaly_module.py
+++ b/src/anomalib/models/components/base/anomalib_module.py
@@ -25,6 +25,7 @@
 from anomalib.metrics.threshold import Threshold
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import ImageVisualizer, Visualizer
 
 from .export_mixin import ExportMixin
 
@@ -40,8 +41,9 @@ class AnomalibModule(ExportMixin, pl.LightningModule, ABC):
     def __init__(
         self,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
         super().__init__()
         logger.info("Initializing %s model.", self.__class__.__name__)
@@ -52,11 +54,12 @@ def __init__(
         self.callbacks: list[Callback]
 
         self.pre_processor = self._resolve_pre_processor(pre_processor)
-        self.post_processor = post_processor or self.default_post_processor()
+        self.post_processor = self._resolve_post_processor(post_processor)
         self.evaluator = self._resolve_evaluator(evaluator)
+        self.visualizer = self._resolve_visualizer(visualizer)
 
         self._input_size: tuple[int, int] | None = None
-        self._is_setup = False  # flag to track if setup has been called from the trainer
+        self._is_setup = False
 
     @property
     def name(self) -> str:
@@ -79,28 +82,20 @@ def _setup(self) -> None:
         initialization.
         """
 
-    def _resolve_pre_processor(self, pre_processor: PreProcessor | bool) -> PreProcessor | None:
-        """Resolve and validate which pre-processor to use..
-
-        Args:
-            pre_processor: Pre-processor configuration
-                - True -> use default pre-processor
-                - False -> no pre-processor
-                - PreProcessor -> use the provided pre-processor
+    def configure_callbacks(self) -> Sequence[Callback] | Callback:
+        """Configure default callbacks for AnomalibModule.
 
         Returns:
-            Configured pre-processor
+            List of callbacks that includes the pre-processor, post-processor, evaluator,
+            and visualizer if they are available and inherit from Callback.
         """
-        if isinstance(pre_processor, PreProcessor):
-            return pre_processor
-        if isinstance(pre_processor, bool):
-            return self.configure_pre_processor() if pre_processor else None
-        msg = f"Invalid pre-processor type: {type(pre_processor)}"
-        raise TypeError(msg)
-
-    def configure_callbacks(self) -> Sequence[Callback] | Callback:
-        """Configure default callbacks for AnomalibModule."""
-        return [self.pre_processor] if self.pre_processor else []
+        callbacks: list[Callback] = []
+        callbacks.extend(
+            component
+            for component in (self.pre_processor, self.post_processor, self.evaluator, self.visualizer)
+            if isinstance(component, Callback)
+        )
+        return callbacks
 
     def forward(self, batch: torch.Tensor, *args, **kwargs) -> InferenceBatch:
         """Perform the forward-pass by passing input tensor to the module.
@@ -170,6 +165,25 @@ def learning_type(self) -> LearningType:
         """Learning type of the model."""
         raise NotImplementedError
 
+    def _resolve_pre_processor(self, pre_processor: PreProcessor | bool) -> PreProcessor | None:
+        """Resolve and validate which pre-processor to use..
+
+        Args:
+            pre_processor: Pre-processor configuration
+                - True -> use default pre-processor
+                - False -> no pre-processor
+                - PreProcessor -> use the provided pre-processor
+
+        Returns:
+            Configured pre-processor
+        """
+        if isinstance(pre_processor, PreProcessor):
+            return pre_processor
+        if isinstance(pre_processor, bool):
+            return self.configure_pre_processor() if pre_processor else None
+        msg = f"Invalid pre-processor type: {type(pre_processor)}"
+        raise TypeError(msg)
+
     @classmethod
     def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
         """Configure the pre-processor.
@@ -214,15 +228,54 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
             ]),
         )
 
-    def default_post_processor(self) -> PostProcessor | None:
-        """Default post processor.
+    def _resolve_post_processor(self, post_processor: PostProcessor | bool) -> PostProcessor | None:
+        """Resolve and validate which post-processor to use.
 
-        Override in subclass for model-specific post-processing behaviour.
+        Args:
+            post_processor: Post-processor configuration
+                - True -> use default post-processor
+                - False -> no post-processor
+                - PostProcessor -> use the provided post-processor
+
+        Returns:
+            Configured post-processor
+        """
+        if isinstance(post_processor, PostProcessor):
+            return post_processor
+        if isinstance(post_processor, bool):
+            return self.configure_post_processor() if post_processor else None
+        msg = f"Invalid post-processor type: {type(post_processor)}"
+        raise TypeError(msg)
+
+    def configure_post_processor(self) -> PostProcessor | None:
+        """Configure the default post-processor based on the learning type.
+
+        Returns:
+            PostProcessor: Configured post-processor instance.
+
+        Raises:
+            NotImplementedError: If no default post-processor is available for the model's learning type.
+
+        Examples:
+            Get default post-processor:
+
+            >>> post_processor = AnomalibModule.configure_post_processor()
+
+            Create model with custom post-processor:
+
+            >>> custom_post_processor = CustomPostProcessor()
+            >>> model = PatchCore(post_processor=custom_post_processor)
+
+            Disable post-processing:
+
+            >>> model = PatchCore(post_processor=False)
         """
         if self.learning_type == LearningType.ONE_CLASS:
             return OneClassPostProcessor()
-        msg = f"No default post-processor available for model {self.__name__} with learning type {self.learning_type}. \
-              Please override the default_post_processor method in the model implementation."
+        msg = (
+            f"No default post-processor available for model with learning type {self.learning_type}. "
+            "Please override the configure_post_processor method in the model implementation."
+        )
         raise NotImplementedError(msg)
 
     def _resolve_evaluator(self, evaluator: Evaluator | bool) -> Evaluator | None:
@@ -251,6 +304,63 @@ def configure_evaluator() -> Evaluator:
         test_metrics = [image_auroc, image_f1score, pixel_auroc, pixel_f1score]
         return Evaluator(test_metrics=test_metrics)
 
+    def _resolve_visualizer(self, visualizer: Visualizer | bool) -> Visualizer | None:
+        """Resolve and validate which visualizer to use.
+
+        Args:
+            visualizer: Visualizer configuration
+                - True -> use default visualizer
+                - False -> no visualizer
+                - Visualizer -> use the provided visualizer
+
+        Returns:
+            Configured visualizer
+        """
+        if isinstance(visualizer, Visualizer):
+            return visualizer
+        if isinstance(visualizer, bool):
+            return self.configure_visualizer() if visualizer else None
+        msg = f"Visualizer must be of type Visualizer or bool, got {type(visualizer)}"
+        raise TypeError(msg)
+
+    @classmethod
+    def configure_visualizer(cls) -> ImageVisualizer:
+        """Configure the default visualizer.
+
+        By default, this method returns an ImageVisualizer instance, which is suitable for
+        visualizing image-based anomaly detection results. However, the visualizer can be
+        customized based on your needs - for example, using VideoVisualizer for video data
+        or implementing a custom visualizer for specific visualization requirements.
+
+        Returns:
+            Visualizer: Configured visualizer instance (ImageVisualizer by default).
+
+        Examples:
+            Get default ImageVisualizer:
+
+            >>> visualizer = AnomalibModule.configure_visualizer()
+
+            Create model with VideoVisualizer:
+
+            >>> from custom_module import VideoVisualizer
+            >>> video_visualizer = VideoVisualizer()
+            >>> model = PatchCore(visualizer=video_visualizer)
+
+            Create model with custom visualizer:
+
+            >>> class CustomVisualizer(Visualizer):
+            ...     def __init__(self):
+            ...         super().__init__()
+            ...         # Custom visualization logic
+            >>> custom_visualizer = CustomVisualizer()
+            >>> model = PatchCore(visualizer=custom_visualizer)
+
+            Disable visualization:
+
+            >>> model = PatchCore(visualizer=False)
+        """
+        return ImageVisualizer()
+
     @property
     def input_size(self) -> tuple[int, int] | None:
         """Return the effective input size of the model.
diff --git a/src/anomalib/models/image/cfa/lightning_model.py b/src/anomalib/models/image/cfa/lightning_model.py
index ea4bf3a2bd..9eed15b6a7 100644
--- a/src/anomalib/models/image/cfa/lightning_model.py
+++ b/src/anomalib/models/image/cfa/lightning_model.py
@@ -20,6 +20,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .loss import CfaLoss
 from .torch_model import CfaModel
@@ -58,11 +59,18 @@ def __init__(
         num_nearest_neighbors: int = 3,
         num_hard_negative_features: int = 3,
         radius: float = 1e-5,
+        # Anomalib's Auxiliary Components
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
         self.model: CfaModel = CfaModel(
             backbone=backbone,
             gamma_c=gamma_c,
diff --git a/src/anomalib/models/image/cflow/lightning_model.py b/src/anomalib/models/image/cflow/lightning_model.py
index d6b39751d0..4dd9c25850 100644
--- a/src/anomalib/models/image/cflow/lightning_model.py
+++ b/src/anomalib/models/image/cflow/lightning_model.py
@@ -27,6 +27,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .torch_model import CflowModel
 from .utils import get_logp, positional_encoding_2d
@@ -71,10 +72,16 @@ def __init__(
         permute_soft: bool = False,
         lr: float = 0.0001,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.model: CflowModel = CflowModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/csflow/lightning_model.py b/src/anomalib/models/image/csflow/lightning_model.py
index 3be936cc90..8e9994631a 100644
--- a/src/anomalib/models/image/csflow/lightning_model.py
+++ b/src/anomalib/models/image/csflow/lightning_model.py
@@ -18,6 +18,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .loss import CsFlowLoss
 from .torch_model import CsFlowModel
@@ -48,10 +49,16 @@ def __init__(
         clamp: int = 3,
         num_channels: int = 3,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
         if self.input_size is None:
             msg = "CsFlow needs input size to build torch model."
             raise ValueError(msg)
diff --git a/src/anomalib/models/image/dfkde/lightning_model.py b/src/anomalib/models/image/dfkde/lightning_model.py
index 5eac9930f7..666fb5507d 100644
--- a/src/anomalib/models/image/dfkde/lightning_model.py
+++ b/src/anomalib/models/image/dfkde/lightning_model.py
@@ -17,6 +17,7 @@
 from anomalib.models.components.classification import FeatureScalingMethod
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .torch_model import DfkdeModel
 
@@ -50,10 +51,16 @@ def __init__(
         feature_scaling_method: FeatureScalingMethod = FeatureScalingMethod.SCALE,
         max_training_points: int = 40000,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.model = DfkdeModel(
             layers=layers,
diff --git a/src/anomalib/models/image/dfm/lightning_model.py b/src/anomalib/models/image/dfm/lightning_model.py
index 0ad179dd98..1bdad50e1e 100644
--- a/src/anomalib/models/image/dfm/lightning_model.py
+++ b/src/anomalib/models/image/dfm/lightning_model.py
@@ -18,6 +18,7 @@
 from anomalib.models.components import AnomalibModule, MemoryBankMixin
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .torch_model import DFMModel
 
@@ -54,10 +55,16 @@ def __init__(
         pca_level: float = 0.97,
         score_type: str = "fre",
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.model: DFMModel = DFMModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py
index 66e87a904b..84b143f3f5 100644
--- a/src/anomalib/models/image/draem/lightning_model.py
+++ b/src/anomalib/models/image/draem/lightning_model.py
@@ -21,6 +21,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .loss import DraemLoss
 from .torch_model import DraemModel
@@ -51,10 +52,16 @@ def __init__(
         anomaly_source_path: str | None = None,
         beta: float | tuple[float, float] = (0.1, 1.0),
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.augmenter = PerlinAnomalyGenerator(anomaly_source_path=anomaly_source_path, blend_factor=beta)
         self.model = DraemModel(sspcab=enable_sspcab)
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index 8aa3de08e2..dd80e88ba7 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -25,6 +25,7 @@
 from anomalib.models.image.dsr.torch_model import DsrModel
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 __all__ = ["Dsr"]
 
@@ -53,10 +54,16 @@ def __init__(
         latent_anomaly_strength: float = 0.2,
         upsampling_train_ratio: float = 0.7,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.automatic_optimization = False
         self.upsampling_train_ratio = upsampling_train_ratio
diff --git a/src/anomalib/models/image/efficient_ad/lightning_model.py b/src/anomalib/models/image/efficient_ad/lightning_model.py
index 47ace2a073..aa99d6a439 100644
--- a/src/anomalib/models/image/efficient_ad/lightning_model.py
+++ b/src/anomalib/models/image/efficient_ad/lightning_model.py
@@ -24,6 +24,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .torch_model import EfficientAdModel, EfficientAdModelSize, reduce_tensor_elems
 
@@ -76,10 +77,16 @@ def __init__(
         padding: bool = False,
         pad_maps: bool = True,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.imagenet_dir = Path(imagenet_dir)
         if not isinstance(model_size, EfficientAdModelSize):
diff --git a/src/anomalib/models/image/fastflow/lightning_model.py b/src/anomalib/models/image/fastflow/lightning_model.py
index 35a5f8dddb..8a98ea9e7a 100644
--- a/src/anomalib/models/image/fastflow/lightning_model.py
+++ b/src/anomalib/models/image/fastflow/lightning_model.py
@@ -18,6 +18,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .loss import FastflowLoss
 from .torch_model import FastflowModel
@@ -50,10 +51,16 @@ def __init__(
         conv3x3_only: bool = False,
         hidden_ratio: float = 1.0,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
         if self.input_size is None:
             msg = "Fastflow needs input size to build torch model."
             raise ValueError(msg)
diff --git a/src/anomalib/models/image/fre/lightning_model.py b/src/anomalib/models/image/fre/lightning_model.py
index 505beb7f1b..953fcd4322 100755
--- a/src/anomalib/models/image/fre/lightning_model.py
+++ b/src/anomalib/models/image/fre/lightning_model.py
@@ -19,6 +19,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .torch_model import FREModel
 
@@ -56,10 +57,16 @@ def __init__(
         input_dim: int = 65536,
         latent_dim: int = 220,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.model: FREModel = FREModel(
             backbone=backbone,
diff --git a/src/anomalib/models/image/ganomaly/lightning_model.py b/src/anomalib/models/image/ganomaly/lightning_model.py
index 982bd93d33..4b48b0b633 100644
--- a/src/anomalib/models/image/ganomaly/lightning_model.py
+++ b/src/anomalib/models/image/ganomaly/lightning_model.py
@@ -19,6 +19,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .loss import DiscriminatorLoss, GeneratorLoss
 from .torch_model import GanomalyModel
@@ -71,10 +72,16 @@ def __init__(
         beta1: float = 0.5,
         beta2: float = 0.999,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
         if self.input_size is None:
             msg = "GANomaly needs input size to build torch model."
             raise ValueError(msg)
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index 2e246e8450..78f17861c0 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -17,6 +17,7 @@
 from anomalib.models.components import AnomalibModule, MemoryBankMixin
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .torch_model import PadimModel
 
@@ -50,10 +51,16 @@ def __init__(
         pre_trained: bool = True,
         n_features: int | None = None,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.model: PadimModel = PadimModel(
             backbone=backbone,
@@ -135,6 +142,6 @@ def learning_type(self) -> LearningType:
         return LearningType.ONE_CLASS
 
     @staticmethod
-    def default_post_processor() -> OneClassPostProcessor:
+    def configure_post_processor() -> OneClassPostProcessor:
         """Return the default post-processor for PADIM."""
         return OneClassPostProcessor()
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index 748be1f443..e58185e50e 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -20,6 +20,7 @@
 from anomalib.models.components import AnomalibModule, MemoryBankMixin
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .torch_model import PatchcoreModel
 
@@ -53,10 +54,16 @@ def __init__(
         coreset_sampling_ratio: float = 0.1,
         num_neighbors: int = 9,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.model: PatchcoreModel = PatchcoreModel(
             backbone=backbone,
@@ -156,7 +163,7 @@ def learning_type(self) -> LearningType:
         return LearningType.ONE_CLASS
 
     @staticmethod
-    def default_post_processor() -> OneClassPostProcessor:
+    def configure_post_processor() -> OneClassPostProcessor:
         """Return the default post-processor for the model.
 
         Returns:
diff --git a/src/anomalib/models/image/reverse_distillation/lightning_model.py b/src/anomalib/models/image/reverse_distillation/lightning_model.py
index e052c864cb..3eb3bf903c 100644
--- a/src/anomalib/models/image/reverse_distillation/lightning_model.py
+++ b/src/anomalib/models/image/reverse_distillation/lightning_model.py
@@ -18,6 +18,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .anomaly_map import AnomalyMapGenerationMode
 from .loss import ReverseDistillationLoss
@@ -48,10 +49,16 @@ def __init__(
         anomaly_map_mode: AnomalyMapGenerationMode = AnomalyMapGenerationMode.ADD,
         pre_trained: bool = True,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
         if self.input_size is None:
             msg = "Input size is required for Reverse Distillation model."
             raise ValueError(msg)
diff --git a/src/anomalib/models/image/stfpm/lightning_model.py b/src/anomalib/models/image/stfpm/lightning_model.py
index 9f37e46239..f3daafe407 100644
--- a/src/anomalib/models/image/stfpm/lightning_model.py
+++ b/src/anomalib/models/image/stfpm/lightning_model.py
@@ -19,6 +19,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .loss import STFPMLoss
 from .torch_model import STFPMModel
@@ -44,10 +45,16 @@ def __init__(
         backbone: str = "resnet18",
         layers: Sequence[str] = ("layer1", "layer2", "layer3"),
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.model = STFPMModel(backbone=backbone, layers=layers)
         self.loss = STFPMLoss()
diff --git a/src/anomalib/models/image/uflow/lightning_model.py b/src/anomalib/models/image/uflow/lightning_model.py
index 60e7a26752..bfd51195ca 100644
--- a/src/anomalib/models/image/uflow/lightning_model.py
+++ b/src/anomalib/models/image/uflow/lightning_model.py
@@ -21,6 +21,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .loss import UFlowLoss
 from .torch_model import UflowModel
@@ -49,8 +50,9 @@ def __init__(
         affine_subnet_channels_ratio: float = 1.0,
         permute_soft: bool = False,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
         """Uflow model.
 
@@ -69,8 +71,16 @@ def __init__(
             evaluator (Evaluator, optional): Evaluator for the model.
                 This is used to evaluate the model.
                 Defaults to ``True``.
+            visualizer (Visualizer, optional): Visualizer for the model.
+                This is used to visualize the model.
+                Defaults to ``True``.
         """
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
         if self.input_size is None:
             msg = "Input size is required for UFlow model."
             raise ValueError(msg)
diff --git a/src/anomalib/models/image/vlm_ad/lightning_model.py b/src/anomalib/models/image/vlm_ad/lightning_model.py
index 6e47e58027..7340474f29 100644
--- a/src/anomalib/models/image/vlm_ad/lightning_model.py
+++ b/src/anomalib/models/image/vlm_ad/lightning_model.py
@@ -102,7 +102,8 @@ def configure_transforms(image_size: tuple[int, int] | None = None) -> None:
         if image_size is not None:
             logger.warning("Ignoring image_size argument as each backend has its own transforms.")
 
-    def default_post_processor(self) -> PostProcessor | None:  # noqa: PLR6301
+    @classmethod
+    def configure_post_processor(cls) -> PostProcessor | None:
         """Post processing is not required for this model."""
         return None
 
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index d3f7481df7..23a7cf23a1 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -22,6 +22,7 @@
 from anomalib.models.components import AnomalibModule
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 from anomalib.pre_processing import PreProcessor
+from anomalib.visualization import Visualizer
 
 from .torch_model import WinClipModel
 
@@ -56,10 +57,16 @@ def __init__(
         scales: tuple = (2, 3),
         few_shot_source: Path | str | None = None,
         pre_processor: PreProcessor | bool = True,
-        post_processor: PostProcessor | None = None,
+        post_processor: PostProcessor | bool = True,
         evaluator: Evaluator | bool = True,
+        visualizer: Visualizer | bool = True,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, post_processor=post_processor, evaluator=evaluator)
+        super().__init__(
+            pre_processor=pre_processor,
+            post_processor=post_processor,
+            evaluator=evaluator,
+            visualizer=visualizer,
+        )
 
         self.model = WinClipModel(scales=scales, apply_transform=False)
         self.class_name = class_name
@@ -195,6 +202,6 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
         return PreProcessor(val_transform=transform, test_transform=transform)
 
     @staticmethod
-    def default_post_processor() -> OneClassPostProcessor:
+    def configure_post_processor() -> OneClassPostProcessor:
         """Return the default post-processor for WinCLIP."""
         return OneClassPostProcessor()
diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py
index fb9044518c..3afd674673 100644
--- a/src/anomalib/models/video/ai_vad/lightning_model.py
+++ b/src/anomalib/models/video/ai_vad/lightning_model.py
@@ -81,9 +81,10 @@ def __init__(
         n_neighbors_pose: int = 1,
         n_neighbors_deep: int = 1,
         pre_processor: PreProcessor | bool = True,
+        post_processor: PostProcessor | bool = True,
         **kwargs,
     ) -> None:
-        super().__init__(pre_processor=pre_processor, **kwargs)
+        super().__init__(pre_processor=pre_processor, post_processor=post_processor, **kwargs)
         self.model = AiVadModel(
             box_score_thresh=box_score_thresh,
             persons_only=persons_only,
@@ -176,6 +177,6 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
         return PreProcessor()  # A pre-processor with no transforms.
 
     @staticmethod
-    def default_post_processor() -> PostProcessor:
+    def configure_post_processor() -> PostProcessor:
         """Return the default post-processor for AI-VAD."""
         return OneClassPostProcessor()
diff --git a/src/anomalib/visualization/__init__.py b/src/anomalib/visualization/__init__.py
index ca0b7bc138..989f4cc34c 100644
--- a/src/anomalib/visualization/__init__.py
+++ b/src/anomalib/visualization/__init__.py
@@ -3,10 +3,13 @@
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+from .base import Visualizer
 from .image import ImageVisualizer, visualize_anomaly_map, visualize_mask
 from .image.item_visualizer import visualize_image_item
 
 __all__ = [
+    # Base visualizer class
+    "Visualizer",
     # Image visualizer class
     "ImageVisualizer",
     # Image visualization functions
diff --git a/src/anomalib/visualization/base.py b/src/anomalib/visualization/base.py
new file mode 100644
index 0000000000..dc49a85401
--- /dev/null
+++ b/src/anomalib/visualization/base.py
@@ -0,0 +1,14 @@
+"""Base Visualizer."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from lightning.pytorch import Callback
+
+
+class Visualizer(Callback):
+    """Base class for all visualizers.
+
+    In Anomalib, the visualizer is used to visualize the results of the model
+    during the testing and prediction phases.
+    """
diff --git a/src/anomalib/visualization/image/visualizer.py b/src/anomalib/visualization/image/visualizer.py
index c8eafc8ae8..c230bdde03 100644
--- a/src/anomalib/visualization/image/visualizer.py
+++ b/src/anomalib/visualization/image/visualizer.py
@@ -4,13 +4,17 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from lightning.pytorch import Callback, Trainer
+# Only import types during type checking to avoid circular imports
+if TYPE_CHECKING:
+    from lightning.pytorch import Trainer
+
+    from anomalib.data import ImageBatch
+    from anomalib.models import AnomalibModule
 
-from anomalib.data import ImageBatch
-from anomalib.models import AnomalibModule
 from anomalib.utils.path import generate_output_filename
+from anomalib.visualization.base import Visualizer
 
 from .item_visualizer import (
     DEFAULT_FIELDS_CONFIG,
@@ -20,7 +24,7 @@
 )
 
 
-class ImageVisualizer(Callback):
+class ImageVisualizer(Visualizer):
     """Image Visualizer.
 
     This class is responsible for visualizing images and their corresponding anomaly maps
@@ -127,6 +131,7 @@ def __init__(
         text_config: dict[str, Any] | None = None,
         output_dir: str | Path | None = None,
     ) -> None:
+        super().__init__()
         self.fields = fields or ["image", "gt_mask"]
         self.overlay_fields = overlay_fields or [("image", ["anomaly_map"]), ("image", ["pred_mask"])]
         self.field_size = field_size
@@ -137,10 +142,10 @@ def __init__(
 
     def on_test_batch_end(
         self,
-        trainer: Trainer,
-        pl_module: AnomalibModule,
-        outputs: ImageBatch,
-        batch: ImageBatch,
+        trainer: "Trainer",
+        pl_module: "AnomalibModule",
+        outputs: "ImageBatch",
+        batch: "ImageBatch",
         batch_idx: int,
         dataloader_idx: int = 0,
     ) -> None:
@@ -175,10 +180,10 @@ def on_test_batch_end(
 
     def on_predict_batch_end(
         self,
-        trainer: Trainer,
-        pl_module: AnomalibModule,
-        outputs: ImageBatch,
-        batch: ImageBatch,
+        trainer: "Trainer",
+        pl_module: "AnomalibModule",
+        outputs: "ImageBatch",
+        batch: "ImageBatch",
         batch_idx: int,
         dataloader_idx: int = 0,
     ) -> None:
diff --git a/tests/integration/tools/upgrade/expected_draem_v1.yaml b/tests/integration/tools/upgrade/expected_draem_v1.yaml
index 438c49fd73..feb059214d 100644
--- a/tests/integration/tools/upgrade/expected_draem_v1.yaml
+++ b/tests/integration/tools/upgrade/expected_draem_v1.yaml
@@ -21,8 +21,9 @@ model:
       - 0.1
       - 1.0
     pre_processor: true
-    post_processor: null
+    post_processor: true
     evaluator: true
+    visualizer: true
 normalization:
   normalization_method: min_max
 metrics:
diff --git a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
index dc9c31e8db..45389c949f 100644
--- a/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
+++ b/tests/unit/utils/callbacks/visualizer_callback/dummy_lightning_model.py
@@ -74,6 +74,6 @@ def learning_type(self) -> LearningType:
         return LearningType.ZERO_SHOT
 
     @staticmethod
-    def default_post_processor() -> PostProcessor:
+    def configure_post_processor() -> PostProcessor:
         """Returns a dummy post-processor."""
         return DummyPostProcessor()

From 7116fecd4abbd73ccd3597a60e48800fff02afd4 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 11 Dec 2024 12:37:45 +0000
Subject: [PATCH 19/45] =?UTF-8?q?=F0=9F=93=9AUpdate=20`CHANGELOG.md`=20fil?=
 =?UTF-8?q?e=20for=20v2.0.0=20release=20(#2463)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Updatechangelog

Signed-off-by: Samet Akcay 
---
 CHANGELOG.md | 46 +++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 41 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b4e8248969..036a2f0e49 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,13 +8,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 
-- Add `AUPIMO` tutorials notebooks in https://github.com/openvinotoolkit/anomalib/pull/2330 and https://github.com/openvinotoolkit/anomalib/pull/2336
-- Add `AUPIMO` metric by [jpcbertoldo](https://github.com/jpcbertoldo) in https://github.com/openvinotoolkit/anomalib/pull/1726 and refactored by [ashwinvaidya17](https://github.com/ashwinvaidya17) in https://github.com/openvinotoolkit/anomalib/pull/2329
-
 ### Removed
 
-- Remove `RKDE` in https://github.com/openvinotoolkit/anomalib/pull/2455
-
 ### Changed
 
 ### Deprecated
@@ -23,6 +18,47 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### New Contributors
 
+## v2.0.0
+
+### Added
+
+- 🚀 Add `Dataclasses` and `PostProcessor` by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/2098
+- 🚀 Add dataclass validators by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2307
+- 🚀 Add Customisable Image Visualizer by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2334
+- 🚀 Metrics redesign by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/2326
+- 🚀 Add `PreProcessor` to `AnomalyModule` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2358
+- 🚀 Add Multi-GPU Training Support by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2435
+- 🔨 Refactor: Add missing auxiliary attributes to `AnomalibModule` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2460
+- 🔨 Rename `AnomalyModule` to `AnomalibModule` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2423
+
+- 🚀 Add `AUPIMO` metric by [jpcbertoldo](https://github.com/jpcbertoldo) in https://github.com/openvinotoolkit/anomalib/pull/1726 and refactored by [ashwinvaidya17](https://github.com/ashwinvaidya17) in https://github.com/openvinotoolkit/anomalib/pull/2329
+- 📚 Add `AUPIMO` tutorials notebooks in https://github.com/openvinotoolkit/anomalib/pull/2330 and https://github.com/openvinotoolkit/anomalib/pull/2336
+
+### Removed
+
+- 🗑️ Remove RKDE by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2455
+- 🗑️ Remove rich methods by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2283
+- 🔨 Replace `imgaug` with Native PyTorch Transforms by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2436
+- 🗑️ Remove task type by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/2450
+
+### Changed
+
+- Refactor Lightning's `trainer.model` to `trainer.lightning_module` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2255
+- Update open-clip-torch requirement from <2.26.1,>=2.23.0 to >=2.23.0,<2.26.2 by @dependabot in https://github.com/openvinotoolkit/anomalib/pull/2189
+- Update sphinx requirement by @dependabot in https://github.com/openvinotoolkit/anomalib/pull/2235
+- Update ruff configuration by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2269
+- Revert "Update open-clip-torch requirement from <2.26.1,>=2.23.0 to >=2.23.0,<2.26.2" by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2270
+- 🔨 Lint: U\* 🔨 Refactor BaseThreshold to Threshold by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2278
+- 🔨 Enable Ruff Rules: PLW1514 and PLR6201 by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2284
+- 🔨 Update nncf export by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/2286
+- 🔨 Linting: Enable `PLR6301`, # could be a function, class method or static method by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2288
+- 🔨 Restructure unit tests and fix ruff issues by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2306pdate Ruff Config - Add Missing Copyright Headers by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/2281
+- 🔨 optimization/quantization added into 500 series by @paularamo in https://github.com/openvinotoolkit/anomalib/pull/2197
+
+### Fixed
+
+- 🐞Replace package_available with module_available by @harimkang in https://github.com/openvinotoolkit/anomalib/pull/2407
+
 ## [v1.2.0]
 
 ### Added

From 244f50b755a33a7c35706c63fdd2ffe356520eda Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 11 Dec 2024 13:12:40 +0000
Subject: [PATCH 20/45] =?UTF-8?q?=F0=9F=9A=80=20Create=20=20a=20new=20CI?=
 =?UTF-8?q?=20Pipeline=20(#2461)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Add new gh actions based ci pipeline

Signed-off-by: Samet Akcay 

* Add new gh actions based ci pipeline

Signed-off-by: Samet Akcay 

* Remove nodejs from reusable workflows

Signed-off-by: Samet Akcay 

* Remove sudo in clamav

Signed-off-by: Samet Akcay 

* Further refactor test suite

Signed-off-by: Samet Akcay 

* update release validation workflow

Signed-off-by: Samet Akcay 

* Add documentation about the release strategy

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 
---
 .ci/ipas_default.config                       | 408 ------------------
 .ci/trivy.yaml                                |  11 -
 .github/CODEOWNERS                            |   1 -
 .../code-quality/pre-commit/action.yaml       | 116 +++++
 .github/actions/pytest/action.yaml            | 177 ++++++++
 .github/actions/security/bandit/action.yaml   | 142 ++++++
 .github/actions/security/clamav/action.yaml   | 167 +++++++
 .github/actions/security/semgrep/action.yaml  | 136 ++++++
 .github/actions/security/trivy/action.yaml    | 183 ++++++++
 .../workflows/_reusable-artifact-builder.yaml | 115 +++++
 .github/workflows/_reusable-code-quality.yaml |  67 +++
 .../_reusable-production-release-process.yaml | 109 +++++
 .../_reusable-rc-release-process.yaml         | 241 +++++++++++
 .../_reusable-release-publisher.yaml          | 101 +++++
 .../workflows/_reusable-release-status.yaml   |  76 ++++
 .../_reusable-release-validation.yaml         | 178 ++++++++
 .../workflows/_reusable-security-scan.yaml    | 181 ++++++++
 .github/workflows/_reusable-test-suite.yaml   | 109 +++++
 .../workflows/_reusable-version-check.yaml    | 104 +++++
 .github/workflows/code_scan.yml               |  52 ---
 .github/workflows/pr.yaml                     |  84 ++++
 .github/workflows/publish.yml                 |  28 --
 .github/workflows/release.yaml                | 104 +++++
 .github/workflows/security-checks.yaml        |  96 +++++
 .github/workflows/upload_coverage.yml         |  30 --
 .../source/markdown/guides/developer/index.md |   1 +
 .../guides/developer/release_guidelines.md    | 367 ++++++++++++++++
 27 files changed, 2854 insertions(+), 530 deletions(-)
 delete mode 100644 .ci/ipas_default.config
 delete mode 100644 .ci/trivy.yaml
 create mode 100644 .github/actions/code-quality/pre-commit/action.yaml
 create mode 100644 .github/actions/pytest/action.yaml
 create mode 100644 .github/actions/security/bandit/action.yaml
 create mode 100644 .github/actions/security/clamav/action.yaml
 create mode 100644 .github/actions/security/semgrep/action.yaml
 create mode 100644 .github/actions/security/trivy/action.yaml
 create mode 100644 .github/workflows/_reusable-artifact-builder.yaml
 create mode 100644 .github/workflows/_reusable-code-quality.yaml
 create mode 100644 .github/workflows/_reusable-production-release-process.yaml
 create mode 100644 .github/workflows/_reusable-rc-release-process.yaml
 create mode 100644 .github/workflows/_reusable-release-publisher.yaml
 create mode 100644 .github/workflows/_reusable-release-status.yaml
 create mode 100644 .github/workflows/_reusable-release-validation.yaml
 create mode 100644 .github/workflows/_reusable-security-scan.yaml
 create mode 100644 .github/workflows/_reusable-test-suite.yaml
 create mode 100644 .github/workflows/_reusable-version-check.yaml
 delete mode 100644 .github/workflows/code_scan.yml
 create mode 100644 .github/workflows/pr.yaml
 delete mode 100644 .github/workflows/publish.yml
 create mode 100644 .github/workflows/release.yaml
 create mode 100644 .github/workflows/security-checks.yaml
 delete mode 100644 .github/workflows/upload_coverage.yml
 create mode 100644 docs/source/markdown/guides/developer/release_guidelines.md

diff --git a/.ci/ipas_default.config b/.ci/ipas_default.config
deleted file mode 100644
index 5cca904cfa..0000000000
--- a/.ci/ipas_default.config
+++ /dev/null
@@ -1,408 +0,0 @@
-
-### Bandit config file generated from:
-# './bandit/bandit/cli/config_generator.py --out ipas_default.config'
-
-### This config may optionally select a subset of tests to run or skip by
-### filling out the 'tests' and 'skips' lists given below. If no tests are
-### specified for inclusion then it is assumed all tests are desired. The skips
-### set will remove specific tests from the include set. This can be controlled
-### using the -t/-s CLI options. Note that the same test ID should not appear
-### in both 'tests' and 'skips', this would be nonsensical and is detected by
-### Bandit at runtime.
-
-# Available tests:
-# B101 : assert_used
-# B102 : exec_used
-# B103 : set_bad_file_permissions
-# B104 : hardcoded_bind_all_interfaces
-# B105 : hardcoded_password_string
-# B106 : hardcoded_password_funcarg
-# B107 : hardcoded_password_default
-# B108 : hardcoded_tmp_directory
-# B110 : try_except_pass
-# B112 : try_except_continue
-# B201 : flask_debug_true
-# B301 : pickle
-# B302 : marshal
-# B303 : md5
-# B304 : ciphers
-# B305 : cipher_modes
-# B306 : mktemp_q
-# B307 : eval
-# B308 : mark_safe
-# B310 : urllib_urlopen
-# B311 : random
-# B312 : telnetlib
-# B313 : xml_bad_cElementTree
-# B314 : xml_bad_ElementTree
-# B315 : xml_bad_expatreader
-# B316 : xml_bad_expatbuilder
-# B317 : xml_bad_sax
-# B318 : xml_bad_minidom
-# B319 : xml_bad_pulldom
-# B320 : xml_bad_etree
-# B321 : ftplib
-# B323 : unverified_context
-# B324 : hashlib_new_insecure_functions
-# B401 : import_telnetlib
-# B402 : import_ftplib
-# B403 : import_pickle
-# B404 : import_subprocess
-# B405 : import_xml_etree
-# B406 : import_xml_sax
-# B407 : import_xml_expat
-# B408 : import_xml_minidom
-# B409 : import_xml_pulldom
-# B410 : import_lxml
-# B411 : import_xmlrpclib
-# B412 : import_httpoxy
-# B413 : import_pycrypto
-# B501 : request_with_no_cert_validation
-# B502 : ssl_with_bad_version
-# B503 : ssl_with_bad_defaults
-# B504 : ssl_with_no_version
-# B505 : weak_cryptographic_key
-# B506 : yaml_load
-# B507 : ssh_no_host_key_verification
-# B601 : paramiko_calls
-# B602 : subprocess_popen_with_shell_equals_true
-# B603 : subprocess_without_shell_equals_true
-# B604 : any_other_function_with_shell_equals_true
-# B605 : start_process_with_a_shell
-# B606 : start_process_with_no_shell
-# B607 : start_process_with_partial_path
-# B608 : hardcoded_sql_expressions
-# B609 : linux_commands_wildcard_injection
-# B610 : django_extra_used
-# B611 : django_rawsql_used
-# B701 : jinja2_autoescape_false
-# B702 : use_of_mako_templates
-# B703 : django_mark_safe
-
-# (optional) list included test IDs here, eg '[B101, B406]':
-# IPAS Required Checkers. Do not disable these
-# Additional checkers may be added if desired
-tests:
-  [ 'B301', 'B302', 'B303', 'B304', 'B305', 'B306', 'B308', 'B310', 'B311', 'B312', 'B313', 'B314', 'B315', 'B316', 'B317', 'B318', 'B319', 'B320', 'B321', 'B323', 'B324', 'B401', 'B402', 'B403', 'B404', 'B405', 'B406', 'B407', 'B408', 'B409', 'B410', 'B411', 'B412', 'B413']
-
-# (optional) list skipped test IDs here, eg '[B101, B406]':
-# The following checkers are not required but be added to tests list if desired
-skips:
-  [ 'B101', 'B102', 'B103', 'B104', 'B105', 'B106', 'B107', 'B108', 'B110', 'B112', 'B201', 'B501', 'B502', 'B503', 'B504', 'B505', 'B506', 'B507', 'B601', 'B602', 'B603', 'B604', 'B605', 'B606', 'B607', 'B608', 'B609', 'B610', 'B611', 'B701', 'B702', 'B703']
-
-
-# Added to exclude some path which are not actual source code for this project
-exclude_dirs: [
-  '.tox/',
-  '.vscode/',
-  '.git/',
-]
-
-### (optional) plugin settings - some test plugins require configuration data
-### that may be given here, per-plugin. All bandit test plugins have a built in
-### set of sensible defaults and these will be used if no configuration is
-### provided. It is not necessary to provide settings for every (or any) plugin
-### if the defaults are acceptable.
-
-any_other_function_with_shell_equals_true:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-assert_used:
-  skips: []
-hardcoded_tmp_directory:
-  tmp_dirs:
-  - /tmp
-  - /var/tmp
-  - /dev/shm
-linux_commands_wildcard_injection:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-ssl_with_bad_defaults:
-  bad_protocol_versions:
-  - PROTOCOL_SSLv2
-  - SSLv2_METHOD
-  - SSLv23_METHOD
-  - PROTOCOL_SSLv3
-  - PROTOCOL_TLSv1
-  - SSLv3_METHOD
-  - TLSv1_METHOD
-ssl_with_bad_version:
-  bad_protocol_versions:
-  - PROTOCOL_SSLv2
-  - SSLv2_METHOD
-  - SSLv23_METHOD
-  - PROTOCOL_SSLv3
-  - PROTOCOL_TLSv1
-  - SSLv3_METHOD
-  - TLSv1_METHOD
-start_process_with_a_shell:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-start_process_with_no_shell:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-start_process_with_partial_path:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-subprocess_popen_with_shell_equals_true:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-subprocess_without_shell_equals_true:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-try_except_continue:
-  check_typed_exception: false
-try_except_pass:
-  check_typed_exception: false
-weak_cryptographic_key:
-  weak_key_size_dsa_high: 1024
-  weak_key_size_dsa_medium: 2048
-  weak_key_size_ec_high: 160
-  weak_key_size_ec_medium: 224
-  weak_key_size_rsa_high: 1024
-  weak_key_size_rsa_medium: 2048
diff --git a/.ci/trivy.yaml b/.ci/trivy.yaml
deleted file mode 100644
index 0b20468b5b..0000000000
--- a/.ci/trivy.yaml
+++ /dev/null
@@ -1,11 +0,0 @@
-ignore-policy: ""
-ignorefile: .trivyignore
-insecure: false
-scan:
-  scanners:
-    - vuln
-    - secret
-  slow: false
-severity: UNKNOWN,LOW,MEDIUM,HIGH,CRITICAL
-vulnerability:
-  ignore-unfixed: false
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 2960d480a7..5703b7174c 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -20,7 +20,6 @@
 /notebooks/200_models                                       @samet-akcay
 /notebooks/300_benchmarking                                 @ashwinvaidya17
 /notebooks/400_openvino                                     @samet-akcay
-/notebooks/500_use_cases                                    @paularamo
 /notebooks/README.md                                        @samet-akcay
 
 # Requirements
diff --git a/.github/actions/code-quality/pre-commit/action.yaml b/.github/actions/code-quality/pre-commit/action.yaml
new file mode 100644
index 0000000000..acbcf87379
--- /dev/null
+++ b/.github/actions/code-quality/pre-commit/action.yaml
@@ -0,0 +1,116 @@
+# Pre-commit Quality Action
+#
+# This composite action executes pre-commit hooks for code quality checks
+# with configurable Python and Node.js environments.
+#
+# Key Features:
+# - Pre-commit hook execution
+# - Environment configuration
+# - Cache management
+# - Multi-language support
+# - Dependency handling
+#
+# Process Stages:
+# 1. Environment Setup:
+#    - Python installation
+#    - Node.js installation
+#    - Cache configuration
+#
+# 2. Dependency Management:
+#    - Pre-commit installation
+#    - Hook installation
+#    - Cache restoration
+#
+# 3. Quality Checks:
+#    - Hook execution
+#    - Error reporting
+#    - Result caching
+#
+# Required Inputs:
+# - python-version: Python version to use
+# - node-version: Node.js version to use (defaults to "20")
+#
+# Example Usage:
+# steps:
+#   - uses: ./.github/actions/code-quality/pre-commit
+#     with:
+#       python-version: "3.11"
+#
+# Note: Requires configured pre-commit hooks in repository
+
+name: "Pre-commit Quality Checks"
+description: "Runs pre-commit hooks for code quality checks"
+
+inputs:
+  python-version:
+    description: "Python version to use"
+    required: false
+    default: "3.10"
+  node-version:
+    description: "Node.js version to use"
+    required: false
+    default: "20"
+  skip:
+    description: "Comma-separated list of hooks to skip"
+    required: false
+    default: ""
+  cache:
+    description: "Whether to use caching"
+    required: false
+    default: "true"
+
+outputs:
+  cache-hit:
+    description: "Whether the cache was hit"
+    value: ${{ steps.pre-commit-cache.outputs.cache-hit }}
+
+runs:
+  using: composite
+  steps:
+    # Set up Python environment with caching
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ inputs.python-version }}
+        cache: pip # Enable pip caching
+        cache-dependency-path: .pre-commit-config.yaml
+
+    # Set up Node.js for JavaScript-related hooks
+    - name: Set up Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ inputs.node-version }}
+
+    # Install pre-commit with latest pip
+    - name: Install pre-commit
+      shell: bash
+      run: |
+        python -m pip install --upgrade pip
+        pip install pre-commit
+
+    # Cache pre-commit hooks to speed up subsequent runs
+    - name: Cache pre-commit hooks
+      if: inputs.cache == 'true'
+      id: pre-commit-cache
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/pre-commit
+        # Cache key includes Python and Node versions to ensure correct environment
+        key: pre-commit-${{ runner.os }}-py${{ inputs.python-version }}-node${{ inputs.node-version }}-${{ hashFiles('.pre-commit-config.yaml') }}
+        restore-keys: |
+          pre-commit-${{ runner.os }}-py${{ inputs.python-version }}-node${{ inputs.node-version }}-
+          pre-commit-${{ runner.os }}-py${{ inputs.python-version }}-
+
+    # Execute pre-commit checks with optional hook skipping
+    - name: Run pre-commit checks
+      shell: bash
+      env:
+        SKIP: ${{ inputs.skip }}
+      run: |
+        if [ -n "$SKIP" ]; then
+          # Run specific hooks if skip parameter is provided
+          pre-commit run --all-files --hook-stage="$SKIP"
+        else
+          # Run all hooks if no skip parameter
+          pre-commit run --all-files
+        fi
diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
new file mode 100644
index 0000000000..8617ea148e
--- /dev/null
+++ b/.github/actions/pytest/action.yaml
@@ -0,0 +1,177 @@
+# Test Runner Action
+#
+# This composite action executes Python tests with pytest, providing
+# comprehensive test execution and reporting capabilities.
+#
+# Key Features:
+# - Multiple test type support
+# - Parallel execution
+# - Coverage reporting
+# - Performance tracking
+# - Result analysis
+#
+# Process Stages:
+# 1. Environment Setup:
+#    - Python configuration
+#    - Virtual environment creation
+#    - Dependency installation
+#
+# 2. Test Execution:
+#    - Test scope determination
+#    - Parallel processing
+#    - Coverage tracking
+#    - Performance monitoring
+#
+# 3. Results Processing:
+#    - Coverage analysis
+#    - Performance reporting
+#    - Results aggregation
+#
+# Required Inputs:
+# - python-version: Python version for tests
+# - test-type: Type of tests to run
+# - codecov-token: Token for coverage upload
+# - max-test-time: Maximum test duration
+#
+# Outputs:
+# - coverage-percentage: Total coverage
+# - tests-passed: Test success status
+# - test-duration: Execution time
+#
+# Example Usage:
+# steps:
+#   - uses: ./.github/actions/pytest
+#     with:
+#       python-version: "3.11"
+#       test-type: "unit"
+#       codecov-token: ${{ secrets.CODECOV_TOKEN }}
+#
+# Note: Requires proper pytest configuration in pyproject.toml
+
+name: "Python Tests Runner"
+description: "Runs Python unit and integration tests with pytest and uploads coverage to Codecov"
+
+inputs:
+  python-version:
+    description: "Python version to use"
+    required: false
+    default: "3.10"
+  test-type:
+    description: "Type of tests to run (unit/integration/all)"
+    required: false
+    default: "all"
+  codecov-token:
+    description: "Codecov upload token"
+    required: true
+  max-test-time:
+    description: "Maximum time in seconds for the test suite to run"
+    required: false
+    default: "300"
+
+outputs:
+  coverage-percentage:
+    description: "Total coverage percentage"
+    value: ${{ steps.coverage.outputs.percentage }}
+  tests-passed:
+    description: "Whether all tests passed"
+    value: ${{ steps.test-execution.outputs.success }}
+  test-duration:
+    description: "Total test duration in seconds"
+    value: ${{ steps.test-execution.outputs.duration }}
+
+runs:
+  using: composite
+  steps:
+    # Set up Python with pip caching
+    - name: Set up Python environment
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ inputs.python-version }}
+        cache: pip # Enable pip caching
+        cache-dependency-path: pyproject.toml
+
+    # Create and configure virtual environment
+    - name: Configure virtual environment
+      id: setup-venv
+      shell: bash
+      run: |
+        # Create isolated test environment
+        python -m venv .venv
+        source .venv/bin/activate
+        # Install dependencies with dev extras
+        python -m pip install --upgrade pip
+        pip install ".[dev]"
+        pip install codecov
+
+    # Determine which tests to run based on input
+    - name: Determine test scope
+      id: test-scope
+      shell: bash
+      run: |
+        case "${{ inputs.test-type }}" in
+          "unit")
+            echo "path=tests/unit" >> $GITHUB_OUTPUT
+            ;;
+          "integration")
+            echo "path=tests/integration" >> $GITHUB_OUTPUT
+            ;;
+          *)
+            # Run both test types if not specified
+            echo "path=tests/unit tests/integration" >> $GITHUB_OUTPUT
+            ;;
+        esac
+
+    # Execute test suite with performance tracking
+    - name: Execute test suite
+      id: test-execution
+      shell: bash
+      run: |
+        source .venv/bin/activate
+        start_time=$(date +%s)
+
+        # Run pytest with:
+        # - Auto parallel execution (-n auto)
+        # - Duration reporting for slow tests
+        # - Configurable timeout
+        # - JSON report generation
+        PYTHONPATH=src pytest ${{ steps.test-scope.outputs.path }} \
+          -n auto \
+          --durations=10 \
+          --durations-min=1.0 \
+          --timeout=${{ inputs.max-test-time }} \
+          --json-report --json-report-file=pytest.json \
+          && echo "success=true" >> $GITHUB_OUTPUT \
+          || echo "success=false" >> $GITHUB_OUTPUT
+
+        # Calculate total test duration
+        end_time=$(date +%s)
+        duration=$((end_time - start_time))
+        echo "duration=${duration}" >> $GITHUB_OUTPUT
+
+    # Analyze and report test performance
+    - name: Analyze test performance
+      if: always() # Run even if tests fail
+      shell: bash
+      run: |
+        echo "Test Duration: ${{ steps.test-execution.outputs.duration }} seconds"
+
+        # Report slowest tests for optimization
+        echo "Top 10 slowest tests:"
+        cat pytest.json | jq -r '.tests[] | select(.duration >= 1) | "\(.duration)s \(.name)"' | sort -rn | head -n 10
+
+        # Warn if tests exceed time limit
+        if [ "${{ steps.test-execution.outputs.duration }}" -gt "${{ inputs.max-test-time }}" ]; then
+          echo "::warning::Test suite exceeded recommended duration of ${{ inputs.max-test-time }} seconds"
+        fi
+
+    # Upload coverage data to Codecov
+    - name: Upload coverage to Codecov
+      if: steps.test-execution.outputs.success == 'true'
+      shell: bash
+      run: |
+        source .venv/bin/activate
+        # Upload with test type and Python version tags
+        codecov --token "${{ inputs.codecov-token }}" \
+                --file coverage.xml \
+                --flags "${{ inputs.test-type }}_py${{ inputs.python-version }}" \
+                --name "${{ inputs.test-type }} tests (Python ${{ inputs.python-version }})"
diff --git a/.github/actions/security/bandit/action.yaml b/.github/actions/security/bandit/action.yaml
new file mode 100644
index 0000000000..a339cb3fca
--- /dev/null
+++ b/.github/actions/security/bandit/action.yaml
@@ -0,0 +1,142 @@
+# Bandit Scanner Action
+#
+# This composite action executes Python security scanning using Bandit,
+# providing configurable security analysis capabilities.
+#
+# Key Features:
+# - Python code scanning
+# - Severity configuration
+# - Flexible scan scope
+# - Multiple report formats
+# - Custom rule support
+#
+# Process Stages:
+# 1. Environment Setup:
+#    - Python installation
+#    - Bandit configuration
+#    - Cache preparation
+#
+# 2. Scan Execution:
+#    - Target determination
+#    - Rule application
+#    - Security analysis
+#
+# 3. Results Processing:
+#    - Report generation
+#    - Finding analysis
+#    - Output formatting
+#
+# Required Inputs:
+# - scan_scope: Files to scan
+# - severity_level: Issue severity threshold
+# - fail_on_findings: Whether to fail on issues
+#
+# Outputs:
+# - scan_result: Scan exit code
+# - report_path: Results location
+#
+# Example Usage:
+# steps:
+#   - uses: ./.github/actions/security/bandit
+#     with:
+#       scan_scope: "changed"
+#       severity_level: "MEDIUM"
+#
+# Note: Configure Bandit settings in pyproject.toml for best results
+
+name: "Bandit Security Scan"
+description: "Runs Bandit security scanner with configurable options"
+
+inputs:
+  scan_scope:
+    description: "Scope of files to scan (all/changed)"
+    required: false
+    default: "changed"
+  paths:
+    description: "Paths to scan when using all scope"
+    required: false
+    default: "./src"
+  config_file:
+    description: "Path to pyproject.toml or custom bandit config"
+    required: false
+    default: "pyproject.toml"
+  severity_level:
+    description: "Minimum severity level to report (all/LOW/MEDIUM/HIGH)"
+    required: false
+    default: "LOW"
+  confidence_level:
+    description: "Minimum confidence level to report (all/LOW/MEDIUM/HIGH)"
+    required: false
+    default: "LOW"
+  output_format:
+    description: "Format for scan results (json/txt/html/csv)"
+    required: false
+    default: "json"
+  fail_on_findings:
+    description: "Whether to fail the action if issues are found"
+    required: false
+    default: "true"
+
+outputs:
+  scan_result:
+    description: "Exit code of the Bandit scan"
+    value: ${{ steps.run-bandit.outputs.exit_code }}
+  report_path:
+    description: "Path to the generated report file"
+    value: ${{ steps.run-bandit.outputs.report_path }}
+
+runs:
+  using: composite
+  steps:
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+
+    - name: Install Bandit
+      shell: bash
+      run: |
+        python -m pip install --upgrade pip
+        pip install bandit[toml]
+
+    - name: Get changed files
+      if: inputs.scan_scope == 'changed'
+      id: changed-files
+      uses: tj-actions/changed-files@v41
+      with:
+        files: |
+          **/*.py
+          **/*.pyx
+          **/*.pyi
+
+    - name: Run Bandit scan
+      id: run-bandit
+      shell: bash
+      run: |
+        REPORT_FILE="bandit-report.${{ inputs.output_format }}"
+
+        if [[ "${{ inputs.scan_scope }}" == "changed" && -n "${{ steps.changed-files.outputs.all_changed_files }}" ]]; then
+          echo "Running Bandit on changed files"
+          FILES="${{ steps.changed-files.outputs.all_changed_files }}"
+        else
+          echo "Running Bandit on all files in ${{ inputs.paths }}"
+          FILES="${{ inputs.paths }}"
+        fi
+
+        # Convert severity and confidence to lowercase
+        SEVERITY=$(echo "${{ inputs.severity_level }}" | tr '[:upper:]' '[:lower:]')
+        CONFIDENCE=$(echo "${{ inputs.confidence_level }}" | tr '[:upper:]' '[:lower:]')
+
+        bandit \
+          -c ${{ inputs.config_file }} \
+          --severity-level ${SEVERITY} \
+          --confidence-level ${CONFIDENCE} \
+          -f ${{ inputs.output_format }} \
+          -o "${REPORT_FILE}" \
+          -r ${FILES} || echo "exit_code=$?" >> $GITHUB_OUTPUT
+
+        echo "report_path=${REPORT_FILE}" >> $GITHUB_OUTPUT
+
+        if [[ "${{ inputs.fail_on_findings }}" == "true" && -n "$exit_code" && "$exit_code" != "0" ]]; then
+          exit $exit_code
+        fi
diff --git a/.github/actions/security/clamav/action.yaml b/.github/actions/security/clamav/action.yaml
new file mode 100644
index 0000000000..8ed31fc7fa
--- /dev/null
+++ b/.github/actions/security/clamav/action.yaml
@@ -0,0 +1,167 @@
+# ClamAV Scanner Action
+#
+# This composite action executes antivirus scanning using ClamAV,
+# providing malware detection and security analysis.
+#
+# Key Features:
+# - Malware detection
+# - Real-time database updates
+# - Configurable scan scope
+# - Exclusion support
+# - Performance optimization
+#
+# Process Stages:
+# 1. Environment Setup:
+#    - ClamAV installation
+#    - Database updates
+#    - Cache configuration
+#
+# 2. Scan Execution:
+#    - Target selection
+#    - Exclusion application
+#    - Threat detection
+#
+# 3. Results Processing:
+#    - Report generation
+#    - Threat analysis
+#    - Finding summary
+#
+# Required Inputs:
+# - scan_scope: Files to scan
+# - exclude_dirs: Directories to skip
+# - max_file_size: Size limit for scanning
+#
+# Outputs:
+# - scan_result: Scan exit code
+# - report_path: Results location
+# - threats_found: Number of threats
+#
+# Example Usage:
+# steps:
+#   - uses: ./.github/actions/security/clamav
+#     with:
+#       scan_scope: "changed"
+#       exclude_dirs: ".git,node_modules"
+#
+# Note: Requires sufficient disk space for virus database
+
+name: "ClamAV Security Scan"
+description: "Runs ClamAV antivirus scanner with configurable options"
+
+inputs:
+  scan_scope:
+    description: "Scope of files to scan (all/changed)"
+    required: false
+    default: "changed"
+  paths:
+    description: "Paths to scan when using all scope"
+    required: false
+    default: "."
+  exclude_dirs:
+    description: "Directories to exclude from scan"
+    required: false
+    default: ".git,node_modules,venv"
+  max_file_size:
+    description: "Maximum file size to scan in MB"
+    required: false
+    default: "100"
+  output_format:
+    description: "Format for scan results (json/txt)"
+    required: false
+    default: "json"
+  fail_on_findings:
+    description: "Whether to fail the action if threats are found"
+    required: false
+    default: "true"
+
+outputs:
+  scan_result:
+    description: "Exit code of the ClamAV scan"
+    value: ${{ steps.run-clamav.outputs.exit_code }}
+  report_path:
+    description: "Path to the generated report file"
+    value: ${{ steps.run-clamav.outputs.report_path }}
+  threats_found:
+    description: "Number of threats found during scan"
+    value: ${{ steps.run-clamav.outputs.threats_found }}
+
+runs:
+  using: composite
+  steps:
+    - name: Get changed files
+      if: inputs.scan_scope == 'changed'
+      id: changed-files
+      uses: tj-actions/changed-files@v41
+
+    - name: Run ClamAV scan
+      id: run-clamav
+      uses: docker://clamav/clamav:stable
+      env:
+        GITHUB_OUTPUT: /tmp/gh_output
+      with:
+        entrypoint: sh
+        args: |
+          -c "
+          # Update virus definitions
+          freshclam --quiet
+
+          # Prepare exclude dirs
+          EXCLUDE_DIRS=`echo '${{ inputs.exclude_dirs }}' | tr ',' ' ' | sed 's/[^ ]* */--exclude-dir=&/g'`
+
+          # Convert MB to bytes
+          MAX_FILE_SIZE=`expr ${{ inputs.max_file_size }} \* 1024 \* 1024`
+
+          # Create output directory
+          mkdir -p security-results/clamav
+
+          # Run scan based on scope
+          if [ '${{ inputs.scan_scope }}' = 'changed' ] && [ -n '${{ steps.changed-files.outputs.all_changed_files }}' ]; then
+            echo 'Running ClamAV on changed files'
+            FILES='${{ steps.changed-files.outputs.all_changed_files }}'
+            SCAN_CMD='clamscan'
+          else
+            echo 'Running ClamAV on all files in ${{ inputs.paths }}'
+            FILES='${{ inputs.paths }}'
+            SCAN_CMD='clamscan -r'
+          fi
+
+          # Run scan and capture output
+          $SCAN_CMD \
+            --max-filesize=$MAX_FILE_SIZE \
+            $EXCLUDE_DIRS \
+            $FILES \
+            > scan_output.txt 2>&1
+
+          SCAN_EXIT_CODE=$?
+
+          # Count infected files
+          INFECTED_FILES=`grep 'Infected files:' scan_output.txt | awk '{print $3}'`
+          if [ -z \"$INFECTED_FILES\" ]; then
+            INFECTED_FILES=0
+          fi
+
+          # Generate report
+          if [ '${{ inputs.output_format }}' = 'json' ]; then
+            echo '{
+              \"scan_summary\": {
+                \"files_scanned\": '`grep 'Scanned files:' scan_output.txt | awk '{print $3}'`',
+                \"threats_found\": '$INFECTED_FILES',
+                \"start_time\": \"'`grep 'Start time:' scan_output.txt | cut -d: -f2- | xargs`'\",
+                \"end_time\": \"'`grep 'End time:' scan_output.txt | cut -d: -f2- | xargs`'\"
+              }
+            }' > security-results/clamav/report.json
+          else
+            cp scan_output.txt security-results/clamav/report.txt
+          fi
+
+          # Write to outputs file
+          {
+            echo \"exit_code=$SCAN_EXIT_CODE\"
+            echo \"threats_found=$INFECTED_FILES\"
+            echo \"report_path=security-results/clamav/report.${{ inputs.output_format }}\"
+          } > \"$GITHUB_OUTPUT\"
+
+          if [ '${{ inputs.fail_on_findings }}' = 'true' ] && [ $INFECTED_FILES -gt 0 ]; then
+            exit 1
+          fi
+          "
diff --git a/.github/actions/security/semgrep/action.yaml b/.github/actions/security/semgrep/action.yaml
new file mode 100644
index 0000000000..e33c6f7851
--- /dev/null
+++ b/.github/actions/security/semgrep/action.yaml
@@ -0,0 +1,136 @@
+# Semgrep Scanner Action
+#
+# This composite action executes static analysis security testing using Semgrep,
+# providing comprehensive code analysis capabilities.
+#
+# Key Features:
+# - Multi-language support
+# - Custom rule sets
+# - Incremental scanning
+# - SARIF reporting
+# - Performance optimization
+#
+# Process Stages:
+# 1. Environment Setup:
+#    - Python installation
+#    - Semgrep configuration
+#    - Rule preparation
+#
+# 2. Scan Execution:
+#    - Target selection
+#    - Rule application
+#    - Code analysis
+#
+# 3. Results Processing:
+#    - Report generation
+#    - Finding analysis
+#    - Output formatting
+#
+# Required Inputs:
+# - scan_scope: Files to scan
+# - config: Rule configuration
+# - severity: Issue threshold
+#
+# Outputs:
+# - scan_result: Scan exit code
+# - report_path: Results location
+#
+# Example Usage:
+# steps:
+#   - uses: ./.github/actions/security/semgrep
+#     with:
+#       scan_scope: "changed"
+#       config: "p/owasp-top-ten"
+#
+# Note: Consider using custom rule sets for project-specific checks
+
+name: "Semgrep SAST Scan"
+description: "Runs Semgrep security scanner with configurable options"
+
+inputs:
+  scan_scope:
+    description: "Scope of files to scan (all/changed)"
+    required: false
+    default: "changed"
+  paths:
+    description: "Paths to scan when using all scope"
+    required: false
+    default: "."
+  config:
+    description: "Semgrep rules or config to use"
+    required: false
+    default: "p/default"
+  severity:
+    description: "Minimum severity level to report (ERROR/WARNING/INFO)"
+    required: false
+    default: "WARNING"
+  timeout:
+    description: "Maximum time to run semgrep in seconds"
+    required: false
+    default: "300"
+  output_format:
+    description: "Format for scan results (text/json/sarif)"
+    required: false
+    default: "sarif"
+  fail_on_findings:
+    description: "Whether to fail the action if issues are found"
+    required: false
+    default: "true"
+
+outputs:
+  scan_result:
+    description: "Exit code of the Semgrep scan"
+    value: ${{ steps.run-semgrep.outputs.exit_code }}
+  report_path:
+    description: "Path to the generated report file"
+    value: ${{ steps.run-semgrep.outputs.report_path }}
+
+runs:
+  using: composite
+  steps:
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+
+    - name: Install Semgrep
+      shell: bash
+      run: |
+        python -m pip install --upgrade pip
+        pip install semgrep
+
+    - name: Get changed files
+      if: inputs.scan_scope == 'changed'
+      id: changed-files
+      uses: tj-actions/changed-files@v41
+      with:
+        files: |
+          **/*.*
+
+    - name: Run Semgrep scan
+      id: run-semgrep
+      shell: bash
+      run: |
+        REPORT_FILE="semgrep-results.${{ inputs.output_format }}"
+
+        if [[ "${{ inputs.scan_scope }}" == "changed" && -n "${{ steps.changed-files.outputs.all_changed_files }}" ]]; then
+          echo "Running Semgrep on changed files"
+          FILES="${{ steps.changed-files.outputs.all_changed_files }}"
+        else
+          echo "Running Semgrep on all files in ${{ inputs.paths }}"
+          FILES="${{ inputs.paths }}"
+        fi
+
+        semgrep \
+          --config ${{ inputs.config }} \
+          --severity ${{ inputs.severity }} \
+          --timeout ${{ inputs.timeout }} \
+          --${{ inputs.output_format }} \
+          -o "${REPORT_FILE}" \
+          ${FILES} || echo "exit_code=$?" >> $GITHUB_OUTPUT
+
+        echo "report_path=${REPORT_FILE}" >> $GITHUB_OUTPUT
+
+        if [[ "${{ inputs.fail_on_findings }}" == "true" && -n "$exit_code" && "$exit_code" != "0" ]]; then
+          exit $exit_code
+        fi
diff --git a/.github/actions/security/trivy/action.yaml b/.github/actions/security/trivy/action.yaml
new file mode 100644
index 0000000000..44f3ca4e95
--- /dev/null
+++ b/.github/actions/security/trivy/action.yaml
@@ -0,0 +1,183 @@
+# Trivy Scanner Action
+#
+# This composite action executes comprehensive security scanning using Trivy,
+# supporting multiple targets and vulnerability detection methods.
+#
+# Key Features:
+# - Multi-target scanning
+# - Vulnerability detection
+# - Secret scanning
+# - SBOM generation
+# - IaC analysis
+#
+# Process Stages:
+# 1. Environment Setup:
+#    - Trivy installation
+#    - Database updates
+#    - Cache configuration
+#
+# 2. Scan Execution:
+#    - Target analysis
+#    - Vulnerability detection
+#    - Configuration checks
+#
+# 3. Results Processing:
+#    - Report generation
+#    - SBOM creation
+#    - Finding analysis
+#
+# Required Inputs:
+# - scan_type: Type of scan
+# - scan_target: Target to analyze
+# - severity: Issue threshold
+#
+# Outputs:
+# - scan_result: Scan exit code
+# - report_path: Results location
+#
+# Example Usage:
+# steps:
+#   - uses: ./.github/actions/security/trivy
+#     with:
+#       scan_type: "fs"
+#       scan_target: "./src"
+#       severity: "HIGH,CRITICAL"
+#
+# Note: Requires appropriate permissions for scanning
+
+name: "Trivy Security Scanner"
+description: "Comprehensive security scanner for vulnerabilities, IaC issues, and secrets"
+
+inputs:
+  scan_type:
+    description: "Type of scan to perform (fs/config/image/repo/rootfs)"
+    required: false
+    default: "fs"
+  scan_scope:
+    description: "Scope of files to scan (all/changed)"
+    required: false
+    default: "changed"
+  scan_target:
+    description: "Target to scan (path, image name, or repo URL)"
+    required: false
+    default: "."
+  severity:
+    description: "Minimum severity level (UNKNOWN,LOW,MEDIUM,HIGH,CRITICAL)"
+    required: false
+    default: "MEDIUM,HIGH,CRITICAL"
+  ignore_unfixed:
+    description: "Ignore unpatched/unfixed vulnerabilities"
+    required: false
+    default: "true"
+  scanners:
+    description: "Scanners to enable (vuln,secret,config)"
+    required: false
+    default: "vuln"
+  misconfig_scanners:
+    description: "Misconfig scanners to enable (azure-arm,cloudformation,dockerfile,helm,kubernetes,terraform,terraformplan)"
+    required: false
+    default: "azure-arm,cloudformation,dockerfile,helm,kubernetes,terraform,terraformplan"
+  format:
+    description: "Output format (table,json,sarif,template)"
+    required: false
+    default: "sarif"
+  timeout:
+    description: "Timeout duration (e.g., 5m, 10m)"
+    required: false
+    default: "10m"
+  generate_sbom:
+    description: "Generate Software Bill of Materials (SBOM)"
+    required: false
+    default: "false"
+  sbom_format:
+    description: "SBOM output format (cyclonedx, spdx, spdx-json)"
+    required: false
+    default: "cyclonedx"
+
+outputs:
+  scan_result:
+    description: "Exit code of the Trivy scan"
+    value: ${{ steps.run-trivy.outputs.exit_code }}
+  report_path:
+    description: "Path to the generated report file"
+    value: ${{ steps.run-trivy.outputs.report_path }}
+
+runs:
+  using: composite
+  steps:
+    - name: Get changed files
+      if: inputs.scan_scope == 'changed'
+      id: changed-files
+      uses: tj-actions/changed-files@v41
+
+    - name: Cache Trivy vulnerability database
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/trivy
+        key: trivy-db-${{ runner.os }}-${{ hashFiles('**/trivy-db/**') }}
+        restore-keys: |
+          trivy-db-${{ runner.os }}-
+
+    - name: Install Trivy
+      shell: bash
+      run: |
+        curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh -s -- -b /usr/local/bin v0.48.0
+        # Download DB in advance with retry mechanism
+        for i in {1..3}; do
+          echo "Attempt $i to download vulnerability database..."
+          trivy --cache-dir ~/.cache/trivy image --download-db-only && break || sleep 10
+        done
+
+    - name: Run Trivy scan
+      id: run-trivy
+      shell: bash
+      run: |
+        # Create output directory
+        mkdir -p reports
+        REPORT_FILE="reports/trivy-${{ inputs.scan_type }}-${{ inputs.scanners }}.sarif"
+
+        echo "Running Trivy with scan type: ${{ inputs.scan_type }}"
+        echo "Output will be saved to: ${REPORT_FILE}"
+
+        # Always scan the entire directory but use different paths based on scope
+        if [[ "${{ inputs.scan_scope }}" == "changed" && -n "${{ steps.changed-files.outputs.all_changed_files }}" ]]; then
+          echo "Changed files detected, scanning repository"
+          SCAN_TARGET="."
+        else
+          echo "Scanning target: ${{ inputs.scan_target }}"
+          SCAN_TARGET="${{ inputs.scan_target }}"
+        fi
+
+        # Build the base command
+        CMD="trivy --cache-dir ~/.cache/trivy ${{ inputs.scan_type }} --severity ${{ inputs.severity }} --format ${{ inputs.format }} --output ${REPORT_FILE} --timeout ${{ inputs.timeout }}"
+
+        # Add scanner-specific flags based on scan type
+        if [[ "${{ inputs.scan_type }}" == "config" ]]; then
+          # For config scans, use all default misconfig scanners or specified ones
+          CMD="$CMD --misconfig-scanners ${{ inputs.misconfig_scanners }}"
+        elif [[ "${{ inputs.scan_type }}" == "fs" ]]; then
+          # For filesystem scans, use --scanners
+          CMD="$CMD --scanners ${{ inputs.scanners }} --ignore-unfixed=${{ inputs.ignore_unfixed }}"
+        fi
+
+        # Add the scan target and execute
+        CMD="$CMD ${SCAN_TARGET}"
+        echo "Executing command: $CMD"
+        eval $CMD || echo "::warning::Trivy scan completed with findings"
+
+        if [ -f "${REPORT_FILE}" ]; then
+          echo "report_path=${REPORT_FILE}" >> $GITHUB_OUTPUT
+          echo "Scan report generated at ${REPORT_FILE}"
+        else
+          echo "::error::Report file was not generated"
+          exit 1
+        fi
+
+        # Generate SBOM if requested
+        if [[ "${{ inputs.generate_sbom }}" == "true" ]]; then
+          echo "Generating SBOM in ${{ inputs.sbom_format }} format"
+          trivy fs \
+            --format ${{ inputs.sbom_format }} \
+            --output "sbom.${{ inputs.sbom_format }}" \
+            ${SCAN_TARGET}
+        fi
diff --git a/.github/workflows/_reusable-artifact-builder.yaml b/.github/workflows/_reusable-artifact-builder.yaml
new file mode 100644
index 0000000000..292a6dbe61
--- /dev/null
+++ b/.github/workflows/_reusable-artifact-builder.yaml
@@ -0,0 +1,115 @@
+# Artifact Builder Workflow
+#
+# This reusable workflow handles Python package building and artifact creation,
+# providing a standardized build process with verification and caching.
+#
+# Key Features:
+# - Python package building
+# - Package verification
+# - Build artifact caching
+# - Configurable Python versions
+# - Artifact retention management
+#
+# Process Stages:
+# 1. Environment Setup:
+#    - Python environment configuration
+#    - Dependency installation
+#    - Cache initialization
+#
+# 2. Build Process:
+#    - Package building
+#    - Distribution creation
+#    - Build verification
+#
+# 3. Artifact Management:
+#    - Artifact naming
+#    - Upload and caching
+#    - Retention configuration
+#
+# Required Inputs:
+# - python-version: Python version for building (default: "3.10")
+# - verify-package: Enable package verification (default: true)
+#
+# Outputs:
+# - artifact-name: Name of the uploaded artifact
+#
+# Example Usage:
+# 1. Basic Build:
+#    jobs:
+#      build:
+#        uses: ./.github/workflows/_reusable-artifact-builder.yaml
+#        with:
+#          python-version: "3.11"
+#
+# 2. Build with Verification:
+#    jobs:
+#      build:
+#        uses: ./.github/workflows/_reusable-artifact-builder.yaml
+#        with:
+#          python-version: "3.10"
+#          verify-package: true
+#
+# Note: Requires proper Python project structure and build configuration
+
+name: Reusable Artifact Builder
+
+on:
+  workflow_call:
+    inputs:
+      python-version:
+        description: "Python version for building"
+        type: string
+        default: "3.10"
+      verify-package:
+        description: "Run package verification"
+        type: boolean
+        default: true
+    outputs:
+      artifact-name:
+        description: "Name of the uploaded artifact"
+        value: ${{ jobs.build.outputs.artifact-name }}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    outputs:
+      artifact-name: ${{ steps.set-artifact-name.outputs.name }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ inputs.python-version }}
+      - name: Build package
+        run: |
+          python -m pip install --upgrade pip build
+          python -m build
+      - name: Verify package
+        if: inputs.verify-package
+        run: |
+          pip install twine
+          twine check dist/*
+      - name: Set artifact name
+        id: set-artifact-name
+        run: echo "name=dist-$(date +%s)" >> $GITHUB_OUTPUT
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ steps.set-artifact-name.outputs.name }}
+          path: dist/
+          retention-days: 5
+      - name: Cache pip dependencies
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cache/pip
+            .venv
+          key: ${{ runner.os }}-pip-${{ hashFiles('**/pyproject.toml') }}-${{ hashFiles('**/poetry.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-pip-
+      - name: Cache build artifacts
+        uses: actions/cache@v3
+        with:
+          path: |
+            dist/
+            *.egg-info/
+            build/
+          key: ${{ runner.os }}-build-${{ hashFiles('**/pyproject.toml') }}
diff --git a/.github/workflows/_reusable-code-quality.yaml b/.github/workflows/_reusable-code-quality.yaml
new file mode 100644
index 0000000000..077285a972
--- /dev/null
+++ b/.github/workflows/_reusable-code-quality.yaml
@@ -0,0 +1,67 @@
+# Code Quality Workflow
+#
+# This reusable workflow executes code quality checks using pre-commit hooks
+# and other quality assurance tools across multiple languages.
+#
+# Key Features:
+# - Pre-commit hook execution
+# - Multi-language support
+# - Dependency caching
+# - Configurable environments
+# - Parallel check execution
+#
+# Process Stages:
+# 1. Environment Preparation:
+#    - Python setup
+#    - Cache configuration
+#
+# 2. Quality Checks:
+#    - Code linting
+#    - Style verification
+#    - Type checking
+#    - Best practices validation
+#
+# 3. Results Processing:
+#    - Error reporting
+#    - Check summaries
+#    - Status updates
+#
+# Required Inputs:
+# - python-version: Python version for checks (default: "3.10")
+#
+# Example Usage:
+# 1. Default Configuration:
+#    jobs:
+#      quality:
+#        uses: ./.github/workflows/_reusable-code-quality.yaml
+#
+# 2. Custom Versions:
+#    jobs:
+#      quality:
+#        uses: ./.github/workflows/_reusable-code-quality.yaml
+#        with:
+#          python-version: "3.11"
+#
+# Note: Requires configured pre-commit hooks in repository
+
+name: Reusable Code Quality
+
+on:
+  workflow_call:
+    inputs:
+      python-version:
+        description: "Python version for checks"
+        type: string
+        default: "3.10"
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/code-quality/pre-commit
+        with:
+          python-version: ${{ inputs.python-version }}
diff --git a/.github/workflows/_reusable-production-release-process.yaml b/.github/workflows/_reusable-production-release-process.yaml
new file mode 100644
index 0000000000..19d36f46cc
--- /dev/null
+++ b/.github/workflows/_reusable-production-release-process.yaml
@@ -0,0 +1,109 @@
+# Production Release Process Workflow
+#
+# This reusable workflow manages the production release process, including
+# validation, preparation, and publication steps.
+#
+# Key Features:
+# - Release readiness validation
+# - RC approval verification
+# - Production deployment
+# - Artifact management
+# - Release publication
+#
+# Process Stages:
+# 1. Release Validation:
+#    - RC approval verification
+#    - Version compatibility check
+#    - Release readiness assessment
+#
+# 2. Release Preparation:
+#    - Artifact collection
+#    - Production bundle creation
+#    - Documentation updates
+#
+# 3. Publication:
+#    - Production PyPI deployment
+#    - GitHub release creation
+#    - Documentation publishing
+#
+# Required Inputs:
+# - version: Release version
+# - artifact-name: Name of validated artifact
+#
+# Required Secrets:
+# - pypi-token: Production PyPI token
+#
+# Example Usage:
+# 1. Production Release:
+#    jobs:
+#      release:
+#        uses: ./.github/workflows/_reusable-production-release-process.yaml
+#        with:
+#          version: "v1.2.3"
+#          artifact-name: "dist-123456789"
+#        secrets:
+#          pypi-token: ${{ secrets.PYPI_TOKEN }}
+#
+# Note: Should only be triggered after successful RC process completion
+
+name: Production Release Process
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      artifact-name:
+        required: true
+        type: string
+    secrets:
+      pypi-token:
+        required: true
+
+jobs:
+  validate-release-readiness:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check for approved RC
+        run: |
+          VERSION="${{ inputs.version }}"
+          ARTIFACTS_JSON=$(curl -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
+            "$GITHUB_API_URL/repos/$GITHUB_REPOSITORY/actions/artifacts")
+
+          RC_APPROVAL=$(echo "$ARTIFACTS_JSON" | jq -r --arg ver "${VERSION%-*}" \
+            '.artifacts[] | select(.name | startswith("rc-approval-v" + $ver))')
+
+          if [ -z "$RC_APPROVAL" ]; then
+            echo "::error::No approved RC found for version $VERSION"
+            exit 1
+          fi
+
+  prepare-release:
+    needs: [validate-release-readiness]
+    environment:
+      name: production
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ inputs.artifact-name }}
+          path: dist
+
+      - name: Upload for production release
+        uses: actions/upload-artifact@v4
+        with:
+          name: production-release-artifacts
+          path: dist/
+          retention-days: 1
+
+  publish:
+    needs: [prepare-release]
+    uses: ./.github/workflows/_reusable-release-publisher.yaml
+    with:
+      version: ${{ inputs.version }}
+      artifact-name: production-release-artifacts
+      is-prerelease: false
+    secrets:
+      pypi-token: ${{ secrets.pypi-token }}
diff --git a/.github/workflows/_reusable-rc-release-process.yaml b/.github/workflows/_reusable-rc-release-process.yaml
new file mode 100644
index 0000000000..93e51a25cb
--- /dev/null
+++ b/.github/workflows/_reusable-rc-release-process.yaml
@@ -0,0 +1,241 @@
+# Release Candidate Process Workflow
+#
+# This reusable workflow implements a comprehensive release candidate (RC) process
+# with multiple validation stages and approvals.
+#
+# Key Features:
+# - Multi-stage validation
+# - Technical review process
+# - QA validation steps
+# - Product review integration
+# - Approval tracking
+#
+# Process Stages:
+# 1. Technical Review:
+#    - Test PyPI deployment
+#    - Build validation
+#    - Security verification
+#
+# 2. QA Validation:
+#    - Test results review
+#    - Deployment verification
+#    - Documentation check
+#
+# 3. Product Review:
+#    - Feature verification
+#    - Release notes review
+#    - Version compatibility
+#
+# 4. Final Approval:
+#    - Sign-off collection
+#    - Approval recording
+#    - Release readiness
+#
+# Required Inputs:
+# - version: Version to release
+# - artifact-name: Name of build artifact
+#
+# Required Secrets:
+# - test-pypi-token: PyPI token for test deployments
+#
+# Example Usage:
+# 1. Standard RC Process:
+#    jobs:
+#      rc-release:
+#        uses: ./.github/workflows/_reusable-rc-release-process.yaml
+#        with:
+#          version: "v1.2.3-rc1"
+#          artifact-name: "dist-123456789"
+#        secrets:
+#          test-pypi-token: ${{ secrets.TEST_PYPI_TOKEN }}
+#
+# Note: Requires configured environments with appropriate approvals
+
+name: RC Release Process
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      artifact-name:
+        required: true
+        type: string
+    secrets:
+      test-pypi-token:
+        required: true
+
+jobs:
+  technical-review:
+    environment:
+      name: technical-review
+      url: ${{ steps.review-url.outputs.url }}
+    runs-on: ubuntu-latest
+    outputs:
+      deployment-status: ${{ steps.validate-deployment.outputs.status }}
+    steps:
+      - name: Generate review URL
+        id: review-url
+        run: |
+          echo "url=$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID" >> $GITHUB_OUTPUT
+
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ inputs.artifact-name }}
+          path: dist
+
+      - name: Download test results
+        uses: actions/download-artifact@v4
+        with:
+          pattern: "*-test-results"
+          merge-multiple: true
+          path: test-results
+
+      - name: Download security results
+        uses: actions/download-artifact@v4
+        with:
+          pattern: "*-security-results"
+          merge-multiple: true
+          path: security-results
+
+      - name: Download quality results
+        uses: actions/download-artifact@v4
+        with:
+          pattern: "*-quality-results"
+          merge-multiple: true
+          path: quality-results
+
+      - name: Deploy to Test PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.test-pypi-token }}
+          TWINE_REPOSITORY_URL: https://test.pypi.org/legacy/
+        run: |
+          pip install --upgrade pip twine
+          twine upload dist/*
+
+      - name: Validate deployment
+        id: validate-deployment
+        run: |
+          WHEEL_FILE=$(ls dist/*.whl | head -n 1)
+          PACKAGE_NAME=$(basename $WHEEL_FILE | cut -d'-' -f1)
+
+          sleep 30
+
+          python -m venv test-env
+          source test-env/bin/activate
+
+          pip install --index-url https://test.pypi.org/simple/ \
+                     --extra-index-url https://pypi.org/simple \
+                     "${PACKAGE_NAME}==${VERSION#v}"
+
+          if python -c "import ${PACKAGE_NAME}"; then
+            echo "status=success" >> $GITHUB_OUTPUT
+          else
+            echo "status=failure" >> $GITHUB_OUTPUT
+            exit 1
+          fi
+        env:
+          VERSION: ${{ inputs.version }}
+
+      - name: Generate technical review report
+        run: |
+          cat << EOF > technical-review-report.md
+          # Technical Review Report
+
+          ## Version Information
+          - Version: ${{ inputs.version }}
+          - Package Name: $(ls dist/*.whl | head -n 1 | xargs basename)
+
+          ## Test Results
+          \`\`\`
+          $(cat test-results/*/report.xml || echo "No test results found")
+          \`\`\`
+
+          ## Security Scan Results
+          \`\`\`
+          $(cat security-results/*/report.json || echo "No security results found")
+          \`\`\`
+
+          ## Code Quality Results
+          \`\`\`
+          $(cat quality-results/*/report.txt || echo "No quality results found")
+          \`\`\`
+
+          ## Test PyPI Deployment
+          - Status: ${{ steps.validate-deployment.outputs.status }}
+          - URL: https://test.pypi.org/project/${PACKAGE_NAME}/${VERSION#v}/
+
+          EOF
+
+      - name: Upload technical review report
+        uses: actions/upload-artifact@v4
+        with:
+          name: technical-review-report
+          path: technical-review-report.md
+
+  qa-validation:
+    needs: [technical-review]
+    environment:
+      name: qa-validation
+      url: ${{ steps.qa-url.outputs.url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Generate QA URL
+        id: qa-url
+        run: |
+          echo "url=$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID" >> $GITHUB_OUTPUT
+
+      - name: Download technical review report
+        uses: actions/download-artifact@v4
+        with:
+          name: technical-review-report
+          path: qa-review
+
+      - name: Generate QA dashboard
+        run: |
+          echo "QA Review Dashboard"
+          echo "==================="
+          echo
+          echo "Technical Review Status: ${{ needs.technical-review.outputs.deployment-status }}"
+          echo
+          echo "Review the full technical report at: qa-review/technical-review-report.md"
+          echo
+          echo "Please validate the following:"
+          echo "1. All tests have passed"
+          echo "2. No security issues found"
+          echo "3. Code quality meets standards"
+          echo "4. Package is installable from Test PyPI"
+          echo "5. Documentation is up to date"
+
+  product-review:
+    needs: [qa-validation]
+    environment:
+      name: product-review
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download technical review report
+        uses: actions/download-artifact@v4
+        with:
+          name: technical-review-report
+
+      - name: Display release information
+        run: |
+          echo "Release Information for ${{ inputs.version }}"
+          echo "----------------------------------------"
+          cat technical-review-report.md
+
+  release-approval:
+    needs: [product-review]
+    environment:
+      name: release-approval
+    runs-on: ubuntu-latest
+    steps:
+      - name: Record approval
+        run: |
+          echo "RC Approval Record:"
+          echo "- Version: ${{ inputs.version }}"
+          echo "- Timestamp: $(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+          echo "- Approver: ${{ github.actor }}"
diff --git a/.github/workflows/_reusable-release-publisher.yaml b/.github/workflows/_reusable-release-publisher.yaml
new file mode 100644
index 0000000000..b8765e8ca1
--- /dev/null
+++ b/.github/workflows/_reusable-release-publisher.yaml
@@ -0,0 +1,101 @@
+# Release Publisher Workflow
+#
+# This reusable workflow handles package publication to PyPI and GitHub,
+# supporting both production and pre-release deployments.
+#
+# Key Features:
+# - PyPI package publishing
+# - GitHub release creation
+# - Pre-release support
+# - Release notes generation
+# - Artifact management
+#
+# Process Stages:
+# 1. Artifact Processing:
+#    - Download validation
+#    - Package verification
+#    - Distribution preparation
+#
+# 2. PyPI Publication:
+#    - Environment selection
+#    - Package upload
+#    - Publication verification
+#
+# 3. GitHub Release:
+#    - Release creation
+#    - Asset attachment
+#    - Notes generation
+#
+# Required Inputs:
+# - version: Version to release
+# - artifact-name: Name of artifact to publish
+# - is-prerelease: Whether this is a pre-release
+#
+# Required Secrets:
+# - pypi-token: Production PyPI token
+# - test-pypi-token: Test PyPI token (for pre-releases)
+#
+# Example Usage:
+# 1. Production Release:
+#    jobs:
+#      publish:
+#        uses: ./.github/workflows/_reusable-release-publisher.yaml
+#        with:
+#          version: "v1.0.0"
+#          artifact-name: "dist-123456789"
+#          is-prerelease: false
+#        secrets:
+#          pypi-token: ${{ secrets.PYPI_TOKEN }}
+#
+# Note: Requires appropriate tokens and permissions for publishing
+
+name: Reusable Release Publisher
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        description: "Version to release"
+        required: true
+        type: string
+      artifact-name:
+        description: "Name of the artifact to publish"
+        required: true
+        type: string
+      is-prerelease:
+        description: "Whether this is a pre-release"
+        type: boolean
+        default: false
+    secrets:
+      pypi-token:
+        required: true
+        description: "PyPI token for package publishing"
+      test-pypi-token:
+        required: false
+        description: "Test PyPI token for pre-releases"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: ${{ inputs.is-prerelease && 'staging' || 'production' }}
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: ${{ inputs.artifact-name }}
+          path: dist
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ inputs.is-prerelease && secrets.test-pypi-token || secrets.pypi-token }}
+          TWINE_REPOSITORY_URL: ${{ inputs.is-prerelease && 'https://test.pypi.org/legacy/' || '' }}
+        run: |
+          pip install --upgrade pip twine
+          twine upload dist/*
+      - uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ inputs.version }}
+          name: Release ${{ inputs.version }}
+          draft: false
+          prerelease: ${{ inputs.is-prerelease }}
+          files: dist/*
+          generate_release_notes: true
diff --git a/.github/workflows/_reusable-release-status.yaml b/.github/workflows/_reusable-release-status.yaml
new file mode 100644
index 0000000000..b855f284ea
--- /dev/null
+++ b/.github/workflows/_reusable-release-status.yaml
@@ -0,0 +1,76 @@
+# Release Status Workflow
+#
+# This reusable workflow validates and reports the status of release processes,
+# handling both RC and production releases.
+#
+# Key Features:
+# - Status verification
+# - Error detection
+# - Release type handling
+# - Status reporting
+# - Process validation
+#
+# Process Stages:
+# 1. Status Collection:
+#    - RC status check
+#    - Production status check
+#    - Process completion verification
+#
+# 2. Validation:
+#    - Error detection
+#    - Status analysis
+#    - Release type determination
+#
+# 3. Reporting:
+#    - Status summary
+#    - Error reporting
+#    - Success confirmation
+#
+# Required Inputs:
+# - version: Release version
+# - rc-status: RC process status
+# - prod-status: Production process status
+#
+# Example Usage:
+# 1. Status Check:
+#    jobs:
+#      status:
+#        uses: ./.github/workflows/_reusable-release-status.yaml
+#        with:
+#          version: "v1.2.3"
+#          rc-status: "success"
+#          prod-status: "success"
+#
+# Note: Should be used as final step in release workflows
+
+name: Release Status Check
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      rc-status:
+        required: true
+        type: string
+      prod-status:
+        required: true
+        type: string
+
+jobs:
+  check-status:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Verify workflow status
+        run: |
+          if [[ "${{ inputs.rc-status }}" == "failure" || "${{ inputs.prod-status }}" == "failure" ]]; then
+            echo "::error::Release workflow failed"
+            exit 1
+          fi
+
+          if [[ "${{ inputs.version }}" =~ -rc ]]; then
+            echo "Release candidate ${{ inputs.version }} processed successfully"
+          else
+            echo "Production release ${{ inputs.version }} completed successfully"
+          fi
diff --git a/.github/workflows/_reusable-release-validation.yaml b/.github/workflows/_reusable-release-validation.yaml
new file mode 100644
index 0000000000..5119531c1c
--- /dev/null
+++ b/.github/workflows/_reusable-release-validation.yaml
@@ -0,0 +1,178 @@
+# Release Validation Workflow
+#
+# This reusable workflow performs comprehensive validation of releases,
+# including quality checks, testing, security scanning, and artifact building.
+#
+# Key Features:
+# - Version format validation
+# - Code quality verification
+# - Test suite execution
+# - Security scanning
+# - Package building
+# - Pre-release validation
+#
+# Process Stages:
+# 1. Version Validation:
+#    - Checks version string format
+#    - Validates pre-release compatibility
+#    - Ensures version consistency
+#
+# 2. Quality Assurance:
+#    - Runs code quality checks
+#    - Performs style verification
+#    - Validates documentation
+#
+# 3. Testing:
+#    - Executes unit tests
+#    - Runs integration tests
+#    - Generates coverage reports
+#
+# 4. Security:
+#    - Performs security scans
+#    - Checks dependencies
+#    - Validates compliance
+#
+# 5. Build Process:
+#    - Creates distribution packages
+#    - Verifies package integrity
+#    - Prepares artifacts
+#
+# Required Inputs:
+# - version: Version string to validate
+# - python-version: Python version for building
+# - verify-package: Whether to verify built package
+# - dry-run: Run without creating artifacts
+# - allow-prerelease: Allow RC versions
+#
+# Required Secrets:
+# - codecov-token: Token for coverage reporting
+#
+# Outputs:
+# - version: Validated version string
+# - artifact-name: Name of built artifact
+#
+# Example Usage:
+# 1. Basic Validation:
+#    jobs:
+#      validate:
+#        uses: ./.github/workflows/_reusable-release-validation.yaml
+#        with:
+#          version: "v1.2.3"
+#          python-version: "3.10"
+#        secrets:
+#          codecov-token: ${{ secrets.CODECOV_TOKEN }}
+#
+# 2. Pre-release Validation:
+#    jobs:
+#      rc-validate:
+#        uses: ./.github/workflows/_reusable-release-validation.yaml
+#        with:
+#          version: "v1.2.3-rc1"
+#          python-version: "3.10"
+#          allow-prerelease: true
+#        secrets:
+#          codecov-token: ${{ secrets.CODECOV_TOKEN }}
+#
+# Note: This workflow is a critical part of the release pipeline and should
+# be completed successfully before proceeding with RC or production releases.
+
+name: Release Validation
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      python-version:
+        required: true
+        type: string
+      verify-package:
+        required: false
+        type: boolean
+        default: true
+      dry-run:
+        required: false
+        type: boolean
+        default: false
+      allow-prerelease:
+        required: false
+        type: boolean
+        default: false
+    secrets:
+      codecov-token:
+        required: true
+    outputs:
+      version:
+        description: "Validated version string"
+        value: ${{ jobs.version-check.outputs.version }}
+      artifact-name:
+        description: "Name of the built artifact"
+        value: ${{ jobs.build.outputs.artifact-name }}
+
+jobs:
+  version-check:
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.validate-version.outputs.version }}
+    steps:
+      - name: Validate version
+        id: validate-version
+        run: |
+          VERSION="${{ inputs.version }}"
+          if [[ ! $VERSION =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-rc[0-9]+)?$ ]]; then
+            echo "::error::Invalid version format: $VERSION"
+            exit 1
+          fi
+          if [[ $VERSION =~ -rc[0-9]+$ ]] && [[ "${{ inputs.allow-prerelease }}" != "true" ]]; then
+            echo "::error::Pre-release versions not allowed"
+            exit 1
+          fi
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+  quality:
+    needs: [version-check]
+    uses: ./.github/workflows/_reusable-code-quality.yaml
+    with:
+      python-version: ${{ inputs.python-version }}
+
+  unit-tests:
+    needs: [version-check]
+    uses: ./.github/workflows/_reusable-test-suite.yaml
+    with:
+      python-version: ${{ inputs.python-version }}
+      test-type: "unit"
+      runner: "ubuntu-latest"
+      timeout: 10
+    secrets:
+      codecov-token: ${{ secrets.codecov-token }}
+
+  integration-tests:
+    needs: [version-check]
+    uses: ./.github/workflows/_reusable-test-suite.yaml
+    with:
+      python-version: ${{ inputs.python-version }}
+      test-type: "integration"
+      runner: "self-hosted"
+      timeout: 30
+    secrets:
+      codecov-token: ${{ secrets.codecov-token }}
+
+  security:
+    needs: [version-check]
+    uses: ./.github/workflows/_reusable-security-scan.yaml
+    with:
+      tools: "bandit,semgrep,trivy,clamav"
+      scan-scope: "all"
+      severity-level: "LOW"
+      fail-on-findings: true
+
+  build:
+    needs: [version-check, quality, unit-tests, integration-tests, security]
+    if: |
+      !inputs.dry_run &&
+      !failure() && !cancelled()
+    uses: ./.github/workflows/_reusable-artifact-builder.yaml
+    with:
+      python-version: ${{ inputs.python-version }}
+      verify-package: ${{ inputs.verify-package }}
diff --git a/.github/workflows/_reusable-security-scan.yaml b/.github/workflows/_reusable-security-scan.yaml
new file mode 100644
index 0000000000..332804282c
--- /dev/null
+++ b/.github/workflows/_reusable-security-scan.yaml
@@ -0,0 +1,181 @@
+# Reusable Security Scan Workflow
+#
+# This reusable workflow orchestrates multiple security scanning tools to provide
+# comprehensive security analysis of the codebase.
+#
+# Key Features:
+# - Parallel security tool execution
+# - Configurable tool selection
+# - Comprehensive result aggregation
+# - Artifact preservation
+# - Customizable failure thresholds
+#
+# Process Stages:
+# 1. Tool Selection and Configuration
+# 2. Parallel Security Scans
+# 3. Result Aggregation
+# 4. Report Generation
+#
+# Required Inputs:
+# - tools: Comma-separated list of tools to run
+# - scan-scope: Scope of scanning
+# - severity-level: Minimum severity threshold
+# - fail-on-findings: Whether to fail on security findings
+#
+# Outputs:
+# - has-findings: Boolean indicating if security issues were found
+#
+# Example Usage:
+#   jobs:
+#     security:
+#       uses: ./.github/workflows/_reusable-security-scan.yaml
+#       with:
+#         tools: "bandit,semgrep"
+#         scan-scope: "changed"
+#         severity-level: "MEDIUM"
+#         fail-on-findings: true
+#
+# Note: Different security tools may require specific permissions
+# or configurations.
+
+name: Reusable Security Scan
+
+on:
+  workflow_call:
+    inputs:
+      tools:
+        description: "Security tools to run (comma-separated: bandit,clamav,semgrep,trivy)"
+        type: string
+        default: "bandit,semgrep"
+      scan-scope:
+        description: "Scan scope (all/changed)"
+        type: string
+        default: "changed"
+      severity-level:
+        description: "Minimum severity level (LOW/MEDIUM/HIGH)"
+        type: string
+        default: "LOW"
+      fail-on-findings:
+        description: "Fail workflow if issues found"
+        type: boolean
+        default: true
+    outputs:
+      has-findings:
+        description: "Whether any security issues were found"
+        value: ${{ jobs.summarize.outputs.has_findings }}
+
+jobs:
+  bandit:
+    if: contains(inputs.tools, 'bandit')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run Bandit scan
+        uses: ./.github/actions/security/bandit
+        with:
+          scan-scope: ${{ inputs.scan-scope }}
+          severity-level: ${{ inputs.severity-level }}
+          fail-on-findings: ${{ inputs.fail-on-findings }}
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: bandit-results
+          path: security-results/bandit
+          retention-days: 7
+
+  semgrep:
+    if: contains(inputs.tools, 'semgrep')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run Semgrep scan
+        uses: ./.github/actions/security/semgrep
+        with:
+          scan-scope: ${{ inputs.scan-scope }}
+          severity-level: ${{ inputs.severity-level }}
+          fail-on-findings: ${{ inputs.fail-on-findings }}
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: semgrep-results
+          path: security-results/semgrep
+          retention-days: 7
+
+  trivy:
+    if: contains(inputs.tools, 'trivy')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Required for changed files detection
+
+      - name: Run Trivy scan
+        id: trivy
+        uses: ./.github/actions/security/trivy
+        with:
+          scan_type: "fs"
+          scan_scope: ${{ inputs.scan-scope }}
+          severity: ${{ inputs.severity-level }},HIGH,CRITICAL
+          scanners: "vuln,secret"
+          format: "sarif"
+          timeout: "15m"
+          ignore_unfixed: "true"
+
+      - name: Move Trivy results
+        if: always() && steps.trivy.outputs.report_path
+        run: |
+          mkdir -p security-results/trivy
+          mv ${{ steps.trivy.outputs.report_path }} security-results/trivy/
+
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: trivy-results
+          path: security-results/trivy
+          retention-days: 7
+
+  clamav:
+    if: contains(inputs.tools, 'clamav')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run ClamAV scan
+        uses: ./.github/actions/security/clamav
+        with:
+          scan-scope: ${{ inputs.scan-scope }}
+          fail-on-findings: ${{ inputs.fail-on-findings }}
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: clamav-results
+          path: security-results/clamav
+          retention-days: 7
+
+  summarize:
+    needs: [bandit, semgrep, trivy, clamav]
+    if: always()
+    runs-on: ubuntu-latest
+    outputs:
+      has_findings: ${{ steps.check-findings.outputs.has_findings }}
+    steps:
+      - id: check-findings
+        run: |
+          if [[ "${{ contains(needs.*.result, 'failure') }}" == "true" ]]; then
+            echo "has_findings=true" >> $GITHUB_OUTPUT
+          else
+            echo "has_findings=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Download all results
+        uses: actions/download-artifact@v4
+        with:
+          pattern: "*-results"
+          merge-multiple: true
+          path: all-results
+
+      - name: Upload combined results
+        uses: actions/upload-artifact@v4
+        with:
+          name: security-scan-results
+          path: all-results
+          retention-days: 7
diff --git a/.github/workflows/_reusable-test-suite.yaml b/.github/workflows/_reusable-test-suite.yaml
new file mode 100644
index 0000000000..4277fd9b49
--- /dev/null
+++ b/.github/workflows/_reusable-test-suite.yaml
@@ -0,0 +1,109 @@
+# Test Suite Workflow
+#
+# This reusable workflow executes comprehensive test suites with configurable
+# parameters for different test types and environments.
+#
+# Key Features:
+# - Parallel test execution
+# - Multiple test types support
+# - Coverage reporting
+# - Configurable timeouts
+# - Result aggregation
+#
+# Process Stages:
+# 1. Unit Testing:
+#    - Environment setup
+#    - Test execution
+#    - Coverage generation
+#
+# 2. Integration Testing:
+#    - Environment preparation
+#    - Test execution
+#    - Result collection
+#
+# 3. Results Processing:
+#    - Coverage reporting
+#    - Result aggregation
+#    - Artifact creation
+#
+# Required Inputs:
+# - python-version: Python version for tests (default: "3.10")
+# - test-type: Type of test to run (unit/integration/e2e)
+# - runner: Runner to use for the tests
+# - timeout: Test timeout in minutes
+#
+# Required Secrets:
+# - codecov-token: Token for coverage reporting (optional)
+#
+# Outputs:
+# - test-results: Path to test results artifact
+#
+# Example Usage:
+# 1. Basic Test Run:
+#    jobs:
+#      test:
+#        uses: ./.github/workflows/_reusable-test-suite.yaml
+#        with:
+#          test-type: "unit"
+#
+# 2. Custom Configuration:
+#    jobs:
+#      test:
+#        uses: ./.github/workflows/_reusable-test-suite.yaml
+#        with:
+#          python-version: "3.11"
+#          test-type: "unit"
+#          timeout: 15
+#        secrets:
+#          codecov-token: ${{ secrets.CODECOV_TOKEN }}
+#
+# Note: Requires properly configured pytest environment and test structure
+
+name: Reusable Test Suite
+
+on:
+  workflow_call:
+    inputs:
+      python-version:
+        description: "Python version to use for tests"
+        type: string
+        default: "3.10"
+      test-type:
+        description: "Type of test to run (unit/integration/e2e)"
+        type: string
+        required: true
+      runner:
+        description: "Runner to use for the tests"
+        type: string
+        default: "ubuntu-latest"
+      timeout:
+        description: "Test timeout in minutes"
+        type: number
+        default: 10
+    secrets:
+      codecov-token:
+        required: false
+        description: "Token for Codecov upload"
+    outputs:
+      test-results:
+        description: "Path to test results artifact"
+        value: ${{ jobs.test.outputs.artifact-path }}
+
+jobs:
+  test:
+    runs-on: ${{ inputs.runner }}
+    timeout-minutes: ${{ inputs.timeout }}
+    steps:
+      - name: Verify GPU availability
+        if: contains(inputs.runner, 'self-hosted')
+        shell: bash
+        run: |
+          nvidia-smi || echo "::error::No GPU found"
+
+      - uses: actions/checkout@v4
+      - name: Run tests
+        uses: ./.github/actions/pytest
+        with:
+          python-version: ${{ inputs.python-version }}
+          test-type: ${{ inputs.test-type }}
+          codecov-token: ${{ secrets.codecov-token }}
diff --git a/.github/workflows/_reusable-version-check.yaml b/.github/workflows/_reusable-version-check.yaml
new file mode 100644
index 0000000000..6f565e87a2
--- /dev/null
+++ b/.github/workflows/_reusable-version-check.yaml
@@ -0,0 +1,104 @@
+# Version Check Workflow
+#
+# This reusable workflow validates version strings and determines their release type,
+# supporting both explicit version inputs and git tags.
+#
+# Key Features:
+# - Semantic version validation
+# - Pre-release version support
+# - Git tag compatibility
+# - Version format enforcement
+# - Configurable pre-release rules
+#
+# Process Stages:
+# 1. Version Extraction:
+#    - Input parsing
+#    - Git tag reading
+#    - Format validation
+#
+# 2. Version Analysis:
+#    - Semantic version parsing
+#    - Pre-release detection
+#    - Format compliance check
+#
+# 3. Validation Rules:
+#    - Version prefix check
+#    - Component validation
+#    - Pre-release acceptance
+#
+# Required Inputs:
+# - version: Version string to validate (optional)
+# - allow-prerelease: Allow pre-release versions (default: true)
+#
+# Outputs:
+# - version: Validated version string
+# - is_prerelease: Whether version is a pre-release
+#
+# Example Usage:
+# 1. Basic Version Check:
+#    jobs:
+#      validate:
+#        uses: ./.github/workflows/_reusable-version-check.yaml
+#        with:
+#          version: "v1.2.3"
+#
+# 2. Pre-release Check:
+#    jobs:
+#      validate:
+#        uses: ./.github/workflows/_reusable-version-check.yaml
+#        with:
+#          version: "v1.2.3-rc1"
+#          allow-prerelease: true
+#
+# Note: Version must follow format vX.Y.Z or vX.Y.Z-rcN
+
+name: Reusable Version Check
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        description: "Version to validate"
+        required: false
+        type: string
+      allow-prerelease:
+        description: "Allow pre-release versions"
+        type: boolean
+        default: true
+    outputs:
+      version:
+        description: "Validated version"
+        value: ${{ jobs.validate.outputs.version }}
+      is_prerelease:
+        description: "Whether version is a pre-release"
+        value: ${{ jobs.validate.outputs.is_prerelease }}
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.get-version.outputs.version }}
+      is_prerelease: ${{ steps.check-prerelease.outputs.is_prerelease }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Validate version
+        id: get-version
+        run: |
+          VERSION="${{ inputs.version || github.ref_name }}"
+          if ! [[ $VERSION =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-rc[0-9]+)?$ ]]; then
+            echo "::error::Invalid version format. Must be vX.Y.Z or vX.Y.Z-rcN"
+            exit 1
+          fi
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+      - name: Check pre-release
+        id: check-prerelease
+        run: |
+          if [[ "${{ steps.get-version.outputs.version }}" =~ -rc[0-9]+$ ]]; then
+            if [[ "${{ inputs.allow-prerelease }}" != "true" ]]; then
+              echo "::error::Pre-release versions are not allowed"
+              exit 1
+            fi
+            echo "is_prerelease=true" >> $GITHUB_OUTPUT
+          else
+            echo "is_prerelease=false" >> $GITHUB_OUTPUT
+          fi
diff --git a/.github/workflows/code_scan.yml b/.github/workflows/code_scan.yml
deleted file mode 100644
index 2ebcf03770..0000000000
--- a/.github/workflows/code_scan.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-name: Code Scanning
-permissions: read-all
-
-on:
-  workflow_dispatch: # run on request (no need for PR)
-  schedule:
-    # every UTC 6PM from Mon to Fri
-    - cron: "0 18 * * 1-5"
-
-jobs:
-  Bandit:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: CHECKOUT REPOSITORY
-        uses: actions/checkout@v4
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.10"
-      - name: Install dependencies
-        run: python -m pip install tox
-      - name: Bandit Scanning
-        run: tox -e bandit-scan
-      - name: UPLOAD BANDIT REPORT
-        uses: actions/upload-artifact@v4
-        with:
-          name: bandit-report
-          path: .tox/bandit-report.txt
-        # Use always() to always run this step to publish scan results when there are test failures
-        if: ${{ always() }}
-  Trivy-scan:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.10"
-      - name: Install dependencies
-        run: python -m pip install tox
-      - name: Trivy Scanning
-        env:
-          TRIVY_DOWNLOAD_URL: ${{ vars.TRIVY_DOWNLOAD_URL }}
-        run: tox -vv -e trivy-scan
-      - name: Upload Trivy results artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: trivy-results
-          path: |
-            .tox/trivy-scan-results.txt
-            .tox/trivy-spdx-anomalib.json
diff --git a/.github/workflows/pr.yaml b/.github/workflows/pr.yaml
new file mode 100644
index 0000000000..fa2cb8e0f8
--- /dev/null
+++ b/.github/workflows/pr.yaml
@@ -0,0 +1,84 @@
+# Pull Request Workflow
+#
+# This workflow orchestrates quality checks, tests, and security scans for
+# pull requests using reusable workflows.
+#
+# Key Features:
+# - Code quality validation
+# - Test suite execution
+# - Security scanning
+# - Concurrent execution handling
+# - Automated feedback
+#
+# Process Stages:
+# 1. Quality Checks:
+#    - Code style verification
+#    - Type checking
+#    - Pre-commit hook validation
+#
+# 2. Testing:
+#    - Unit test execution
+#    - Integration testing
+#    - Coverage reporting
+#
+# 3. Security:
+#    - Changed files scanning
+#    - Vulnerability detection
+#    - Security report generation
+#
+# Required Secrets:
+# - CODECOV_TOKEN: Coverage reporting token
+#
+# Example Usage:
+# Automatically triggered on:
+# 1. Pull requests to main branch
+# 2. Pull requests to feature/* branches
+#
+# Note: Configured to cancel outdated runs when new commits are pushed
+
+name: PR Checks
+
+on:
+  pull_request:
+    branches: [main, "feature/**"]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # Code quality job using reusable workflow
+  quality:
+    uses: ./.github/workflows/_reusable-code-quality.yaml
+    with:
+      python-version: "3.10"
+
+  # Test suite job using reusable workflow
+  unit-tests:
+    uses: ./.github/workflows/_reusable-test-suite.yaml
+    with:
+      test-type: "unit"
+      runner: "ubuntu-latest"
+      timeout: 10
+    secrets:
+      codecov-token: ${{ secrets.CODECOV_TOKEN }}
+
+  integration-tests:
+    uses: ./.github/workflows/_reusable-test-suite.yaml
+    with:
+      test-type: "integration"
+      runner: "self-hosted"
+      timeout: 30
+    secrets:
+      codecov-token: ${{ secrets.CODECOV_TOKEN }}
+
+  # NOTE: When we have e2e or other tests, we can add them here.
+
+  # Security scanning job using reusable workflow
+  security:
+    needs: [] # No dependencies, can run in parallel
+    uses: ./.github/workflows/_reusable-security-scan.yaml
+    with:
+      tools: "semgrep" # Security tools to run
+      scan-scope: "changed" # Only scan changed files
+      severity-level: "MEDIUM" # Minimum severity to report
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
deleted file mode 100644
index 777f9b0645..0000000000
--- a/.github/workflows/publish.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-name: Upload Python Package
-permissions: read-all
-
-on:
-  release:
-    types: [published]
-  workflow_dispatch: # run on request (no need for PR)
-
-jobs:
-  deploy:
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.10"
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install build twine
-      - name: Build the python package
-        run: |
-          python -m build
-      - name: Upload to PyPI
-        run: twine upload dist/*
-        env:
-          TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
new file mode 100644
index 0000000000..bcb203506f
--- /dev/null
+++ b/.github/workflows/release.yaml
@@ -0,0 +1,104 @@
+# Release Workflow
+#
+# This workflow manages the complete release process for both production
+# and release candidate versions.
+#
+# Key Features:
+# - Version validation
+# - Comprehensive testing
+# - Security scanning
+# - RC and production releases
+# - Manual and automated triggers
+#
+# Process Stages:
+# 1. Release Validation:
+#    - Version format check
+#    - Code quality verification
+#    - Test suite execution
+#    - Security assessment
+#
+# 2. RC Process:
+#    - Test PyPI deployment
+#    - Validation steps
+#    - Approval collection
+#
+# 3. Production Release:
+#    - Production PyPI deployment
+#    - GitHub release creation
+#    - Documentation updates
+#
+# Required Secrets:
+# - CODECOV_TOKEN: Coverage reporting
+# - TEST_PYPI_TOKEN: RC deployments
+# - PYPI_TOKEN: Production deployments
+#
+# Example Usage:
+# 1. Automated (Tag Push):
+#    - Production: Push tag v1.2.3
+#    - RC: Push tag v1.2.3-rc1
+#
+# 2. Manual Trigger:
+#    - With version input
+#    - Optional dry-run mode
+#
+# Note: Supports both automated tag-based and manual releases
+
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+      - "v*.*.*-rc*"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to release (e.g., v1.2.3 or v1.2.3-rc1)"
+        required: true
+        type: string
+      dry_run:
+        description: "Perform a dry run without creating a release"
+        required: false
+        type: boolean
+        default: false
+
+jobs:
+  validation:
+    uses: ./.github/workflows/_reusable-release-validation.yaml
+    with:
+      version: ${{ github.event_name == 'push' && github.ref_name || inputs.version }}
+      python-version: "3.10"
+      verify-package: true
+      dry-run: ${{ github.event.inputs.dry_run || false }}
+      allow-prerelease: true
+    secrets:
+      codecov-token: ${{ secrets.CODECOV_TOKEN }}
+
+  rc-release-process:
+    needs: [validation]
+    if: contains(needs.validation.outputs.version, '-rc')
+    uses: ./.github/workflows/_reusable-rc-release-process.yaml
+    with:
+      version: ${{ needs.validation.outputs.version }}
+      artifact-name: ${{ needs.validation.outputs.artifact-name }}
+    secrets:
+      test-pypi-token: ${{ secrets.TEST_PYPI_TOKEN }}
+
+  production-release-process:
+    needs: [validation]
+    if: ${{ !contains(needs.validation.outputs.version, '-rc') }}
+    uses: ./.github/workflows/_reusable-production-release-process.yaml
+    with:
+      version: ${{ needs.validation.outputs.version }}
+      artifact-name: ${{ needs.validation.outputs.artifact-name }}
+    secrets:
+      pypi-token: ${{ secrets.PYPI_TOKEN }}
+
+  status:
+    needs: [validation, rc-release-process, production-release-process]
+    if: always() && !inputs.dry_run
+    uses: ./.github/workflows/_reusable-release-status.yaml
+    with:
+      version: ${{ needs.validation.outputs.version }}
+      rc-status: ${{ needs.rc-release-process.result }}
+      prod-status: ${{ needs.production-release-process.result }}
diff --git a/.github/workflows/security-checks.yaml b/.github/workflows/security-checks.yaml
new file mode 100644
index 0000000000..0fd15148f7
--- /dev/null
+++ b/.github/workflows/security-checks.yaml
@@ -0,0 +1,96 @@
+# Security Checks Workflow
+#
+# This workflow orchestrates comprehensive security scanning using multiple tools and
+# configurable parameters. It supports both scheduled and manual execution modes.
+#
+# Key Features:
+# - Multiple security tool integration
+# - Scheduled daily scans
+# - Manual trigger with customization
+# - Configurable severity thresholds
+# - Flexible scan scope options
+#
+# Process Stages:
+# 1. Scheduled Execution (Daily at 2 AM UTC):
+#    - Full security toolset
+#    - Complete codebase scan
+#    - LOW severity threshold
+#
+# 2. Manual Execution:
+#    - Selectable security tools
+#    - Adjustable scan scope
+#    - Customizable severity level
+#
+# Security Tools:
+# - Bandit: Python-specific security scanning
+# - ClamAV: Malware detection
+# - Semgrep: Static Application Security Testing (SAST)
+# - Trivy: Vulnerability scanning
+#
+# Required Permissions:
+# - contents: read
+# - security-events: write
+#
+# Example Usage:
+# 1. Scheduled Run:
+#    Automatically runs with full configuration
+#
+# 2. Manual Trigger:
+#    workflow_dispatch:
+#      inputs:
+#        tools: "bandit,semgrep,trivy"
+#        scan-scope: "changed"
+#        severity-level: "MEDIUM"
+#
+# Note: Results are available as workflow artifacts and in the
+# Security tab when integrated with GitHub Advanced Security.
+
+name: Security Checks
+
+on:
+  schedule:
+    # Run security checks every day at 2 AM UTC
+    - cron: "0 2 * * *"
+
+  workflow_dispatch:
+    inputs:
+      tools:
+        description: "Security tools to run"
+        required: true
+        type: choice
+        options:
+          - "bandit,semgrep,trivy" # Default set
+          - "bandit,clamav,semgrep,trivy" # Full set
+          - "bandit,semgrep" # Minimal set
+        default: "bandit,semgrep,trivy"
+      scan-scope:
+        description: "Scan scope"
+        required: true
+        type: choice
+        options:
+          - all
+          - changed
+        default: "all"
+      severity-level:
+        description: "Minimum severity level"
+        required: true
+        type: choice
+        options:
+          - LOW
+          - MEDIUM
+          - HIGH
+        default: "LOW"
+
+permissions:
+  contents: read
+  security-events: write
+
+jobs:
+  security:
+    uses: ./.github/workflows/_reusable-security-scan.yaml
+    with:
+      # For scheduled runs, use full scan configuration
+      tools: ${{ github.event_name == 'schedule' && 'bandit,clamav,semgrep,trivy' || inputs.tools }}
+      scan-scope: ${{ github.event_name == 'schedule' && 'all' || inputs.scan-scope }}
+      severity-level: ${{ github.event_name == 'schedule' && 'LOW' || inputs.severity-level }}
+      fail-on-findings: true
diff --git a/.github/workflows/upload_coverage.yml b/.github/workflows/upload_coverage.yml
deleted file mode 100644
index 7770cb8b31..0000000000
--- a/.github/workflows/upload_coverage.yml
+++ /dev/null
@@ -1,30 +0,0 @@
-name: Upload coverage
-permissions: read-all
-
-on:
-  workflow_run:
-    workflows: ["Pre-Merge Checks"]
-    types:
-      - completed
-
-jobs:
-  Upload-Coverage:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: ${{ github.event.workflow_run.artifact_url }}
-          path: coverage
-      - name: Upload coverage report
-        run: |
-          COMMIT_ID=${{ github.event.workflow_run.head_sha }}
-          # Pass token from secrets if available. Otherwise it takes it from the environment variable of the CI
-          curl -Os https://uploader.codecov.io/latest/linux/codecov
-          chmod +x codecov
-          if [ -n "${{ secrets.CODECOV_TOKEN }}" ]
-          then
-            ./codecov -t ${{ secrets.CODECOV_TOKEN }} --sha $COMMIT_ID -U $HTTP_PROXY -f coverage/coverage.xml
-          else
-            ./codecov -t "${CODECOV_TOKEN}"  --sha $COMMIT_ID -U $HTTP_PROXY -f coverage/coverage.xml
-          fi
diff --git a/docs/source/markdown/guides/developer/index.md b/docs/source/markdown/guides/developer/index.md
index 33bb6e950a..3c7b83cf39 100644
--- a/docs/source/markdown/guides/developer/index.md
+++ b/docs/source/markdown/guides/developer/index.md
@@ -34,4 +34,5 @@ Learn the criteria for reviewing code.
 ./sdd
 ./contributing
 ./code_review_checklist
+./release_guidelines
 ```
diff --git a/docs/source/markdown/guides/developer/release_guidelines.md b/docs/source/markdown/guides/developer/release_guidelines.md
new file mode 100644
index 0000000000..3fdf7f12b7
--- /dev/null
+++ b/docs/source/markdown/guides/developer/release_guidelines.md
@@ -0,0 +1,367 @@
+# {octicon}`rocket` Release Process Guide
+
+This document outlines the release process for our Python package, including environment setup, workflow configuration, and step-by-step release instructions.
+
+## {octicon}`checklist` Prerequisites
+
+### {octicon}`key` Required Tokens
+
+:::{dropdown} Test PyPI Token
+:animate: fade-in-slide-down
+
+1. Create account on [Test PyPI](https://test.pypi.org)
+2. Generate API token: Account Settings → API tokens
+3. Scope: Upload to project
+4. Save as `TEST_PYPI_TOKEN` in GitHub Actions secrets
+   :::
+
+:::{dropdown} Production PyPI Token
+:animate: fade-in-slide-down
+
+1. Create account on [PyPI](https://pypi.org)
+2. Generate API token: Account Settings → API tokens
+3. Scope: Upload to project
+4. Save as `PYPI_TOKEN` in GitHub Actions secrets
+   :::
+
+:::{dropdown} Codecov Token
+:animate: fade-in-slide-down
+
+1. Create account on [Codecov](https://codecov.io)
+2. Generate repository upload token
+3. Scope: Repository-specific access
+4. Save as `CODECOV_TOKEN` in GitHub Actions secrets
+   :::
+
+### {octicon}`repo` GitHub Repository Setup
+
+:::{dropdown} Branch Protection
+:animate: fade-in-slide-down
+
+```text
+main branch:
+☑️ Require pull request reviews
+☑️ Require status checks to pass
+☑️ Require linear history
+☑️ Include administrators
+```
+
+:::
+
+:::{dropdown} Required Status Checks
+:animate: fade-in-slide-down
+
+- Unit Tests
+- Integration Tests
+- Security Scans
+- Quality Checks
+  :::
+
+## {octicon}`gear` Environment Setup
+
+### {octicon}`project` 1. Create GitHub Environments
+
+Create the following environments in your repository:
+
+1. Go to Repository Settings → Environments → New environment
+
+:::{dropdown} Staging Environment
+:animate: fade-in-slide-down
+
+```yaml
+Name: staging
+Protection rules: None (allows automated RC deployments)
+```
+
+:::
+
+:::{dropdown} QA Environment
+:animate: fade-in-slide-down
+
+```yaml
+Name: qa
+Protection rules:
+  - Required reviewers: [QA team members]
+  - Wait timer: 0 minutes
+  - Deployment branches: main
+Environment secrets: None
+```
+
+:::
+
+:::{dropdown} Production Release Environment
+:animate: fade-in-slide-down
+
+```yaml
+Name: production-release
+Protection rules:
+  - Required reviewers: [Release managers]
+  - Wait timer: 30 minutes
+  - Deployment branches: main
+Environment secrets: None
+```
+
+:::
+
+:::{dropdown} Production Deploy Environment
+:animate: fade-in-slide-down
+
+```yaml
+Name: production-deploy
+Protection rules:
+  - Required reviewers: [Senior engineers, DevOps]
+  - Wait timer: 0 minutes
+  - Deployment branches: main
+Environment secrets:
+  - PYPI_TOKEN: [Production PyPI token]
+```
+
+:::
+
+### {octicon}`key-asterisk` 2. Configure Repository Secrets
+
+Go to Repository Settings → Secrets and variables → Actions → New repository secret
+
+```yaml
+TEST_PYPI_TOKEN: [Test PyPI token]
+PYPI_TOKEN: [Production PyPI token]
+```
+
+## {octicon}`versions` Release Types
+
+### {octicon}`git-branch` Release Candidate (RC)
+
+- Format: `vX.Y.Z-rcN`
+- Examples: `v1.2.3-rc1`, `v1.2.3-rc2`
+- Purpose: Testing and validation
+- Deploys to: Test PyPI
+
+### {octicon}`git-merge` Production Release
+
+- Format: `vX.Y.Z`
+- Examples: `v1.2.3`, `v2.0.0`
+- Purpose: Production deployment
+- Deploys to: Production PyPI
+
+## {octicon}`workflow` Release Process
+
+### {octicon}`pencil` 1. Prepare Release
+
+1. Update version in package files:
+
+   ```python
+   # src/__init__.py or similar
+   __version__ = "1.2.3"
+   ```
+
+2. Update CHANGELOG.md:
+
+   ```markdown
+   ## [1.2.3] - YYYY-MM-DD
+
+   ### Added
+
+   - New feature X
+
+   ### Changed
+
+   - Modified behavior Y
+
+   ### Fixed
+
+   - Bug fix Z
+   ```
+
+3. Create release branch:
+
+   ```bash
+   git checkout -b release/v1.2.3
+   git add .
+   git commit -m "chore: prepare release v1.2.3"
+   git push origin release/v1.2.3
+   ```
+
+4. Create and merge PR to main
+
+### {octicon}`git-branch` 2. Create Release Candidate
+
+```bash
+# Ensure you're on main and up-to-date
+git checkout main
+git pull origin main
+
+# Create and push RC tag
+git tag v1.2.3-rc1
+git push origin v1.2.3-rc1
+```
+
+### {octicon}`checklist` 3. RC Validation Process
+
+:::{dropdown} Automated Checks
+:animate: fade-in-slide-down
+
+- Quality checks
+- Security scans
+- Test suite
+- Build verification
+  :::
+
+:::{dropdown} RC Deployment
+:animate: fade-in-slide-down
+
+- Automatic upload to Test PyPI
+- Creates draft GitHub release
+  :::
+
+:::{dropdown} QA Validation
+:animate: fade-in-slide-down
+
+- Install from Test PyPI
+- Run smoke tests
+- Validate functionality
+  :::
+
+:::{dropdown} Review Approvals
+:animate: fade-in-slide-down
+
+- QA team approves in QA environment
+- Release managers approve in production-release environment
+  :::
+
+### {octicon}`git-merge` 4. Production Release
+
+After successful RC validation:
+
+```bash
+# Create and push production tag
+git tag v1.2.3
+git push origin v1.2.3
+```
+
+The workflow will:
+
+1. Run all checks
+2. Create GitHub release
+3. Await approvals
+4. Deploy to PyPI
+
+## {octicon}`bug` Troubleshooting
+
+### {octicon}`alert` Common Issues
+
+:::{dropdown} RC Upload Fails
+:animate: fade-in-slide-down
+
+- Check Test PyPI token permissions
+- Verify version doesn't exist on Test PyPI
+- Ensure version follows PEP 440
+  :::
+
+:::{dropdown} Workflow Failures
+:animate: fade-in-slide-down
+
+```bash
+# View workflow logs
+gh run list
+gh run view [run-id]
+```
+
+:::
+
+:::{dropdown} Environment Approval Issues
+:animate: fade-in-slide-down
+
+- Verify reviewer permissions
+- Check environment protection rules
+- Ensure reviewers are in correct teams
+  :::
+
+### {octicon}`sync` Recovery Steps
+
+:::{dropdown} Failed RC
+:animate: fade-in-slide-down
+
+```bash
+# Delete failed RC tag
+git tag -d v1.2.3-rc1
+git push origin :refs/tags/v1.2.3-rc1
+
+# Create new RC
+git tag v1.2.3-rc2
+git push origin v1.2.3-rc2
+```
+
+:::
+
+:::{dropdown} Failed Production Release
+:animate: fade-in-slide-down
+
+- Do not delete production tags
+- Create new patch version if needed
+  :::
+
+## {octicon}`light-bulb` Best Practices
+
+### {octicon}`versions` Version Management
+
+- Follow semantic versioning
+- Use RCs for significant changes
+- Include build metadata in package
+
+### {octicon}`note` Release Notes
+
+- Use consistent format
+- Include upgrade instructions
+- Document breaking changes
+
+### {octicon}`shield-lock` Security
+
+- Never share or commit tokens
+- Review dependency updates
+- Monitor security advisories
+
+### {octicon}`megaphone` Communication
+
+- Announce release schedule
+- Document known issues
+- Maintain changelog
+
+## {octicon}`bookmark` Quick Reference
+
+### {octicon}`terminal` Commands Cheatsheet
+
+```bash
+# Create RC
+git tag v1.2.3-rc1
+git push origin v1.2.3-rc1
+
+# Create Release
+git tag v1.2.3
+git push origin v1.2.3
+
+# Delete Tag (only for RCs)
+git tag -d v1.2.3-rc1
+git push origin :refs/tags/v1.2.3-rc1
+
+# View Tags
+git tag -l "v*"
+
+# Check Workflow Status
+gh workflow list
+gh run list
+```
+
+### {octicon}`file-directory` Required Files
+
+```text
+repository/
+├── .github/
+│   ├── workflows/
+│   │   └── release.yaml
+│   └── actions/
+├── src/
+│   └── __init__.py
+├── tests/
+├── CHANGELOG.md
+└── pyproject.toml
+```

From 31ad99906b0ff1f24f785e2fe39f4b52e0ac7f66 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 11 Dec 2024 15:58:15 +0000
Subject: [PATCH 21/45] Exclude tiled ensemble for now

Signed-off-by: Samet Akcay 
---
 .../markdown/guides/how_to/pipelines/index.md |   7 -
 .../guides/how_to/pipelines/tiled_ensemble.md | 157 -------
 .../pipelines/tiled_ensemble/__init__.py      |  12 -
 .../tiled_ensemble/components/__init__.py     |  30 --
 .../tiled_ensemble/components/merging.py      | 110 -----
 .../components/metrics_calculation.py         | 217 ----------
 .../components/model_training.py              | 192 ---------
 .../components/normalization.py               | 120 ------
 .../tiled_ensemble/components/prediction.py   | 228 -----------
 .../tiled_ensemble/components/smoothing.py    | 167 --------
 .../components/stats_calculation.py           | 180 --------
 .../tiled_ensemble/components/thresholding.py | 114 ------
 .../components/utils/__init__.py              |  44 --
 .../components/utils/ensemble_engine.py       |  92 -----
 .../components/utils/ensemble_tiling.py       | 147 -------
 .../components/utils/helper_functions.py      | 179 --------
 .../components/utils/prediction_data.py       |  45 --
 .../components/utils/prediction_merging.py    | 167 --------
 .../components/visualization.py               | 125 ------
 .../pipelines/tiled_ensemble/test_pipeline.py | 124 ------
 .../tiled_ensemble/train_pipeline.py          | 123 ------
 .../pipelines/test_tiled_ensemble.py          |  62 ---
 .../integration/pipelines/tiled_ensemble.yaml |  43 --
 .../unit/pipelines/tiled_ensemble/__init__.py |   4 -
 .../unit/pipelines/tiled_ensemble/conftest.py | 151 -------
 .../tiled_ensemble/dummy_config.yaml          |  52 ---
 .../tiled_ensemble/test_components.py         | 387 ------------------
 .../tiled_ensemble/test_helper_functions.py   | 113 -----
 .../tiled_ensemble/test_prediction_data.py    |  69 ----
 .../pipelines/tiled_ensemble/test_tiler.py    | 119 ------
 tools/tiled_ensemble/ens_config.yaml          |  43 --
 tools/tiled_ensemble/eval.py                  |  28 --
 tools/tiled_ensemble/train.py                 |  17 -
 33 files changed, 3668 deletions(-)
 delete mode 100644 docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/__init__.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/__init__.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/merging.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/metrics_calculation.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/model_training.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/normalization.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/prediction.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/smoothing.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/stats_calculation.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/thresholding.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/utils/__init__.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_engine.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_tiling.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/utils/helper_functions.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_data.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_merging.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/components/visualization.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/test_pipeline.py
 delete mode 100644 src/anomalib/pipelines/tiled_ensemble/train_pipeline.py
 delete mode 100644 tests/integration/pipelines/test_tiled_ensemble.py
 delete mode 100644 tests/integration/pipelines/tiled_ensemble.yaml
 delete mode 100644 tests/unit/pipelines/tiled_ensemble/__init__.py
 delete mode 100644 tests/unit/pipelines/tiled_ensemble/conftest.py
 delete mode 100644 tests/unit/pipelines/tiled_ensemble/dummy_config.yaml
 delete mode 100644 tests/unit/pipelines/tiled_ensemble/test_components.py
 delete mode 100644 tests/unit/pipelines/tiled_ensemble/test_helper_functions.py
 delete mode 100644 tests/unit/pipelines/tiled_ensemble/test_prediction_data.py
 delete mode 100644 tests/unit/pipelines/tiled_ensemble/test_tiler.py
 delete mode 100644 tools/tiled_ensemble/ens_config.yaml
 delete mode 100644 tools/tiled_ensemble/eval.py
 delete mode 100644 tools/tiled_ensemble/train.py

diff --git a/docs/source/markdown/guides/how_to/pipelines/index.md b/docs/source/markdown/guides/how_to/pipelines/index.md
index c7f2c44706..d70e6be757 100644
--- a/docs/source/markdown/guides/how_to/pipelines/index.md
+++ b/docs/source/markdown/guides/how_to/pipelines/index.md
@@ -6,13 +6,6 @@ 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
diff --git a/docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md b/docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md
deleted file mode 100644
index 3550efb5fd..0000000000
--- a/docs/source/markdown/guides/how_to/pipelines/tiled_ensemble.md
+++ /dev/null
@@ -1,157 +0,0 @@
-# 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/openvinotoolkit/anomalib/issues) and feel free to ask any question in [Discussions](https://github.com/openvinotoolkit/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: "gpu"
-default_root_dir: "results"
-```
-
-### Tiling
-
-This section contains the following settings, used for image tiling:
-
-```{code-block} yaml
-
-tiling:
-    tile_size: 256
-    stride: 256
-```
-
-These settings determine the tile size and stride. Another important parameter is image_size from `data` section later in the config. It determines the original size of the image.
-
-Input image is 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:
-  method: F1AdaptiveThreshold
-  stage: image
-```
-
-- **Normalization**: Can be applied per each tile location separately (`tile` option), after combining prediction (`image` option), or skipped (`none` option).
-
-- **Thresholding**: Can also be applied at different stages, but it is limited to `tile` and `image`. Another setting for thresholding is the method used. It can be specified as a string or by the class path.
-
-### Data
-
-The `data` section is used to configure the input `image_size` and other parameters for the dataset used.
-
-```{code-block} yaml
-data:
-  class_path: anomalib.data.MVTec
-  init_args:
-    root: ./datasets/MVTec
-    category: bottle
-    train_batch_size: 32
-    eval_batch_size: 32
-    num_workers: 8
-    task: segmentation
-    transform: null
-    train_transform: null
-    eval_transform: null
-    test_split_mode: from_dir
-    test_split_ratio: 0.2
-    val_split_mode: same_as_test
-    val_split_ratio: 0.5
-    image_size: [256, 256]
-```
-
-Refer to [Data](../../reference/data/image/index.md) for more details on parameters.
-
-### 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
-
-  metrics:
-    pixel: AUROC
-    image: AUROC
-
-  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.
-- **Metrics**: Defines evaluation metrics for pixel and image level.
-- **Trainer**: _optional_ parameters, used to control the training process. Refer to [Engine](../../reference/engine/index.md) for more details.
diff --git a/src/anomalib/pipelines/tiled_ensemble/__init__.py b/src/anomalib/pipelines/tiled_ensemble/__init__.py
deleted file mode 100644
index 1a068562b7..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""Tiled ensemble pipelines."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from .test_pipeline import EvalTiledEnsemble
-from .train_pipeline import TrainTiledEnsemble
-
-__all__ = [
-    "TrainTiledEnsemble",
-    "EvalTiledEnsemble",
-]
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/__init__.py b/src/anomalib/pipelines/tiled_ensemble/components/__init__.py
deleted file mode 100644
index 619dc2e673..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/__init__.py
+++ /dev/null
@@ -1,30 +0,0 @@
-"""Tiled ensemble pipeline components."""
-
-# Copyright (C) 2024 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, ThresholdStage
-from .visualization import VisualizationJobGenerator
-
-__all__ = [
-    "NormalizationStage",
-    "ThresholdStage",
-    "PredictData",
-    "TrainModelJobGenerator",
-    "PredictJobGenerator",
-    "MergeJobGenerator",
-    "SmoothingJobGenerator",
-    "StatisticsJobGenerator",
-    "NormalizationJobGenerator",
-    "ThresholdingJobGenerator",
-    "VisualizationJobGenerator",
-    "MetricsCalculationJobGenerator",
-]
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/merging.py b/src/anomalib/pipelines/tiled_ensemble/components/merging.py
deleted file mode 100644
index 6e8d5fc84c..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/merging.py
+++ /dev/null
@@ -1,110 +0,0 @@
-"""Tiled ensemble - prediction merging job."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from collections.abc import Generator
-from typing import Any
-
-from tqdm import tqdm
-
-from anomalib.pipelines.components import Job, JobGenerator
-from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS
-
-from .utils.ensemble_tiling import EnsembleTiler
-from .utils.helper_functions import get_ensemble_tiler
-from .utils.prediction_data import EnsemblePredictions
-from .utils.prediction_merging import PredictionMergingMechanism
-
-logger = logging.getLogger(__name__)
-
-
-class MergeJob(Job):
-    """Job for merging tile-level predictions into image-level predictions.
-
-    Args:
-        predictions (EnsemblePredictions): Object containing ensemble predictions.
-        tiler (EnsembleTiler): Ensemble tiler used for untiling.
-    """
-
-    name = "Merge"
-
-    def __init__(self, predictions: EnsemblePredictions, tiler: EnsembleTiler) -> None:
-        super().__init__()
-        self.predictions = predictions
-        self.tiler = tiler
-
-    def run(self, task_id: int | None = None) -> list[Any]:
-        """Run merging job that merges all batches of tile-level predictions into image-level predictions.
-
-        Args:
-            task_id: Not used in this case.
-
-        Returns:
-            list[Any]: List of merged predictions.
-        """
-        del task_id  # not needed here
-
-        merger = PredictionMergingMechanism(self.predictions, self.tiler)
-
-        logger.info("Merging predictions.")
-
-        # merge all batches
-        merged_predictions = [
-            merger.merge_tile_predictions(batch_idx)
-            for batch_idx in tqdm(range(merger.num_batches), desc="Prediction merging")
-        ]
-
-        return merged_predictions  # noqa: RET504
-
-    @staticmethod
-    def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS:
-        """Nothing to collect in this job.
-
-        Returns:
-            list[Any]: List of predictions.
-        """
-        # take the first element as result is list of lists here
-        return results[0]
-
-    @staticmethod
-    def save(results: GATHERED_RESULTS) -> None:
-        """Nothing to save in this job."""
-
-
-class MergeJobGenerator(JobGenerator):
-    """Generate MergeJob."""
-
-    def __init__(self, tiling_args: dict, data_args: dict) -> None:
-        super().__init__()
-        self.tiling_args = tiling_args
-        self.data_args = data_args
-
-    @property
-    def job_class(self) -> type:
-        """Return the job class."""
-        return MergeJob
-
-    def generate_jobs(
-        self,
-        args: dict | None = None,
-        prev_stage_result: EnsemblePredictions | None = None,
-    ) -> Generator[MergeJob, None, None]:
-        """Return a generator producing a single merging job.
-
-        Args:
-            args (dict): Tiled ensemble pipeline args.
-            prev_stage_result (EnsemblePredictions): Ensemble predictions from predict step.
-
-        Returns:
-            Generator[MergeJob, None, None]: MergeJob generator
-        """
-        del args  # args not used here
-
-        tiler = get_ensemble_tiler(self.tiling_args, self.data_args)
-        if prev_stage_result is not None:
-            yield MergeJob(prev_stage_result, tiler)
-        else:
-            msg = "Merging job requires tile level predictions from previous step."
-            raise ValueError(msg)
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/metrics_calculation.py b/src/anomalib/pipelines/tiled_ensemble/components/metrics_calculation.py
deleted file mode 100644
index 530662b1d3..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/metrics_calculation.py
+++ /dev/null
@@ -1,217 +0,0 @@
-"""Tiled ensemble - metrics calculation job."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from collections.abc import Generator
-from pathlib import Path
-from typing import Any
-
-import pandas as pd
-from tqdm import tqdm
-
-from anomalib import TaskType
-from anomalib.metrics import AnomalibMetricCollection, create_metric_collection
-from anomalib.pipelines.components import Job, JobGenerator
-from anomalib.pipelines.types import GATHERED_RESULTS, PREV_STAGE_RESULT, RUN_RESULTS
-
-from .utils import NormalizationStage
-from .utils.helper_functions import get_threshold_values
-
-logger = logging.getLogger(__name__)
-
-
-class MetricsCalculationJob(Job):
-    """Job for image and pixel metrics calculation.
-
-    Args:
-        accelerator (str): Accelerator (device) to use.
-        predictions (list[Any]): List of batch predictions.
-        root_dir (Path): Root directory to save checkpoints, stats and images.
-        image_metrics (AnomalibMetricCollection): Collection of all image-level metrics.
-        pixel_metrics (AnomalibMetricCollection): Collection of all pixel-level metrics.
-    """
-
-    name = "Metrics"
-
-    def __init__(
-        self,
-        accelerator: str,
-        predictions: list[Any] | None,
-        root_dir: Path,
-        image_metrics: AnomalibMetricCollection,
-        pixel_metrics: AnomalibMetricCollection,
-    ) -> None:
-        super().__init__()
-        self.accelerator = accelerator
-        self.predictions = predictions
-        self.root_dir = root_dir
-        self.image_metrics = image_metrics
-        self.pixel_metrics = pixel_metrics
-
-    def run(self, task_id: int | None = None) -> dict:
-        """Run a job that calculates image and pixel level metrics.
-
-        Args:
-            task_id: Not used in this case.
-
-        Returns:
-            dict[str, float]: Dictionary containing calculated metric values.
-        """
-        del task_id  # not needed here
-
-        logger.info("Starting metrics calculation.")
-
-        # add predicted data to metrics
-        for data in tqdm(self.predictions, desc="Calculating metrics"):
-            self.image_metrics.update(data["pred_scores"], data["label"].int())
-            if "mask" in data and "anomaly_maps" in data:
-                self.pixel_metrics.update(data["anomaly_maps"], data["mask"].int())
-
-        # compute all metrics on specified accelerator
-        metrics_dict = {}
-        for name, metric in self.image_metrics.items():
-            metric.to(self.accelerator)
-            metrics_dict[name] = metric.compute().item()
-            metric.cpu()
-
-        if self.pixel_metrics.update_called:
-            for name, metric in self.pixel_metrics.items():
-                metric.to(self.accelerator)
-                metrics_dict[name] = metric.compute().item()
-                metric.cpu()
-
-        for name, value in metrics_dict.items():
-            print(f"{name}: {value:.4f}")
-
-        # save path used in `save` method
-        metrics_dict["save_path"] = self.root_dir / "metric_results.csv"
-
-        return metrics_dict
-
-    @staticmethod
-    def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS:
-        """Nothing to collect in this job.
-
-        Returns:
-            list[Any]: list of predictions.
-        """
-        # take the first element as result is list of dict here
-        return results[0]
-
-    @staticmethod
-    def save(results: GATHERED_RESULTS) -> None:
-        """Save metrics values to csv."""
-        logger.info("Saving metrics to csv.")
-
-        # get and remove path from stats dict
-        results_path: Path = results.pop("save_path")
-        results_path.parent.mkdir(parents=True, exist_ok=True)
-
-        df_dict = {k: [v] for k, v in results.items()}
-        metrics_df = pd.DataFrame(df_dict)
-        metrics_df.to_csv(results_path, index=False)
-
-
-class MetricsCalculationJobGenerator(JobGenerator):
-    """Generate MetricsCalculationJob.
-
-    Args:
-        root_dir (Path): Root directory to save checkpoints, stats and images.
-    """
-
-    def __init__(
-        self,
-        accelerator: str,
-        root_dir: Path,
-        task: TaskType,
-        metrics: dict,
-        normalization_stage: NormalizationStage,
-    ) -> None:
-        self.accelerator = accelerator
-        self.root_dir = root_dir
-        self.task = task
-        self.metrics = metrics
-        self.normalization_stage = normalization_stage
-
-    @property
-    def job_class(self) -> type:
-        """Return the job class."""
-        return MetricsCalculationJob
-
-    def configure_ensemble_metrics(
-        self,
-        image_metrics: list[str] | dict[str, dict[str, Any]] | None = None,
-        pixel_metrics: list[str] | dict[str, dict[str, Any]] | None = None,
-    ) -> tuple[AnomalibMetricCollection, AnomalibMetricCollection]:
-        """Configure image and pixel metrics and put them into a collection.
-
-        Args:
-            image_metrics (list[str] | None): List of image-level metric names.
-            pixel_metrics (list[str] | None): List of pixel-level metric names.
-
-        Returns:
-            tuple[AnomalibMetricCollection, AnomalibMetricCollection]:
-                Image-metrics collection and pixel-metrics collection
-        """
-        image_metrics = [] if image_metrics is None else image_metrics
-
-        if pixel_metrics is None:
-            pixel_metrics = []
-        elif self.task == TaskType.CLASSIFICATION:
-            pixel_metrics = []
-            logger.warning(
-                "Cannot perform pixel-level evaluation when task type is classification. "
-                "Ignoring the following pixel-level metrics: %s",
-                pixel_metrics,
-            )
-
-        # if a single metric is passed, transform to list to fit the creation function
-        if isinstance(image_metrics, str):
-            image_metrics = [image_metrics]
-        if isinstance(pixel_metrics, str):
-            pixel_metrics = [pixel_metrics]
-
-        image_metrics_collection = create_metric_collection(image_metrics, "image_")
-        pixel_metrics_collection = create_metric_collection(pixel_metrics, "pixel_")
-
-        return image_metrics_collection, pixel_metrics_collection
-
-    def generate_jobs(
-        self,
-        args: dict | None = None,
-        prev_stage_result: PREV_STAGE_RESULT = None,
-    ) -> Generator[MetricsCalculationJob, None, None]:
-        """Make a generator that yields a single metrics calculation job.
-
-        Args:
-            args: ensemble run config.
-            prev_stage_result: ensemble predictions from previous step.
-
-        Returns:
-            Generator[MetricsCalculationJob, None, None]: MetricsCalculationJob generator
-        """
-        del args  # args not used here
-
-        image_metrics_config = self.metrics.get("image", None)
-        pixel_metrics_config = self.metrics.get("pixel", None)
-
-        image_threshold, pixel_threshold = get_threshold_values(self.normalization_stage, self.root_dir)
-
-        image_metrics, pixel_metrics = self.configure_ensemble_metrics(
-            image_metrics=image_metrics_config,
-            pixel_metrics=pixel_metrics_config,
-        )
-
-        # set thresholds for metrics that need it
-        image_metrics.set_threshold(image_threshold)
-        pixel_metrics.set_threshold(pixel_threshold)
-
-        yield MetricsCalculationJob(
-            accelerator=self.accelerator,
-            predictions=prev_stage_result,
-            root_dir=self.root_dir,
-            image_metrics=image_metrics,
-            pixel_metrics=pixel_metrics,
-        )
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/model_training.py b/src/anomalib/pipelines/tiled_ensemble/components/model_training.py
deleted file mode 100644
index 6bc81c793b..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/model_training.py
+++ /dev/null
@@ -1,192 +0,0 @@
-"""Tiled ensemble - ensemble training job."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from collections.abc import Generator
-from itertools import product
-from pathlib import Path
-
-from lightning import seed_everything
-
-from anomalib.data import AnomalibDataModule
-from anomalib.models import AnomalyModule
-from anomalib.pipelines.components import Job, JobGenerator
-from anomalib.pipelines.types import GATHERED_RESULTS, PREV_STAGE_RESULT
-
-from .utils import NormalizationStage
-from .utils.ensemble_engine import TiledEnsembleEngine
-from .utils.helper_functions import (
-    get_ensemble_datamodule,
-    get_ensemble_engine,
-    get_ensemble_model,
-    get_ensemble_tiler,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class TrainModelJob(Job):
-    """Job for training of individual models in the tiled ensemble.
-
-    Args:
-        accelerator (str): Accelerator (device) to use.
-        seed (int): Random seed for reproducibility.
-        root_dir (Path): Root directory to save checkpoints, stats and images.
-        tile_index (tuple[int, int]): Index of tile that this model processes.
-        normalization_stage (str): Normalization stage flag.
-        metrics (dict): metrics dict with pixel and image metric names.
-        trainer_args (dict| None): Additional arguments to pass to the trainer class.
-        model (AnomalyModule): Model to train.
-        datamodule (AnomalibDataModule): Datamodule with all dataloaders.
-
-    """
-
-    name = "TrainModels"
-
-    def __init__(
-        self,
-        accelerator: str,
-        seed: int,
-        root_dir: Path,
-        tile_index: tuple[int, int],
-        normalization_stage: str,
-        metrics: dict,
-        trainer_args: dict | None,
-        model: AnomalyModule,
-        datamodule: AnomalibDataModule,
-    ) -> None:
-        super().__init__()
-        self.accelerator = accelerator
-        self.seed = seed
-        self.root_dir = root_dir
-        self.tile_index = tile_index
-        self.normalization_stage = normalization_stage
-        self.metrics = metrics
-        self.trainer_args = trainer_args
-        self.model = model
-        self.datamodule = datamodule
-
-    def run(
-        self,
-        task_id: int | None = None,
-    ) -> TiledEnsembleEngine:
-        """Run train job that fits the model for given tile location.
-
-        Args:
-            task_id: Passed when job is ran in parallel.
-
-        Returns:
-            TiledEnsembleEngine: Engine containing trained model.
-        """
-        devices: str | list[int] = "auto"
-        if task_id is not None:
-            devices = [task_id]
-            logger.info(f"Running job {self.model.__class__.__name__} with device {task_id}")
-
-        logger.info("Start of training for tile at position %s,", self.tile_index)
-        seed_everything(self.seed)
-
-        # create engine for specific tile location and fit the model
-        engine = get_ensemble_engine(
-            tile_index=self.tile_index,
-            accelerator=self.accelerator,
-            devices=devices,
-            root_dir=self.root_dir,
-            normalization_stage=self.normalization_stage,
-            metrics=self.metrics,
-            trainer_args=self.trainer_args,
-        )
-        engine.fit(model=self.model, datamodule=self.datamodule)
-        # move model to cpu to avoid memory issues as the engine is returned to be used in validation phase
-        engine.model.cpu()
-
-        return engine
-
-    @staticmethod
-    def collect(results: list[TiledEnsembleEngine]) -> dict[tuple[int, int], TiledEnsembleEngine]:
-        """Collect engines from each tile location into a dict.
-
-        Returns:
-            dict[tuple[int, int], TiledEnsembleEngine]: Dict has form {tile_index: TiledEnsembleEngine}
-        """
-        return {r.tile_index: r for r in results}
-
-    @staticmethod
-    def save(results: GATHERED_RESULTS) -> None:
-        """Skip as checkpoints are already saved by callback."""
-
-
-class TrainModelJobGenerator(JobGenerator):
-    """Generator for training job that train model for each tile location.
-
-    Args:
-        root_dir (Path): Root directory to save checkpoints, stats and images.
-    """
-
-    def __init__(
-        self,
-        seed: int,
-        accelerator: str,
-        root_dir: Path,
-        tiling_args: dict,
-        data_args: dict,
-        normalization_stage: NormalizationStage,
-    ) -> None:
-        self.seed = seed
-        self.accelerator = accelerator
-        self.root_dir = root_dir
-        self.tiling_args = tiling_args
-        self.data_args = data_args
-        self.normalization_stage = normalization_stage
-
-    @property
-    def job_class(self) -> type:
-        """Return the job class."""
-        return TrainModelJob
-
-    def generate_jobs(
-        self,
-        args: dict | None = None,
-        prev_stage_result: PREV_STAGE_RESULT = None,
-    ) -> Generator[TrainModelJob, None, None]:
-        """Generate training jobs for each tile location.
-
-        Args:
-            args (dict): Dict with config passed to training.
-            prev_stage_result (None): Not used here.
-
-        Returns:
-            Generator[TrainModelJob, None, None]: TrainModelJob generator
-        """
-        del prev_stage_result  # Not needed for this job
-        if args is None:
-            msg = "TrainModels job requires config args"
-            raise ValueError(msg)
-
-        # tiler used for splitting the image and getting the tile count
-        tiler = get_ensemble_tiler(self.tiling_args, self.data_args)
-
-        logger.info(
-            "Tiled ensemble training started. Separate models will be trained for %d tile locations.",
-            tiler.num_tiles,
-        )
-        # go over all tile positions
-        for tile_index in product(range(tiler.num_patches_h), range(tiler.num_patches_w)):
-            # prepare datamodule with custom collate function that only provides specific tile of image
-            datamodule = get_ensemble_datamodule(self.data_args, tiler, tile_index)
-            model = get_ensemble_model(args["model"], tiler)
-
-            # pass root_dir to engine so all models in ensemble have the same root dir
-            yield TrainModelJob(
-                accelerator=self.accelerator,
-                seed=self.seed,
-                root_dir=self.root_dir,
-                tile_index=tile_index,
-                normalization_stage=self.normalization_stage,
-                metrics=args["metrics"],
-                trainer_args=args.get("trainer", {}),
-                model=model,
-                datamodule=datamodule,
-            )
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/normalization.py b/src/anomalib/pipelines/tiled_ensemble/components/normalization.py
deleted file mode 100644
index 8c7a563506..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/normalization.py
+++ /dev/null
@@ -1,120 +0,0 @@
-"""Tiled ensemble - normalization job."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-import logging
-from collections.abc import Generator
-from pathlib import Path
-from typing import Any
-
-from tqdm import tqdm
-
-from anomalib.pipelines.components import Job, JobGenerator
-from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS
-from anomalib.utils.normalization.min_max import normalize
-
-logger = logging.getLogger(__name__)
-
-
-class NormalizationJob(Job):
-    """Job for normalization of predictions.
-
-    Args:
-        predictions (list[Any]): List of predictions.
-        root_dir (Path): Root directory containing statistics needed for normalization.
-    """
-
-    name = "Normalize"
-
-    def __init__(self, predictions: list[Any] | None, root_dir: Path) -> None:
-        super().__init__()
-        self.predictions = predictions
-        self.root_dir = root_dir
-
-    def run(self, task_id: int | None = None) -> list[Any] | None:
-        """Run normalization job which normalizes image, pixel and box scores.
-
-        Args:
-            task_id: Not used in this case.
-
-        Returns:
-            list[Any]: List of normalized predictions.
-        """
-        del task_id  # not needed here
-
-        # load all statistics needed for normalization
-        stats_path = self.root_dir / "weights" / "lightning" / "stats.json"
-        with stats_path.open("r") as f:
-            stats = json.load(f)
-        minmax = stats["minmax"]
-        image_threshold = stats["image_threshold"]
-        pixel_threshold = stats["pixel_threshold"]
-
-        logger.info("Starting normalization.")
-
-        for data in tqdm(self.predictions, desc="Normalizing"):
-            data["pred_scores"] = normalize(
-                data["pred_scores"],
-                image_threshold,
-                minmax["pred_scores"]["min"],
-                minmax["pred_scores"]["max"],
-            )
-            if "anomaly_maps" in data:
-                data["anomaly_maps"] = normalize(
-                    data["anomaly_maps"],
-                    pixel_threshold,
-                    minmax["anomaly_maps"]["min"],
-                    minmax["anomaly_maps"]["max"],
-                )
-
-        return self.predictions
-
-    @staticmethod
-    def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS:
-        """Nothing to collect in this job.
-
-        Returns:
-            list[Any]: List of predictions.
-        """
-        # take the first element as result is list of lists here
-        return results[0]
-
-    @staticmethod
-    def save(results: GATHERED_RESULTS) -> None:
-        """Nothing is saved in this job."""
-
-
-class NormalizationJobGenerator(JobGenerator):
-    """Generate NormalizationJob.
-
-    Args:
-        root_dir (Path): Root directory where statistics are saved.
-    """
-
-    def __init__(self, root_dir: Path) -> None:
-        self.root_dir = root_dir
-
-    @property
-    def job_class(self) -> type:
-        """Return the job class."""
-        return NormalizationJob
-
-    def generate_jobs(
-        self,
-        args: dict | None = None,
-        prev_stage_result: list[Any] | None = None,
-    ) -> Generator[NormalizationJob, None, None]:
-        """Return a generator producing a single normalization job.
-
-        Args:
-            args: not used here.
-            prev_stage_result (list[Any]): Ensemble predictions from previous step.
-
-        Returns:
-            Generator[NormalizationJob, None, None]: NormalizationJob generator.
-        """
-        del args  # not needed here
-
-        yield NormalizationJob(prev_stage_result, self.root_dir)
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/prediction.py b/src/anomalib/pipelines/tiled_ensemble/components/prediction.py
deleted file mode 100644
index 792d86a497..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/prediction.py
+++ /dev/null
@@ -1,228 +0,0 @@
-"""Tiled ensemble - ensemble prediction job."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from collections.abc import Generator
-from itertools import product
-from pathlib import Path
-from typing import Any
-
-from lightning import seed_everything
-from torch.utils.data import DataLoader
-
-from anomalib.models import AnomalyModule
-from anomalib.pipelines.components import Job, JobGenerator
-from anomalib.pipelines.types import GATHERED_RESULTS, PREV_STAGE_RESULT
-
-from .utils import NormalizationStage, PredictData
-from .utils.ensemble_engine import TiledEnsembleEngine
-from .utils.helper_functions import (
-    get_ensemble_datamodule,
-    get_ensemble_engine,
-    get_ensemble_model,
-    get_ensemble_tiler,
-)
-from .utils.prediction_data import EnsemblePredictions
-
-logger = logging.getLogger(__name__)
-
-
-class PredictJob(Job):
-    """Job for generating predictions with individual models in the tiled ensemble.
-
-    Args:
-        accelerator (str): Accelerator (device) to use.
-        seed (int): Random seed for reproducibility.
-        root_dir (Path): Root directory to save checkpoints, stats and images.
-        tile_index (tuple[int, int]): Index of tile that this model processes.
-        normalization_stage (str): Normalization stage flag.
-        dataloader (DataLoader): Dataloader to use for training (either val or test).
-        model (AnomalyModule): Model to train.
-        engine (TiledEnsembleEngine | None):
-            engine from train job. If job is used standalone, instantiate engine and model from checkpoint.
-        ckpt_path (Path | None): Path to checkpoint to be loaded if engine doesn't contain correct weights.
-
-    """
-
-    name = "Predict"
-
-    def __init__(
-        self,
-        accelerator: str,
-        seed: int,
-        root_dir: Path,
-        tile_index: tuple[int, int],
-        normalization_stage: str,
-        dataloader: DataLoader,
-        model: AnomalyModule | None,
-        engine: TiledEnsembleEngine | None,
-        ckpt_path: Path | None,
-    ) -> None:
-        super().__init__()
-        if engine is None and ckpt_path is None:
-            msg = "Either engine or checkpoint must be provided to predict job."
-            raise ValueError(msg)
-
-        self.accelerator = accelerator
-        self.seed = seed
-        self.root_dir = root_dir
-        self.tile_index = tile_index
-        self.normalization_stage = normalization_stage
-        self.dataloader = dataloader
-        self.model = model
-        self.engine = engine
-        self.ckpt_path = ckpt_path
-
-    def run(
-        self,
-        task_id: int | None = None,
-    ) -> tuple[tuple[int, int], Any | None]:
-        """Predict job that predicts the data with specific model for given tile location.
-
-        Args:
-            task_id: Passed when job is ran in parallel.
-
-        Returns:
-            tuple[tuple[int, int], list[Any]]: Tile index, List of predictions.
-        """
-        devices: str | list[int] = "auto"
-        if task_id is not None:
-            devices = [task_id]
-            logger.info(f"Running job {self.model.__class__.__name__} with device {task_id}")
-
-        logger.info("Start of predicting for tile at position %s,", self.tile_index)
-        seed_everything(self.seed)
-
-        if self.engine is None:
-            # in case predict is invoked separately from train job, make new engine instance
-            self.engine = get_ensemble_engine(
-                tile_index=self.tile_index,
-                accelerator=self.accelerator,
-                devices=devices,
-                root_dir=self.root_dir,
-                normalization_stage=self.normalization_stage,
-            )
-
-        predictions = self.engine.predict(model=self.model, dataloaders=self.dataloader, ckpt_path=self.ckpt_path)
-
-        # also return tile index as it's needed in collect method
-        return self.tile_index, predictions
-
-    @staticmethod
-    def collect(results: list[tuple[tuple[int, int], list[Any]]]) -> EnsemblePredictions:
-        """Collect predictions from each tile location into the predictions class.
-
-        Returns:
-            EnsemblePredictions: Object containing all predictions in form ready for merging.
-        """
-        storage = EnsemblePredictions()
-
-        for tile_index, predictions in results:
-            storage.add_tile_prediction(tile_index, predictions)
-
-        return storage
-
-    @staticmethod
-    def save(results: GATHERED_RESULTS) -> None:
-        """This stage doesn't save anything."""
-
-
-class PredictJobGenerator(JobGenerator):
-    """Generator for predict job that uses individual models to predict for each tile location.
-
-    Args:
-        root_dir (Path): Root directory to save checkpoints, stats and images.
-        data_source (PredictData): Whether to predict on validation set. If false use test set.
-    """
-
-    def __init__(
-        self,
-        data_source: PredictData,
-        seed: int,
-        accelerator: str,
-        root_dir: Path,
-        tiling_args: dict,
-        data_args: dict,
-        model_args: dict,
-        normalization_stage: NormalizationStage,
-    ) -> None:
-        self.data_source = data_source
-        self.seed = seed
-        self.accelerator = accelerator
-        self.root_dir = root_dir
-        self.tiling_args = tiling_args
-        self.data_args = data_args
-        self.model_args = model_args
-        self.normalization_stage = normalization_stage
-
-    @property
-    def job_class(self) -> type:
-        """Return the job class."""
-        return PredictJob
-
-    def generate_jobs(
-        self,
-        args: dict | None = None,
-        prev_stage_result: PREV_STAGE_RESULT = None,
-    ) -> Generator[PredictJob, None, None]:
-        """Generate predict jobs for each tile location.
-
-        Args:
-            args (dict): Dict with config passed to training.
-            prev_stage_result (dict[tuple[int, int], TiledEnsembleEngine] | None):
-                if called after train job this contains engines with individual models, otherwise load from checkpoints.
-
-        Returns:
-            Generator[PredictJob, None, None]: PredictJob generator.
-        """
-        del args  # args not used here
-
-        # tiler used for splitting the image and getting the tile count
-        tiler = get_ensemble_tiler(self.tiling_args, self.data_args)
-
-        logger.info(
-            "Tiled ensemble predicting started using %s data.",
-            self.data_source.value,
-        )
-        # go over all tile positions
-        for tile_index in product(range(tiler.num_patches_h), range(tiler.num_patches_w)):
-            # prepare datamodule with custom collate function that only provides specific tile of image
-            datamodule = get_ensemble_datamodule(self.data_args, tiler, tile_index)
-
-            # check if predict step is positioned after training
-            if prev_stage_result and tile_index in prev_stage_result:
-                engine = prev_stage_result[tile_index]
-                # model is inside engine in this case
-                model = engine.model
-                ckpt_path = None
-            else:
-                # any other case - predict is called standalone
-                engine = None
-                # we need to make new model instance as it's not inside engine
-                model = get_ensemble_model(self.model_args, tiler)
-                tile_i, tile_j = tile_index
-                # prepare checkpoint path for model on current tile location
-                ckpt_path = self.root_dir / "weights" / "lightning" / f"model{tile_i}_{tile_j}.ckpt"
-
-            # pick the dataloader based on predict data
-            dataloader = datamodule.test_dataloader()
-            if self.data_source == PredictData.VAL:
-                dataloader = datamodule.val_dataloader()
-            # TODO(blaz-r): - this is tweak to avoid problem in engine:388
-            # 2254
-            dataloader.dataset.transform = None
-
-            # pass root_dir to engine so all models in ensemble have the same root dir
-            yield PredictJob(
-                accelerator=self.accelerator,
-                seed=self.seed,
-                root_dir=self.root_dir,
-                tile_index=tile_index,
-                normalization_stage=self.normalization_stage,
-                model=model,
-                dataloader=dataloader,
-                engine=engine,
-                ckpt_path=ckpt_path,
-            )
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/smoothing.py b/src/anomalib/pipelines/tiled_ensemble/components/smoothing.py
deleted file mode 100644
index b3d5a51000..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/smoothing.py
+++ /dev/null
@@ -1,167 +0,0 @@
-"""Tiled ensemble - seam smoothing job."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from collections.abc import Generator
-from typing import Any
-
-import torch
-from tqdm import tqdm
-
-from anomalib.models.components import GaussianBlur2d
-from anomalib.pipelines.components import Job, JobGenerator
-from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS
-
-from .utils.ensemble_tiling import EnsembleTiler
-from .utils.helper_functions import get_ensemble_tiler
-
-logger = logging.getLogger(__name__)
-
-
-class SmoothingJob(Job):
-    """Job for smoothing the area around the tile seam.
-
-    Args:
-        accelerator (str): Accelerator used for processing.
-        predictions (list[Any]): List of image-level predictions.
-        width_factor (float):  Factor multiplied by tile dimension to get the region around seam which will be smoothed.
-        filter_sigma (float): Sigma of filter used for smoothing the seams.
-        tiler (EnsembleTiler): Tiler object used to get tile dimension data.
-    """
-
-    name = "SeamSmoothing"
-
-    def __init__(
-        self,
-        accelerator: str,
-        predictions: list[Any],
-        width_factor: float,
-        filter_sigma: float,
-        tiler: EnsembleTiler,
-    ) -> None:
-        super().__init__()
-        self.accelerator = accelerator
-        self.predictions = predictions
-
-        # offset in pixels of region around tile seam that will be smoothed
-        self.height_offset = int(tiler.tile_size_h * width_factor)
-        self.width_offset = int(tiler.tile_size_w * width_factor)
-        self.tiler = tiler
-
-        self.seam_mask = self.prepare_seam_mask()
-
-        self.blur = GaussianBlur2d(sigma=filter_sigma)
-
-    def prepare_seam_mask(self) -> torch.Tensor:
-        """Prepare boolean mask of regions around the part where tiles seam in ensemble.
-
-        Returns:
-            torch.Tensor: Representation of boolean mask where filtered seams should be used.
-        """
-        img_h, img_w = self.tiler.image_size
-        stride_h, stride_w = self.tiler.stride_h, self.tiler.stride_w
-
-        mask = torch.zeros(img_h, img_w, dtype=torch.bool)
-
-        # prepare mask strip on vertical seams
-        curr_w = stride_w
-        while curr_w < img_w:
-            start_i = curr_w - self.width_offset
-            end_i = curr_w + self.width_offset
-            mask[:, start_i:end_i] = 1
-            curr_w += stride_w
-
-        # prepare mask strip on horizontal seams
-        curr_h = stride_h
-        while curr_h < img_h:
-            start_i = curr_h - self.height_offset
-            end_i = curr_h + self.height_offset
-            mask[start_i:end_i, :] = True
-            curr_h += stride_h
-
-        return mask
-
-    def run(self, task_id: int | None = None) -> list[Any]:
-        """Run smoothing job.
-
-        Args:
-            task_id: Not used in this case.
-
-        Returns:
-            list[Any]: List of predictions.
-        """
-        del task_id  # not needed here
-
-        logger.info("Starting seam smoothing.")
-
-        for data in tqdm(self.predictions, desc="Seam smoothing"):
-            # move to specified accelerator for faster execution
-            data["anomaly_maps"] = data["anomaly_maps"].to(self.accelerator)
-            # smooth the anomaly map and take only region around seams delimited by seam_mask
-            smoothed = self.blur(data["anomaly_maps"])
-            data["anomaly_maps"][:, :, self.seam_mask] = smoothed[:, :, self.seam_mask]
-            data["anomaly_maps"] = data["anomaly_maps"].cpu()
-
-        return self.predictions
-
-    @staticmethod
-    def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS:
-        """Nothing to collect in this job.
-
-        Returns:
-            list[Any]: List of predictions.
-        """
-        # take the first element as result is list of lists here
-        return results[0]
-
-    @staticmethod
-    def save(results: GATHERED_RESULTS) -> None:
-        """Nothing to save in this job."""
-
-
-class SmoothingJobGenerator(JobGenerator):
-    """Generate SmoothingJob."""
-
-    def __init__(self, accelerator: str, tiling_args: dict, data_args: dict) -> None:
-        super().__init__()
-        self.accelerator = accelerator
-        self.tiling_args = tiling_args
-        self.data_args = data_args
-
-    @property
-    def job_class(self) -> type:
-        """Return the job class."""
-        return SmoothingJob
-
-    def generate_jobs(
-        self,
-        args: dict | None = None,
-        prev_stage_result: list[Any] | None = None,
-    ) -> Generator[SmoothingJob, None, None]:
-        """Return a generator producing a single seam smoothing job.
-
-        Args:
-            args: Tiled ensemble pipeline args.
-            prev_stage_result (list[Any]): Ensemble predictions from previous step.
-
-        Returns:
-            Generator[SmoothingJob, None, None]: SmoothingJob generator
-        """
-        if args is None:
-            msg = "SeamSmoothing job requires config args"
-            raise ValueError(msg)
-        # tiler is used to determine where seams appear
-        tiler = get_ensemble_tiler(self.tiling_args, self.data_args)
-        if prev_stage_result is not None:
-            yield SmoothingJob(
-                accelerator=self.accelerator,
-                predictions=prev_stage_result,
-                width_factor=args["width"],
-                filter_sigma=args["sigma"],
-                tiler=tiler,
-            )
-        else:
-            msg = "Join smoothing job requires tile level predictions from previous step."
-            raise ValueError(msg)
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/stats_calculation.py b/src/anomalib/pipelines/tiled_ensemble/components/stats_calculation.py
deleted file mode 100644
index 6c48b639f7..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/stats_calculation.py
+++ /dev/null
@@ -1,180 +0,0 @@
-"""Tiled ensemble - post-processing statistics calculation job."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-import logging
-from collections.abc import Generator
-from pathlib import Path
-from typing import Any
-
-import torch
-from omegaconf import DictConfig, ListConfig
-from torchmetrics import MetricCollection
-from tqdm import tqdm
-
-from anomalib.callbacks.thresholding import _ThresholdCallback
-from anomalib.metrics import MinMax
-from anomalib.metrics.threshold import Threshold
-from anomalib.pipelines.components import Job, JobGenerator
-from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS
-
-logger = logging.getLogger(__name__)
-
-
-class StatisticsJob(Job):
-    """Job for calculating min, max and threshold statistics for post-processing.
-
-    Args:
-        predictions (list[Any]): List of image-level predictions.
-        root_dir (Path): Root directory to save checkpoints, stats and images.
-    """
-
-    name = "Stats"
-
-    def __init__(
-        self,
-        predictions: list[Any] | None,
-        root_dir: Path,
-        image_threshold: Threshold,
-        pixel_threshold: Threshold,
-    ) -> None:
-        super().__init__()
-        self.predictions = predictions
-        self.root_dir = root_dir
-        self.image_threshold = image_threshold
-        self.pixel_threshold = pixel_threshold
-
-    def run(self, task_id: int | None = None) -> dict:
-        """Run job that calculates statistics needed in post-processing steps.
-
-        Args:
-            task_id: Not used in this case
-
-        Returns:
-            dict: Statistics dict with min, max and threshold values.
-        """
-        del task_id  # not needed here
-
-        minmax = MetricCollection(
-            {
-                "anomaly_maps": MinMax().cpu(),
-                "pred_scores": MinMax().cpu(),
-            },
-        )
-        pixel_update_called = False
-
-        logger.info("Starting post-processing statistics calculation.")
-
-        for data in tqdm(self.predictions, desc="Stats calculation"):
-            # update minmax
-            if "anomaly_maps" in data:
-                minmax["anomaly_maps"](data["anomaly_maps"])
-            if "pred_scores" in data:
-                minmax["pred_scores"](data["pred_scores"])
-
-            # update thresholds
-            self.image_threshold.update(data["pred_scores"], data["label"].int())
-            if "mask" in data and "anomaly_maps" in data:
-                self.pixel_threshold.update(torch.squeeze(data["anomaly_maps"]), torch.squeeze(data["mask"].int()))
-                pixel_update_called = True
-
-        self.image_threshold.compute()
-        if pixel_update_called:
-            self.pixel_threshold.compute()
-        else:
-            self.pixel_threshold.value = self.image_threshold.value
-
-        min_max_vals = {}
-        for pred_name, pred_metric in minmax.items():
-            min_max_vals[pred_name] = {
-                "min": pred_metric.min.item(),
-                "max": pred_metric.max.item(),
-            }
-
-        # return stats with save path that is later used to save statistics.
-        return {
-            "minmax": min_max_vals,
-            "image_threshold": self.image_threshold.value.item(),
-            "pixel_threshold": self.pixel_threshold.value.item(),
-            "save_path": (self.root_dir / "weights" / "lightning" / "stats.json"),
-        }
-
-    @staticmethod
-    def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS:
-        """Nothing to collect in this job.
-
-        Returns:
-            dict: statistics dictionary.
-        """
-        # take the first element as result is list of lists here
-        return results[0]
-
-    @staticmethod
-    def save(results: GATHERED_RESULTS) -> None:
-        """Save statistics to file system."""
-        # get and remove path from stats dict
-        stats_path: Path = results.pop("save_path")
-        stats_path.parent.mkdir(parents=True, exist_ok=True)
-
-        # save statistics next to weights
-        with stats_path.open("w", encoding="utf-8") as stats_file:
-            json.dump(results, stats_file, ensure_ascii=False, indent=4)
-
-
-class StatisticsJobGenerator(JobGenerator):
-    """Generate StatisticsJob.
-
-    Args:
-        root_dir (Path): Root directory where statistics file will be saved (in weights folder).
-    """
-
-    def __init__(
-        self,
-        root_dir: Path,
-        thresholding_method: DictConfig | str | ListConfig | list[dict[str, str | float]],
-    ) -> None:
-        self.root_dir = root_dir
-        self.threshold = thresholding_method
-
-    @property
-    def job_class(self) -> type:
-        """Return the job class."""
-        return StatisticsJob
-
-    def generate_jobs(
-        self,
-        args: dict | None = None,
-        prev_stage_result: list[Any] | None = None,
-    ) -> Generator[StatisticsJob, None, None]:
-        """Return a generator producing a single stats calculating job.
-
-        Args:
-            args: Not used here.
-            prev_stage_result (list[Any]): Ensemble predictions from previous step.
-
-        Returns:
-            Generator[StatisticsJob, None, None]: StatisticsJob generator.
-        """
-        del args  # not needed here
-
-        # get threshold class based config
-        if isinstance(self.threshold, str | DictConfig):
-            # single method provided
-            image_threshold = _ThresholdCallback._get_threshold_from_config(self.threshold)  # noqa: SLF001
-            pixel_threshold = image_threshold.clone()
-        elif isinstance(self.threshold, ListConfig | list):
-            # image and pixel method specified separately
-            image_threshold = _ThresholdCallback._get_threshold_from_config(self.threshold[0])  # noqa: SLF001
-            pixel_threshold = _ThresholdCallback._get_threshold_from_config(self.threshold[1])  # noqa: SLF001
-        else:
-            msg = f"Invalid threshold config {self.threshold}"
-            raise TypeError(msg)
-
-        yield StatisticsJob(
-            predictions=prev_stage_result,
-            root_dir=self.root_dir,
-            image_threshold=image_threshold,
-            pixel_threshold=pixel_threshold,
-        )
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/thresholding.py b/src/anomalib/pipelines/tiled_ensemble/components/thresholding.py
deleted file mode 100644
index 733c3d99db..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/thresholding.py
+++ /dev/null
@@ -1,114 +0,0 @@
-"""Tiled ensemble - thresholding job."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from collections.abc import Generator
-from pathlib import Path
-from typing import Any
-
-from tqdm import tqdm
-
-from anomalib.pipelines.components import Job, JobGenerator
-from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS
-
-from .utils import NormalizationStage
-from .utils.helper_functions import get_threshold_values
-
-logger = logging.getLogger(__name__)
-
-
-class ThresholdingJob(Job):
-    """Job used to threshold predictions, producing labels from scores.
-
-    Args:
-        predictions (list[Any]): List of predictions.
-        image_threshold (float): Threshold used for image-level thresholding.
-        pixel_threshold (float): Threshold used for pixel-level thresholding.
-    """
-
-    name = "Threshold"
-
-    def __init__(self, predictions: list[Any] | None, image_threshold: float, pixel_threshold: float) -> None:
-        super().__init__()
-        self.predictions = predictions
-        self.image_threshold = image_threshold
-        self.pixel_threshold = pixel_threshold
-
-    def run(self, task_id: int | None = None) -> list[Any] | None:
-        """Run job that produces prediction labels from scores.
-
-        Args:
-            task_id: Not used in this case.
-
-        Returns:
-            list[Any]: List of thresholded predictions.
-        """
-        del task_id  # not needed here
-
-        logger.info("Starting thresholding.")
-
-        for data in tqdm(self.predictions, desc="Thresholding"):
-            if "pred_scores" in data:
-                data["pred_labels"] = data["pred_scores"] >= self.image_threshold
-            if "anomaly_maps" in data:
-                data["pred_masks"] = data["anomaly_maps"] >= self.pixel_threshold
-
-        return self.predictions
-
-    @staticmethod
-    def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS:
-        """Nothing to collect in this job.
-
-        Returns:
-            list[Any]: List of predictions.
-        """
-        # take the first element as result is list of lists here
-        return results[0]
-
-    @staticmethod
-    def save(results: GATHERED_RESULTS) -> None:
-        """Nothing is saved in this job."""
-
-
-class ThresholdingJobGenerator(JobGenerator):
-    """Generate ThresholdingJob.
-
-    Args:
-        root_dir (Path): Root directory containing post-processing stats.
-    """
-
-    def __init__(self, root_dir: Path, normalization_stage: NormalizationStage) -> None:
-        self.root_dir = root_dir
-        self.normalization_stage = normalization_stage
-
-    @property
-    def job_class(self) -> type:
-        """Return the job class."""
-        return ThresholdingJob
-
-    def generate_jobs(
-        self,
-        args: dict | None = None,
-        prev_stage_result: list[Any] | None = None,
-    ) -> Generator[ThresholdingJob, None, None]:
-        """Return a generator producing a single thresholding job.
-
-        Args:
-            args: ensemble run args.
-            prev_stage_result (list[Any]): Ensemble predictions from previous step.
-
-        Returns:
-            Generator[ThresholdingJob, None, None]: ThresholdingJob generator.
-        """
-        del args  # args not used here
-
-        # get threshold values base on normalization
-        image_threshold, pixel_threshold = get_threshold_values(self.normalization_stage, self.root_dir)
-
-        yield ThresholdingJob(
-            predictions=prev_stage_result,
-            image_threshold=image_threshold,
-            pixel_threshold=pixel_threshold,
-        )
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/__init__.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/__init__.py
deleted file mode 100644
index a010208908..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/utils/__init__.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""Tiled ensemble utils and helper functions."""
-
-from enum import Enum
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-
-class NormalizationStage(str, Enum):
-    """Enum signaling at which stage the normalization is done.
-
-    In case of tile, tiles are normalized for each tile position separately.
-    In case of image, normalization is done at the end when images are joined back together.
-    In case of none, output is not normalized.
-    """
-
-    TILE = "tile"
-    IMAGE = "image"
-    NONE = "none"
-
-
-class ThresholdStage(str, Enum):
-    """Enum signaling at which stage the thresholding is applied.
-
-    In case of tile, thresholding is applied for each tile location separately.
-    In case of image, thresholding is applied at the end when images are joined back together.
-    """
-
-    TILE = "tile"
-    IMAGE = "image"
-
-
-class PredictData(Enum):
-    """Enum indicating which data to use in prediction job."""
-
-    VAL = "val"
-    TEST = "test"
-
-
-__all__ = [
-    "NormalizationStage",
-    "ThresholdStage",
-    "PredictData",
-]
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_engine.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_engine.py
deleted file mode 100644
index 449109ed3f..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_engine.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""Implements custom Anomalib engine for tiled ensemble training."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from pathlib import Path
-
-from lightning.pytorch.callbacks import Callback, RichModelSummary
-
-from anomalib.callbacks import ModelCheckpoint, TimerCallback
-from anomalib.callbacks.metrics import _MetricsCallback
-from anomalib.callbacks.normalization import get_normalization_callback
-from anomalib.callbacks.post_processor import _PostProcessorCallback
-from anomalib.callbacks.thresholding import _ThresholdCallback
-from anomalib.engine import Engine
-from anomalib.models import AnomalyModule
-from anomalib.utils.path import create_versioned_dir
-
-logger = logging.getLogger(__name__)
-
-
-class TiledEnsembleEngine(Engine):
-    """Engine used for training and evaluating tiled ensemble.
-
-    Most of the logic stays the same, but workspace creation and callbacks are adjusted for ensemble.
-
-    Args:
-        tile_index (tuple[int, int]): index of tile that this engine instance processes.
-        **kwargs: Engine arguments.
-    """
-
-    def __init__(self, tile_index: tuple[int, int], **kwargs) -> None:
-        self.tile_index = tile_index
-        super().__init__(**kwargs)
-
-    def _setup_workspace(self, *args, **kwargs) -> None:
-        """Skip since in case of tiled ensemble, workspace is only setup once at the beginning of training."""
-
-    @staticmethod
-    def setup_ensemble_workspace(args: dict, versioned_dir: bool = True) -> Path:
-        """Set up the workspace at the beginning of tiled ensemble training.
-
-        Args:
-            args (dict): Tiled ensemble config dict.
-            versioned_dir (bool, optional): Whether to create a versioned directory.
-                Defaults to ``True``.
-
-        Returns:
-            Path: path to new workspace root dir
-        """
-        model_name = args["TrainModels"]["model"]["class_path"].split(".")[-1]
-        dataset_name = args["data"]["class_path"].split(".")[-1]
-        category = args["data"]["init_args"]["category"]
-        root_dir = Path(args["default_root_dir"]) / model_name / dataset_name / category
-        return create_versioned_dir(root_dir) if versioned_dir else root_dir / "latest"
-
-    def _setup_anomalib_callbacks(self, model: AnomalyModule) -> None:
-        """Modified method to enable individual model training. It's called when Trainer is being set up."""
-        del model  # not used here
-
-        _callbacks: list[Callback] = [RichModelSummary()]
-
-        # Add ModelCheckpoint if it is not in the callbacks list.
-        has_checkpoint_callback = any(isinstance(c, ModelCheckpoint) for c in self._cache.args["callbacks"])
-        if not has_checkpoint_callback:
-            tile_i, tile_j = self.tile_index
-            _callbacks.append(
-                ModelCheckpoint(
-                    dirpath=self._cache.args["default_root_dir"] / "weights" / "lightning",
-                    filename=f"model{tile_i}_{tile_j}",
-                    auto_insert_metric_name=False,
-                ),
-            )
-
-        # Add the post-processor callbacks. Used for thresholding and label calculation.
-        _callbacks.append(_PostProcessorCallback())
-
-        # Add the  normalization callback if tile level normalization was specified (is not none).
-        normalization_callback = get_normalization_callback(self.normalization)
-        if normalization_callback is not None:
-            _callbacks.append(normalization_callback)
-
-        # Add the thresholding and metrics callbacks in all cases,
-        # because individual model might still need this for early stop.
-        _callbacks.append(_ThresholdCallback(self.threshold))
-        _callbacks.append(_MetricsCallback(self.task, self.image_metric_names, self.pixel_metric_names))
-
-        _callbacks.append(TimerCallback())
-
-        # Combine the callbacks, and update the trainer callbacks.
-        self._cache.args["callbacks"] = _callbacks + self._cache.args["callbacks"]
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_tiling.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_tiling.py
deleted file mode 100644
index db56f88b47..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/utils/ensemble_tiling.py
+++ /dev/null
@@ -1,147 +0,0 @@
-"""Tiler used with ensemble of models."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from collections.abc import Sequence
-from typing import Any
-
-from torch import Tensor
-
-from anomalib.data.base.datamodule import collate_fn
-from anomalib.data.utils.tiler import Tiler, compute_new_image_size
-
-
-class EnsembleTiler(Tiler):
-    """Tile Image into (non)overlapping Patches which are then used for ensemble training.
-
-    Args:
-        tile_size (int | Sequence): Tile dimension for each patch.
-        stride (int | Sequence): Stride length between patches.
-        image_size (int | Sequence): Size of input image that will be tiled.
-
-    Examples:
-        >>> import torch
-        >>> tiler = EnsembleTiler(tile_size=256, stride=128, image_size=512)
-        >>>
-        >>> # random images, shape:  [B, C, H, W]
-        >>> images = torch.rand(32, 5, 512, 512)
-        >>> # once tiled, the shape is [tile_count_H, tile_count_W, B, C, tile_H, tile_W]
-        >>> tiled = tiler.tile(images)
-        >>> tiled.shape
-        torch.Size([3, 3, 32, 5, 256, 256])
-
-        >>> # assemble the tiles back together
-        >>> untiled = tiler.untile(tiled)
-        >>> untiled.shape
-        torch.Size([32, 5, 512, 512])
-    """
-
-    def __init__(self, tile_size: int | Sequence, stride: int | Sequence, image_size: int | Sequence) -> None:
-        super().__init__(
-            tile_size=tile_size,
-            stride=stride,
-        )
-
-        # calculate final image size
-        self.image_size = self.validate_size_type(image_size)
-        self.input_h, self.input_w = self.image_size
-        self.resized_h, self.resized_w = compute_new_image_size(
-            image_size=(self.input_h, self.input_w),
-            tile_size=(self.tile_size_h, self.tile_size_w),
-            stride=(self.stride_h, self.stride_w),
-        )
-
-        # get number of patches in both dimensions
-        self.num_patches_h = int((self.resized_h - self.tile_size_h) / self.stride_h) + 1
-        self.num_patches_w = int((self.resized_w - self.tile_size_w) / self.stride_w) + 1
-        self.num_tiles = self.num_patches_h * self.num_patches_w
-
-    def tile(self, image: Tensor, use_random_tiling: bool = False) -> Tensor:
-        """Tiles an input image to either overlapping or non-overlapping patches.
-
-        Args:
-            image (Tensor): Input images.
-            use_random_tiling (bool): Random tiling, which is part of original tiler but is unused here.
-
-        Returns:
-            Tensor: Tiles generated from images.
-                Returned shape: [num_h, num_w, batch, channel, tile_height, tile_width].
-        """
-        # tiles are returned in order [tile_count * batch, channels, tile_height, tile_width]
-        combined_tiles = super().tile(image, use_random_tiling)
-
-        # rearrange to [num_h, num_w, batch, channel, tile_height, tile_width]
-        tiles = combined_tiles.contiguous().view(
-            self.batch_size,
-            self.num_patches_h,
-            self.num_patches_w,
-            self.num_channels,
-            self.tile_size_h,
-            self.tile_size_w,
-        )
-        tiles = tiles.permute(1, 2, 0, 3, 4, 5)
-
-        return tiles  # noqa: RET504
-
-    def untile(self, tiles: Tensor) -> Tensor:
-        """Reassemble the tiled tensor into image level representation.
-
-        Args:
-            tiles (Tensor): Tiles in shape: [num_h, num_w, batch, channel, tile_height, tile_width].
-
-        Returns:
-            Tensor: Image constructed from input tiles. Shape: [B, C, H, W].
-        """
-        # tiles have shape [num_h, num_w, batch, channel, tile_height, tile_width]
-        _, _, batch, channels, tile_size_h, tile_size_w = tiles.shape
-
-        # set tilers batch size as it might have been changed by previous tiling
-        self.batch_size = batch
-
-        # rearrange the tiles in order [tile_count * batch, channels, tile_height, tile_width]
-        # the required shape for untiling
-        tiles = tiles.permute(2, 0, 1, 3, 4, 5)
-        tiles = tiles.contiguous().view(-1, channels, tile_size_h, tile_size_w)
-
-        untiled = super().untile(tiles)
-
-        return untiled  # noqa: RET504
-
-
-class TileCollater:
-    """Class serving as collate function to perform tiling on batch of images from Dataloader.
-
-    Args:
-        tiler (EnsembleTiler): Tiler used to split the images to tiles.
-        tile_index (tuple[int, int]): Index of tile we want to return.
-    """
-
-    def __init__(self, tiler: EnsembleTiler, tile_index: tuple[int, int]) -> None:
-        self.tiler = tiler
-        self.tile_index = tile_index
-
-    def __call__(self, batch: list) -> dict[str, Any]:
-        """Collate batch and tile images + masks from batch.
-
-        Args:
-            batch (list): Batch of elements from data, also including images.
-
-        Returns:
-            dict[str, Any]: Collated batch dictionary with tiled images.
-        """
-        # use default collate
-        coll_batch = collate_fn(batch)
-
-        tiled_images = self.tiler.tile(coll_batch["image"])
-        # return only tiles at given index
-        coll_batch["image"] = tiled_images[self.tile_index]
-
-        if "mask" in coll_batch:
-            # insert channel (as mask has just one)
-            tiled_masks = self.tiler.tile(coll_batch["mask"].unsqueeze(1))
-
-            # return only tiled at given index, squeeze to remove previously added channel
-            coll_batch["mask"] = tiled_masks[self.tile_index].squeeze(1)
-
-        return coll_batch
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/helper_functions.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/helper_functions.py
deleted file mode 100644
index bc1e5f4f55..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/utils/helper_functions.py
+++ /dev/null
@@ -1,179 +0,0 @@
-"""Helper functions for the tiled ensemble training."""
-
-import json
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-from pathlib import Path
-
-from jsonargparse import ArgumentParser, Namespace
-from lightning import Trainer
-
-from anomalib.data import AnomalibDataModule, get_datamodule
-from anomalib.models import AnomalyModule, get_model
-from anomalib.utils.normalization import NormalizationMethod
-
-from . import NormalizationStage
-from .ensemble_engine import TiledEnsembleEngine
-from .ensemble_tiling import EnsembleTiler, TileCollater
-
-
-def get_ensemble_datamodule(data_args: dict, tiler: EnsembleTiler, tile_index: tuple[int, int]) -> AnomalibDataModule:
-    """Get Anomaly Datamodule adjusted for use in ensemble.
-
-    Datamodule collate function gets replaced by TileCollater in order to tile all images before they are passed on.
-
-    Args:
-        data_args: tiled ensemble data configuration.
-        tiler (EnsembleTiler): Tiler used to split the images to tiles for use in ensemble.
-        tile_index (tuple[int, int]): Index of the tile in the split image.
-
-    Returns:
-        AnomalibDataModule: Anomalib Lightning DataModule
-    """
-    datamodule = get_datamodule(data_args)
-    # set custom collate function that does the tiling
-    datamodule.collate_fn = TileCollater(tiler, tile_index)
-    datamodule.setup()
-
-    return datamodule
-
-
-def get_ensemble_model(model_args: dict, tiler: EnsembleTiler) -> AnomalyModule:
-    """Get model prepared for ensemble training.
-
-    Args:
-        model_args: tiled ensemble model configuration.
-        tiler (EnsembleTiler): tiler used to get tile dimensions.
-
-    Returns:
-        AnomalyModule: model with input_size setup
-    """
-    model = get_model(model_args)
-    # set model input size match tile size
-    model.set_input_size((tiler.tile_size_h, tiler.tile_size_w))
-
-    return model
-
-
-def get_ensemble_tiler(tiling_args: dict, data_args: dict) -> EnsembleTiler:
-    """Get tiler used for image tiling and to obtain tile dimensions.
-
-    Args:
-        tiling_args: tiled ensemble tiling configuration.
-        data_args: tiled ensemble data configuration.
-
-    Returns:
-        EnsembleTiler: tiler object.
-    """
-    tiler = EnsembleTiler(
-        tile_size=tiling_args["tile_size"],
-        stride=tiling_args["stride"],
-        image_size=data_args["init_args"]["image_size"],
-    )
-
-    return tiler  # noqa: RET504
-
-
-def parse_trainer_kwargs(trainer_args: dict | None) -> Namespace | dict:
-    """Parse trainer args and instantiate all needed elements.
-
-    Transforms config into kwargs ready for Trainer, including instantiation of callback etc.
-
-    Args:
-        trainer_args (dict): Trainer args dictionary.
-
-    Returns:
-        dict: parsed kwargs with instantiated elements.
-    """
-    if not trainer_args:
-        return {}
-
-    # try to get trainer args, if not present return empty
-    parser = ArgumentParser()
-
-    parser.add_class_arguments(Trainer, fail_untyped=False, instantiate=False, sub_configs=True)
-    config = parser.parse_object(trainer_args)
-    objects = parser.instantiate_classes(config)
-
-    return objects  # noqa: RET504
-
-
-def get_ensemble_engine(
-    tile_index: tuple[int, int],
-    accelerator: str,
-    devices: list[int] | str | int,
-    root_dir: Path,
-    normalization_stage: str,
-    metrics: dict | None = None,
-    trainer_args: dict | None = None,
-) -> TiledEnsembleEngine:
-    """Prepare engine for ensemble training or prediction.
-
-    This method makes sure correct normalization is used, prepares metrics and additional trainer kwargs..
-
-    Args:
-        tile_index (tuple[int, int]): Index of tile that this model processes.
-        accelerator (str): Accelerator (device) to use.
-        devices (list[int] | str | int): device IDs used for training.
-        root_dir (Path): Root directory to save checkpoints, stats and images.
-        normalization_stage (str): Config dictionary for ensemble post-processing.
-        metrics (dict): Dict containing pixel and image metrics names.
-        trainer_args (dict): Trainer args dictionary. Empty dict if not present.
-
-    Returns:
-        TiledEnsembleEngine: set up engine for ensemble training/prediction.
-    """
-    # if we want tile level normalization we set it here, otherwise it's done later on joined images
-    if normalization_stage == NormalizationStage.TILE:
-        normalization = NormalizationMethod.MIN_MAX
-    else:
-        normalization = NormalizationMethod.NONE
-
-    # parse additional trainer args and callbacks if present in config
-    trainer_kwargs = parse_trainer_kwargs(trainer_args)
-    # remove keys that we already have
-    trainer_kwargs.pop("accelerator", None)
-    trainer_kwargs.pop("default_root_dir", None)
-    trainer_kwargs.pop("devices", None)
-
-    # create engine for specific tile location
-    engine = TiledEnsembleEngine(
-        tile_index=tile_index,
-        normalization=normalization,
-        accelerator=accelerator,
-        devices=devices,
-        default_root_dir=root_dir,
-        image_metrics=metrics.get("image", None) if metrics else None,
-        pixel_metrics=metrics.get("pixel", None) if metrics else None,
-        **trainer_kwargs,
-    )
-
-    return engine  # noqa: RET504
-
-
-def get_threshold_values(normalization_stage: NormalizationStage, root_dir: Path) -> tuple[float, float]:
-    """Get threshold values for image and pixel level predictions.
-
-    If normalization is not used, get values based on statistics obtained from validation set.
-    If normalization is used, both image and pixel threshold are 0.5
-
-    Args:
-        normalization_stage (NormalizationStage): ensemble run args, used to get normalization stage.
-        root_dir (Path): path to run root where stats file is saved.
-
-    Returns:
-        tuple[float, float]: image and pixel threshold.
-    """
-    if normalization_stage == NormalizationStage.NONE:
-        stats_path = root_dir / "weights" / "lightning" / "stats.json"
-        with stats_path.open("r") as f:
-            stats = json.load(f)
-        image_threshold = stats["image_threshold"]
-        pixel_threshold = stats["pixel_threshold"]
-    else:
-        # normalization transforms the scores so that threshold is at 0.5
-        image_threshold = 0.5
-        pixel_threshold = 0.5
-
-    return image_threshold, pixel_threshold
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_data.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_data.py
deleted file mode 100644
index 4fe45e9c4a..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_data.py
+++ /dev/null
@@ -1,45 +0,0 @@
-"""Classes used to store ensemble predictions."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from torch import Tensor
-
-
-class EnsemblePredictions:
-    """Basic implementation of EnsemblePredictionData that keeps all predictions in main memory."""
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.all_data: dict[tuple[int, int], list] = {}
-
-    def add_tile_prediction(self, tile_index: tuple[int, int], tile_prediction: list[dict[str, Tensor | list]]) -> None:
-        """Add tile prediction data at provided index to class dictionary in main memory.
-
-        Args:
-            tile_index (tuple[int, int]): Index of tile that we are adding in form (row, column).
-            tile_prediction (list[dict[str, Tensor | list]]):
-                List of batches containing all predicted data for current tile position.
-
-        """
-        self.num_batches = len(tile_prediction)
-
-        self.all_data[tile_index] = tile_prediction
-
-    def get_batch_tiles(self, batch_index: int) -> dict[tuple[int, int], dict]:
-        """Get all tiles of current batch from class dictionary.
-
-        Called by merging mechanism.
-
-        Args:
-            batch_index (int): Index of current batch of tiles to be returned.
-
-        Returns:
-            dict[tuple[int, int], dict]: Dictionary mapping tile index to predicted data, for provided batch index.
-        """
-        batch_data = {}
-
-        for index, batches in self.all_data.items():
-            batch_data[index] = batches[batch_index]
-
-        return batch_data
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_merging.py b/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_merging.py
deleted file mode 100644
index 7337cc4ffe..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/utils/prediction_merging.py
+++ /dev/null
@@ -1,167 +0,0 @@
-"""Class used as mechanism to merge ensemble predictions from each tile into complete whole-image representation."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import torch
-from torch import Tensor
-
-from .ensemble_tiling import EnsembleTiler
-from .prediction_data import EnsemblePredictions
-
-
-class PredictionMergingMechanism:
-    """Class used for merging the data predicted by each separate model of tiled ensemble.
-
-    Tiles are stacked in one tensor and untiled using Ensemble Tiler.
-    Boxes from tiles are either stacked or generated anew from anomaly map.
-    Labels are combined with OR operator, meaning one anomalous tile -> anomalous image.
-    Scores are averaged across all tiles.
-
-    Args:
-        ensemble_predictions (EnsemblePredictions): Object containing predictions on tile level.
-        tiler (EnsembleTiler): Tiler used to transform tiles back to image level representation.
-
-    Example:
-        >>> from anomalib.pipelines.tiled_ensemble.components.utils.ensemble_tiling import EnsembleTiler
-        >>> from anomalib.pipelines.tiled_ensemble.components.utils.prediction_data import EnsemblePredictions
-        >>>
-        >>> tiler = EnsembleTiler(tile_size=256, stride=128, image_size=512)
-        >>> data = EnsemblePredictions()
-        >>> merger = PredictionMergingMechanism(data, tiler)
-        >>>
-        >>> # we can then start merging procedure for each batch
-        >>> merger.merge_tile_predictions(0)
-    """
-
-    def __init__(self, ensemble_predictions: EnsemblePredictions, tiler: EnsembleTiler) -> None:
-        assert ensemble_predictions.num_batches > 0, "There should be at least one batch for each tile prediction."
-        assert (0, 0) in ensemble_predictions.get_batch_tiles(
-            0,
-        ), "Tile prediction dictionary should always have at least one tile"
-
-        self.ensemble_predictions = ensemble_predictions
-        self.num_batches = self.ensemble_predictions.num_batches
-
-        self.tiler = tiler
-
-    def merge_tiles(self, batch_data: dict, tile_key: str) -> Tensor:
-        """Merge tiles back into one tensor and perform untiling with tiler.
-
-        Args:
-            batch_data (dict): Dictionary containing all tile predictions of current batch.
-            tile_key (str): Key used in prediction dictionary for tiles that we want to merge.
-
-        Returns:
-            Tensor: Tensor of tiles in original (stitched) shape.
-        """
-        # batch of tiles with index (0, 0) always exists, so we use it to get some basic information
-        first_tiles = batch_data[0, 0][tile_key]
-        batch_size = first_tiles.shape[0]
-        device = first_tiles.device
-
-        if tile_key == "mask":
-            # in case of ground truth masks, we don't have channels
-            merged_size = [
-                self.tiler.num_patches_h,
-                self.tiler.num_patches_w,
-                batch_size,
-                self.tiler.tile_size_h,
-                self.tiler.tile_size_w,
-            ]
-        else:
-            # all tiles beside masks also have channels
-            num_channels = first_tiles.shape[1]
-            merged_size = [
-                self.tiler.num_patches_h,
-                self.tiler.num_patches_w,
-                batch_size,
-                int(num_channels),
-                self.tiler.tile_size_h,
-                self.tiler.tile_size_w,
-            ]
-
-        # create new empty tensor for merged tiles
-        merged_masks = torch.zeros(size=merged_size, device=device)
-
-        # insert tile into merged tensor at right locations
-        for (tile_i, tile_j), tile_data in batch_data.items():
-            merged_masks[tile_i, tile_j, ...] = tile_data[tile_key]
-
-        if tile_key == "mask":
-            # add channel as tiler needs it
-            merged_masks = merged_masks.unsqueeze(3)
-
-        # stitch tiles back into whole, output is [B, C, H, W]
-        merged_output = self.tiler.untile(merged_masks)
-
-        if tile_key == "mask":
-            # remove previously added channels
-            merged_output = merged_output.squeeze(1)
-
-        return merged_output
-
-    def merge_labels_and_scores(self, batch_data: dict) -> dict[str, Tensor]:
-        """Join scores and their corresponding label predictions from all tiles for each image.
-
-        Label merging is done by rule where one anomalous tile in image results in whole image being anomalous.
-        Scores are averaged over tiles.
-
-        Args:
-            batch_data (dict): Dictionary containing all tile predictions of current batch.
-
-        Returns:
-            dict[str, Tensor]: Dictionary with "pred_labels" and "pred_scores"
-        """
-        # create accumulator with same shape as original
-        labels = torch.zeros(batch_data[0, 0]["pred_labels"].shape, dtype=torch.bool)
-        scores = torch.zeros(batch_data[0, 0]["pred_scores"].shape)
-
-        for curr_tile_data in batch_data.values():
-            curr_labels = curr_tile_data["pred_labels"]
-            curr_scores = curr_tile_data["pred_scores"]
-
-            labels = labels.logical_or(curr_labels)
-            scores += curr_scores
-
-        scores /= self.tiler.num_tiles
-
-        return {"pred_labels": labels, "pred_scores": scores}
-
-    def merge_tile_predictions(self, batch_index: int) -> dict[str, Tensor | list]:
-        """Join predictions from ensemble into whole image level representation for batch at index batch_index.
-
-        Args:
-            batch_index (int): Index of current batch.
-
-        Returns:
-            dict[str, Tensor | list]: List of merged predictions for specified batch.
-        """
-        current_batch_data = self.ensemble_predictions.get_batch_tiles(batch_index)
-
-        # take first tile as base prediction, keep items that are the same over all tiles:
-        # image_path, label, mask_path
-        merged_predictions = {
-            "image_path": current_batch_data[0, 0]["image_path"],
-            "label": current_batch_data[0, 0]["label"],
-        }
-        if "mask_path" in current_batch_data[0, 0]:
-            merged_predictions["mask_path"] = current_batch_data[0, 0]["mask_path"]
-        if "boxes" in current_batch_data[0, 0]:
-            merged_predictions["boxes"] = current_batch_data[0, 0]["boxes"]
-
-        tiled_data = ["image", "mask"]
-        if "anomaly_maps" in current_batch_data[0, 0]:
-            tiled_data += ["anomaly_maps", "pred_masks"]
-
-        # merge all tiled data
-        for t_key in tiled_data:
-            if t_key in current_batch_data[0, 0]:
-                merged_predictions[t_key] = self.merge_tiles(current_batch_data, t_key)
-
-        # label and score merging
-        merged_scores_and_labels = self.merge_labels_and_scores(current_batch_data)
-        merged_predictions["pred_labels"] = merged_scores_and_labels["pred_labels"]
-        merged_predictions["pred_scores"] = merged_scores_and_labels["pred_scores"]
-
-        return merged_predictions
diff --git a/src/anomalib/pipelines/tiled_ensemble/components/visualization.py b/src/anomalib/pipelines/tiled_ensemble/components/visualization.py
deleted file mode 100644
index 1298ece89f..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/components/visualization.py
+++ /dev/null
@@ -1,125 +0,0 @@
-"""Tiled ensemble - visualization job."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from collections.abc import Generator
-from pathlib import Path
-from typing import Any
-
-from tqdm import tqdm
-
-from anomalib import TaskType
-from anomalib.data.utils.image import save_image
-from anomalib.pipelines.components import Job, JobGenerator
-from anomalib.pipelines.tiled_ensemble.components.utils import NormalizationStage
-from anomalib.pipelines.types import GATHERED_RESULTS, RUN_RESULTS
-from anomalib.utils.visualization import ImageVisualizer
-
-logger = logging.getLogger(__name__)
-
-
-class VisualizationJob(Job):
-    """Job for visualization of predictions.
-
-    Args:
-        predictions (list[Any]): list of image-level predictions.
-        root_dir (Path): Root directory to save checkpoints, stats and images.
-        task (TaskType): type of task the predictions represent.
-        normalize (bool): if predictions need to be normalized
-    """
-
-    name = "Visualize"
-
-    def __init__(self, predictions: list[Any], root_dir: Path, task: TaskType, normalize: bool) -> None:
-        super().__init__()
-        self.predictions = predictions
-        self.root_dir = root_dir / "images"
-        self.task = task
-        self.normalize = normalize
-
-    def run(self, task_id: int | None = None) -> list[Any]:
-        """Run job that visualizes all prediction data.
-
-        Args:
-            task_id: Not used in this case.
-
-        Returns:
-            list[Any]: Unchanged predictions.
-        """
-        del task_id  # not needed here
-
-        visualizer = ImageVisualizer(task=self.task, normalize=self.normalize)
-
-        logger.info("Starting visualization.")
-
-        for data in tqdm(self.predictions, desc="Visualizing"):
-            for result in visualizer(outputs=data):
-                # Finally image path is root/defect_type/image_name
-                if result.file_name is not None:
-                    file_path = Path(result.file_name)
-                else:
-                    msg = "file_path should exist in returned Visualizer."
-                    raise ValueError(msg)
-
-                root = self.root_dir / file_path.parent.name
-                filename = file_path.name
-
-                save_image(image=result.image, root=root, filename=filename)
-
-        return self.predictions
-
-    @staticmethod
-    def collect(results: list[RUN_RESULTS]) -> GATHERED_RESULTS:
-        """Nothing to collect in this job.
-
-        Returns:
-            list[Any]: Unchanged list of predictions.
-        """
-        # take the first element as result is list of lists here
-        return results[0]
-
-    @staticmethod
-    def save(results: GATHERED_RESULTS) -> None:
-        """This job doesn't save anything."""
-
-
-class VisualizationJobGenerator(JobGenerator):
-    """Generate VisualizationJob.
-
-    Args:
-        root_dir (Path): Root directory where images will be saved (root/images).
-    """
-
-    def __init__(self, root_dir: Path, task: TaskType, normalization_stage: NormalizationStage) -> None:
-        self.root_dir = root_dir
-        self.task = task
-        self.normalize = normalization_stage == NormalizationStage.NONE
-
-    @property
-    def job_class(self) -> type:
-        """Return the job class."""
-        return VisualizationJob
-
-    def generate_jobs(
-        self,
-        args: dict | None = None,
-        prev_stage_result: list[Any] | None = None,
-    ) -> Generator[VisualizationJob, None, None]:
-        """Return a generator producing a single visualization job.
-
-        Args:
-            args: Ensemble run args.
-            prev_stage_result (list[Any]): Ensemble predictions from previous step.
-
-        Returns:
-            Generator[VisualizationJob, None, None]: VisualizationJob generator
-        """
-        del args  # args not used here
-
-        if prev_stage_result is not None:
-            yield VisualizationJob(prev_stage_result, self.root_dir, self.task, self.normalize)
-        else:
-            msg = "Visualization job requires tile level predictions from previous step."
-            raise ValueError(msg)
diff --git a/src/anomalib/pipelines/tiled_ensemble/test_pipeline.py b/src/anomalib/pipelines/tiled_ensemble/test_pipeline.py
deleted file mode 100644
index 7fdd61e9ff..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/test_pipeline.py
+++ /dev/null
@@ -1,124 +0,0 @@
-"""Tiled ensemble test pipeline."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-from pathlib import Path
-
-import torch
-
-from anomalib.data.utils import TestSplitMode
-from anomalib.pipelines.components.base import Pipeline, Runner
-from anomalib.pipelines.components.runners import ParallelRunner, SerialRunner
-from anomalib.pipelines.tiled_ensemble.components import (
-    MergeJobGenerator,
-    MetricsCalculationJobGenerator,
-    NormalizationJobGenerator,
-    PredictJobGenerator,
-    SmoothingJobGenerator,
-    ThresholdingJobGenerator,
-    VisualizationJobGenerator,
-)
-from anomalib.pipelines.tiled_ensemble.components.utils import NormalizationStage, PredictData, ThresholdStage
-
-logger = logging.getLogger(__name__)
-
-
-class EvalTiledEnsemble(Pipeline):
-    """Tiled ensemble evaluation pipeline.
-
-    Args:
-        root_dir (Path): Path to root dir of run that contains checkpoints.
-    """
-
-    def __init__(self, root_dir: Path) -> None:
-        self.root_dir = Path(root_dir)
-
-    def _setup_runners(self, args: dict) -> list[Runner]:
-        """Set up the runners for the pipeline.
-
-        This pipeline consists of jobs used to test/evaluate tiled ensemble:
-        Prediction on test data > merging of predictions > (optional) seam smoothing
-        > (optional) Normalization > (optional) Thresholding
-        > Visualisation of predictions > Metrics calculation.
-
-        Returns:
-            list[Runner]: List of runners executing tiled ensemble testing jobs.
-        """
-        runners: list[Runner] = []
-
-        if args["data"]["init_args"]["test_split_mode"] == TestSplitMode.NONE:
-            logger.info("Test split mode set to `none`, skipping test phase.")
-            return runners
-
-        seed = args["seed"]
-        accelerator = args["accelerator"]
-        tiling_args = args["tiling"]
-        data_args = args["data"]
-        normalization_stage = NormalizationStage(args["normalization_stage"])
-        threshold_stage = ThresholdStage(args["thresholding"]["stage"])
-        model_args = args["TrainModels"]["model"]
-        task = args["data"]["init_args"]["task"]
-        metrics = args["TrainModels"]["metrics"]
-
-        predict_job_generator = PredictJobGenerator(
-            PredictData.TEST,
-            seed=seed,
-            accelerator=accelerator,
-            root_dir=self.root_dir,
-            tiling_args=tiling_args,
-            data_args=data_args,
-            model_args=model_args,
-            normalization_stage=normalization_stage,
-        )
-        # 1. predict using test data
-        if accelerator == "cuda":
-            runners.append(
-                ParallelRunner(
-                    predict_job_generator,
-                    n_jobs=torch.cuda.device_count(),
-                ),
-            )
-        else:
-            runners.append(
-                SerialRunner(
-                    predict_job_generator,
-                ),
-            )
-        # 2. merge predictions
-        runners.append(SerialRunner(MergeJobGenerator(tiling_args=tiling_args, data_args=data_args)))
-
-        # 3. (optional) smooth seams
-        if args["SeamSmoothing"]["apply"]:
-            runners.append(
-                SerialRunner(
-                    SmoothingJobGenerator(accelerator=accelerator, tiling_args=tiling_args, data_args=data_args),
-                ),
-            )
-
-        # 4. (optional) normalize
-        if normalization_stage == NormalizationStage.IMAGE:
-            runners.append(SerialRunner(NormalizationJobGenerator(self.root_dir)))
-        # 5. (optional) threshold to get labels from scores
-        if threshold_stage == ThresholdStage.IMAGE:
-            runners.append(SerialRunner(ThresholdingJobGenerator(self.root_dir, normalization_stage)))
-
-        # 6. visualize predictions
-        runners.append(
-            SerialRunner(VisualizationJobGenerator(self.root_dir, task=task, normalization_stage=normalization_stage)),
-        )
-        # calculate metrics
-        runners.append(
-            SerialRunner(
-                MetricsCalculationJobGenerator(
-                    accelerator=accelerator,
-                    root_dir=self.root_dir,
-                    task=task,
-                    metrics=metrics,
-                    normalization_stage=normalization_stage,
-                ),
-            ),
-        )
-
-        return runners
diff --git a/src/anomalib/pipelines/tiled_ensemble/train_pipeline.py b/src/anomalib/pipelines/tiled_ensemble/train_pipeline.py
deleted file mode 100644
index 38e4e34e4b..0000000000
--- a/src/anomalib/pipelines/tiled_ensemble/train_pipeline.py
+++ /dev/null
@@ -1,123 +0,0 @@
-"""Tiled ensemble training pipeline."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from typing import TYPE_CHECKING
-
-from anomalib.data.utils import ValSplitMode
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-import logging
-
-import torch
-
-from anomalib.pipelines.components.base import Pipeline, Runner
-from anomalib.pipelines.components.runners import ParallelRunner, SerialRunner
-
-from .components import (
-    MergeJobGenerator,
-    PredictJobGenerator,
-    SmoothingJobGenerator,
-    StatisticsJobGenerator,
-    TrainModelJobGenerator,
-)
-from .components.utils import NormalizationStage, PredictData
-from .components.utils.ensemble_engine import TiledEnsembleEngine
-
-logger = logging.getLogger(__name__)
-
-
-class TrainTiledEnsemble(Pipeline):
-    """Tiled ensemble training pipeline."""
-
-    def __init__(self) -> None:
-        self.root_dir: Path
-
-    def _setup_runners(self, args: dict) -> list[Runner]:
-        """Setup the runners for the pipeline.
-
-        This pipeline consists of training and validation steps:
-        Training models > prediction on val data > merging val data >
-        > (optionally) smoothing seams > calculation of post-processing statistics
-
-        Returns:
-            list[Runner]: List of runners executing tiled ensemble train + val jobs.
-        """
-        runners: list[Runner] = []
-        self.root_dir = TiledEnsembleEngine.setup_ensemble_workspace(args)
-
-        seed = args["seed"]
-        accelerator = args["accelerator"]
-        tiling_args = args["tiling"]
-        data_args = args["data"]
-        normalization_stage = NormalizationStage(args["normalization_stage"])
-        thresholding_method = args["thresholding"]["method"]
-        model_args = args["TrainModels"]["model"]
-
-        train_job_generator = TrainModelJobGenerator(
-            seed=seed,
-            accelerator=accelerator,
-            root_dir=self.root_dir,
-            tiling_args=tiling_args,
-            data_args=data_args,
-            normalization_stage=normalization_stage,
-        )
-
-        predict_job_generator = PredictJobGenerator(
-            data_source=PredictData.VAL,
-            seed=seed,
-            accelerator=accelerator,
-            root_dir=self.root_dir,
-            tiling_args=tiling_args,
-            data_args=data_args,
-            model_args=model_args,
-            normalization_stage=normalization_stage,
-        )
-
-        # 1. train
-        if accelerator == "cuda":
-            runners.append(
-                ParallelRunner(
-                    train_job_generator,
-                    n_jobs=torch.cuda.device_count(),
-                ),
-            )
-        else:
-            runners.append(
-                SerialRunner(
-                    train_job_generator,
-                ),
-            )
-
-        if data_args["init_args"]["val_split_mode"] == ValSplitMode.NONE:
-            logger.warning("No validation set provided, skipping statistics calculation.")
-            return runners
-
-        # 2. predict using validation data
-        if accelerator == "cuda":
-            runners.append(
-                ParallelRunner(predict_job_generator, n_jobs=torch.cuda.device_count()),
-            )
-        else:
-            runners.append(
-                SerialRunner(predict_job_generator),
-            )
-
-        # 3. merge predictions
-        runners.append(SerialRunner(MergeJobGenerator(tiling_args=tiling_args, data_args=data_args)))
-
-        # 4. (optional) smooth seams
-        if args["SeamSmoothing"]["apply"]:
-            runners.append(
-                SerialRunner(
-                    SmoothingJobGenerator(accelerator=accelerator, tiling_args=tiling_args, data_args=data_args),
-                ),
-            )
-
-        # 5. calculate statistics used for inference
-        runners.append(SerialRunner(StatisticsJobGenerator(self.root_dir, thresholding_method)))
-
-        return runners
diff --git a/tests/integration/pipelines/test_tiled_ensemble.py b/tests/integration/pipelines/test_tiled_ensemble.py
deleted file mode 100644
index 2909311276..0000000000
--- a/tests/integration/pipelines/test_tiled_ensemble.py
+++ /dev/null
@@ -1,62 +0,0 @@
-"""Test tiled ensemble training and prediction."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from pathlib import Path
-
-import pytest
-import yaml
-
-from anomalib.pipelines.tiled_ensemble import EvalTiledEnsemble, TrainTiledEnsemble
-
-
-@pytest.fixture(scope="session")
-def get_mock_environment(dataset_path: Path, project_path: Path) -> Path:
-    """Return mock directory for testing with datapath setup to dummy data."""
-    ens_temp_dir = project_path / "ens_tmp"
-    ens_temp_dir.mkdir(exist_ok=True)
-
-    with Path("tests/integration/pipelines/tiled_ensemble.yaml").open(encoding="utf-8") as file:
-        config = yaml.safe_load(file)
-
-    # use separate project temp dir to avoid messing with other tests
-    config["default_root_dir"] = str(ens_temp_dir)
-    config["data"]["init_args"]["root"] = str(dataset_path / "mvtec")
-
-    with (Path(ens_temp_dir) / "tiled_ensemble.yaml").open("w", encoding="utf-8") as file:
-        yaml.safe_dump(config, file)
-
-    return Path(ens_temp_dir)
-
-
-def test_train(get_mock_environment: Path, capsys: pytest.CaptureFixture) -> None:
-    """Test training of the tiled ensemble."""
-    train_pipeline = TrainTiledEnsemble()
-    train_parser = train_pipeline.get_parser()
-    args = train_parser.parse_args(["--config", str(get_mock_environment / "tiled_ensemble.yaml")])
-    train_pipeline.run(args)
-    # check that no errors were printed -> all stages were successful
-    out = capsys.readouterr().out
-    assert not any(line.startswith("There were some errors") for line in out.split("\n"))
-
-
-def test_predict(get_mock_environment: Path, capsys: pytest.CaptureFixture) -> None:
-    """Test prediction with the tiled ensemble."""
-    predict_pipeline = EvalTiledEnsemble(root_dir=get_mock_environment / "Padim" / "MVTec" / "dummy" / "v0")
-    predict_parser = predict_pipeline.get_parser()
-    args = predict_parser.parse_args(["--config", str(get_mock_environment / "tiled_ensemble.yaml")])
-    predict_pipeline.run(args)
-    # check that no errors were printed -> all stages were successful
-    out = capsys.readouterr().out
-    assert not any(line.startswith("There were some errors") for line in out.split("\n"))
-
-
-def test_visualisation(get_mock_environment: Path) -> None:
-    """Test that images were produced."""
-    assert (get_mock_environment / "Padim/MVTec/dummy/v0/images/bad/000.png").exists()
-
-
-def test_metric_results(get_mock_environment: Path) -> None:
-    """Test that metrics were saved."""
-    assert (get_mock_environment / "Padim/MVTec/dummy/v0/metric_results.csv").exists()
diff --git a/tests/integration/pipelines/tiled_ensemble.yaml b/tests/integration/pipelines/tiled_ensemble.yaml
deleted file mode 100644
index 8d35be8297..0000000000
--- a/tests/integration/pipelines/tiled_ensemble.yaml
+++ /dev/null
@@ -1,43 +0,0 @@
-seed: 42
-accelerator: "cpu"
-default_root_dir: "results"
-
-tiling:
-  tile_size: [50, 50]
-  stride: 50
-
-normalization_stage: image # on what level we normalize, options: [tile, image, none]
-thresholding:
-  method: F1AdaptiveThreshold # refer to documentation for thresholding methods
-  stage: image # stage at which we apply threshold, options: [tile, image]
-
-data:
-  class_path: anomalib.data.MVTec
-  init_args:
-    root: toBeSetup
-    category: dummy
-    train_batch_size: 32
-    eval_batch_size: 32
-    num_workers: 0
-    task: segmentation
-    transform: null
-    train_transform: null
-    eval_transform: null
-    test_split_mode: from_dir
-    test_split_ratio: 0.2
-    val_split_mode: same_as_test
-    val_split_ratio: 0.5
-    image_size: [50, 100]
-
-SeamSmoothing:
-  apply: True # if this is applied, area around tile seams are is smoothed
-  sigma: 2 # sigma of gaussian filter used to smooth this area
-  width: 0.1 # width factor, multiplied by tile dimension gives the region width around seam which will be smoothed
-
-TrainModels:
-  model:
-    class_path: Padim
-
-  metrics:
-    pixel: AUROC
-    image: AUROC
diff --git a/tests/unit/pipelines/tiled_ensemble/__init__.py b/tests/unit/pipelines/tiled_ensemble/__init__.py
deleted file mode 100644
index a78a1ad659..0000000000
--- a/tests/unit/pipelines/tiled_ensemble/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-"""Tiled ensemble unit tests."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
diff --git a/tests/unit/pipelines/tiled_ensemble/conftest.py b/tests/unit/pipelines/tiled_ensemble/conftest.py
deleted file mode 100644
index b4fad61ebb..0000000000
--- a/tests/unit/pipelines/tiled_ensemble/conftest.py
+++ /dev/null
@@ -1,151 +0,0 @@
-"""Fixtures that are used in tiled ensemble testing."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-from pathlib import Path
-from tempfile import TemporaryDirectory
-
-import pytest
-import torch
-import yaml
-
-from anomalib.data import AnomalibDataModule
-from anomalib.models import AnomalyModule
-from anomalib.pipelines.tiled_ensemble.components.utils.ensemble_tiling import EnsembleTiler
-from anomalib.pipelines.tiled_ensemble.components.utils.helper_functions import (
-    get_ensemble_datamodule,
-    get_ensemble_model,
-    get_ensemble_tiler,
-)
-from anomalib.pipelines.tiled_ensemble.components.utils.prediction_data import EnsemblePredictions
-from anomalib.pipelines.tiled_ensemble.components.utils.prediction_merging import PredictionMergingMechanism
-
-
-@pytest.fixture(scope="module")
-def get_ensemble_config(dataset_path: Path) -> dict:
-    """Return ensemble dummy config dict with corrected dataset path to dummy temp dir."""
-    with Path("tests/unit/pipelines/tiled_ensemble/dummy_config.yaml").open(encoding="utf-8") as file:
-        config = yaml.safe_load(file)
-        # dummy dataset
-        config["data"]["init_args"]["root"] = dataset_path / "mvtec"
-
-        return config
-
-
-@pytest.fixture(scope="module")
-def get_tiler(get_ensemble_config: dict) -> EnsembleTiler:
-    """Return EnsembleTiler object based on test dummy config."""
-    config = get_ensemble_config
-
-    return get_ensemble_tiler(config["tiling"], config["data"])
-
-
-@pytest.fixture(scope="module")
-def get_model(get_ensemble_config: dict, get_tiler: EnsembleTiler) -> AnomalyModule:
-    """Return model prepared for tiled ensemble training."""
-    config = get_ensemble_config
-    tiler = get_tiler
-
-    return get_ensemble_model(config["TrainModels"]["model"], tiler)
-
-
-@pytest.fixture(scope="module")
-def get_datamodule(get_ensemble_config: dict, get_tiler: EnsembleTiler) -> AnomalibDataModule:
-    """Return ensemble datamodule."""
-    config = get_ensemble_config
-    tiler = get_tiler
-    datamodule = get_ensemble_datamodule(config, tiler, (0, 0))
-    datamodule.setup()
-
-    return datamodule
-
-
-@pytest.fixture(scope="module")
-def get_tile_predictions(get_datamodule: AnomalibDataModule) -> EnsemblePredictions:
-    """Return tile predictions inside EnsemblePredictions object."""
-    datamodule = get_datamodule
-
-    data = EnsemblePredictions()
-
-    for tile_index in [(0, 0), (0, 1), (1, 0), (1, 1)]:
-        datamodule.collate_fn.tile_index = tile_index
-
-        tile_prediction = []
-        batch = next(iter(datamodule.test_dataloader()))
-
-        # make mock labels and scores
-        batch["pred_scores"] = torch.rand(batch["label"].shape)
-        batch["pred_labels"] = batch["pred_scores"] > 0.5
-
-        # set mock maps to just one channel of image
-        batch["anomaly_maps"] = batch["image"].clone()[:, 0, :, :].unsqueeze(1)
-        # set mock pred mask to mask but add channel
-        batch["pred_masks"] = batch["mask"].clone().unsqueeze(1)
-
-        tile_prediction.append(batch)
-
-        # store to prediction storage object
-        data.add_tile_prediction(tile_index, tile_prediction)
-
-    return data
-
-
-@pytest.fixture(scope="module")
-def get_batch_predictions() -> list[dict]:
-    """Return mock batched predictions."""
-    mock_data = {
-        "image": torch.rand((5, 3, 100, 100)),
-        "mask": (torch.rand((5, 100, 100)) > 0.5).type(torch.float32),
-        "anomaly_maps": torch.rand((5, 1, 100, 100)),
-        "label": torch.Tensor([0, 1, 1, 0, 1]),
-        "pred_scores": torch.rand(5),
-        "pred_labels": torch.ones(5),
-        "pred_masks": torch.zeros((5, 100, 100)),
-    }
-
-    return [mock_data, mock_data]
-
-
-@pytest.fixture(scope="module")
-def get_merging_mechanism(
-    get_tile_predictions: EnsemblePredictions,
-    get_tiler: EnsembleTiler,
-) -> PredictionMergingMechanism:
-    """Return ensemble prediction merging mechanism object."""
-    tiler = get_tiler
-    predictions = get_tile_predictions
-    return PredictionMergingMechanism(predictions, tiler)
-
-
-@pytest.fixture(scope="module")
-def get_mock_stats_dir() -> Path:
-    """Get temp dir containing statistics."""
-    with TemporaryDirectory() as temp_dir:
-        stats = {
-            "minmax": {
-                "anomaly_maps": {
-                    "min": 1.9403648376464844,
-                    "max": 209.91940307617188,
-                },
-                "box_scores": {
-                    "min": 0.5,
-                    "max": 0.45,
-                },
-                "pred_scores": {
-                    "min": 9.390382766723633,
-                    "max": 209.91940307617188,
-                },
-            },
-            "image_threshold": 0.1111,
-            "pixel_threshold": 0.1111,
-        }
-        stats_path = Path(temp_dir) / "weights" / "lightning" / "stats.json"
-        stats_path.parent.mkdir(parents=True)
-
-        # save mock statistics
-        with stats_path.open("w", encoding="utf-8") as stats_file:
-            json.dump(stats, stats_file, ensure_ascii=False, indent=4)
-
-        yield Path(temp_dir)
diff --git a/tests/unit/pipelines/tiled_ensemble/dummy_config.yaml b/tests/unit/pipelines/tiled_ensemble/dummy_config.yaml
deleted file mode 100644
index fcd4b7c716..0000000000
--- a/tests/unit/pipelines/tiled_ensemble/dummy_config.yaml
+++ /dev/null
@@ -1,52 +0,0 @@
-seed: 42
-accelerator: "cpu"
-default_root_dir: "results"
-
-tiling:
-  tile_size: [50, 50]
-  stride: 50
-
-normalization_stage: image # on what level we normalize, options: [tile, image, none]
-thresholding:
-  method: F1AdaptiveThreshold # refer to documentation for thresholding methods
-  stage: image # stage at which we apply threshold, options: [tile, image]
-
-data:
-  class_path: anomalib.data.MVTec
-  init_args:
-    root: toBeSetup
-    category: dummy
-    train_batch_size: 32
-    eval_batch_size: 32
-    num_workers: 0
-    task: segmentation
-    transform: null
-    train_transform: null
-    eval_transform: null
-    test_split_mode: from_dir
-    test_split_ratio: 0.2
-    val_split_mode: same_as_test
-    val_split_ratio: 0.5
-    image_size: [100, 100]
-
-SeamSmoothing:
-  apply: True # if this is applied, area around tile seams are is smoothed
-  sigma: 2 # sigma of gaussian filter used to smooth this area
-  width: 0.1 # width factor, multiplied by tile dimension gives the region width around seam which will be smoothed
-
-TrainModels:
-  model:
-    class_path: Fastflow
-
-  metrics:
-    pixel: AUROC
-    image: AUROC
-
-  trainer:
-    max_epochs: 1
-    callbacks:
-      - class_path: lightning.pytorch.callbacks.EarlyStopping
-        init_args:
-          patience: 1
-          monitor: pixel_AUROC
-          mode: max
diff --git a/tests/unit/pipelines/tiled_ensemble/test_components.py b/tests/unit/pipelines/tiled_ensemble/test_components.py
deleted file mode 100644
index 0e3c0dcdd4..0000000000
--- a/tests/unit/pipelines/tiled_ensemble/test_components.py
+++ /dev/null
@@ -1,387 +0,0 @@
-"""Test working of tiled ensemble pipeline components."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import copy
-from pathlib import Path
-from tempfile import TemporaryDirectory
-
-import pytest
-import torch
-
-from anomalib.data import get_datamodule
-from anomalib.metrics import F1AdaptiveThreshold, ManualThreshold
-from anomalib.pipelines.tiled_ensemble.components import (
-    MergeJobGenerator,
-    MetricsCalculationJobGenerator,
-    NormalizationJobGenerator,
-    SmoothingJobGenerator,
-    StatisticsJobGenerator,
-    ThresholdingJobGenerator,
-)
-from anomalib.pipelines.tiled_ensemble.components.metrics_calculation import MetricsCalculationJob
-from anomalib.pipelines.tiled_ensemble.components.smoothing import SmoothingJob
-from anomalib.pipelines.tiled_ensemble.components.utils import NormalizationStage
-from anomalib.pipelines.tiled_ensemble.components.utils.prediction_data import EnsemblePredictions
-from anomalib.pipelines.tiled_ensemble.components.utils.prediction_merging import PredictionMergingMechanism
-
-
-class TestMerging:
-    """Test merging mechanism and merging job."""
-
-    @staticmethod
-    def test_tile_merging(get_ensemble_config: dict, get_merging_mechanism: PredictionMergingMechanism) -> None:
-        """Test tiled data merging."""
-        config = get_ensemble_config
-        merger = get_merging_mechanism
-
-        # prepared original data
-        datamodule = get_datamodule(config)
-        datamodule.prepare_data()
-        datamodule.setup()
-        original_data = next(iter(datamodule.test_dataloader()))
-
-        batch = merger.ensemble_predictions.get_batch_tiles(0)
-
-        merged_image = merger.merge_tiles(batch, "image")
-        assert merged_image.equal(original_data["image"])
-
-        merged_mask = merger.merge_tiles(batch, "mask")
-        assert merged_mask.equal(original_data["mask"])
-
-    @staticmethod
-    def test_label_and_score_merging(get_merging_mechanism: PredictionMergingMechanism) -> None:
-        """Test label and score merging."""
-        merger = get_merging_mechanism
-        scores = torch.rand(4, 10)
-        labels = scores > 0.5
-
-        mock_data = {(0, 0): {}, (0, 1): {}, (1, 0): {}, (1, 1): {}}
-
-        for i, data in enumerate(mock_data.values()):
-            data["pred_scores"] = scores[i]
-            data["pred_labels"] = labels[i]
-
-        merged = merger.merge_labels_and_scores(mock_data)
-
-        assert merged["pred_scores"].equal(scores.mean(dim=0))
-
-        assert merged["pred_labels"].equal(labels.any(dim=0))
-
-    @staticmethod
-    def test_merge_job(
-        get_tile_predictions: EnsemblePredictions,
-        get_ensemble_config: dict,
-        get_merging_mechanism: PredictionMergingMechanism,
-    ) -> None:
-        """Test merging job execution."""
-        config = get_ensemble_config
-        predictions = copy.deepcopy(get_tile_predictions)
-        merging_mechanism = get_merging_mechanism
-
-        merging_job_generator = MergeJobGenerator(tiling_args=config["tiling"], data_args=config["data"])
-        merging_job = next(merging_job_generator.generate_jobs(prev_stage_result=predictions))
-
-        merged_direct = merging_mechanism.merge_tile_predictions(0)
-        merged_with_job = merging_job.run()[0]
-
-        # check that merging by job is same as with the mechanism directly
-        for key, value in merged_direct.items():
-            if isinstance(value, torch.Tensor):
-                assert merged_with_job[key].equal(value)
-            elif isinstance(value, list) and isinstance(value[0], torch.Tensor):
-                # boxes
-                assert all(j.equal(d) for j, d in zip(merged_with_job[key], value, strict=False))
-            else:
-                assert merged_with_job[key] == value
-
-
-class TestStatsCalculation:
-    """Test post-processing statistics calculations."""
-
-    @staticmethod
-    @pytest.mark.parametrize(
-        ("threshold_str", "threshold_cls"),
-        [("F1AdaptiveThreshold", F1AdaptiveThreshold), ("ManualThreshold", ManualThreshold)],
-    )
-    def test_threshold_method(threshold_str: str, threshold_cls: type, get_ensemble_config: dict) -> None:
-        """Test that correct thresholding method is used."""
-        config = copy.deepcopy(get_ensemble_config)
-        config["thresholding"]["method"] = threshold_str
-
-        stats_job_generator = StatisticsJobGenerator(Path("mock"), threshold_str)
-        stats_job = next(stats_job_generator.generate_jobs(None, None))
-
-        assert isinstance(stats_job.image_threshold, threshold_cls)
-
-    @staticmethod
-    def test_stats_run(project_path: Path) -> None:
-        """Test execution of statistics calc. job."""
-        mock_preds = [
-            {
-                "pred_scores": torch.rand(4),
-                "label": torch.ones(4),
-                "anomaly_maps": torch.rand(4, 1, 50, 50),
-                "mask": torch.ones(4, 1, 50, 50),
-            },
-        ]
-
-        stats_job_generator = StatisticsJobGenerator(project_path, "F1AdaptiveThreshold")
-        stats_job = next(stats_job_generator.generate_jobs(None, mock_preds))
-
-        results = stats_job.run()
-
-        assert "minmax" in results
-        assert "image_threshold" in results
-        assert "pixel_threshold" in results
-
-        # save as it's removed from results
-        save_path = results["save_path"]
-        stats_job.save(results)
-        assert Path(save_path).exists()
-
-    @staticmethod
-    @pytest.mark.parametrize(
-        ("key", "values"),
-        [
-            ("anomaly_maps", [torch.rand(5, 1, 50, 50), torch.rand(5, 1, 50, 50)]),
-            ("pred_scores", [torch.rand(5), torch.rand(5)]),
-        ],
-    )
-    def test_minmax(key: str, values: list) -> None:
-        """Test minmax stats calculation."""
-        # add given keys to test all possible sources of minmax
-        data = [
-            {"pred_scores": torch.rand(5), "label": torch.ones(5), key: values[0]},
-            {"pred_scores": torch.rand(5), "label": torch.ones(5), key: values[1]},
-        ]
-
-        stats_job_generator = StatisticsJobGenerator(Path("mock"), "F1AdaptiveThreshold")
-        stats_job = next(stats_job_generator.generate_jobs(None, data))
-        results = stats_job.run()
-
-        if isinstance(values[0], list):
-            values[0] = torch.cat(values[0])
-            values[1] = torch.cat(values[1])
-        values = torch.stack(values)
-
-        assert results["minmax"][key]["min"] == torch.min(values)
-        assert results["minmax"][key]["max"] == torch.max(values)
-
-    @staticmethod
-    @pytest.mark.parametrize(
-        ("labels", "preds", "target_threshold"),
-        [
-            (torch.Tensor([0, 0, 0, 1, 1]), torch.Tensor([2.3, 1.6, 2.6, 7.9, 3.3]), 3.3),  # standard case
-            (torch.Tensor([1, 0, 0, 0]), torch.Tensor([4, 3, 2, 1]), 4),  # 100% recall for all thresholds
-        ],
-    )
-    def test_threshold(labels: torch.Tensor, preds: torch.Tensor, target_threshold: float) -> None:
-        """Test threshold calculation job."""
-        data = [
-            {
-                "label": labels,
-                "mask": labels,
-                "pred_scores": preds,
-                "anomaly_maps": preds,
-            },
-        ]
-
-        stats_job_generator = StatisticsJobGenerator(Path("mock"), "F1AdaptiveThreshold")
-        stats_job = next(stats_job_generator.generate_jobs(None, data))
-        results = stats_job.run()
-
-        assert round(results["image_threshold"], 5) == target_threshold
-        assert round(results["pixel_threshold"], 5) == target_threshold
-
-
-class TestMetrics:
-    """Test ensemble metrics."""
-
-    @pytest.fixture(scope="class")
-    @staticmethod
-    def get_ensemble_metrics_job(
-        get_ensemble_config: dict,
-        get_batch_predictions: list[dict],
-    ) -> tuple[MetricsCalculationJob, str]:
-        """Return Metrics calculation job and path to directory where metrics csv will be saved."""
-        config = get_ensemble_config
-        with TemporaryDirectory() as tmp_dir:
-            metrics = MetricsCalculationJobGenerator(
-                config["accelerator"],
-                root_dir=Path(tmp_dir),
-                task=config["data"]["init_args"]["task"],
-                metrics=config["TrainModels"]["metrics"],
-                normalization_stage=NormalizationStage(config["normalization_stage"]),
-            )
-
-        mock_predictions = get_batch_predictions
-
-        return next(metrics.generate_jobs(prev_stage_result=copy.deepcopy(mock_predictions))), tmp_dir
-
-    @staticmethod
-    def test_metrics_result(get_ensemble_metrics_job: tuple[MetricsCalculationJob, str]) -> None:
-        """Test metrics result."""
-        metrics_job, _ = get_ensemble_metrics_job
-
-        result = metrics_job.run()
-
-        assert "pixel_AUROC" in result
-        assert "image_AUROC" in result
-
-    @staticmethod
-    def test_metrics_saving(get_ensemble_metrics_job: tuple[MetricsCalculationJob, str]) -> None:
-        """Test metrics saving to csv."""
-        metrics_job, tmp_dir = get_ensemble_metrics_job
-
-        result = metrics_job.run()
-        metrics_job.save(result)
-        assert (Path(tmp_dir) / "metric_results.csv").exists()
-
-
-class TestJoinSmoothing:
-    """Test JoinSmoothing job responsible for smoothing area at tile seams."""
-
-    @pytest.fixture(scope="class")
-    @staticmethod
-    def get_join_smoothing_job(get_ensemble_config: dict, get_batch_predictions: list[dict]) -> SmoothingJob:
-        """Make and return SmoothingJob instance."""
-        config = get_ensemble_config
-        job_gen = SmoothingJobGenerator(
-            accelerator=config["accelerator"],
-            tiling_args=config["tiling"],
-            data_args=config["data"],
-        )
-        # copy since smoothing changes data
-        mock_predictions = copy.deepcopy(get_batch_predictions)
-        return next(job_gen.generate_jobs(config["SeamSmoothing"], mock_predictions))
-
-    @staticmethod
-    def test_mask(get_join_smoothing_job: SmoothingJob) -> None:
-        """Test seam mask in case where tiles don't overlap."""
-        smooth = get_join_smoothing_job
-
-        join_index = smooth.tiler.tile_size_h, smooth.tiler.tile_size_w
-
-        # seam should be covered by True
-        assert smooth.seam_mask[join_index]
-
-        # non-seam region should be false
-        assert not smooth.seam_mask[0, 0]
-        assert not smooth.seam_mask[-1, -1]
-
-    @staticmethod
-    def test_mask_overlapping(get_ensemble_config: dict, get_batch_predictions: list[dict]) -> None:
-        """Test seam mask in case where tiles overlap."""
-        config = copy.deepcopy(get_ensemble_config)
-        # tile size = 50, stride = 25 -> overlapping
-        config["tiling"]["stride"] = 25
-        job_gen = SmoothingJobGenerator(
-            accelerator=config["accelerator"],
-            tiling_args=config["tiling"],
-            data_args=config["data"],
-        )
-        mock_predictions = copy.deepcopy(get_batch_predictions)
-        smooth = next(job_gen.generate_jobs(config["SeamSmoothing"], mock_predictions))
-
-        join_index = smooth.tiler.stride_h, smooth.tiler.stride_w
-
-        # overlap seam should be covered by True
-        assert smooth.seam_mask[join_index]
-        assert smooth.seam_mask[-join_index[0], -join_index[1]]
-
-        # non-seam region should be false
-        assert not smooth.seam_mask[0, 0]
-        assert not smooth.seam_mask[-1, -1]
-
-    @staticmethod
-    def test_smoothing(get_join_smoothing_job: SmoothingJob, get_batch_predictions: list[dict]) -> None:
-        """Test smoothing job run."""
-        original_data = get_batch_predictions
-        # fixture makes a copy of data
-        smooth = get_join_smoothing_job
-
-        # take first batch
-        smoothed = smooth.run()[0]
-        join_index = smooth.tiler.tile_size_h, smooth.tiler.tile_size_w
-
-        # join sections should be processed
-        assert not smoothed["anomaly_maps"][:, :, join_index].equal(original_data[0]["anomaly_maps"][:, :, join_index])
-
-        # non-join section shouldn't be changed
-        assert smoothed["anomaly_maps"][:, :, 0, 0].equal(original_data[0]["anomaly_maps"][:, :, 0, 0])
-
-
-def test_normalization(get_batch_predictions: list[dict], project_path: Path) -> None:
-    """Test normalization step."""
-    original_predictions = copy.deepcopy(get_batch_predictions)
-
-    for batch in original_predictions:
-        batch["anomaly_maps"] *= 100
-        batch["pred_scores"] *= 100
-
-    # # get and save stats using stats job on predictions
-    stats_job_generator = StatisticsJobGenerator(project_path, "F1AdaptiveThreshold")
-    stats_job = next(stats_job_generator.generate_jobs(prev_stage_result=original_predictions))
-    stats = stats_job.run()
-    stats_job.save(stats)
-
-    # normalize predictions based on obtained stats
-    norm_job_generator = NormalizationJobGenerator(root_dir=project_path)
-    # copy as this changes preds
-    norm_job = next(norm_job_generator.generate_jobs(prev_stage_result=original_predictions))
-    normalized_predictions = norm_job.run()
-
-    for batch in normalized_predictions:
-        assert (batch["anomaly_maps"] >= 0).all()
-        assert (batch["anomaly_maps"] <= 1).all()
-
-        assert (batch["pred_scores"] >= 0).all()
-        assert (batch["pred_scores"] <= 1).all()
-
-
-class TestThresholding:
-    """Test tiled ensemble thresholding stage."""
-
-    @pytest.fixture(scope="class")
-    @staticmethod
-    def get_threshold_job(get_mock_stats_dir: Path) -> callable:
-        """Return a function that takes prediction data and runs threshold job."""
-        thresh_job_generator = ThresholdingJobGenerator(
-            root_dir=get_mock_stats_dir,
-            normalization_stage=NormalizationStage.IMAGE,
-        )
-
-        def thresh_helper(preds: dict) -> list | None:
-            thresh_job = next(thresh_job_generator.generate_jobs(prev_stage_result=preds))
-            return thresh_job.run()
-
-        return thresh_helper
-
-    @staticmethod
-    def test_score_threshold(get_threshold_job: callable) -> None:
-        """Test anomaly score thresholding."""
-        thresholding = get_threshold_job
-
-        data = [{"pred_scores": torch.tensor([0.7, 0.8, 0.1, 0.33, 0.5])}]
-
-        thresholded = thresholding(data)[0]
-
-        assert thresholded["pred_labels"].equal(torch.tensor([True, True, False, False, True]))
-
-    @staticmethod
-    def test_anomap_threshold(get_threshold_job: callable) -> None:
-        """Test anomaly map thresholding."""
-        thresholding = get_threshold_job
-
-        data = [
-            {
-                "pred_scores": torch.tensor([0.7, 0.8, 0.1, 0.33, 0.5]),
-                "anomaly_maps": torch.tensor([[0.7, 0.8, 0.1], [0.33, 0.5, 0.1]]),
-            },
-        ]
-
-        thresholded = thresholding(data)[0]
-
-        assert thresholded["pred_masks"].equal(torch.tensor([[True, True, False], [False, True, False]]))
diff --git a/tests/unit/pipelines/tiled_ensemble/test_helper_functions.py b/tests/unit/pipelines/tiled_ensemble/test_helper_functions.py
deleted file mode 100644
index 06e5864cef..0000000000
--- a/tests/unit/pipelines/tiled_ensemble/test_helper_functions.py
+++ /dev/null
@@ -1,113 +0,0 @@
-"""Test ensemble helper functions."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from pathlib import Path
-
-import pytest
-from jsonargparse import Namespace
-from lightning.pytorch.callbacks import EarlyStopping
-
-from anomalib.callbacks.normalization import _MinMaxNormalizationCallback
-from anomalib.models import AnomalyModule
-from anomalib.pipelines.tiled_ensemble.components.utils import NormalizationStage
-from anomalib.pipelines.tiled_ensemble.components.utils.ensemble_tiling import EnsembleTiler, TileCollater
-from anomalib.pipelines.tiled_ensemble.components.utils.helper_functions import (
-    get_ensemble_datamodule,
-    get_ensemble_engine,
-    get_ensemble_model,
-    get_ensemble_tiler,
-    get_threshold_values,
-    parse_trainer_kwargs,
-)
-
-
-class TestHelperFunctions:
-    """Test ensemble helper functions."""
-
-    @staticmethod
-    def test_ensemble_datamodule(get_ensemble_config: dict, get_tiler: EnsembleTiler) -> None:
-        """Test that datamodule is created and has correct collate function."""
-        config = get_ensemble_config
-        tiler = get_tiler
-        datamodule = get_ensemble_datamodule(config, tiler, (0, 0))
-
-        assert isinstance(datamodule.collate_fn, TileCollater)
-
-    @staticmethod
-    def test_ensemble_model(get_ensemble_config: dict, get_tiler: EnsembleTiler) -> None:
-        """Test that model is successfully created with correct input shape."""
-        config = get_ensemble_config
-        tiler = get_tiler
-        model = get_ensemble_model(config["TrainModels"]["model"], tiler)
-
-        assert model.input_size == tuple(config["tiling"]["tile_size"])
-
-    @staticmethod
-    def test_tiler(get_ensemble_config: dict) -> None:
-        """Test that tiler is successfully instantiated."""
-        config = get_ensemble_config
-
-        tiler = get_ensemble_tiler(config["tiling"], config["data"])
-        assert isinstance(tiler, EnsembleTiler)
-
-    @staticmethod
-    def test_trainer_kwargs(get_ensemble_config: dict) -> None:
-        """Test that objects are correctly constructed from kwargs."""
-        config = get_ensemble_config
-
-        objects = parse_trainer_kwargs(config["TrainModels"]["trainer"])
-        assert isinstance(objects, Namespace)
-        # verify that early stopping is parsed and added to callbacks
-        assert isinstance(objects.callbacks[0], EarlyStopping)
-
-    @staticmethod
-    @pytest.mark.parametrize(
-        "normalization_stage",
-        [NormalizationStage.NONE, NormalizationStage.IMAGE, NormalizationStage.TILE],
-    )
-    def test_threshold_values(normalization_stage: NormalizationStage, get_mock_stats_dir: Path) -> None:
-        """Test that threshold values are correctly set based on normalization stage."""
-        stats_dir = get_mock_stats_dir
-
-        i_thresh, p_thresh = get_threshold_values(normalization_stage, stats_dir)
-
-        if normalization_stage != NormalizationStage.NONE:
-            # minmax normalization sets thresholds to 0.5
-            assert i_thresh == p_thresh == 0.5
-        else:
-            assert i_thresh == p_thresh == 0.1111
-
-
-class TestEnsembleEngine:
-    """Test ensemble engine configuration."""
-
-    @staticmethod
-    @pytest.mark.parametrize(
-        "normalization_stage",
-        [NormalizationStage.NONE, NormalizationStage.IMAGE, NormalizationStage.TILE],
-    )
-    def test_normalisation(normalization_stage: NormalizationStage, get_model: AnomalyModule) -> None:
-        """Test that normalization callback is correctly initialized."""
-        engine = get_ensemble_engine(
-            tile_index=(0, 0),
-            accelerator="cpu",
-            devices="1",
-            root_dir=Path("mock"),
-            normalization_stage=normalization_stage,
-        )
-
-        engine._setup_anomalib_callbacks(get_model)  # noqa: SLF001
-
-        # verify that only in case of tile level normalization the callback is present
-        if normalization_stage == NormalizationStage.TILE:
-            assert any(
-                isinstance(x, _MinMaxNormalizationCallback)
-                for x in engine._cache.args["callbacks"]  # noqa: SLF001
-            )
-        else:
-            assert not any(
-                isinstance(x, _MinMaxNormalizationCallback)
-                for x in engine._cache.args["callbacks"]  # noqa: SLF001
-            )
diff --git a/tests/unit/pipelines/tiled_ensemble/test_prediction_data.py b/tests/unit/pipelines/tiled_ensemble/test_prediction_data.py
deleted file mode 100644
index 7185f1e2ca..0000000000
--- a/tests/unit/pipelines/tiled_ensemble/test_prediction_data.py
+++ /dev/null
@@ -1,69 +0,0 @@
-"""Test tiled prediction storage class."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import copy
-from collections.abc import Callable
-
-import torch
-from torch import Tensor
-
-from anomalib.data import AnomalibDataModule
-from anomalib.pipelines.tiled_ensemble.components.utils.prediction_data import EnsemblePredictions
-
-
-class TestPredictionData:
-    """Test EnsemblePredictions class, used for tiled prediction storage."""
-
-    @staticmethod
-    def store_all(data: EnsemblePredictions, datamodule: AnomalibDataModule) -> dict:
-        """Store the tiled predictions in the EnsemblePredictions object."""
-        tile_dict = {}
-        for tile_index in [(0, 0), (0, 1), (1, 0), (1, 1)]:
-            datamodule.collate_fn.tile_index = tile_index
-
-            tile_prediction = []
-            for batch in iter(datamodule.train_dataloader()):
-                # set mock maps to just one channel of image
-                batch["anomaly_maps"] = batch["image"].clone()[:, 0, :, :].unsqueeze(1)
-                # set mock pred mask to mask but add channel
-                batch["pred_masks"] = batch["mask"].clone().unsqueeze(1)
-                tile_prediction.append(batch)
-            # save original
-            tile_dict[tile_index] = copy.deepcopy(tile_prediction)
-            # store to prediction storage object
-            data.add_tile_prediction(tile_index, tile_prediction)
-
-        return tile_dict
-
-    @staticmethod
-    def verify_equal(name: str, tile_dict: dict, storage: EnsemblePredictions, eq_funct: Callable) -> bool:
-        """Verify that all data at same tile index and same batch index matches."""
-        batch_num = len(tile_dict[0, 0])
-
-        for batch_i in range(batch_num):
-            # batch is dict where key: tile index and val is batched data of that tile
-            curr_batch = storage.get_batch_tiles(batch_i)
-
-            # go over all indices of current batch of stored data
-            for tile_index, stored_data_batch in curr_batch.items():
-                stored_data = stored_data_batch[name]
-                # get original data dict at current tile index and batch index
-                original_data = tile_dict[tile_index][batch_i][name]
-                if isinstance(original_data, Tensor):
-                    if not eq_funct(original_data, stored_data):
-                        return False
-                elif original_data != stored_data:
-                    return False
-
-        return True
-
-    def test_prediction_object(self, get_datamodule: AnomalibDataModule) -> None:
-        """Test prediction storage class."""
-        datamodule = get_datamodule
-        storage = EnsemblePredictions()
-        original = self.store_all(storage, datamodule)
-
-        for name in original[0, 0][0]:
-            assert self.verify_equal(name, original, storage, torch.equal), f"{name} doesn't match"
diff --git a/tests/unit/pipelines/tiled_ensemble/test_tiler.py b/tests/unit/pipelines/tiled_ensemble/test_tiler.py
deleted file mode 100644
index 96b6c0e7bc..0000000000
--- a/tests/unit/pipelines/tiled_ensemble/test_tiler.py
+++ /dev/null
@@ -1,119 +0,0 @@
-"""Tiling related tests for tiled ensemble."""
-
-# Copyright (C) 2023-2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import copy
-
-import pytest
-import torch
-
-from anomalib.data import AnomalibDataModule
-from anomalib.pipelines.tiled_ensemble.components.utils.helper_functions import get_ensemble_tiler
-
-tiler_config = {
-    "tiling": {
-        "tile_size": 256,
-        "stride": 256,
-    },
-    "data": {"init_args": {"image_size": 512}},
-}
-
-tiler_config_overlap = {
-    "tiling": {
-        "tile_size": 256,
-        "stride": 128,
-    },
-    "data": {"init_args": {"image_size": 512}},
-}
-
-
-class TestTiler:
-    """EnsembleTiler tests."""
-
-    @staticmethod
-    @pytest.mark.parametrize(
-        ("input_shape", "config", "expected_shape"),
-        [
-            (torch.Size([5, 3, 512, 512]), tiler_config, torch.Size([2, 2, 5, 3, 256, 256])),
-            (torch.Size([5, 3, 512, 512]), tiler_config_overlap, torch.Size([3, 3, 5, 3, 256, 256])),
-            (torch.Size([5, 3, 500, 500]), tiler_config, torch.Size([2, 2, 5, 3, 256, 256])),
-            (torch.Size([5, 3, 500, 500]), tiler_config_overlap, torch.Size([3, 3, 5, 3, 256, 256])),
-        ],
-    )
-    def test_basic_tile_for_ensemble(input_shape: torch.Size, config: dict, expected_shape: torch.Size) -> None:
-        """Test basic tiling of data."""
-        config = copy.deepcopy(config)
-        config["data"]["init_args"]["image_size"] = input_shape[-1]
-        tiler = get_ensemble_tiler(config["tiling"], config["data"])
-
-        images = torch.rand(size=input_shape)
-        tiled = tiler.tile(images)
-
-        assert tiled.shape == expected_shape
-
-    @staticmethod
-    @pytest.mark.parametrize(
-        ("input_shape", "config"),
-        [
-            (torch.Size([5, 3, 512, 512]), tiler_config),
-            (torch.Size([5, 3, 512, 512]), tiler_config_overlap),
-            (torch.Size([5, 3, 500, 500]), tiler_config),
-            (torch.Size([5, 3, 500, 500]), tiler_config_overlap),
-        ],
-    )
-    def test_basic_tile_reconstruction(input_shape: torch.Size, config: dict) -> None:
-        """Test basic reconstruction of tiled data."""
-        config = copy.deepcopy(config)
-        config["data"]["init_args"]["image_size"] = input_shape[-1]
-
-        tiler = get_ensemble_tiler(config["tiling"], config["data"])
-
-        images = torch.rand(size=input_shape)
-        tiled = tiler.tile(images.clone())
-        untiled = tiler.untile(tiled)
-
-        assert images.shape == untiled.shape
-        assert images.equal(untiled)
-
-    @staticmethod
-    @pytest.mark.parametrize(
-        ("input_shape", "config"),
-        [
-            (torch.Size([5, 3, 512, 512]), tiler_config),
-            (torch.Size([5, 3, 500, 500]), tiler_config),
-        ],
-    )
-    def test_untile_different_instance(input_shape: torch.Size, config: dict) -> None:
-        """Test untiling with different Tiler instance."""
-        config = copy.deepcopy(config)
-        config["data"]["init_args"]["image_size"] = input_shape[-1]
-        tiler_1 = get_ensemble_tiler(config["tiling"], config["data"])
-
-        tiler_2 = get_ensemble_tiler(config["tiling"], config["data"])
-
-        images = torch.rand(size=input_shape)
-        tiled = tiler_1.tile(images.clone())
-
-        untiled = tiler_2.untile(tiled)
-
-        # untiling should work even with different instance of tiler
-        assert images.shape == untiled.shape
-        assert images.equal(untiled)
-
-
-class TestTileCollater:
-    """Test tile collater."""
-
-    @staticmethod
-    def test_collate_tile_shape(get_ensemble_config: dict, get_datamodule: AnomalibDataModule) -> None:
-        """Test that collate function successfully tiles the image."""
-        config = get_ensemble_config
-        # datamodule with tile collater
-        datamodule = get_datamodule
-
-        tile_w, tile_h = config["tiling"]["tile_size"]
-
-        batch = next(iter(datamodule.train_dataloader()))
-        assert batch["image"].shape[1:] == (3, tile_w, tile_h)
-        assert batch["mask"].shape[1:] == (tile_w, tile_h)
diff --git a/tools/tiled_ensemble/ens_config.yaml b/tools/tiled_ensemble/ens_config.yaml
deleted file mode 100644
index 2490b22e9a..0000000000
--- a/tools/tiled_ensemble/ens_config.yaml
+++ /dev/null
@@ -1,43 +0,0 @@
-seed: 42
-accelerator: "gpu"
-default_root_dir: "results"
-
-tiling:
-  tile_size: [128, 128]
-  stride: 128
-
-normalization_stage: image # on what level we normalize, options: [tile, image, none]
-thresholding:
-  method: F1AdaptiveThreshold # refer to documentation for thresholding methods
-  stage: image # stage at which we apply threshold, options: [tile, image]
-
-data:
-  class_path: anomalib.data.MVTec
-  init_args:
-    root: ./datasets/MVTec
-    category: bottle
-    train_batch_size: 32
-    eval_batch_size: 32
-    num_workers: 8
-    task: segmentation
-    transform: null
-    train_transform: null
-    eval_transform: null
-    test_split_mode: from_dir
-    test_split_ratio: 0.2
-    val_split_mode: same_as_test
-    val_split_ratio: 0.5
-    image_size: [256, 256]
-
-SeamSmoothing:
-  apply: True # if this is applied, area around tile seams are is smoothed
-  sigma: 2 # sigma of gaussian filter used to smooth this area
-  width: 0.1 # width factor, multiplied by tile dimension gives the region width around seam which will be smoothed
-
-TrainModels:
-  model:
-    class_path: Padim
-
-  metrics:
-    pixel: AUROC
-    image: AUROC
diff --git a/tools/tiled_ensemble/eval.py b/tools/tiled_ensemble/eval.py
deleted file mode 100644
index 58be27c25c..0000000000
--- a/tools/tiled_ensemble/eval.py
+++ /dev/null
@@ -1,28 +0,0 @@
-"""Run tiled ensemble prediction."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from pathlib import Path
-
-from jsonargparse import ArgumentParser
-
-from anomalib.pipelines.tiled_ensemble import EvalTiledEnsemble
-
-
-def get_parser() -> ArgumentParser:
-    """Create a new parser if none is provided."""
-    parser = ArgumentParser()
-    parser.add_argument("--config", type=str | Path, help="Configuration file path.", required=True)
-    parser.add_argument("--root", type=str | Path, help="Weights file path.", required=True)
-
-    return parser
-
-
-if __name__ == "__main__":
-    args = get_parser().parse_args()
-
-    print("Running tiled ensemble test pipeline.")
-    # pass the path to root dir with checkpoints
-    test_pipeline = EvalTiledEnsemble(args.root)
-    test_pipeline.run(args)
diff --git a/tools/tiled_ensemble/train.py b/tools/tiled_ensemble/train.py
deleted file mode 100644
index 8aed47ea0d..0000000000
--- a/tools/tiled_ensemble/train.py
+++ /dev/null
@@ -1,17 +0,0 @@
-"""Run tiled ensemble training."""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from anomalib.pipelines.tiled_ensemble import EvalTiledEnsemble, TrainTiledEnsemble
-
-if __name__ == "__main__":
-    print("Running tiled ensemble train pipeline")
-    train_pipeline = TrainTiledEnsemble()
-    # run training
-    train_pipeline.run()
-
-    print("Running tiled ensemble test pipeline.")
-    # pass the root dir from train run to load checkpoints
-    test_pipeline = EvalTiledEnsemble(train_pipeline.root_dir)
-    test_pipeline.run()

From 4635158206202bf80a539085dab278ecc7cad6ea Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 11 Dec 2024 16:15:55 +0000
Subject: [PATCH 22/45] Install the required pytest plugins

Signed-off-by: Samet Akcay 
---
 pyproject.toml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index 805795da40..325c60cac9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -84,6 +84,8 @@ test = [
     "pytest-xdist",
     "pytest-mock",
     "pytest-sugar",
+    "pytest-timeout",
+    "pytest-json-report",
     "coverage[toml]",
     "tox",
 ]

From dda04210414cc5b1ff1995bac0a5540896e47e04 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Wed, 11 Dec 2024 16:41:28 +0000
Subject: [PATCH 23/45] Disable parallel execution for now

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 8617ea148e..f33b5e19d1 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -130,14 +130,14 @@ runs:
         start_time=$(date +%s)
 
         # Run pytest with:
-        # - Auto parallel execution (-n auto)
+        # - Disable parallel execution for now (-n0 instead of -n auto)
         # - Duration reporting for slow tests
         # - Configurable timeout
         # - JSON report generation
         PYTHONPATH=src pytest ${{ steps.test-scope.outputs.path }} \
-          -n auto \
+          -n0 \
           --durations=10 \
-          --durations-min=1.0 \
+          --durations-min=10.0 \
           --timeout=${{ inputs.max-test-time }} \
           --json-report --json-report-file=pytest.json \
           && echo "success=true" >> $GITHUB_OUTPUT \

From d4c8f82e9bc28f3b0bf5098ebfd2a1cbed1bfaba Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 05:49:31 +0000
Subject: [PATCH 24/45] Fix the status of the unit tests

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index f33b5e19d1..d9a05bde9c 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -125,6 +125,7 @@ runs:
     - name: Execute test suite
       id: test-execution
       shell: bash
+      continue-on-error: true # Allow the step to continue even if tests fail
       run: |
         source .venv/bin/activate
         start_time=$(date +%s)
@@ -137,16 +138,22 @@ runs:
         PYTHONPATH=src pytest ${{ steps.test-scope.outputs.path }} \
           -n0 \
           --durations=10 \
-          --durations-min=10.0 \
+          --durations-min=1.0 \
           --timeout=${{ inputs.max-test-time }} \
-          --json-report --json-report-file=pytest.json \
-          && echo "success=true" >> $GITHUB_OUTPUT \
-          || echo "success=false" >> $GITHUB_OUTPUT
+          --json-report --json-report-file=pytest.json
 
-        # Calculate total test duration
+        # Store test result
+        echo "success=$?" >> $GITHUB_OUTPUT
+
+        # Calculate duration
         end_time=$(date +%s)
-        duration=$((end_time - start_time))
-        echo "duration=${duration}" >> $GITHUB_OUTPUT
+        echo "duration=$((end_time - start_time))" >> $GITHUB_OUTPUT
+
+    # Fail the workflow if tests failed
+    - name: Check test results
+      if: steps.test-execution.outputs.success != '0'
+      shell: bash
+      run: exit 1
 
     # Analyze and report test performance
     - name: Analyze test performance

From b8455b41b3c9125997660b640e5c7ae5d5dc2c6b Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 06:00:10 +0000
Subject: [PATCH 25/45] Automatically set the device to run the
 unit/integration tests

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml          | 26 ++++++++++++++-------
 .github/workflows/_reusable-test-suite.yaml |  1 +
 tests/unit/metrics/test_pro.py              |  7 +++++-
 3 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index d9a05bde9c..bc6ef8c5d9 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -32,6 +32,7 @@
 # - test-type: Type of tests to run
 # - codecov-token: Token for coverage upload
 # - max-test-time: Maximum test duration
+# - device: Device to run tests on (cpu/gpu)
 #
 # Outputs:
 # - coverage-percentage: Total coverage
@@ -67,6 +68,10 @@ inputs:
     description: "Maximum time in seconds for the test suite to run"
     required: false
     default: "300"
+  device:
+    description: "Device to run tests on (cpu/gpu)"
+    required: false
+    default: "gpu"
 
 outputs:
   coverage-percentage:
@@ -125,22 +130,27 @@ runs:
     - name: Execute test suite
       id: test-execution
       shell: bash
-      continue-on-error: true # Allow the step to continue even if tests fail
+      continue-on-error: true
       run: |
         source .venv/bin/activate
         start_time=$(date +%s)
 
-        # Run pytest with:
-        # - Disable parallel execution for now (-n0 instead of -n auto)
-        # - Duration reporting for slow tests
-        # - Configurable timeout
-        # - JSON report generation
+        # Set device-specific pytest arguments
+        if [ "${{ inputs.device }}" = "cpu" ]; then
+          DEVICE_ARGS="--markers='not gpu'"
+        else
+          # For GPU runners, no need to skip GPU tests
+          DEVICE_ARGS=""
+        fi
+
+        # Run pytest
         PYTHONPATH=src pytest ${{ steps.test-scope.outputs.path }} \
-          -n0 \
+          --numprocesses=0 \
           --durations=10 \
           --durations-min=1.0 \
           --timeout=${{ inputs.max-test-time }} \
-          --json-report --json-report-file=pytest.json
+          --json-report --json-report-file=pytest.json \
+          $DEVICE_ARGS
 
         # Store test result
         echo "success=$?" >> $GITHUB_OUTPUT
diff --git a/.github/workflows/_reusable-test-suite.yaml b/.github/workflows/_reusable-test-suite.yaml
index 4277fd9b49..ef0cadd68b 100644
--- a/.github/workflows/_reusable-test-suite.yaml
+++ b/.github/workflows/_reusable-test-suite.yaml
@@ -107,3 +107,4 @@ jobs:
           python-version: ${{ inputs.python-version }}
           test-type: ${{ inputs.test-type }}
           codecov-token: ${{ secrets.codecov-token }}
+          device: ${{ contains(inputs.runner, 'self-hosted') && 'gpu' || 'cpu' }}
diff --git a/tests/unit/metrics/test_pro.py b/tests/unit/metrics/test_pro.py
index fe6e149cb1..6b2731b4d5 100644
--- a/tests/unit/metrics/test_pro.py
+++ b/tests/unit/metrics/test_pro.py
@@ -3,6 +3,7 @@
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+import pytest
 import torch
 from torchvision.transforms import RandomAffine
 
@@ -44,8 +45,12 @@ def test_pro() -> None:
         assert pro.compute() == target
 
 
+@pytest.mark.gpu
 def test_device_consistency() -> None:
-    """Test if the pro metric yields the same results between cpu and gpu."""
+    """Test if the pro metric yields the same results between cpu and gpu.
+
+    Note: This test will only run on a GPU-enabled device.
+    """
     transform = RandomAffine(5, None, (0.95, 1.05), 5)
 
     batch = torch.zeros((32, 256, 256))

From 40d27e9c5e8f6b8715094373d2b030d988e7b427 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 06:07:58 +0000
Subject: [PATCH 26/45] Enhance the device management for unit/integration
 tests

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index bc6ef8c5d9..fa63309760 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -139,7 +139,6 @@ runs:
         if [ "${{ inputs.device }}" = "cpu" ]; then
           DEVICE_ARGS="--markers='not gpu'"
         else
-          # For GPU runners, no need to skip GPU tests
           DEVICE_ARGS=""
         fi
 
@@ -149,15 +148,19 @@ runs:
           --durations=10 \
           --durations-min=1.0 \
           --timeout=${{ inputs.max-test-time }} \
-          --json-report --json-report-file=pytest.json \
+          --verbosity=0 \
+          --durations-only \
           $DEVICE_ARGS
 
-        # Store test result
-        echo "success=$?" >> $GITHUB_OUTPUT
+        # Store test result and duration
+        exit_code=$?
+        echo "success=$exit_code" >> $GITHUB_OUTPUT
 
-        # Calculate duration
         end_time=$(date +%s)
-        echo "duration=$((end_time - start_time))" >> $GITHUB_OUTPUT
+        duration=$((end_time - start_time))
+        echo "duration=$duration" >> $GITHUB_OUTPUT
+
+        exit $exit_code
 
     # Fail the workflow if tests failed
     - name: Check test results
@@ -165,17 +168,13 @@ runs:
       shell: bash
       run: exit 1
 
-    # Analyze and report test performance
-    - name: Analyze test performance
-      if: always() # Run even if tests fail
+    # Analyze test performance
+    - name: Check test duration
+      if: always()
       shell: bash
       run: |
         echo "Test Duration: ${{ steps.test-execution.outputs.duration }} seconds"
 
-        # Report slowest tests for optimization
-        echo "Top 10 slowest tests:"
-        cat pytest.json | jq -r '.tests[] | select(.duration >= 1) | "\(.duration)s \(.name)"' | sort -rn | head -n 10
-
         # Warn if tests exceed time limit
         if [ "${{ steps.test-execution.outputs.duration }}" -gt "${{ inputs.max-test-time }}" ]; then
           echo "::warning::Test suite exceeded recommended duration of ${{ inputs.max-test-time }} seconds"

From a960a18614f29a2b5652a677afae98ef9e6b3419 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 08:46:44 +0000
Subject: [PATCH 27/45] Add cpu and gpu markers to tests to be able to
 explicitly choose them

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 6 +++---
 pyproject.toml                     | 4 ++++
 tests/conftest.py                  | 7 +++++++
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index fa63309760..68df15302b 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -137,9 +137,9 @@ runs:
 
         # Set device-specific pytest arguments
         if [ "${{ inputs.device }}" = "cpu" ]; then
-          DEVICE_ARGS="--markers='not gpu'"
+          DEVICE_ARGS="-m cpu"
         else
-          DEVICE_ARGS=""
+          DEVICE_ARGS="-m 'cpu or gpu'"  # Run all tests on GPU
         fi
 
         # Run pytest
@@ -150,7 +150,7 @@ runs:
           --timeout=${{ inputs.max-test-time }} \
           --verbosity=0 \
           --durations-only \
-          $DEVICE_ARGS
+          ${DEVICE_ARGS}
 
         # Store test result and duration
         exit_code=$?
diff --git a/pyproject.toml b/pyproject.toml
index 325c60cac9..efdad6e41c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -291,6 +291,10 @@ skips = ["B101"]
 addopts = ["--strict-markers", "--strict-config", "--showlocals", "-ra"]
 testpaths = "tests"
 pythonpath = "src"
+markers = [
+    "gpu: marks tests that require GPU",
+    "cpu: marks tests that can run on CPU only (default)",
+]
 
 
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
diff --git a/tests/conftest.py b/tests/conftest.py
index a9db6c1d3d..c2709ad275 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -101,3 +101,10 @@ def checkpoint(model_name: str) -> Path:
         return _ckpt_path
 
     return checkpoint
+
+
+def pytest_collection_modifyitems(items: list[pytest.Item]) -> None:
+    """Automatically mark tests as 'cpu' unless they're marked as 'gpu'."""
+    for item in items:
+        if not any(marker.name == "gpu" for marker in item.iter_markers()):
+            item.add_marker(pytest.mark.cpu)

From 6e988631fd75d5b747151b3b47c1ca64300f5dff Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 08:58:26 +0000
Subject: [PATCH 28/45] Handle duration, and fix failed tests status

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 68df15302b..5badedeac9 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -149,22 +149,21 @@ runs:
           --durations-min=1.0 \
           --timeout=${{ inputs.max-test-time }} \
           --verbosity=0 \
-          --durations-only \
           ${DEVICE_ARGS}
 
-        # Store test result and duration
-        exit_code=$?
-        echo "success=$exit_code" >> $GITHUB_OUTPUT
+        test_exit_code=$?
+        echo "success=$test_exit_code" >> $GITHUB_OUTPUT
 
         end_time=$(date +%s)
         duration=$((end_time - start_time))
         echo "duration=$duration" >> $GITHUB_OUTPUT
 
-        exit $exit_code
+        # Exit with the test result - this will set the step status but won't stop the workflow
+        exit $test_exit_code
 
-    # Fail the workflow if tests failed
+    # Always fail the workflow if tests failed, but after all steps complete
     - name: Check test results
-      if: steps.test-execution.outputs.success != '0'
+      if: always() && steps.test-execution.outcome != 'success'
       shell: bash
       run: exit 1
 
@@ -173,10 +172,11 @@ runs:
       if: always()
       shell: bash
       run: |
-        echo "Test Duration: ${{ steps.test-execution.outputs.duration }} seconds"
+        duration="${{ steps.test-execution.outputs.duration }}"
+        echo "Test Duration: ${duration:-0} seconds"
 
         # Warn if tests exceed time limit
-        if [ "${{ steps.test-execution.outputs.duration }}" -gt "${{ inputs.max-test-time }}" ]; then
+        if [ -n "$duration" ] && [ "$duration" -gt "${{ inputs.max-test-time }}" ]; then
           echo "::warning::Test suite exceeded recommended duration of ${{ inputs.max-test-time }} seconds"
         fi
 

From 2d444354df7d7539e13516c708f46c97811c9cdc Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 09:49:49 +0000
Subject: [PATCH 29/45] Add gpu marker to the tests that require gpu device

Signed-off-by: Samet Akcay 
---
 tests/unit/metrics/test_pro.py                              | 6 +++++-
 tests/unit/models/components/base/test_buffer_list_mixin.py | 6 +++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/tests/unit/metrics/test_pro.py b/tests/unit/metrics/test_pro.py
index 6b2731b4d5..e5d66ae313 100644
--- a/tests/unit/metrics/test_pro.py
+++ b/tests/unit/metrics/test_pro.py
@@ -70,8 +70,12 @@ def test_device_consistency() -> None:
     assert torch.isclose(pro_cpu.compute(), pro_gpu.compute().cpu())
 
 
+@pytest.mark.gpu
 def test_connected_component_labeling() -> None:
-    """Tests if the connected component labeling algorithms on cpu and gpu yield the same result."""
+    """Tests if the connected component labeling algorithms on cpu and gpu yield the same result.
+
+    Note: This test will only run on a GPU-enabled device.
+    """
     # generate batch of random binary images using perlin noise
     batch = torch.zeros((32, 1, 256, 256))
     for i in range(batch.shape[0]):
diff --git a/tests/unit/models/components/base/test_buffer_list_mixin.py b/tests/unit/models/components/base/test_buffer_list_mixin.py
index 82cbaf6794..449a77f6dd 100644
--- a/tests/unit/models/components/base/test_buffer_list_mixin.py
+++ b/tests/unit/models/components/base/test_buffer_list_mixin.py
@@ -48,9 +48,13 @@ def test_set_buffer_list(module: BufferListModule) -> None:
         module.tensor_list = tensor_list
         assert tensor_lists_are_equal(module.tensor_list, tensor_list)
 
+    @pytest.mark.gpu
     @staticmethod
     def test_buffer_list_device_placement(module: BufferListModule) -> None:
-        """Test if the device of the buffer list is updated with the module."""
+        """Test if the device of the buffer list is updated with the module.
+
+        Note: This test will only run on a GPU-enabled device.
+        """
         module.cuda()
         assert all(tensor.is_cuda for tensor in module.tensor_list)
         module.cpu()

From 1a7976fb680c15629b2e2b13ade35d01e35ff1a9 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 10:27:11 +0000
Subject: [PATCH 30/45] Enhance the error message on tests

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 60 +++++++++++++++++++++---------
 1 file changed, 42 insertions(+), 18 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 5badedeac9..edeafbbcbf 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -126,7 +126,6 @@ runs:
             ;;
         esac
 
-    # Execute test suite with performance tracking
     - name: Execute test suite
       id: test-execution
       shell: bash
@@ -139,54 +138,79 @@ runs:
         if [ "${{ inputs.device }}" = "cpu" ]; then
           DEVICE_ARGS="-m cpu"
         else
-          DEVICE_ARGS="-m 'cpu or gpu'"  # Run all tests on GPU
+          if python -c "import torch; print(torch.cuda.is_available())" | grep -q "True"; then
+            DEVICE_ARGS="-m 'cpu or gpu'"
+          else
+            echo "::warning::GPU requested but CUDA is not available. Running CPU tests only."
+            DEVICE_ARGS="-m cpu"
+          fi
         fi
 
-        # Run pytest
+        # Run pytest with settings to show all failures
         PYTHONPATH=src pytest ${{ steps.test-scope.outputs.path }} \
           --numprocesses=0 \
           --durations=10 \
           --durations-min=1.0 \
           --timeout=${{ inputs.max-test-time }} \
-          --verbosity=0 \
-          ${DEVICE_ARGS}
+          --verbosity=1 \
+          --tb=short \
+          -ra \
+          --no-header \
+          ${DEVICE_ARGS} | tee pytest_output.log
 
-        test_exit_code=$?
-        echo "success=$test_exit_code" >> $GITHUB_OUTPUT
+        test_exit_code=${PIPESTATUS[0]}
 
+        # Calculate and store duration
         end_time=$(date +%s)
         duration=$((end_time - start_time))
         echo "duration=$duration" >> $GITHUB_OUTPUT
+        echo "success=$([[ $test_exit_code == 0 ]] && echo true || echo false)" >> $GITHUB_OUTPUT
+
+        # Store test results summary
+        if [ $test_exit_code -ne 0 ]; then
+          echo "::error::Tests failed. See summary below:"
+          echo "----------------------------------------"
+          # Extract the summary section from pytest output
+          sed -n '/=* short test summary info =*/,$p' pytest_output.log || true
+          echo "----------------------------------------"
+          echo "Full test output saved to artifacts"
+        fi
 
-        # Exit with the test result - this will set the step status but won't stop the workflow
         exit $test_exit_code
 
-    # Always fail the workflow if tests failed, but after all steps complete
+    - name: Upload test results
+      if: always() && steps.test-execution.outcome == 'failure'
+      uses: actions/upload-artifact@v3
+      with:
+        name: pytest-results-${{ inputs.test-type }}
+        path: pytest_output.log
+        retention-days: 7
+
     - name: Check test results
-      if: always() && steps.test-execution.outcome != 'success'
+      if: always() && steps.test-execution.outcome == 'failure'
       shell: bash
       run: exit 1
 
-    # Analyze test performance
     - name: Check test duration
       if: always()
       shell: bash
       run: |
         duration="${{ steps.test-execution.outputs.duration }}"
-        echo "Test Duration: ${duration:-0} seconds"
+        if [ -n "$duration" ]; then
+          echo "Test Duration: $duration seconds"
 
-        # Warn if tests exceed time limit
-        if [ -n "$duration" ] && [ "$duration" -gt "${{ inputs.max-test-time }}" ]; then
-          echo "::warning::Test suite exceeded recommended duration of ${{ inputs.max-test-time }} seconds"
+          if [ "$duration" -gt "${{ inputs.max-test-time }}" ]; then
+            echo "::warning::Test suite exceeded recommended duration of ${{ inputs.max-test-time }} seconds"
+          fi
+        else
+          echo "Test Duration: Not available"
         fi
 
-    # Upload coverage data to Codecov
     - name: Upload coverage to Codecov
-      if: steps.test-execution.outputs.success == 'true'
+      if: success()
       shell: bash
       run: |
         source .venv/bin/activate
-        # Upload with test type and Python version tags
         codecov --token "${{ inputs.codecov-token }}" \
                 --file coverage.xml \
                 --flags "${{ inputs.test-type }}_py${{ inputs.python-version }}" \

From 4e0ec91678a70cc239d307f4b6dac8bf53fa7c17 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 11:20:59 +0000
Subject: [PATCH 31/45] pass pytest native marker to trigger cpu and gpu tests

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index edeafbbcbf..8cc0d98cf2 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -136,27 +136,19 @@ runs:
 
         # Set device-specific pytest arguments
         if [ "${{ inputs.device }}" = "cpu" ]; then
-          DEVICE_ARGS="-m cpu"
+          marker="cpu"
         else
-          if python -c "import torch; print(torch.cuda.is_available())" | grep -q "True"; then
-            DEVICE_ARGS="-m 'cpu or gpu'"
-          else
-            echo "::warning::GPU requested but CUDA is not available. Running CPU tests only."
-            DEVICE_ARGS="-m cpu"
-          fi
+          marker="cpu,gpu"  # Run both CPU and GPU tests
         fi
 
-        # Run pytest with settings to show all failures
+        # Run pytest with pytest's native marker expression
         PYTHONPATH=src pytest ${{ steps.test-scope.outputs.path }} \
           --numprocesses=0 \
           --durations=10 \
           --durations-min=1.0 \
           --timeout=${{ inputs.max-test-time }} \
           --verbosity=1 \
-          --tb=short \
-          -ra \
-          --no-header \
-          ${DEVICE_ARGS} | tee pytest_output.log
+          -m "$marker"
 
         test_exit_code=${PIPESTATUS[0]}
 

From 1b62c34a683c46102974aae361fc2967f43a524c Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 11:53:30 +0000
Subject: [PATCH 32/45] Remove gpu marker

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml                        | 8 ++++----
 .../unit/models/components/base/test_buffer_list_mixin.py | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 8cc0d98cf2..759c872a6f 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -136,19 +136,19 @@ runs:
 
         # Set device-specific pytest arguments
         if [ "${{ inputs.device }}" = "cpu" ]; then
-          marker="cpu"
+          marker="-m cpu"  # Only run CPU tests
         else
-          marker="cpu,gpu"  # Run both CPU and GPU tests
+          marker="-m gpu"  # Run all tests
         fi
 
-        # Run pytest with pytest's native marker expression
+        # Run pytest
         PYTHONPATH=src pytest ${{ steps.test-scope.outputs.path }} \
           --numprocesses=0 \
           --durations=10 \
           --durations-min=1.0 \
           --timeout=${{ inputs.max-test-time }} \
           --verbosity=1 \
-          -m "$marker"
+          ${marker}
 
         test_exit_code=${PIPESTATUS[0]}
 
diff --git a/tests/unit/models/components/base/test_buffer_list_mixin.py b/tests/unit/models/components/base/test_buffer_list_mixin.py
index 449a77f6dd..c18b4a6692 100644
--- a/tests/unit/models/components/base/test_buffer_list_mixin.py
+++ b/tests/unit/models/components/base/test_buffer_list_mixin.py
@@ -48,8 +48,8 @@ def test_set_buffer_list(module: BufferListModule) -> None:
         module.tensor_list = tensor_list
         assert tensor_lists_are_equal(module.tensor_list, tensor_list)
 
-    @pytest.mark.gpu
     @staticmethod
+    @pytest.mark.gpu
     def test_buffer_list_device_placement(module: BufferListModule) -> None:
         """Test if the device of the buffer list is updated with the module.
 

From 80007fecec239267d0f33035856e460d1d89c8db Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 13:17:52 +0000
Subject: [PATCH 33/45] Create a new caching pipeline

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 33 ++++++++++++++++++++++--------
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 759c872a6f..3288a70ed3 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -87,28 +87,45 @@ outputs:
 runs:
   using: composite
   steps:
-    # Set up Python with pip caching
     - name: Set up Python environment
       uses: actions/setup-python@v5
       with:
         python-version: ${{ inputs.python-version }}
-        cache: pip # Enable pip caching
-        cache-dependency-path: pyproject.toml
 
-    # Create and configure virtual environment
+    - name: Configure pip cache
+      shell: bash
+      run: |
+        CACHE_DIR="/opt/github/cache/pip"
+
+        # Ensure cache directory exists and is writable
+        sudo mkdir -p $CACHE_DIR
+        sudo chmod 777 $CACHE_DIR
+
+        # Configure pip to use the persistent cache
+        pip config set global.cache-dir $CACHE_DIR
+
+        # Display cache info
+        echo "Using pip cache directory: $(pip cache dir)"
+        echo "Current cache size: $(du -sh $CACHE_DIR 2>/dev/null || echo 'Empty')"
+
     - name: Configure virtual environment
       id: setup-venv
       shell: bash
       run: |
-        # Create isolated test environment
+        # Create and activate venv
         python -m venv .venv
         source .venv/bin/activate
-        # Install dependencies with dev extras
+
+        # Upgrade pip
         python -m pip install --upgrade pip
-        pip install ".[dev]"
+
+        # Install dependencies using the persistent cache
+        pip install --prefer-binary ".[dev]"
         pip install codecov
 
-    # Determine which tests to run based on input
+        # Show installed packages for debugging
+        pip list
+
     - name: Determine test scope
       id: test-scope
       shell: bash

From 4b9f6fb0fe4fe062a7e7d9658ad97cda97fb51ee Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 13:33:24 +0000
Subject: [PATCH 34/45] Add enable-cache as an input argument

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml          | 40 ++++++++-------------
 .github/workflows/_reusable-test-suite.yaml |  6 ++++
 .github/workflows/pr.yaml                   |  2 ++
 3 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 3288a70ed3..87b9e70ece 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -33,6 +33,7 @@
 # - codecov-token: Token for coverage upload
 # - max-test-time: Maximum test duration
 # - device: Device to run tests on (cpu/gpu)
+# - enable-cache: Enable pip caching
 #
 # Outputs:
 # - coverage-percentage: Total coverage
@@ -72,6 +73,10 @@ inputs:
     description: "Device to run tests on (cpu/gpu)"
     required: false
     default: "gpu"
+  enable-cache:
+    description: "Enable pip caching"
+    required: false
+    default: "true"
 
 outputs:
   coverage-percentage:
@@ -87,45 +92,28 @@ outputs:
 runs:
   using: composite
   steps:
+    # Set up Python with pip caching
     - name: Set up Python environment
       uses: actions/setup-python@v5
       with:
         python-version: ${{ inputs.python-version }}
+        cache: ${{ inputs.enable-cache == 'true' }}
+        cache-dependency-path: pyproject.toml
 
-    - name: Configure pip cache
-      shell: bash
-      run: |
-        CACHE_DIR="/opt/github/cache/pip"
-
-        # Ensure cache directory exists and is writable
-        sudo mkdir -p $CACHE_DIR
-        sudo chmod 777 $CACHE_DIR
-
-        # Configure pip to use the persistent cache
-        pip config set global.cache-dir $CACHE_DIR
-
-        # Display cache info
-        echo "Using pip cache directory: $(pip cache dir)"
-        echo "Current cache size: $(du -sh $CACHE_DIR 2>/dev/null || echo 'Empty')"
-
+    # Create and configure virtual environment
     - name: Configure virtual environment
       id: setup-venv
       shell: bash
       run: |
-        # Create and activate venv
+        # Create isolated test environment
         python -m venv .venv
         source .venv/bin/activate
-
-        # Upgrade pip
+        # Install dependencies with dev extras
         python -m pip install --upgrade pip
-
-        # Install dependencies using the persistent cache
-        pip install --prefer-binary ".[dev]"
+        pip install ".[dev]"
         pip install codecov
 
-        # Show installed packages for debugging
-        pip list
-
+    # Determine which tests to run based on input
     - name: Determine test scope
       id: test-scope
       shell: bash
@@ -155,7 +143,7 @@ runs:
         if [ "${{ inputs.device }}" = "cpu" ]; then
           marker="-m cpu"  # Only run CPU tests
         else
-          marker="-m gpu"  # Run all tests
+          marker=""  # Run all tests (both CPU and GPU marked tests)
         fi
 
         # Run pytest
diff --git a/.github/workflows/_reusable-test-suite.yaml b/.github/workflows/_reusable-test-suite.yaml
index ef0cadd68b..14edcd1244 100644
--- a/.github/workflows/_reusable-test-suite.yaml
+++ b/.github/workflows/_reusable-test-suite.yaml
@@ -31,6 +31,7 @@
 # - test-type: Type of test to run (unit/integration/e2e)
 # - runner: Runner to use for the tests
 # - timeout: Test timeout in minutes
+# - enable-cache: Enable pip caching
 #
 # Required Secrets:
 # - codecov-token: Token for coverage reporting (optional)
@@ -80,6 +81,10 @@ on:
         description: "Test timeout in minutes"
         type: number
         default: 10
+      enable-cache:
+        description: "Enable pip caching"
+        type: boolean
+        default: true
     secrets:
       codecov-token:
         required: false
@@ -108,3 +113,4 @@ jobs:
           test-type: ${{ inputs.test-type }}
           codecov-token: ${{ secrets.codecov-token }}
           device: ${{ contains(inputs.runner, 'self-hosted') && 'gpu' || 'cpu' }}
+          enable-cache: ${{ inputs.enable-cache }}
diff --git a/.github/workflows/pr.yaml b/.github/workflows/pr.yaml
index fa2cb8e0f8..33fac4a327 100644
--- a/.github/workflows/pr.yaml
+++ b/.github/workflows/pr.yaml
@@ -58,6 +58,7 @@ jobs:
     uses: ./.github/workflows/_reusable-test-suite.yaml
     with:
       test-type: "unit"
+      enable-cache: true
       runner: "ubuntu-latest"
       timeout: 10
     secrets:
@@ -67,6 +68,7 @@ jobs:
     uses: ./.github/workflows/_reusable-test-suite.yaml
     with:
       test-type: "integration"
+      enable-cache: false
       runner: "self-hosted"
       timeout: 30
     secrets:

From f4646cd8fd89c4631138ce8e02f9fee2f8d0b8cf Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 13:44:34 +0000
Subject: [PATCH 35/45] Add enable-cache as an input argument

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml          | 2 +-
 .github/workflows/_reusable-test-suite.yaml | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 87b9e70ece..8e3b7b6f68 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -97,7 +97,7 @@ runs:
       uses: actions/setup-python@v5
       with:
         python-version: ${{ inputs.python-version }}
-        cache: ${{ inputs.enable-cache == 'true' }}
+        cache: ${{ inputs.enable-cache == 'true' && 'pip' || 'none' }}
         cache-dependency-path: pyproject.toml
 
     # Create and configure virtual environment
diff --git a/.github/workflows/_reusable-test-suite.yaml b/.github/workflows/_reusable-test-suite.yaml
index 14edcd1244..3daac10189 100644
--- a/.github/workflows/_reusable-test-suite.yaml
+++ b/.github/workflows/_reusable-test-suite.yaml
@@ -83,8 +83,8 @@ on:
         default: 10
       enable-cache:
         description: "Enable pip caching"
-        type: boolean
-        default: true
+        type: string
+        default: "true"
     secrets:
       codecov-token:
         required: false

From f245ace376115ab537ee112adcb5d28dc11e2cf4 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 13:51:26 +0000
Subject: [PATCH 36/45] pass cache none for self-hosted runner

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 4 ++--
 .github/workflows/pr.yaml          | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 8e3b7b6f68..2dd319adf7 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -97,8 +97,8 @@ runs:
       uses: actions/setup-python@v5
       with:
         python-version: ${{ inputs.python-version }}
-        cache: ${{ inputs.enable-cache == 'true' && 'pip' || 'none' }}
-        cache-dependency-path: pyproject.toml
+        cache: ${{ inputs.enable-cache == 'true' && 'pip' || '' }}
+        cache-dependency-path: ${{ inputs.enable-cache == 'true' && 'pyproject.toml' || '' }}
 
     # Create and configure virtual environment
     - name: Configure virtual environment
diff --git a/.github/workflows/pr.yaml b/.github/workflows/pr.yaml
index 33fac4a327..789a3deaaa 100644
--- a/.github/workflows/pr.yaml
+++ b/.github/workflows/pr.yaml
@@ -58,9 +58,9 @@ jobs:
     uses: ./.github/workflows/_reusable-test-suite.yaml
     with:
       test-type: "unit"
-      enable-cache: true
       runner: "ubuntu-latest"
       timeout: 10
+      enable-cache: "true"
     secrets:
       codecov-token: ${{ secrets.CODECOV_TOKEN }}
 
@@ -68,9 +68,9 @@ jobs:
     uses: ./.github/workflows/_reusable-test-suite.yaml
     with:
       test-type: "integration"
-      enable-cache: false
       runner: "self-hosted"
       timeout: 30
+      enable-cache: "false"
     secrets:
       codecov-token: ${{ secrets.CODECOV_TOKEN }}
 

From 461f6d77fe7f848bbb28c11dbba85dfab5c55c70 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 14:34:12 +0000
Subject: [PATCH 37/45] fix the warning messages

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml            |  2 +-
 .github/actions/security/bandit/action.yaml   | 22 +++++++++---------
 .github/actions/security/clamav/action.yaml   | 20 ++++++++--------
 .github/actions/security/semgrep/action.yaml  | 23 +++++++++++--------
 .github/actions/security/trivy/action.yaml    |  6 ++---
 .../workflows/_reusable-security-scan.yaml    | 12 ++++++++--
 .github/workflows/pr.yaml                     |  2 +-
 7 files changed, 49 insertions(+), 38 deletions(-)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 2dd319adf7..929f0fee2f 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -68,7 +68,7 @@ inputs:
   max-test-time:
     description: "Maximum time in seconds for the test suite to run"
     required: false
-    default: "300"
+    default: "3600"
   device:
     description: "Device to run tests on (cpu/gpu)"
     required: false
diff --git a/.github/actions/security/bandit/action.yaml b/.github/actions/security/bandit/action.yaml
index a339cb3fca..7bac930196 100644
--- a/.github/actions/security/bandit/action.yaml
+++ b/.github/actions/security/bandit/action.yaml
@@ -27,9 +27,9 @@
 #    - Output formatting
 #
 # Required Inputs:
-# - scan_scope: Files to scan
+# - scan-scope: Files to scan
 # - severity_level: Issue severity threshold
-# - fail_on_findings: Whether to fail on issues
+# - fail-on-findings: Whether to fail on issues
 #
 # Outputs:
 # - scan_result: Scan exit code
@@ -39,7 +39,7 @@
 # steps:
 #   - uses: ./.github/actions/security/bandit
 #     with:
-#       scan_scope: "changed"
+#       scan-scope: "changed"
 #       severity_level: "MEDIUM"
 #
 # Note: Configure Bandit settings in pyproject.toml for best results
@@ -48,7 +48,7 @@ name: "Bandit Security Scan"
 description: "Runs Bandit security scanner with configurable options"
 
 inputs:
-  scan_scope:
+  scan-scope:
     description: "Scope of files to scan (all/changed)"
     required: false
     default: "changed"
@@ -68,11 +68,11 @@ inputs:
     description: "Minimum confidence level to report (all/LOW/MEDIUM/HIGH)"
     required: false
     default: "LOW"
-  output_format:
+  output-format:
     description: "Format for scan results (json/txt/html/csv)"
     required: false
     default: "json"
-  fail_on_findings:
+  fail-on-findings:
     description: "Whether to fail the action if issues are found"
     required: false
     default: "true"
@@ -100,7 +100,7 @@ runs:
         pip install bandit[toml]
 
     - name: Get changed files
-      if: inputs.scan_scope == 'changed'
+      if: inputs.scan-scope == 'changed'
       id: changed-files
       uses: tj-actions/changed-files@v41
       with:
@@ -113,9 +113,9 @@ runs:
       id: run-bandit
       shell: bash
       run: |
-        REPORT_FILE="bandit-report.${{ inputs.output_format }}"
+        REPORT_FILE="bandit-report.${{ inputs.output-format }}"
 
-        if [[ "${{ inputs.scan_scope }}" == "changed" && -n "${{ steps.changed-files.outputs.all_changed_files }}" ]]; then
+        if [[ "${{ inputs.scan-scope }}" == "changed" && -n "${{ steps.changed-files.outputs.all_changed_files }}" ]]; then
           echo "Running Bandit on changed files"
           FILES="${{ steps.changed-files.outputs.all_changed_files }}"
         else
@@ -131,12 +131,12 @@ runs:
           -c ${{ inputs.config_file }} \
           --severity-level ${SEVERITY} \
           --confidence-level ${CONFIDENCE} \
-          -f ${{ inputs.output_format }} \
+          -f ${{ inputs.output-format }} \
           -o "${REPORT_FILE}" \
           -r ${FILES} || echo "exit_code=$?" >> $GITHUB_OUTPUT
 
         echo "report_path=${REPORT_FILE}" >> $GITHUB_OUTPUT
 
-        if [[ "${{ inputs.fail_on_findings }}" == "true" && -n "$exit_code" && "$exit_code" != "0" ]]; then
+        if [[ "${{ inputs.fail-on-findings }}" == "true" && -n "$exit_code" && "$exit_code" != "0" ]]; then
           exit $exit_code
         fi
diff --git a/.github/actions/security/clamav/action.yaml b/.github/actions/security/clamav/action.yaml
index 8ed31fc7fa..a2200b50d4 100644
--- a/.github/actions/security/clamav/action.yaml
+++ b/.github/actions/security/clamav/action.yaml
@@ -27,7 +27,7 @@
 #    - Finding summary
 #
 # Required Inputs:
-# - scan_scope: Files to scan
+# - scan-scope: Files to scan
 # - exclude_dirs: Directories to skip
 # - max_file_size: Size limit for scanning
 #
@@ -40,7 +40,7 @@
 # steps:
 #   - uses: ./.github/actions/security/clamav
 #     with:
-#       scan_scope: "changed"
+#       scan-scope: "changed"
 #       exclude_dirs: ".git,node_modules"
 #
 # Note: Requires sufficient disk space for virus database
@@ -49,7 +49,7 @@ name: "ClamAV Security Scan"
 description: "Runs ClamAV antivirus scanner with configurable options"
 
 inputs:
-  scan_scope:
+  scan-scope:
     description: "Scope of files to scan (all/changed)"
     required: false
     default: "changed"
@@ -65,11 +65,11 @@ inputs:
     description: "Maximum file size to scan in MB"
     required: false
     default: "100"
-  output_format:
+  output-format:
     description: "Format for scan results (json/txt)"
     required: false
     default: "json"
-  fail_on_findings:
+  fail-on-findings:
     description: "Whether to fail the action if threats are found"
     required: false
     default: "true"
@@ -89,7 +89,7 @@ runs:
   using: composite
   steps:
     - name: Get changed files
-      if: inputs.scan_scope == 'changed'
+      if: inputs.scan-scope == 'changed'
       id: changed-files
       uses: tj-actions/changed-files@v41
 
@@ -115,7 +115,7 @@ runs:
           mkdir -p security-results/clamav
 
           # Run scan based on scope
-          if [ '${{ inputs.scan_scope }}' = 'changed' ] && [ -n '${{ steps.changed-files.outputs.all_changed_files }}' ]; then
+          if [ '${{ inputs.scan-scope }}' = 'changed' ] && [ -n '${{ steps.changed-files.outputs.all_changed_files }}' ]; then
             echo 'Running ClamAV on changed files'
             FILES='${{ steps.changed-files.outputs.all_changed_files }}'
             SCAN_CMD='clamscan'
@@ -141,7 +141,7 @@ runs:
           fi
 
           # Generate report
-          if [ '${{ inputs.output_format }}' = 'json' ]; then
+          if [ '${{ inputs.output-format }}' = 'json' ]; then
             echo '{
               \"scan_summary\": {
                 \"files_scanned\": '`grep 'Scanned files:' scan_output.txt | awk '{print $3}'`',
@@ -158,10 +158,10 @@ runs:
           {
             echo \"exit_code=$SCAN_EXIT_CODE\"
             echo \"threats_found=$INFECTED_FILES\"
-            echo \"report_path=security-results/clamav/report.${{ inputs.output_format }}\"
+            echo \"report_path=security-results/clamav/report.${{ inputs.output-format }}\"
           } > \"$GITHUB_OUTPUT\"
 
-          if [ '${{ inputs.fail_on_findings }}' = 'true' ] && [ $INFECTED_FILES -gt 0 ]; then
+          if [ '${{ inputs.fail-on-findings }}' = 'true' ] && [ $INFECTED_FILES -gt 0 ]; then
             exit 1
           fi
           "
diff --git a/.github/actions/security/semgrep/action.yaml b/.github/actions/security/semgrep/action.yaml
index e33c6f7851..583b910a4a 100644
--- a/.github/actions/security/semgrep/action.yaml
+++ b/.github/actions/security/semgrep/action.yaml
@@ -27,7 +27,7 @@
 #    - Output formatting
 #
 # Required Inputs:
-# - scan_scope: Files to scan
+# - scan-scope: Files to scan
 # - config: Rule configuration
 # - severity: Issue threshold
 #
@@ -39,7 +39,7 @@
 # steps:
 #   - uses: ./.github/actions/security/semgrep
 #     with:
-#       scan_scope: "changed"
+#       scan-scope: "changed"
 #       config: "p/owasp-top-ten"
 #
 # Note: Consider using custom rule sets for project-specific checks
@@ -48,7 +48,7 @@ name: "Semgrep SAST Scan"
 description: "Runs Semgrep security scanner with configurable options"
 
 inputs:
-  scan_scope:
+  scan-scope:
     description: "Scope of files to scan (all/changed)"
     required: false
     default: "changed"
@@ -68,11 +68,11 @@ inputs:
     description: "Maximum time to run semgrep in seconds"
     required: false
     default: "300"
-  output_format:
+  output-format:
     description: "Format for scan results (text/json/sarif)"
     required: false
     default: "sarif"
-  fail_on_findings:
+  fail-on-findings:
     description: "Whether to fail the action if issues are found"
     required: false
     default: "true"
@@ -100,7 +100,7 @@ runs:
         pip install semgrep
 
     - name: Get changed files
-      if: inputs.scan_scope == 'changed'
+      if: inputs.scan-scope == 'changed'
       id: changed-files
       uses: tj-actions/changed-files@v41
       with:
@@ -111,9 +111,12 @@ runs:
       id: run-semgrep
       shell: bash
       run: |
-        REPORT_FILE="semgrep-results.${{ inputs.output_format }}"
+        # Create results directory
+        mkdir -p security-results/semgrep
 
-        if [[ "${{ inputs.scan_scope }}" == "changed" && -n "${{ steps.changed-files.outputs.all_changed_files }}" ]]; then
+        REPORT_FILE="security-results/semgrep/semgrep-results.${{ inputs.output-format }}"
+
+        if [[ "${{ inputs.scan-scope }}" == "changed" && -n "${{ steps.changed-files.outputs.all_changed_files }}" ]]; then
           echo "Running Semgrep on changed files"
           FILES="${{ steps.changed-files.outputs.all_changed_files }}"
         else
@@ -125,12 +128,12 @@ runs:
           --config ${{ inputs.config }} \
           --severity ${{ inputs.severity }} \
           --timeout ${{ inputs.timeout }} \
-          --${{ inputs.output_format }} \
+          --${{ inputs.output-format }} \
           -o "${REPORT_FILE}" \
           ${FILES} || echo "exit_code=$?" >> $GITHUB_OUTPUT
 
         echo "report_path=${REPORT_FILE}" >> $GITHUB_OUTPUT
 
-        if [[ "${{ inputs.fail_on_findings }}" == "true" && -n "$exit_code" && "$exit_code" != "0" ]]; then
+        if [[ "${{ inputs.fail-on-findings }}" == "true" && -n "$exit_code" && "$exit_code" != "0" ]]; then
           exit $exit_code
         fi
diff --git a/.github/actions/security/trivy/action.yaml b/.github/actions/security/trivy/action.yaml
index 44f3ca4e95..a4cf78ee5e 100644
--- a/.github/actions/security/trivy/action.yaml
+++ b/.github/actions/security/trivy/action.yaml
@@ -53,7 +53,7 @@ inputs:
     description: "Type of scan to perform (fs/config/image/repo/rootfs)"
     required: false
     default: "fs"
-  scan_scope:
+  scan-scope:
     description: "Scope of files to scan (all/changed)"
     required: false
     default: "changed"
@@ -106,7 +106,7 @@ runs:
   using: composite
   steps:
     - name: Get changed files
-      if: inputs.scan_scope == 'changed'
+      if: inputs.scan-scope == 'changed'
       id: changed-files
       uses: tj-actions/changed-files@v41
 
@@ -140,7 +140,7 @@ runs:
         echo "Output will be saved to: ${REPORT_FILE}"
 
         # Always scan the entire directory but use different paths based on scope
-        if [[ "${{ inputs.scan_scope }}" == "changed" && -n "${{ steps.changed-files.outputs.all_changed_files }}" ]]; then
+        if [[ "${{ inputs.scan-scope }}" == "changed" && -n "${{ steps.changed-files.outputs.all_changed_files }}" ]]; then
           echo "Changed files detected, scanning repository"
           SCAN_TARGET="."
         else
diff --git a/.github/workflows/_reusable-security-scan.yaml b/.github/workflows/_reusable-security-scan.yaml
index 332804282c..3f88d05285 100644
--- a/.github/workflows/_reusable-security-scan.yaml
+++ b/.github/workflows/_reusable-security-scan.yaml
@@ -92,7 +92,7 @@ jobs:
         uses: ./.github/actions/security/semgrep
         with:
           scan-scope: ${{ inputs.scan-scope }}
-          severity-level: ${{ inputs.severity-level }}
+          severity: ${{ inputs.severity-level }}
           fail-on-findings: ${{ inputs.fail-on-findings }}
       - uses: actions/upload-artifact@v4
         if: always()
@@ -114,7 +114,7 @@ jobs:
         uses: ./.github/actions/security/trivy
         with:
           scan_type: "fs"
-          scan_scope: ${{ inputs.scan-scope }}
+          scan-scope: ${{ inputs.scan-scope }}
           severity: ${{ inputs.severity-level }},HIGH,CRITICAL
           scanners: "vuln,secret"
           format: "sarif"
@@ -166,14 +166,22 @@ jobs:
             echo "has_findings=false" >> $GITHUB_OUTPUT
           fi
 
+      # Create directory first
+      - name: Create results directory
+        run: mkdir -p all-results
+
+      # Download artifacts with error handling
       - name: Download all results
         uses: actions/download-artifact@v4
+        continue-on-error: true # Don't fail if some tools didn't generate results
         with:
           pattern: "*-results"
           merge-multiple: true
           path: all-results
 
+      # Only upload if there are files
       - name: Upload combined results
+        if: hashFiles('all-results/**/*') != ''
         uses: actions/upload-artifact@v4
         with:
           name: security-scan-results
diff --git a/.github/workflows/pr.yaml b/.github/workflows/pr.yaml
index 789a3deaaa..bf46101497 100644
--- a/.github/workflows/pr.yaml
+++ b/.github/workflows/pr.yaml
@@ -69,7 +69,7 @@ jobs:
     with:
       test-type: "integration"
       runner: "self-hosted"
-      timeout: 30
+      timeout: 60
       enable-cache: "false"
     secrets:
       codecov-token: ${{ secrets.CODECOV_TOKEN }}

From 9887c946f3929f127fd570e95531801b08f10cfc Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 14:51:47 +0000
Subject: [PATCH 38/45] Map semgrep severity level keys

Signed-off-by: Samet Akcay 
---
 .github/actions/security/bandit/action.yaml  |  1 -
 .github/actions/security/semgrep/action.yaml | 18 +++++++++++++++++-
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/.github/actions/security/bandit/action.yaml b/.github/actions/security/bandit/action.yaml
index 7bac930196..1b89ef2e71 100644
--- a/.github/actions/security/bandit/action.yaml
+++ b/.github/actions/security/bandit/action.yaml
@@ -62,7 +62,6 @@ inputs:
     default: "pyproject.toml"
   severity_level:
     description: "Minimum severity level to report (all/LOW/MEDIUM/HIGH)"
-    required: false
     default: "LOW"
   confidence_level:
     description: "Minimum confidence level to report (all/LOW/MEDIUM/HIGH)"
diff --git a/.github/actions/security/semgrep/action.yaml b/.github/actions/security/semgrep/action.yaml
index 583b910a4a..85b726a4c9 100644
--- a/.github/actions/security/semgrep/action.yaml
+++ b/.github/actions/security/semgrep/action.yaml
@@ -111,6 +111,22 @@ runs:
       id: run-semgrep
       shell: bash
       run: |
+        # Map standard severity levels to Semgrep's levels
+        case "${{ inputs.severity }}" in
+          "LOW")
+            SEMGREP_SEVERITY="INFO"
+            ;;
+          "MEDIUM")
+            SEMGREP_SEVERITY="WARNING"
+            ;;
+          "HIGH"|"CRITICAL")
+            SEMGREP_SEVERITY="ERROR"
+            ;;
+          *)
+            SEMGREP_SEVERITY="WARNING"
+            ;;
+        esac
+
         # Create results directory
         mkdir -p security-results/semgrep
 
@@ -126,7 +142,7 @@ runs:
 
         semgrep \
           --config ${{ inputs.config }} \
-          --severity ${{ inputs.severity }} \
+          --severity $SEMGREP_SEVERITY \
           --timeout ${{ inputs.timeout }} \
           --${{ inputs.output-format }} \
           -o "${REPORT_FILE}" \

From 725173994596765030ecb6463ece813d06789216 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 12 Dec 2024 16:18:02 +0000
Subject: [PATCH 39/45] Add coverage args

Signed-off-by: Samet Akcay 
---
 .github/actions/pytest/action.yaml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/actions/pytest/action.yaml b/.github/actions/pytest/action.yaml
index 929f0fee2f..8c86eacada 100644
--- a/.github/actions/pytest/action.yaml
+++ b/.github/actions/pytest/action.yaml
@@ -153,6 +153,9 @@ runs:
           --durations-min=1.0 \
           --timeout=${{ inputs.max-test-time }} \
           --verbosity=1 \
+          --cov=src \
+          --cov-report=xml \
+          --cov-report=term-missing \
           ${marker}
 
         test_exit_code=${PIPESTATUS[0]}

From 58453efec4d0ebfb063f3ab0df8890d8b8e55744 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Thu, 19 Dec 2024 18:16:20 +0000
Subject: [PATCH 40/45] =?UTF-8?q?=F0=9F=93=9A=20Update=20Documentation=20a?=
 =?UTF-8?q?nd=20Docstrings=20(#2468)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* update conf.py

Signed-off-by: Samet Akcay 

* Remove requirements.txt

Signed-off-by: Samet Akcay 

* Remove topic guide

Signed-off-by: Samet Akcay 

* Update conf.py

Signed-off-by: Samet Akcay 

* Add api guide landing page

Signed-off-by: Samet Akcay 

* Add data landing page

Signed-off-by: Samet Akcay 

* Add data documentation

Signed-off-by: Samet Akcay 

* Deleted files

Signed-off-by: Samet Akcay 

* Deleted files

Signed-off-by: Samet Akcay 

* Deleted files

Signed-off-by: Samet Akcay 

* Modified files

Signed-off-by: Samet Akcay 

* Modified files

Signed-off-by: Samet Akcay 

* Update callback docstrings

Signed-off-by: Samet Akcay 

* Update cli docstrings

Signed-off-by: Samet Akcay 

* Update callback docstrings

Signed-off-by: Samet Akcay 

* Update dataclasses and datamodules docstrings

Signed-off-by: Samet Akcay 

* Update datasets docstrings

Signed-off-by: Samet Akcay 

* Update utils docstrings

Signed-off-by: Samet Akcay 

* Update validators docstrings

Signed-off-by: Samet Akcay 

* Add the remaining docstrings

Signed-off-by: Samet Akcay 

* Add deploy docstrings

Signed-off-by: Samet Akcay 

* Add engine docstrings

Signed-off-by: Samet Akcay 

* Add logger docstrings

Signed-off-by: Samet Akcay 

* Add pimo docstrings

Signed-off-by: Samet Akcay 

* Add threshold docstrings

Signed-off-by: Samet Akcay 

* Add threshold docstrings

Signed-off-by: Samet Akcay 

* Add model components docstrings

Signed-off-by: Samet Akcay 

* add cfa

Signed-off-by: Samet Akcay 

* add cflow

Signed-off-by: Samet Akcay 

* add csflow

Signed-off-by: Samet Akcay 

* add dfm

Signed-off-by: Samet Akcay 

* add draem

Signed-off-by: Samet Akcay 

* add dsr

Signed-off-by: Samet Akcay 

* Add efficient-ad

Signed-off-by: Samet Akcay 

* add fastflow

Signed-off-by: Samet Akcay 

* add fre

Signed-off-by: Samet Akcay 

* add ganomaly

Signed-off-by: Samet Akcay 

* add patchcore

Signed-off-by: Samet Akcay 

* add reverse distillation

Signed-off-by: Samet Akcay 

* add stfpm

Signed-off-by: Samet Akcay 

* add uflow

Signed-off-by: Samet Akcay 

* add vlm-ad

Signed-off-by: Samet Akcay 

* add winclip

Signed-off-by: Samet Akcay 

* Add ai-vad

Signed-off-by: Samet Akcay 

* Add pipelines

Signed-off-by: Samet Akcay 

* Add pre and post processors

Signed-off-by: Samet Akcay 

* Add utils

Signed-off-by: Samet Akcay 

* Add visualizer

Signed-off-by: Samet Akcay 

* Update the licenses

Signed-off-by: Samet Akcay 

* Revert validators

Signed-off-by: Samet Akcay 

* Revert item_visualizer.py

Signed-off-by: Samet Akcay 

* Fix visualization tests due to a deprecated function in matplotlib

Signed-off-by: Samet Akcay 

---------

Signed-off-by: Samet Akcay 
---
 docs/Makefile                                 |   2 +-
 docs/requirements.txt                         |   8 -
 docs/source/conf.py                           |  60 +-
 docs/source/index.md                          |   9 -
 .../guides/reference/callbacks/index.md       |  86 +-
 .../markdown/guides/reference/cli/index.md    |   2 +-
 .../guides/reference/data/base/datamodule.md  |   7 -
 .../guides/reference/data/base/dataset.md     |   7 -
 .../guides/reference/data/base/depth.md       |   7 -
 .../guides/reference/data/base/index.md       |  43 -
 .../guides/reference/data/base/video.md       |   7 -
 .../reference/data/dataclasses/generic.md     | 111 +++
 .../reference/data/dataclasses/index.md       |  70 ++
 .../reference/data/dataclasses/numpy.md       |  93 +++
 .../reference/data/dataclasses/torch.md       | 109 +++
 .../reference/data/datamodules/base/image.md  |   7 +
 .../reference/data/datamodules/base/index.md  |  21 +
 .../reference/data/datamodules/base/video.md  |   7 +
 .../data/datamodules/depth/folder_3d.md       |   7 +
 .../reference/data/datamodules/depth/index.md |  31 +
 .../data/datamodules/depth/mvtec_3d.md        |   7 +
 .../reference/data/datamodules/image.md       |  60 ++
 .../reference/data/datamodules/image/btech.md |   7 +
 .../data/datamodules/image/datumaro.md        |   7 +
 .../data/datamodules/image/folder.md          |   7 +
 .../reference/data/datamodules/image/index.md |  63 ++
 .../data/datamodules/image/kolektor.md        |   7 +
 .../reference/data/datamodules/image/mvtec.md |   7 +
 .../reference/data/datamodules/image/visa.md  |   7 +
 .../reference/data/datamodules/index.md       | 107 +++
 .../reference/data/datamodules/video.md       |  39 +
 .../data/datamodules/video/avenue.md          |   7 +
 .../reference/data/datamodules/video/index.md |  39 +
 .../data/datamodules/video/shanghaitech.md    |   7 +
 .../data/datamodules/video/ucsdped.md         |   7 +
 .../guides/reference/data/depth/folder_3d.md  |   7 -
 .../guides/reference/data/depth/index.md      |  27 -
 .../guides/reference/data/depth/mvtec_3d.md   |   7 -
 .../guides/reference/data/image/btech.md      |   7 -
 .../guides/reference/data/image/folder.md     |   7 -
 .../guides/reference/data/image/index.md      |  51 --
 .../guides/reference/data/image/kolektor.md   |   7 -
 .../guides/reference/data/image/mvtec.md      |   7 -
 .../guides/reference/data/image/visa.md       |   7 -
 .../markdown/guides/reference/data/index.md   |  65 +-
 .../guides/reference/data/utils/index.md      |   9 +-
 .../guides/reference/data/utils/transforms.md |   7 -
 .../guides/reference/data/video/avenue.md     |   7 -
 .../guides/reference/data/video/index.md      |  35 -
 .../reference/data/video/shanghaitech.md      |   7 -
 .../guides/reference/data/video/ucsd_ped.md   |   7 -
 .../markdown/guides/reference/deploy/index.md |   2 +-
 .../markdown/guides/reference/engine/index.md |   3 +-
 .../source/markdown/guides/reference/index.md |  92 +-
 .../guides/reference/loggers/index.md         |  69 +-
 .../guides/reference/models/image/fre.md      |  13 +
 .../guides/reference/models/image/index.md    |  15 +
 .../guides/reference/models/image/vlm_ad.md   |   8 +
 .../markdown/guides/reference/models/index.md |  15 +-
 .../guides/reference/post_processing/index.md |  46 +
 .../guides/reference/pre_processing/index.md  |   7 +
 docs/source/markdown/guides/topic/index.md    |   7 -
 pyproject.toml                                |   2 +-
 src/anomalib/__init__.py                      |  71 +-
 src/anomalib/callbacks/__init__.py            |  84 +-
 src/anomalib/callbacks/checkpoint.py          | 111 ++-
 src/anomalib/callbacks/graph.py               |  97 ++-
 src/anomalib/callbacks/model_loader.py        |  60 +-
 src/anomalib/callbacks/nncf/__init__.py       |   2 +-
 src/anomalib/callbacks/nncf/callback.py       | 102 ++-
 src/anomalib/callbacks/nncf/utils.py          | 226 ++++-
 src/anomalib/callbacks/tiler_configuration.py | 108 ++-
 src/anomalib/callbacks/timer.py               | 111 ++-
 src/anomalib/callbacks/visualizer.py          | 160 +++-
 src/anomalib/cli/__init__.py                  |   2 +-
 src/anomalib/cli/cli.py                       |  36 +-
 src/anomalib/cli/install.py                   |  32 +-
 src/anomalib/cli/pipelines.py                 |  35 +-
 src/anomalib/cli/utils/__init__.py            |   2 +-
 src/anomalib/cli/utils/help_formatter.py      | 268 ++++--
 src/anomalib/cli/utils/installation.py        | 250 +++---
 src/anomalib/cli/utils/openvino.py            |  46 +-
 src/anomalib/data/__init__.py                 |  51 +-
 src/anomalib/data/dataclasses/__init__.py     |  89 +-
 src/anomalib/data/dataclasses/generic.py      | 772 ++++++++++-------
 .../data/dataclasses/numpy/__init__.py        |  63 +-
 src/anomalib/data/dataclasses/numpy/base.py   |  41 +-
 src/anomalib/data/dataclasses/numpy/depth.py  |  63 +-
 src/anomalib/data/dataclasses/numpy/image.py  |  95 ++-
 src/anomalib/data/dataclasses/numpy/video.py  |  53 +-
 src/anomalib/data/dataclasses/torch/base.py   |  79 +-
 src/anomalib/data/dataclasses/torch/depth.py  |  37 +-
 src/anomalib/data/dataclasses/torch/image.py  |  91 +-
 src/anomalib/data/dataclasses/torch/video.py  |  86 +-
 src/anomalib/data/datamodules/base/image.py   | 198 +++--
 src/anomalib/data/datamodules/base/video.py   |  42 +-
 .../data/datamodules/depth/__init__.py        |   2 +-
 .../data/datamodules/depth/folder_3d.py       |  91 +-
 .../data/datamodules/depth/mvtec_3d.py        |  59 +-
 .../data/datamodules/image/__init__.py        |  36 +-
 src/anomalib/data/datamodules/image/btech.py  | 167 ++--
 .../data/datamodules/image/datumaro.py        |  85 +-
 src/anomalib/data/datamodules/image/folder.py | 155 ++--
 .../data/datamodules/image/kolektor.py        |  81 +-
 src/anomalib/data/datamodules/image/mvtec.py  | 170 ++--
 src/anomalib/data/datamodules/image/visa.py   | 141 ++--
 .../data/datamodules/video/__init__.py        |  29 +-
 src/anomalib/data/datamodules/video/avenue.py | 204 +++--
 .../data/datamodules/video/shanghaitech.py    |  97 ++-
 .../data/datamodules/video/ucsd_ped.py        |  57 +-
 src/anomalib/data/datasets/__init__.py        |  35 +-
 src/anomalib/data/datasets/base/__init__.py   |  13 +-
 src/anomalib/data/datasets/base/depth.py      |  44 +-
 src/anomalib/data/datasets/base/image.py      | 200 ++++-
 src/anomalib/data/datasets/base/video.py      |  95 ++-
 src/anomalib/data/datasets/depth/__init__.py  |  24 +-
 src/anomalib/data/datasets/depth/folder_3d.py | 146 ++--
 src/anomalib/data/datasets/depth/mvtec_3d.py  | 140 ++--
 src/anomalib/data/datasets/image/__init__.py  |  21 +-
 src/anomalib/data/datasets/image/btech.py     | 100 ++-
 src/anomalib/data/datasets/image/datumaro.py  | 114 +--
 src/anomalib/data/datasets/image/folder.py    | 182 ++--
 src/anomalib/data/datasets/image/kolektor.py  | 122 +--
 src/anomalib/data/datasets/image/mvtec.py     | 185 +++--
 src/anomalib/data/datasets/image/visa.py      |  73 +-
 src/anomalib/data/datasets/video/__init__.py  |  17 +-
 src/anomalib/data/datasets/video/avenue.py    | 166 ++--
 .../data/datasets/video/shanghaitech.py       | 181 +++-
 src/anomalib/data/datasets/video/ucsd_ped.py  | 132 ++-
 src/anomalib/data/errors.py                   |  25 +-
 src/anomalib/data/image/datumaro.py           | 226 -----
 src/anomalib/data/predict.py                  |  61 +-
 src/anomalib/data/transforms/center_crop.py   |  89 +-
 .../data/transforms/multi_random_choice.py    |  55 +-
 src/anomalib/data/utils/__init__.py           |  21 +-
 src/anomalib/data/utils/boxes.py              |  98 ++-
 src/anomalib/data/utils/download.py           | 229 +++--
 .../data/utils/generators/__init__.py         |  24 +-
 src/anomalib/data/utils/generators/perlin.py  | 104 ++-
 src/anomalib/data/utils/image.py              | 355 ++++----
 src/anomalib/data/utils/label.py              |  29 +-
 src/anomalib/data/utils/path.py               | 181 ++--
 src/anomalib/data/utils/split.py              | 117 ++-
 src/anomalib/data/utils/synthetic.py          | 134 ++-
 src/anomalib/data/utils/tiler.py              | 302 ++++---
 src/anomalib/data/utils/video.py              |  92 +-
 .../data/validators/numpy/__init__.py         |  28 +-
 src/anomalib/data/validators/numpy/depth.py   | 323 +++++++-
 src/anomalib/data/validators/numpy/image.py   | 783 ++++++++++++------
 src/anomalib/data/validators/numpy/video.py   | 245 ++++--
 src/anomalib/data/validators/path.py          | 121 ++-
 .../data/validators/torch/__init__.py         |  31 +-
 src/anomalib/data/validators/torch/depth.py   | 414 ++++++---
 src/anomalib/data/validators/torch/image.py   | 556 +++++++++----
 src/anomalib/data/validators/torch/video.py   | 522 ++++++++----
 src/anomalib/deploy/__init__.py               |  24 +-
 src/anomalib/deploy/export.py                 |  61 +-
 src/anomalib/deploy/inferencers/__init__.py   |  17 +-
 .../deploy/inferencers/base_inferencer.py     | 155 +++-
 .../deploy/inferencers/openvino_inferencer.py | 172 ++--
 .../deploy/inferencers/torch_inferencer.py    | 155 ++--
 src/anomalib/engine/__init__.py               |  25 +-
 src/anomalib/engine/engine.py                 | 103 ++-
 src/anomalib/loggers/__init__.py              |  47 +-
 src/anomalib/loggers/base.py                  |  42 +-
 src/anomalib/loggers/comet.py                 | 136 +--
 src/anomalib/loggers/mlflow.py                | 104 ++-
 src/anomalib/loggers/tensorboard.py           | 106 ++-
 src/anomalib/loggers/wandb.py                 | 104 ++-
 src/anomalib/metrics/__init__.py              |  39 +-
 .../metrics/anomaly_score_distribution.py     |  68 +-
 src/anomalib/metrics/aupr.py                  |  32 +-
 src/anomalib/metrics/aupro.py                 | 158 +++-
 src/anomalib/metrics/auroc.py                 |  72 +-
 src/anomalib/metrics/base.py                  | 164 ++--
 src/anomalib/metrics/binning.py               |  63 +-
 src/anomalib/metrics/evaluator.py             |  49 +-
 src/anomalib/metrics/f1_score.py              | 144 +++-
 src/anomalib/metrics/min_max.py               |  82 +-
 src/anomalib/metrics/pimo/__init__.py         |  20 +-
 src/anomalib/metrics/pimo/_validate.py        | 400 ++++++++-
 .../pimo/binary_classification_curve.py       | 274 +++---
 src/anomalib/metrics/pimo/dataclasses.py      | 249 ++++--
 src/anomalib/metrics/pimo/functional.py       | 252 ++++--
 src/anomalib/metrics/pimo/pimo.py             | 270 +++---
 src/anomalib/metrics/pimo/utils.py            |  39 +-
 src/anomalib/metrics/plotting_utils.py        |  54 +-
 .../metrics/precision_recall_curve.py         |  62 +-
 src/anomalib/metrics/pro.py                   | 125 ++-
 src/anomalib/metrics/threshold/__init__.py    |  20 +-
 src/anomalib/metrics/threshold/base.py        |  83 +-
 .../threshold/f1_adaptive_threshold.py        |  86 +-
 .../metrics/threshold/manual_threshold.py     |  26 +-
 src/anomalib/models/__init__.py               | 165 +++-
 src/anomalib/models/components/__init__.py    |  36 +-
 .../models/components/base/__init__.py        |  19 +-
 .../models/components/base/anomalib_module.py | 421 ++++++----
 .../models/components/base/buffer_list.py     | 151 ++--
 .../models/components/base/dynamic_buffer.py  |  55 +-
 .../models/components/base/export_mixin.py    | 280 +++----
 .../components/base/memory_bank_module.py     |  57 +-
 .../components/classification/__init__.py     |  19 +-
 .../classification/kde_classifier.py          | 138 ++-
 .../models/components/cluster/__init__.py     |  20 +-
 src/anomalib/models/components/cluster/gmm.py | 148 ++--
 .../models/components/cluster/kmeans.py       |  87 +-
 .../dimensionality_reduction/__init__.py      |  25 +-
 .../dimensionality_reduction/pca.py           | 151 ++--
 .../random_projection.py                      | 133 +--
 .../components/feature_extractors/__init__.py |  26 +-
 .../components/feature_extractors/timm.py     | 116 ++-
 .../components/feature_extractors/torchfx.py  | 263 +++---
 .../components/feature_extractors/utils.py    |  62 +-
 .../models/components/filters/__init__.py     |  18 +-
 .../models/components/filters/blur.py         |  85 +-
 .../models/components/flow/__init__.py        |  21 +-
 .../components/flow/all_in_one_block.py       | 210 +++--
 .../models/components/layers/__init__.py      |  21 +-
 .../models/components/layers/sspcab.py        | 121 ++-
 .../models/components/sampling/__init__.py    |  21 +-
 .../components/sampling/k_center_greedy.py    |  65 +-
 .../models/components/stats/__init__.py       |  24 +-
 src/anomalib/models/components/stats/kde.py   |  76 +-
 .../stats/multi_variate_gaussian.py           | 100 ++-
 src/anomalib/models/image/__init__.py         |  37 +-
 src/anomalib/models/image/cfa/__init__.py     |  21 +-
 src/anomalib/models/image/cfa/anomaly_map.py  |  78 +-
 .../models/image/cfa/lightning_model.py       |  98 ++-
 src/anomalib/models/image/cfa/loss.py         |  60 +-
 src/anomalib/models/image/cfa/torch_model.py  | 253 ++++--
 src/anomalib/models/image/cflow/__init__.py   |  24 +-
 .../models/image/cflow/anomaly_map.py         |  94 ++-
 .../models/image/cflow/lightning_model.py     | 116 ++-
 .../models/image/cflow/torch_model.py         |  88 +-
 src/anomalib/models/image/cflow/utils.py      |  91 +-
 src/anomalib/models/image/csflow/__init__.py  |  23 +-
 .../models/image/csflow/anomaly_map.py        |  60 +-
 .../models/image/csflow/lightning_model.py    | 101 ++-
 src/anomalib/models/image/csflow/loss.py      |  45 +-
 .../models/image/csflow/torch_model.py        | 235 ++++--
 src/anomalib/models/image/dfkde/__init__.py   |  22 +-
 .../models/image/dfkde/lightning_model.py     | 102 ++-
 .../models/image/dfkde/torch_model.py         |  94 ++-
 src/anomalib/models/image/dfm/__init__.py     |  22 +-
 .../models/image/dfm/lightning_model.py       | 115 ++-
 src/anomalib/models/image/dfm/torch_model.py  | 123 ++-
 src/anomalib/models/image/draem/__init__.py   |  21 +-
 .../models/image/draem/lightning_model.py     | 126 ++-
 src/anomalib/models/image/draem/loss.py       |  46 +-
 .../models/image/draem/torch_model.py         | 194 +++--
 src/anomalib/models/image/dsr/__init__.py     |  21 +-
 .../models/image/dsr/anomaly_generator.py     |  61 +-
 .../models/image/dsr/lightning_model.py       | 164 +++-
 src/anomalib/models/image/dsr/loss.py         |  98 ++-
 src/anomalib/models/image/dsr/torch_model.py  | 119 ++-
 .../models/image/efficient_ad/__init__.py     |  13 +-
 .../image/efficient_ad/lightning_model.py     | 209 +++--
 .../models/image/efficient_ad/torch_model.py  | 376 +++++++--
 .../models/image/fastflow/__init__.py         |  28 +-
 .../models/image/fastflow/anomaly_map.py      |  55 +-
 .../models/image/fastflow/lightning_model.py  |  74 +-
 src/anomalib/models/image/fastflow/loss.py    |  50 +-
 src/anomalib/models/image/fre/__init__.py     |  24 +-
 .../models/image/fre/lightning_model.py       | 116 ++-
 src/anomalib/models/image/fre/torch_model.py  | 127 ++-
 .../models/image/ganomaly/__init__.py         |  28 +-
 .../models/image/ganomaly/lightning_model.py  |  86 +-
 src/anomalib/models/image/ganomaly/loss.py    |  89 +-
 .../models/image/ganomaly/torch_model.py      | 234 ++++--
 src/anomalib/models/image/padim/__init__.py   |  15 +-
 .../models/image/padim/anomaly_map.py         | 118 ++-
 .../models/image/padim/lightning_model.py     | 110 ++-
 .../models/image/padim/torch_model.py         |  85 +-
 .../models/image/patchcore/__init__.py        |  24 +-
 .../models/image/patchcore/anomaly_map.py     |  75 +-
 .../models/image/patchcore/lightning_model.py | 168 +++-
 .../models/image/patchcore/torch_model.py     | 238 +++++-
 .../image/reverse_distillation/__init__.py    |  25 +-
 .../image/reverse_distillation/anomaly_map.py |  24 +-
 .../components/__init__.py                    |  26 +-
 .../components/bottleneck.py                  |  93 ++-
 .../components/de_resnet.py                   | 225 ++++-
 .../reverse_distillation/lightning_model.py   |  23 +-
 .../models/image/reverse_distillation/loss.py |  72 +-
 .../image/reverse_distillation/torch_model.py | 112 ++-
 src/anomalib/models/image/stfpm/__init__.py   |  31 +-
 .../models/image/stfpm/anomaly_map.py         | 119 ++-
 .../models/image/stfpm/lightning_model.py     | 120 ++-
 src/anomalib/models/image/stfpm/loss.py       | 112 ++-
 .../models/image/stfpm/torch_model.py         |  95 ++-
 src/anomalib/models/image/uflow/__init__.py   |  30 +-
 .../models/image/uflow/anomaly_map.py         | 138 ++-
 .../models/image/uflow/feature_extraction.py  | 176 +++-
 .../models/image/uflow/lightning_model.py     | 174 +++-
 src/anomalib/models/image/uflow/loss.py       |  56 +-
 .../models/image/uflow/torch_model.py         | 170 +++-
 src/anomalib/models/image/vlm_ad/__init__.py  |  21 +-
 .../models/image/vlm_ad/backends/__init__.py  |  21 +-
 .../models/image/vlm_ad/backends/base.py      |  78 +-
 .../models/image/vlm_ad/backends/chat_gpt.py  | 136 ++-
 .../image/vlm_ad/backends/huggingface.py      | 117 ++-
 .../models/image/vlm_ad/backends/ollama.py    | 109 ++-
 .../models/image/vlm_ad/lightning_model.py    | 117 ++-
 src/anomalib/models/image/vlm_ad/utils.py     |  66 +-
 src/anomalib/models/image/winclip/__init__.py |  16 +-
 .../models/image/winclip/lightning_model.py   | 179 +++-
 .../models/image/winclip/prompting.py         |  57 +-
 .../models/image/winclip/torch_model.py       | 277 ++++---
 src/anomalib/models/image/winclip/utils.py    | 190 +++--
 src/anomalib/models/video/__init__.py         |  29 +-
 src/anomalib/models/video/ai_vad/__init__.py  |  29 +-
 src/anomalib/models/video/ai_vad/density.py   | 318 +++++--
 src/anomalib/models/video/ai_vad/features.py  | 209 ++++-
 src/anomalib/models/video/ai_vad/flow.py      |  21 +-
 .../models/video/ai_vad/lightning_model.py    | 171 +++-
 src/anomalib/models/video/ai_vad/regions.py   | 155 ++--
 .../models/video/ai_vad/torch_model.py        | 129 ++-
 src/anomalib/pipelines/__init__.py            |  25 +-
 src/anomalib/pipelines/benchmark/__init__.py  |  21 +-
 src/anomalib/pipelines/benchmark/generator.py |  67 +-
 src/anomalib/pipelines/benchmark/job.py       | 115 ++-
 src/anomalib/pipelines/benchmark/pipeline.py  |  69 +-
 src/anomalib/pipelines/components/__init__.py |  23 +-
 .../pipelines/components/base/__init__.py     |  26 +-
 src/anomalib/pipelines/components/base/job.py |  32 +-
 .../pipelines/components/base/pipeline.py     |  25 +-
 .../pipelines/components/base/runner.py       |  29 +-
 .../pipelines/components/runners/__init__.py  |  20 +-
 .../pipelines/components/runners/parallel.py  |  70 +-
 .../pipelines/components/runners/serial.py    |  88 +-
 .../pipelines/components/utils/__init__.py    |  20 +-
 .../pipelines/components/utils/grid_search.py |  34 +-
 src/anomalib/pipelines/types.py               |  18 +-
 src/anomalib/post_processing/__init__.py      |  19 +-
 src/anomalib/post_processing/base.py          |  55 +-
 src/anomalib/post_processing/one_class.py     | 180 +++-
 src/anomalib/pre_processing/__init__.py       |  21 +-
 src/anomalib/pre_processing/pre_processing.py | 103 ++-
 src/anomalib/pre_processing/utils/__init__.py |  15 +-
 .../pre_processing/utils/transform.py         | 229 ++++-
 src/anomalib/utils/__init__.py                |  27 +-
 src/anomalib/utils/config.py                  | 402 +++++++--
 src/anomalib/utils/cv/__init__.py             |  20 +-
 src/anomalib/utils/cv/connected_components.py |  85 +-
 src/anomalib/utils/exceptions/__init__.py     |  19 +-
 src/anomalib/utils/exceptions/imports.py      |  45 +-
 src/anomalib/utils/logging.py                 | 118 ++-
 src/anomalib/utils/normalization/__init__.py  |  44 +-
 src/anomalib/utils/normalization/min_max.py   |  57 +-
 src/anomalib/utils/path.py                    | 193 ++++-
 src/anomalib/utils/post_processing.py         | 322 ++++++-
 src/anomalib/utils/types/__init__.py          |  21 +-
 src/anomalib/utils/visualization/__init__.py  |  24 +-
 src/anomalib/utils/visualization/base.py      |  24 +-
 .../utils/visualization/explanation.py        |  31 +-
 src/anomalib/utils/visualization/image.py     | 171 +++-
 src/anomalib/utils/visualization/metrics.py   |  53 +-
 src/anomalib/visualization/__init__.py        |  28 +-
 src/anomalib/visualization/base.py            |  57 +-
 src/anomalib/visualization/image/__init__.py  |  29 +-
 .../visualization/image/functional.py         | 637 ++++++++++----
 .../visualization/image/visualizer.py         | 148 ++--
 tests/unit/cli/test_installation.py           |   2 +-
 363 files changed, 25302 insertions(+), 8842 deletions(-)
 delete mode 100644 docs/requirements.txt
 delete mode 100644 docs/source/markdown/guides/reference/data/base/datamodule.md
 delete mode 100644 docs/source/markdown/guides/reference/data/base/dataset.md
 delete mode 100644 docs/source/markdown/guides/reference/data/base/depth.md
 delete mode 100644 docs/source/markdown/guides/reference/data/base/index.md
 delete mode 100644 docs/source/markdown/guides/reference/data/base/video.md
 create mode 100644 docs/source/markdown/guides/reference/data/dataclasses/generic.md
 create mode 100644 docs/source/markdown/guides/reference/data/dataclasses/index.md
 create mode 100644 docs/source/markdown/guides/reference/data/dataclasses/numpy.md
 create mode 100644 docs/source/markdown/guides/reference/data/dataclasses/torch.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/base/image.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/base/index.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/base/video.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/depth/folder_3d.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/depth/index.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/depth/mvtec_3d.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/image.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/image/btech.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/image/datumaro.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/image/folder.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/image/index.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/image/kolektor.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/image/mvtec.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/image/visa.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/index.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/video.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/video/avenue.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/video/index.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/video/shanghaitech.md
 create mode 100644 docs/source/markdown/guides/reference/data/datamodules/video/ucsdped.md
 delete mode 100644 docs/source/markdown/guides/reference/data/depth/folder_3d.md
 delete mode 100644 docs/source/markdown/guides/reference/data/depth/index.md
 delete mode 100644 docs/source/markdown/guides/reference/data/depth/mvtec_3d.md
 delete mode 100644 docs/source/markdown/guides/reference/data/image/btech.md
 delete mode 100644 docs/source/markdown/guides/reference/data/image/folder.md
 delete mode 100644 docs/source/markdown/guides/reference/data/image/index.md
 delete mode 100644 docs/source/markdown/guides/reference/data/image/kolektor.md
 delete mode 100644 docs/source/markdown/guides/reference/data/image/mvtec.md
 delete mode 100644 docs/source/markdown/guides/reference/data/image/visa.md
 delete mode 100644 docs/source/markdown/guides/reference/data/utils/transforms.md
 delete mode 100644 docs/source/markdown/guides/reference/data/video/avenue.md
 delete mode 100644 docs/source/markdown/guides/reference/data/video/index.md
 delete mode 100644 docs/source/markdown/guides/reference/data/video/shanghaitech.md
 delete mode 100644 docs/source/markdown/guides/reference/data/video/ucsd_ped.md
 create mode 100644 docs/source/markdown/guides/reference/models/image/fre.md
 create mode 100644 docs/source/markdown/guides/reference/models/image/vlm_ad.md
 create mode 100644 docs/source/markdown/guides/reference/post_processing/index.md
 create mode 100644 docs/source/markdown/guides/reference/pre_processing/index.md
 delete mode 100644 docs/source/markdown/guides/topic/index.md
 delete mode 100644 src/anomalib/data/image/datumaro.py

diff --git a/docs/Makefile b/docs/Makefile
index d0c3cbf102..7f7c18fca8 100644
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -3,7 +3,7 @@
 
 # You can set these variables from the command line, and also
 # from the environment for the first two.
-SPHINXOPTS    ?=
+SPHINXOPTS    = -j auto
 SPHINXBUILD   ?= sphinx-build
 SOURCEDIR     = source
 BUILDDIR      = build
diff --git a/docs/requirements.txt b/docs/requirements.txt
deleted file mode 100644
index 02603dc810..0000000000
--- a/docs/requirements.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-myst-parser
-nbsphinx
-pandoc
-sphinx
-sphinx_autodoc_typehints
-sphinx_book_theme
-sphinx-copybutton
-sphinx_design
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 16e79a59af..890bb5100b 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -10,26 +10,25 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from __future__ import annotations
-
 import sys
 from pathlib import Path
 
-# Define the path to your module using Path
-module_path = Path(__file__).parent.parent / "src"
+# Define paths
+project_root = Path(__file__).parent.parent.parent
+module_path = project_root / "src"
+examples_path = project_root / "examples"
 
-# Insert the path to sys.path
+# Insert paths to sys.path
 sys.path.insert(0, str(module_path.resolve()))
+sys.path.insert(0, str(project_root.resolve()))
 
 project = "Anomalib"
-copyright = "2023, Intel OpenVINO"  # noqa: A001
-author = "Intel OpenVINO"
-release = "2022"
+copyright = "Intel Corporation"  # noqa: A001
+author = "Intel Corporation"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
 
-
 extensions = [
     "sphinx.ext.autodoc",
     "sphinx.ext.mathjax",
@@ -39,20 +38,49 @@
     "sphinx.ext.napoleon",
     "sphinx_autodoc_typehints",
     "sphinx_copybutton",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.autosectionlabel",
 ]
 
+# MyST configuration
 myst_enable_extensions = [
     "colon_fence",
-    # other MyST extensions...
+    "linkify",
+    "substitution",
+    "tasklist",
+    "deflist",
+    "fieldlist",
 ]
+
+# Add separate setting for eval-rst
+myst_enable_eval_rst = True
+
+# Notebook handling
 nbsphinx_allow_errors = True
+nbsphinx_execute = "auto"  # Execute notebooks during build
+nbsphinx_timeout = 300  # Timeout in seconds
+
+# Templates and patterns
 templates_path = ["_templates"]
-exclude_patterns: list[str] = []
+exclude_patterns: list[str] = [
+    "_build",
+    "**.ipynb_checkpoints",
+    "**/.pytest_cache",
+    "**/.git",
+    "**/.github",
+    "**/.venv",
+    "**/*.egg-info",
+    "**/build",
+    "**/dist",
+]
 
 # Automatic exclusion of prompts from the copies
 # https://sphinx-copybutton.readthedocs.io/en/latest/use.html#automatic-exclusion-of-prompts-from-the-copies
 copybutton_exclude = ".linenos, .gp, .go"
 
+# Enable section anchors for cross-referencing
+autosectionlabel_prefix_document = True
+
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
 
@@ -65,3 +93,13 @@
         "text": "Anomalib",
     },
 }
+
+# Add references to example files
+html_context = {"examples_path": str(examples_path)}
+
+# External documentation references
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3", None),
+    "torch": ("https://pytorch.org/docs/stable", None),
+    "lightning": ("https://lightning.ai/docs/pytorch/stable/", None),
+}
diff --git a/docs/source/index.md b/docs/source/index.md
index eea06f1275..46199a425d 100644
--- a/docs/source/index.md
+++ b/docs/source/index.md
@@ -68,19 +68,11 @@ Learn more about anomalib API and CLI.
 Learn how to use anomalib for your anomaly detection tasks.
 :::
 
-:::{grid-item-card} {octicon}`telescope` Topic Guide
-:link: markdown/guides/topic/index
-:link-type: doc
-
-Learn more about the internals of anomalib.
-:::
-
 :::{grid-item-card} {octicon}`code` Developer Guide
 :link: markdown/guides/developer/index
 :link-type: doc
 
 Learn how to develop and contribute to anomalib.
-:::
 
 ::::
 
@@ -98,7 +90,6 @@ markdown/get_started/migration
 
 markdown/guides/reference/index
 markdown/guides/how_to/index
-markdown/guides/topic/index
 markdown/guides/developer/index
 ```
 
diff --git a/docs/source/markdown/guides/reference/callbacks/index.md b/docs/source/markdown/guides/reference/callbacks/index.md
index 4fdeaedfff..1c76a19fcb 100644
--- a/docs/source/markdown/guides/reference/callbacks/index.md
+++ b/docs/source/markdown/guides/reference/callbacks/index.md
@@ -1,8 +1,90 @@
 # Callbacks
 
+```{grid} 2
+:gutter: 2
+
+:::{card} {octicon}`download` Model Checkpoint
+:link: checkpoint
+:link-type: ref
+
+Save and manage model checkpoints during training.
+:::
+
+:::{card} {octicon}`graph` Graph Logger
+:link: graph-logger
+:link-type: ref
+
+Log model computation graphs for visualization.
+:::
+
+:::{card} {octicon}`package` Load Model
+:link: load-model
+:link-type: ref
+
+Load pre-trained models and weights.
+:::
+
+:::{card} {octicon}`table` Tile Configuration
+:link: tile-configuration
+:link-type: ref
+
+Configure and manage image tiling settings.
+:::
+
+:::{card} {octicon}`clock` Timer
+:link: timer
+:link-type: ref
+
+Track and measure execution times during training.
+:::
+```
+
+(checkpoint)=
+
+## {octicon}`download` Model Checkpoint
+
+```{eval-rst}
+.. automodule:: anomalib.callbacks.checkpoint
+   :members:
+   :show-inheritance:
+```
+
+(graph-logger)=
+
+## {octicon}`graph` Graph Logger
+
+```{eval-rst}
+.. automodule:: anomalib.callbacks.graph
+   :members:
+   :show-inheritance:
+```
+
+(load-model)=
+
+## {octicon}`package` Load Model
+
+```{eval-rst}
+.. automodule:: anomalib.callbacks.model_loader
+   :members:
+   :show-inheritance:
+```
+
+(tile-configuration)=
+
+## {octicon}`table` Tile Configuration
+
+```{eval-rst}
+.. automodule:: anomalib.callbacks.tile_configuration
+   :members:
+   :show-inheritance:
+```
+
+(timer)=
+
+## {octicon}`clock` Timer
+
 ```{eval-rst}
-.. automodule:: anomalib.callbacks
+.. automodule:: anomalib.callbacks.timer
    :members:
-   :exclude-members: get_visualization_callbacks
    :show-inheritance:
 ```
diff --git a/docs/source/markdown/guides/reference/cli/index.md b/docs/source/markdown/guides/reference/cli/index.md
index 69f183f142..5c047b2b74 100644
--- a/docs/source/markdown/guides/reference/cli/index.md
+++ b/docs/source/markdown/guides/reference/cli/index.md
@@ -1,7 +1,7 @@
 # CLI
 
 ```{eval-rst}
-.. automodule:: anomalib.cli
+.. automodule:: anomalib.cli.cli
    :members:
    :show-inheritance:
 ```
diff --git a/docs/source/markdown/guides/reference/data/base/datamodule.md b/docs/source/markdown/guides/reference/data/base/datamodule.md
deleted file mode 100644
index 2c48711943..0000000000
--- a/docs/source/markdown/guides/reference/data/base/datamodule.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Base Datamodules
-
-```{eval-rst}
-.. automodule:: anomalib.data.base.datamodule
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/base/dataset.md b/docs/source/markdown/guides/reference/data/base/dataset.md
deleted file mode 100644
index 38ba53fc41..0000000000
--- a/docs/source/markdown/guides/reference/data/base/dataset.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Base Dataset
-
-```{eval-rst}
-.. automodule:: anomalib.data.base.dataset
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/base/depth.md b/docs/source/markdown/guides/reference/data/base/depth.md
deleted file mode 100644
index f179b07f60..0000000000
--- a/docs/source/markdown/guides/reference/data/base/depth.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Base Depth Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.base.depth
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/base/index.md b/docs/source/markdown/guides/reference/data/base/index.md
deleted file mode 100644
index efe077950b..0000000000
--- a/docs/source/markdown/guides/reference/data/base/index.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# Base Data
-
-::::{grid}
-
-:::{grid-item-card} {octicon}`copy` Base Dataset
-:link: ./dataset
-:link-type: doc
-
-Learn more about base anomalib dataset
-:::
-
-:::{grid-item-card} {octicon}`file-media` Base Datamodule
-:link: ./datamodule
-:link-type: doc
-
-Learn more about base anomalib datamodule
-:::
-
-:::{grid-item-card} {octicon}`video` Video
-:link: ./video
-:link-type: doc
-
-Learn more about base anomalib video data
-:::
-
-:::{grid-item-card} {octicon}`database` Depth
-:link: ./depth/
-:link-type: doc
-
-Learn more about base anomalib depth data
-:::
-
-::::
-
-```{toctree}
-:caption: Base Data
-:hidden:
-
-./dataset
-./datamodule
-./depth
-./video
-```
diff --git a/docs/source/markdown/guides/reference/data/base/video.md b/docs/source/markdown/guides/reference/data/base/video.md
deleted file mode 100644
index bb9284d583..0000000000
--- a/docs/source/markdown/guides/reference/data/base/video.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Base Video Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.base.video
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/dataclasses/generic.md b/docs/source/markdown/guides/reference/data/dataclasses/generic.md
new file mode 100644
index 0000000000..e435911394
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/dataclasses/generic.md
@@ -0,0 +1,111 @@
+# Generic Dataclasses
+
+The generic dataclasses module provides the foundational data structures and validation logic used throughout Anomalib. These classes are designed to be flexible and type-safe, serving as the base for both PyTorch and NumPy implementations.
+
+```{eval-rst}
+.. currentmodule:: anomalib.data.dataclasses.generic
+```
+
+## Core Concepts
+
+### Type Variables
+
+The module uses several type variables to ensure type safety across different implementations:
+
+- `ImageT`: Type variable for image data (PyTorch Image/Video or NumPy array)
+- `T`: Type variable for tensor-like data (PyTorch Tensor or NumPy array)
+- `MaskT`: Type variable for mask data (PyTorch Mask or NumPy array)
+- `PathT`: Type variable for path data (string or list of strings)
+
+## Base Classes
+
+### InputFields
+
+```{eval-rst}
+.. autoclass:: _InputFields
+   :members:
+   :show-inheritance:
+```
+
+### ImageInputFields
+
+```{eval-rst}
+.. autoclass:: _ImageInputFields
+   :members:
+   :show-inheritance:
+```
+
+### VideoInputFields
+
+```{eval-rst}
+.. autoclass:: _VideoInputFields
+   :members:
+   :show-inheritance:
+```
+
+### DepthInputFields
+
+```{eval-rst}
+.. autoclass:: _DepthInputFields
+   :members:
+   :show-inheritance:
+```
+
+### OutputFields
+
+```{eval-rst}
+.. autoclass:: _OutputFields
+   :members:
+   :show-inheritance:
+```
+
+## Mixins
+
+### UpdateMixin
+
+```{eval-rst}
+.. autoclass:: UpdateMixin
+   :members:
+   :show-inheritance:
+```
+
+### BatchIterateMixin
+
+```{eval-rst}
+.. autoclass:: BatchIterateMixin
+   :members:
+   :show-inheritance:
+```
+
+## Generic Classes
+
+### GenericItem
+
+```{eval-rst}
+.. autoclass:: _GenericItem
+   :members:
+   :show-inheritance:
+```
+
+### GenericBatch
+
+```{eval-rst}
+.. autoclass:: _GenericBatch
+   :members:
+   :show-inheritance:
+```
+
+## Field Validation
+
+### FieldDescriptor
+
+```{eval-rst}
+.. autoclass:: FieldDescriptor
+   :members:
+   :show-inheritance:
+```
+
+## See Also
+
+- {doc}`torch`
+- {doc}`numpy`
diff --git a/docs/source/markdown/guides/reference/data/dataclasses/index.md b/docs/source/markdown/guides/reference/data/dataclasses/index.md
new file mode 100644
index 0000000000..d762045abe
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/dataclasses/index.md
@@ -0,0 +1,70 @@
+# Data Classes
+
+Anomalib's dataclasses provide type-safe data containers with automatic validation. They support both PyTorch and NumPy backends for flexible data handling.
+
+::::{grid} 1 2 2 3
+:gutter: 3
+:padding: 2
+:class-container: landing-grid
+
+:::{grid-item-card} {octicon}`package` Generic Classes
+:link: generic
+:link-type: doc
+:class-card: custom-card
+
+Base dataclasses that define common data structures and validation logic:
+
+- Generic Item/Batch
+- Input/Output Fields
+- Validation Mixins
+
++++
+[Learn More »](generic)
+:::
+
+:::{grid-item-card} {octicon}`cpu` PyTorch Classes
+:link: torch
+:link-type: doc
+:class-card: custom-card
+
+PyTorch tensor-based implementations:
+
+- Image, Video, Depth Items
+- Batch Processing Support
+- Type-safe Validation
+
++++
+[Learn More »](torch)
+:::
+
+:::{grid-item-card} {octicon}`database` NumPy Classes
+:link: numpy
+:link-type: doc
+:class-card: custom-card
+
+NumPy array-based implementations:
+
+- Efficient Data Processing
+- Array-based Containers
+- Conversion Utilities
+
++++
+[Learn More »](numpy)
+:::
+::::
+
+## Documentation
+
+For detailed documentation and examples, see:
+
+- {doc}`Generic Base Classes `
+- {doc}`PyTorch Classes `
+- {doc}`NumPy Classes `
+
+```{toctree}
+:hidden:
+
+generic
+torch
+numpy
+```
diff --git a/docs/source/markdown/guides/reference/data/dataclasses/numpy.md b/docs/source/markdown/guides/reference/data/dataclasses/numpy.md
new file mode 100644
index 0000000000..a6f622ca6a
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/dataclasses/numpy.md
@@ -0,0 +1,93 @@
+# Numpy Dataclasses
+
+The numpy dataclasses module provides numpy-based implementations of the generic dataclasses used in Anomalib. These classes are designed to work with numpy arrays for efficient data handling and processing in anomaly detection tasks.
+
+```{eval-rst}
+.. currentmodule:: anomalib.data.dataclasses.numpy
+```
+
+## Overview
+
+The module includes several categories of dataclasses:
+
+- **Base Classes**: Generic numpy-based data structures
+- **Image Classes**: Specialized for image data processing
+- **Video Classes**: Designed for video data handling
+- **Depth Classes**: Specific to depth-based anomaly detection
+
+## Base Classes
+
+### NumpyItem
+
+```{eval-rst}
+.. autoclass:: NumpyItem
+   :members:
+   :show-inheritance:
+```
+
+### NumpyBatch
+
+```{eval-rst}
+.. autoclass:: NumpyBatch
+   :members:
+   :show-inheritance:
+```
+
+## Image Classes
+
+### NumpyImageItem
+
+```{eval-rst}
+.. autoclass:: NumpyImageItem
+   :members:
+   :show-inheritance:
+```
+
+### NumpyImageBatch
+
+```{eval-rst}
+.. autoclass:: NumpyImageBatch
+   :members:
+   :show-inheritance:
+```
+
+## Video Classes
+
+### NumpyVideoItem
+
+```{eval-rst}
+.. autoclass:: NumpyVideoItem
+   :members:
+   :show-inheritance:
+```
+
+### NumpyVideoBatch
+
+```{eval-rst}
+.. autoclass:: NumpyVideoBatch
+   :members:
+   :show-inheritance:
+```
+
+## Depth Classes
+
+### NumpyDepthItem
+
+```{eval-rst}
+.. autoclass:: NumpyDepthItem
+   :members:
+   :show-inheritance:
+```
+
+### NumpyDepthBatch
+
+```{eval-rst}
+.. autoclass:: NumpyDepthBatch
+   :members:
+   :show-inheritance:
+```
+
+## See Also
+
+- {doc}`../index`
+- {doc}`../torch`
diff --git a/docs/source/markdown/guides/reference/data/dataclasses/torch.md b/docs/source/markdown/guides/reference/data/dataclasses/torch.md
new file mode 100644
index 0000000000..c8010dbad4
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/dataclasses/torch.md
@@ -0,0 +1,109 @@
+# Torch Dataclasses
+
+The torch dataclasses module provides PyTorch-based implementations of the generic dataclasses used in Anomalib. These classes are designed to work with PyTorch tensors for efficient data handling and processing in anomaly detection tasks.
+
+```{eval-rst}
+.. currentmodule:: anomalib.data.dataclasses.torch
+```
+
+## Overview
+
+The module includes several categories of dataclasses:
+
+- **Base Classes**: Generic PyTorch-based data structures
+- **Image Classes**: Specialized for image data processing
+- **Video Classes**: Designed for video data handling
+- **Depth Classes**: Specific to depth-based anomaly detection
+
+## Base Classes
+
+### DatasetItem
+
+```{eval-rst}
+.. autoclass:: DatasetItem
+   :members:
+   :show-inheritance:
+```
+
+### Batch
+
+```{eval-rst}
+.. autoclass:: Batch
+   :members:
+   :show-inheritance:
+```
+
+### InferenceBatch
+
+```{eval-rst}
+.. autoclass:: InferenceBatch
+   :members:
+   :show-inheritance:
+```
+
+### ToNumpyMixin
+
+```{eval-rst}
+.. autoclass:: ToNumpyMixin
+   :members:
+   :show-inheritance:
+```
+
+## Image Classes
+
+### ImageItem
+
+```{eval-rst}
+.. autoclass:: ImageItem
+   :members:
+   :show-inheritance:
+```
+
+### ImageBatch
+
+```{eval-rst}
+.. autoclass:: ImageBatch
+   :members:
+   :show-inheritance:
+```
+
+## Video Classes
+
+### VideoItem
+
+```{eval-rst}
+.. autoclass:: VideoItem
+   :members:
+   :show-inheritance:
+```
+
+### VideoBatch
+
+```{eval-rst}
+.. autoclass:: VideoBatch
+   :members:
+   :show-inheritance:
+```
+
+## Depth Classes
+
+### DepthItem
+
+```{eval-rst}
+.. autoclass:: DepthItem
+   :members:
+   :show-inheritance:
+```
+
+### DepthBatch
+
+```{eval-rst}
+.. autoclass:: DepthBatch
+   :members:
+   :show-inheritance:
+```
+
+## See Also
+
+- {doc}`../index`
+- {doc}`../numpy`
diff --git a/docs/source/markdown/guides/reference/data/datamodules/base/image.md b/docs/source/markdown/guides/reference/data/datamodules/base/image.md
new file mode 100644
index 0000000000..aa08a3a351
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/base/image.md
@@ -0,0 +1,7 @@
+# Image Base Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.base.image
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/base/index.md b/docs/source/markdown/guides/reference/data/datamodules/base/index.md
new file mode 100644
index 0000000000..f85477c722
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/base/index.md
@@ -0,0 +1,21 @@
+# Base Datamodules
+
+Base DataModules provide core functionality for specific data types that can be extended by other DataModules.
+
+::::{grid} 2
+:gutter: 2
+
+:::{card} Image DataModule
+:link: image
+:link-type: doc
+
+Base DataModule for image-based anomaly detection tasks.
+:::
+
+:::{card} Video DataModule
+:link: video
+:link-type: doc
+
+Base DataModule for video-based anomaly detection tasks.
+:::
+::::
diff --git a/docs/source/markdown/guides/reference/data/datamodules/base/video.md b/docs/source/markdown/guides/reference/data/datamodules/base/video.md
new file mode 100644
index 0000000000..4e6522f5a6
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/base/video.md
@@ -0,0 +1,7 @@
+# Video Base Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.base.video
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/depth/folder_3d.md b/docs/source/markdown/guides/reference/data/datamodules/depth/folder_3d.md
new file mode 100644
index 0000000000..1b29484123
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/depth/folder_3d.md
@@ -0,0 +1,7 @@
+# Folder Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.depth.folder_3d
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/depth/index.md b/docs/source/markdown/guides/reference/data/datamodules/depth/index.md
new file mode 100644
index 0000000000..9e8ce32a4e
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/depth/index.md
@@ -0,0 +1,31 @@
+# Depth Datamodules
+
+Anomalib provides datamodules for handling depth-based anomaly detection datasets. These datamodules are designed to work with both RGB and depth information for 3D anomaly detection tasks.
+
+## Available Datamodules
+
+```{grid} 2
+:gutter: 2
+
+:::{grid-item-card} MVTec 3D
+:link: mvtec_3d
+:link-type: doc
+
+MVTec 3D-AD dataset datamodule for unsupervised 3D anomaly detection and localization.
+:::
+
+:::{grid-item-card} Folder 3D
+:link: folder_3d
+:link-type: doc
+
+Custom folder-based 3D datamodule for organizing your own depth-based anomaly detection dataset.
+:::
+```
+
+```{toctree}
+:hidden:
+:maxdepth: 1
+
+mvtec_3d
+folder_3d
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/depth/mvtec_3d.md b/docs/source/markdown/guides/reference/data/datamodules/depth/mvtec_3d.md
new file mode 100644
index 0000000000..ae5c2cd842
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/depth/mvtec_3d.md
@@ -0,0 +1,7 @@
+# MVTec 3D Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.depth.mvtec_3d
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/image.md b/docs/source/markdown/guides/reference/data/datamodules/image.md
new file mode 100644
index 0000000000..c79a299a92
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/image.md
@@ -0,0 +1,60 @@
+# Image Datamodules
+
+Image datamodules in Anomalib are designed to handle image-based anomaly detection datasets. They provide a standardized interface for loading and processing image data for both training and inference.
+
+## Available Datamodules
+
+```{grid} 3
+:gutter: 2
+
+:::{grid-item-card} BTech
+:link: anomalib.data.datamodules.image.BTech
+:link-type: doc
+
+Surface defect detection in steel manufacturing.
+:::
+
+:::{grid-item-card} Datumaro
+:link: anomalib.data.datamodules.image.Datumaro
+:link-type: doc
+
+Dataset format compatible with Intel Geti™.
+:::
+
+:::{grid-item-card} Folder
+:link: anomalib.data.datamodules.image.Folder
+:link-type: doc
+
+Custom folder-based dataset organization.
+:::
+
+:::{grid-item-card} Kolektor
+:link: anomalib.data.datamodules.image.Kolektor
+:link-type: doc
+
+Surface defect detection in electrical commutators.
+:::
+
+:::{grid-item-card} MVTec
+:link: anomalib.data.datamodules.image.MVTec
+:link-type: doc
+
+Industrial anomaly detection benchmark.
+:::
+
+:::{grid-item-card} Visa
+:link: anomalib.data.datamodules.image.Visa
+:link-type: doc
+
+Visual inspection of surface anomalies.
+:::
+```
+
+## API Reference
+
+```{eval-rst}
+.. automodule:: anomalib.data
+   :members: BTech, Datumaro, Folder, Kolektor, MVTec, Visa
+   :undoc-members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/image/btech.md b/docs/source/markdown/guides/reference/data/datamodules/image/btech.md
new file mode 100644
index 0000000000..5abeb7c4c8
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/image/btech.md
@@ -0,0 +1,7 @@
+# Btech Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.image.btech
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/image/datumaro.md b/docs/source/markdown/guides/reference/data/datamodules/image/datumaro.md
new file mode 100644
index 0000000000..a26a8e4e9b
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/image/datumaro.md
@@ -0,0 +1,7 @@
+# Datumaro Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.image.datumaro
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/image/folder.md b/docs/source/markdown/guides/reference/data/datamodules/image/folder.md
new file mode 100644
index 0000000000..918d5a22e3
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/image/folder.md
@@ -0,0 +1,7 @@
+# Folder Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.image.folder
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/image/index.md b/docs/source/markdown/guides/reference/data/datamodules/image/index.md
new file mode 100644
index 0000000000..50e1c4a86d
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/image/index.md
@@ -0,0 +1,63 @@
+# Image Datamodules
+
+Anomalib provides various datamodules for handling image-based anomaly detection datasets. These datamodules support both standard image datasets and custom folder structures.
+
+## Available Datamodules
+
+```{grid} 3
+:gutter: 2
+
+:::{grid-item-card} BTech
+:link: btech
+:link-type: doc
+
+BTech dataset datamodule for surface defect detection.
+:::
+
+:::{grid-item-card} Datumaro
+:link: datumaro
+:link-type: doc
+
+Datumaro format datamodule (compatible with Intel Geti™).
+:::
+
+:::{grid-item-card} Folder
+:link: folder
+:link-type: doc
+
+Custom folder-based datamodule for organizing your own image dataset.
+:::
+
+:::{grid-item-card} Kolektor
+:link: kolektor
+:link-type: doc
+
+Kolektor Surface-Defect dataset datamodule.
+:::
+
+:::{grid-item-card} MVTec
+:link: mvtec
+:link-type: doc
+
+MVTec AD dataset datamodule for unsupervised anomaly detection.
+:::
+
+:::{grid-item-card} Visa
+:link: visa
+:link-type: doc
+
+Visual Inspection of Surface Anomalies (VisA) dataset datamodule.
+:::
+```
+
+```{toctree}
+:hidden:
+:maxdepth: 1
+
+btech
+datumaro
+folder
+kolektor
+mvtec
+visa
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/image/kolektor.md b/docs/source/markdown/guides/reference/data/datamodules/image/kolektor.md
new file mode 100644
index 0000000000..e86a321ea2
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/image/kolektor.md
@@ -0,0 +1,7 @@
+# Kolektor Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.image.kolektor
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/image/mvtec.md b/docs/source/markdown/guides/reference/data/datamodules/image/mvtec.md
new file mode 100644
index 0000000000..3ef6847c0d
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/image/mvtec.md
@@ -0,0 +1,7 @@
+# MVTec Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.image.mvtec
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/image/visa.md b/docs/source/markdown/guides/reference/data/datamodules/image/visa.md
new file mode 100644
index 0000000000..0c0bed8b45
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/image/visa.md
@@ -0,0 +1,7 @@
+# Visa Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.image.visa
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/index.md b/docs/source/markdown/guides/reference/data/datamodules/index.md
new file mode 100644
index 0000000000..699c4e7b3c
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/index.md
@@ -0,0 +1,107 @@
+# Datamodules
+
+Anomalib provides various datamodules for different types of data modalities. These datamodules are organized into three main categories:
+
+## Image Datamodules
+
+```{grid} 3
+:gutter: 2
+
+:::{grid-item-card} BTech
+:link: image/btech
+:link-type: doc
+
+BTech dataset datamodule for surface defect detection.
+:::
+
+:::{grid-item-card} Datumaro
+:link: image/datumaro
+:link-type: doc
+
+Datumaro format datamodule (compatible with Intel Geti™).
+:::
+
+:::{grid-item-card} Folder
+:link: image/folder
+:link-type: doc
+
+Custom folder-based datamodule for organizing your own image dataset.
+:::
+
+:::{grid-item-card} Kolektor
+:link: image/kolektor
+:link-type: doc
+
+Kolektor Surface-Defect dataset datamodule.
+:::
+
+:::{grid-item-card} MVTec
+:link: image/mvtec
+:link-type: doc
+
+MVTec AD dataset datamodule for unsupervised anomaly detection.
+:::
+
+:::{grid-item-card} Visa
+:link: image/visa
+:link-type: doc
+
+Visual Inspection of Surface Anomalies (VisA) dataset datamodule.
+:::
+```
+
+## Video Datamodules
+
+```{grid} 3
+:gutter: 2
+
+:::{grid-item-card} Avenue
+:link: video/avenue
+:link-type: doc
+
+CUHK Avenue dataset datamodule for video anomaly detection.
+:::
+
+:::{grid-item-card} ShanghaiTech
+:link: video/shanghaitech
+:link-type: doc
+
+ShanghaiTech dataset datamodule for video anomaly detection.
+:::
+
+:::{grid-item-card} UCSDped
+:link: video/ucsdped
+:link-type: doc
+
+UCSD Pedestrian dataset datamodule for video anomaly detection.
+:::
+```
+
+```{toctree}
+:hidden:
+:maxdepth: 1
+
+depth/index
+image/index
+video/index
+```
+
+## Depth Datamodules
+
+```{grid} 2
+:gutter: 2
+
+:::{grid-item-card} MVTec 3D
+:link: depth/mvtec_3d
+:link-type: doc
+
+MVTec 3D-AD dataset datamodule for unsupervised 3D anomaly detection and localization.
+:::
+
+:::{grid-item-card} Folder 3D
+:link: depth/folder_3d
+:link-type: doc
+
+Custom folder-based 3D datamodule for organizing your own depth-based anomaly detection dataset.
+:::
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/video.md b/docs/source/markdown/guides/reference/data/datamodules/video.md
new file mode 100644
index 0000000000..1899e91f51
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/video.md
@@ -0,0 +1,39 @@
+# Video Datamodules
+
+Video datamodules in Anomalib are designed to handle video-based anomaly detection datasets. They provide a standardized interface for loading and processing video data for both training and inference.
+
+## Available Datamodules
+
+```{grid} 3
+:gutter: 2
+
+:::{grid-item-card} Avenue
+:link: anomalib.data.Avenue
+:link-type: doc
+
+CUHK Avenue dataset for video anomaly detection.
+:::
+
+:::{grid-item-card} ShanghaiTech
+:link: anomalib.data.ShanghaiTech
+:link-type: doc
+
+ShanghaiTech dataset for video anomaly detection.
+:::
+
+:::{grid-item-card} UCSDped
+:link: anomalib.data.UCSDped
+:link-type: doc
+
+UCSD Pedestrian dataset for video anomaly detection.
+:::
+```
+
+## API Reference
+
+```{eval-rst}
+.. automodule:: anomalib.data
+   :members: Avenue, ShanghaiTech, UCSDped
+   :undoc-members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/video/avenue.md b/docs/source/markdown/guides/reference/data/datamodules/video/avenue.md
new file mode 100644
index 0000000000..3f4cf842a0
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/video/avenue.md
@@ -0,0 +1,7 @@
+#  Avenue Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.video.avenue
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/video/index.md b/docs/source/markdown/guides/reference/data/datamodules/video/index.md
new file mode 100644
index 0000000000..0be1043020
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/video/index.md
@@ -0,0 +1,39 @@
+# Video Datamodules
+
+Anomalib provides datamodules for handling video-based anomaly detection datasets. These datamodules are specifically designed to work with video sequences and support various video anomaly detection benchmarks.
+
+## Available Datamodules
+
+```{grid} 3
+:gutter: 2
+
+:::{grid-item-card} Avenue
+:link: avenue
+:link-type: doc
+
+CUHK Avenue dataset datamodule for video anomaly detection.
+:::
+
+:::{grid-item-card} ShanghaiTech
+:link: shanghaitech
+:link-type: doc
+
+ShanghaiTech dataset datamodule for video anomaly detection.
+:::
+
+:::{grid-item-card} UCSDped
+:link: ucsdped
+:link-type: doc
+
+UCSD Pedestrian dataset datamodule for video anomaly detection.
+:::
+```
+
+```{toctree}
+:hidden:
+:maxdepth: 1
+
+avenue
+shanghaitech
+ucsdped
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/video/shanghaitech.md b/docs/source/markdown/guides/reference/data/datamodules/video/shanghaitech.md
new file mode 100644
index 0000000000..fa919af894
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/video/shanghaitech.md
@@ -0,0 +1,7 @@
+# ShanghaiTech Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.video.shanghaitech
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/datamodules/video/ucsdped.md b/docs/source/markdown/guides/reference/data/datamodules/video/ucsdped.md
new file mode 100644
index 0000000000..dffac0534b
--- /dev/null
+++ b/docs/source/markdown/guides/reference/data/datamodules/video/ucsdped.md
@@ -0,0 +1,7 @@
+# UCSDped Datamodule
+
+```{eval-rst}
+.. automodule:: anomalib.data.datamodules.video.ucsd_ped
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/data/depth/folder_3d.md b/docs/source/markdown/guides/reference/data/depth/folder_3d.md
deleted file mode 100644
index 3b0f93280d..0000000000
--- a/docs/source/markdown/guides/reference/data/depth/folder_3d.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Folder 3D Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.depth.folder_3d
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/depth/index.md b/docs/source/markdown/guides/reference/data/depth/index.md
deleted file mode 100644
index ca63ee078d..0000000000
--- a/docs/source/markdown/guides/reference/data/depth/index.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# Depth Data
-
-::::{grid}
-
-:::{grid-item-card} Folder 3D
-:link: ./folder_3d
-:link-type: doc
-
-Learn more about custom folder 3D dataset.
-:::
-
-:::{grid-item-card} MVTec 3D
-:link: ./mvtec_3d
-:link-type: doc
-
-Learn more about MVTec 3D dataset
-:::
-
-::::
-
-```{toctree}
-:caption: Depth
-:hidden:
-
-./folder_3d
-./mvtec_3d
-```
diff --git a/docs/source/markdown/guides/reference/data/depth/mvtec_3d.md b/docs/source/markdown/guides/reference/data/depth/mvtec_3d.md
deleted file mode 100644
index dfcf4fd814..0000000000
--- a/docs/source/markdown/guides/reference/data/depth/mvtec_3d.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# MVTec 3D Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.depth.mvtec_3d
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/image/btech.md b/docs/source/markdown/guides/reference/data/image/btech.md
deleted file mode 100644
index 92199ccd1b..0000000000
--- a/docs/source/markdown/guides/reference/data/image/btech.md
+++ /dev/null
@@ -1,7 +0,0 @@
-#  BTech Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.image.btech
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/image/folder.md b/docs/source/markdown/guides/reference/data/image/folder.md
deleted file mode 100644
index 307262b9c4..0000000000
--- a/docs/source/markdown/guides/reference/data/image/folder.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Folder Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.image.folder
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/image/index.md b/docs/source/markdown/guides/reference/data/image/index.md
deleted file mode 100644
index 2525d0d914..0000000000
--- a/docs/source/markdown/guides/reference/data/image/index.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# Image Data
-
-::::{grid}
-
-:::{grid-item-card} BTech
-:link: ./btech
-:link-type: doc
-
-Learn more about BTech dataset.
-:::
-
-:::{grid-item-card} Folder
-:link: ./folder
-:link-type: doc
-
-Learn more about custom folder dataset.
-:::
-
-:::{grid-item-card} Kolektor
-:link: ./kolektor
-:link-type: doc
-
-Learn more about Kolektor dataset.
-:::
-
-:::{grid-item-card} MVTec 2D
-:link: ./mvtec
-:link-type: doc
-
-Learn more about MVTec 2D dataset
-:::
-
-:::{grid-item-card} Visa
-:link: ./visa
-:link-type: doc
-
-Learn more about Visa dataset.
-:::
-
-::::
-
-```{toctree}
-:caption: Image
-:hidden:
-
-./btech
-./folder
-./kolektor
-./mvtec
-./visa
-```
diff --git a/docs/source/markdown/guides/reference/data/image/kolektor.md b/docs/source/markdown/guides/reference/data/image/kolektor.md
deleted file mode 100644
index ace9d62127..0000000000
--- a/docs/source/markdown/guides/reference/data/image/kolektor.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Kolektor Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.image.kolektor
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/image/mvtec.md b/docs/source/markdown/guides/reference/data/image/mvtec.md
deleted file mode 100644
index c0cbb77735..0000000000
--- a/docs/source/markdown/guides/reference/data/image/mvtec.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# MVTec Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.image.mvtec
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/image/visa.md b/docs/source/markdown/guides/reference/data/image/visa.md
deleted file mode 100644
index 43bfa7c7fb..0000000000
--- a/docs/source/markdown/guides/reference/data/image/visa.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Visa Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.image.visa
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/index.md b/docs/source/markdown/guides/reference/data/index.md
index e646d06f91..26635a0380 100644
--- a/docs/source/markdown/guides/reference/data/index.md
+++ b/docs/source/markdown/guides/reference/data/index.md
@@ -1,46 +1,73 @@
 # Data
 
-Anomalib data can be categorized into four main types: base, image, video, and depth. Image, video and depth datasets are based on the base dataset and datamodule implementations.
+A comprehensive data handling pipeline with modular components for anomaly detection tasks.
 
-::::{grid}
+::::{grid} 1 2 2 3
+:gutter: 3
+:padding: 2
+:class-container: landing-grid
 
-:::{grid-item-card} {octicon}`copy` Base Classes
-:link: ./base/index
+:::{grid-item-card} {octicon}`package` Data Classes
+:link: ./dataclasses/index
 :link-type: doc
+:class-card: custom-card
 
-Learn more about base anomalib data interfaces.
+Core data structures that define how data is represented and validated throughout the pipeline. Features type-safe containers, dual backend support, and automatic validation.
+
++++
+[Learn more »](./dataclasses/index)
 :::
 
-:::{grid-item-card} {octicon}`file-media` Image
-:link: ./image/index
+:::{grid-item-card} {octicon}`database` Datasets
+:link: ./datasets/index
 :link-type: doc
+:class-card: custom-card
+
+Ready-to-use PyTorch Dataset implementations of standard benchmark datasets (MVTec, BTech) and support for custom datasets across multiple modalities (Image, Video, Depth).
 
-Learn more about anomalib image datasets.
++++
+[Learn more »](./datasets/index)
 :::
 
-:::{grid-item-card} {octicon}`video` Video
-:link: ./video/index
+:::{grid-item-card} {octicon}`workflow` Data Modules
+:link: ./datamodules/index
 :link-type: doc
+:class-card: custom-card
+
+Lightning implementations of these PyTorch datasets that provide automated data loading, train/val/test splitting, and distributed training support through the PyTorch Lightning DataModule interface.
 
-Learn more about anomalib video datasets.
++++
+[Learn more »](./datamodules/index)
 :::
+::::
+
+## Additional Resources
 
-:::{grid-item-card} {octicon}`database` Depth
-:link: ./depth/index
+::::{grid} 2 2 2 2
+:gutter: 2
+:padding: 1
+
+:::{grid-item-card} {octicon}`tools` Data Utils
+:link: ./utils/index
 :link-type: doc
 
-Learn more about anomalib depth datasets.
+Helper functions and utilities for data processing and augmentation.
 :::
 
+:::{grid-item-card} {octicon}`book` Tutorials
+:link: ../tutorials/index
+:link-type: doc
+
+Step-by-step guides on using the data components.
+:::
 ::::
 
 ```{toctree}
-:caption: Data
+:caption: Data Components
 :hidden:
 
-./base/index
-./image/index
-./video/index
-./depth/index
+./dataclasses/index
+./datasets/index
+./datamodules/index
 ./utils/index
 ```
diff --git a/docs/source/markdown/guides/reference/data/utils/index.md b/docs/source/markdown/guides/reference/data/utils/index.md
index 7a7fc97efa..1e388c2080 100644
--- a/docs/source/markdown/guides/reference/data/utils/index.md
+++ b/docs/source/markdown/guides/reference/data/utils/index.md
@@ -1,6 +1,6 @@
 # Data Utils
 
-::::{grid} 1 2 2 2
+::::{grid} 1 3 3 3
 :margin: 1 1 0 0
 :gutter: 1
 
@@ -11,13 +11,6 @@
 Learn more about anomalib API and CLI.
 :::
 
-:::{grid-item-card} {octicon}`question` Data Transforms
-:link: transforms
-:link-type: doc
-
-Learn how to use anomalib for your anomaly detection tasks.
-:::
-
 :::{grid-item-card} {octicon}`telescope` Tiling
 :link: tiling
 :link-type: doc
diff --git a/docs/source/markdown/guides/reference/data/utils/transforms.md b/docs/source/markdown/guides/reference/data/utils/transforms.md
deleted file mode 100644
index e59e9ae3d6..0000000000
--- a/docs/source/markdown/guides/reference/data/utils/transforms.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Data Transforms
-
-```{eval-rst}
-.. automodule:: anomalib.data.utils.transforms
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/video/avenue.md b/docs/source/markdown/guides/reference/data/video/avenue.md
deleted file mode 100644
index 2dd00dce4d..0000000000
--- a/docs/source/markdown/guides/reference/data/video/avenue.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Avenue Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.video.avenue
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/video/index.md b/docs/source/markdown/guides/reference/data/video/index.md
deleted file mode 100644
index 9f357053fa..0000000000
--- a/docs/source/markdown/guides/reference/data/video/index.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# Video Data
-
-::::{grid}
-
-:::{grid-item-card} Avenue
-:link: ./avenue
-:link-type: doc
-
-Learn more about Avenue dataset.
-:::
-
-:::{grid-item-card} Shanghai Tech
-:link: ./shanghaitech
-:link-type: doc
-
-Learn more about Shanghai Tech dataset.
-:::
-
-:::{grid-item-card} UCSD
-:link: ./ucsd_ped
-:link-type: doc
-
-Learn more about UCSD Ped1 and Ped2 datasets.
-:::
-
-::::
-
-```{toctree}
-:caption: Image
-:hidden:
-
-./avenue
-./shanghaitech
-./ucsd_ped
-```
diff --git a/docs/source/markdown/guides/reference/data/video/shanghaitech.md b/docs/source/markdown/guides/reference/data/video/shanghaitech.md
deleted file mode 100644
index 38b9ea77c0..0000000000
--- a/docs/source/markdown/guides/reference/data/video/shanghaitech.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Shanghai Tech Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.video.shanghaitech
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/data/video/ucsd_ped.md b/docs/source/markdown/guides/reference/data/video/ucsd_ped.md
deleted file mode 100644
index 0236868341..0000000000
--- a/docs/source/markdown/guides/reference/data/video/ucsd_ped.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# UCSD Data
-
-```{eval-rst}
-.. automodule:: anomalib.data.video.ucsd_ped
-   :members:
-   :show-inheritance:
-```
diff --git a/docs/source/markdown/guides/reference/deploy/index.md b/docs/source/markdown/guides/reference/deploy/index.md
index 58dee6829c..463dcd80b4 100644
--- a/docs/source/markdown/guides/reference/deploy/index.md
+++ b/docs/source/markdown/guides/reference/deploy/index.md
@@ -1,4 +1,4 @@
-# Deployment
+# Inference
 
 ```{eval-rst}
 .. automodule:: anomalib.deploy
diff --git a/docs/source/markdown/guides/reference/engine/index.md b/docs/source/markdown/guides/reference/engine/index.md
index 629a8bdd0b..25b4251880 100644
--- a/docs/source/markdown/guides/reference/engine/index.md
+++ b/docs/source/markdown/guides/reference/engine/index.md
@@ -1,7 +1,8 @@
 # Engine
 
 ```{eval-rst}
-.. automodule:: anomalib.engine
+.. currentmodule:: anomalib.engine.engine
+.. autoclass:: Engine
    :members:
    :show-inheritance:
 ```
diff --git a/docs/source/markdown/guides/reference/index.md b/docs/source/markdown/guides/reference/index.md
index 435569f5f2..b5931cf29c 100644
--- a/docs/source/markdown/guides/reference/index.md
+++ b/docs/source/markdown/guides/reference/index.md
@@ -2,86 +2,138 @@
 
 This section contains the API and CLI reference for anomalib.
 
-::::{grid} 1 2 2 3
-:margin: 1 1 0 0
-:gutter: 1
+## Core Components
+
+::::{grid} 2 2 2 3
+:gutter: 2
+:padding: 1
 
 :::{grid-item-card} {octicon}`database` Data
 :link: ./data/index
 :link-type: doc
 
-Learn more about anomalib datamodules.
+Core component for data handling and datasets.
 :::
 
 :::{grid-item-card} {octicon}`dependabot` Models
 :link: ./models/index
 :link-type: doc
 
-Learn more about image and video models.
+Anomaly detection model implementations.
 :::
 
 :::{grid-item-card} {octicon}`gear` Engine
 :link: ./engine/index
 :link-type: doc
 
-Learn more about anomalib Engine.
+Core training and inference engine.
+:::
+::::
+
+## Processing & Analysis
+
+::::{grid} 2 2 2 3
+:gutter: 2
+:padding: 1
+
+:::{grid-item-card} {octicon}`filter` Pre-processing
+:link: ./pre_processing/index
+:link-type: doc
+
+Data preparation and augmentation.
+:::
+
+:::{grid-item-card} {octicon}`filter` Post-processing
+:link: ./post_processing/index
+:link-type: doc
+
+Anomaly map processing and thresholding.
 :::
 
 :::{grid-item-card} {octicon}`meter` Metrics
 :link: ./metrics/index
 :link-type: doc
 
-Learn more about anomalib metrics
+Performance evaluation metrics.
 :::
+::::
+
+## Framework Components
+
+::::{grid} 2 2 2 3
+:gutter: 2
+:padding: 1
 
 :::{grid-item-card} {octicon}`graph` Loggers
 :link: ./loggers/index
 :link-type: doc
 
-Learn more about anomalib loggers
+Experiment logging and tracking.
 :::
 
 :::{grid-item-card} {octicon}`gear` Callbacks
 :link: ./callbacks/index
 :link-type: doc
 
-Learn more about anomalib callbacks
+Training callbacks and hooks.
 :::
 
-:::{grid-item-card} {octicon}`code-square` CLI
-:link: ./cli/index
+:::{grid-item-card} {octicon}`workflow` Pipelines
+:link: ./pipelines/index
 :link-type: doc
 
-Learn more about anomalib CLI
+Training and optimization pipelines.
 :::
 
-:::{grid-item-card} {octicon}`cpu` Deployment
-:link: ./deploy/index
+:::{grid-item-card} {octicon}`image` Visualization
+:link: ./visualization/index
 :link-type: doc
 
-Learn more about anomalib CLI
+Result visualization tools.
 :::
 
-:::{grid-item-card} {octicon}`workflow` Pipelines
-:link: ./pipelines/index
+:::{grid-item-card} {octicon}`tools` Utils
+:link: ./utils/index
 :link-type: doc
 
-Learn more about anomalib hpo, sweep and benchmarking pipelines
+Utility functions and helpers.
 :::
 
+:::{grid-item-card} {octicon}`terminal` CLI
+:link: ./cli/index
+:link-type: doc
+
+Command line interface tools.
+:::
+::::
+
+::::{grid} 1
+:gutter: 2
+:padding: 1
+
+:::{grid-item-card} {octicon}`cpu` Inference
+:link: ./deploy/index
+:link-type: doc
+
+Model inference and optimization.
+:::
 ::::
 
 ```{toctree}
-:caption: Data
+:caption: Reference
 :hidden:
 
 ./data/index
 ./models/index
 ./engine/index
+./pre_processing/index
+./post_processing/index
 ./metrics/index
 ./loggers/index
 ./callbacks/index
+./pipelines/index
+./visualization/index
+./utils/index
 ./cli/index
 ./deploy/index
-./pipelines/index
 ```
diff --git a/docs/source/markdown/guides/reference/loggers/index.md b/docs/source/markdown/guides/reference/loggers/index.md
index 6f89dc102c..de1ce52213 100644
--- a/docs/source/markdown/guides/reference/loggers/index.md
+++ b/docs/source/markdown/guides/reference/loggers/index.md
@@ -1,8 +1,73 @@
 # Loggers
 
+```{grid} 2
+:gutter: 2
+
+:::{card} Comet Logger
+:link: comet-logger
+:link-type: ref
+
+Monitor your experiments with Comet's comprehensive ML platform.
+:::
+
+:::{card} Wandb Logger
+:link: wandb-logger
+:link-type: ref
+
+Track and visualize your ML experiments with Weights & Biases.
+:::
+
+:::{card} Tensorboard Logger
+:link: tensorboard-logger
+:link-type: ref
+
+Visualize your training metrics with TensorBoard.
+:::
+
+:::{card} MLFlow Logger
+:link: mlflow-logger
+:link-type: ref
+
+Track and manage your ML lifecycle with MLflow.
+:::
+```
+
+(comet-logger)=
+
+## Comet Logger
+
+```{eval-rst}
+.. automodule:: anomalib.loggers.comet
+   :members:
+   :show-inheritance:
+```
+
+(wandb-logger)=
+
+## Wandb Logger
+
+```{eval-rst}
+.. automodule:: anomalib.loggers.wandb
+   :members:
+   :show-inheritance:
+```
+
+(tensorboard-logger)=
+
+## Tensorboard Logger
+
+```{eval-rst}
+.. automodule:: anomalib.loggers.tensorboard
+   :members:
+   :show-inheritance:
+```
+
+(mlflow-logger)=
+
+## MLFlow Logger
+
 ```{eval-rst}
-.. automodule:: anomalib.loggers
+.. automodule:: anomalib.loggers.mlflow
    :members:
-   :exclude-members: get_experiment_logger, configure_logger
    :show-inheritance:
 ```
diff --git a/docs/source/markdown/guides/reference/models/image/fre.md b/docs/source/markdown/guides/reference/models/image/fre.md
new file mode 100644
index 0000000000..180f8d3775
--- /dev/null
+++ b/docs/source/markdown/guides/reference/models/image/fre.md
@@ -0,0 +1,13 @@
+# FRE
+
+```{eval-rst}
+.. automodule:: anomalib.models.image.fre.lightning_model
+   :members:
+   :show-inheritance:
+```
+
+```{eval-rst}
+.. automodule:: anomalib.models.image.fre.torch_model
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/models/image/index.md b/docs/source/markdown/guides/reference/models/image/index.md
index a872a2c7b2..cabd819860 100644
--- a/docs/source/markdown/guides/reference/models/image/index.md
+++ b/docs/source/markdown/guides/reference/models/image/index.md
@@ -67,6 +67,13 @@ EfficientAD: Accurate Visual Anomaly Detection at Millisecond-Level Latencies
 FastFlow: Unsupervised Anomaly Detection and Localization via 2D Normalizing Flows
 :::
 
+:::{grid-item-card} {material-regular}`model_training;1.5em` FRE
+:link: ./fre
+:link-type: doc
+
+FRE: A Fast Method For Anomaly Detection And Segmentation
+:::
+
 :::{grid-item-card} {material-regular}`model_training;1.5em` GANomaly
 :link: ./ganomaly
 :link-type: doc
@@ -109,6 +116,13 @@ Student-Teacher Feature Pyramid Matching for Unsupervised Anomaly Detection
 U-Flow: A U-shaped Normalizing Flow for Anomaly Detection with Unsupervised Threshold
 :::
 
+:::{grid-item-card} {material-regular}`model_training;1.5em` VLM-AD
+:link: ./vlm_ad
+:link-type: doc
+
+VLM-AD: Vision-Language Model for Anomaly Detection
+:::
+
 :::{grid-item-card} {material-regular}`model_training;1.5em` WinCLIP
 :link: ./winclip
 :link-type: doc
@@ -130,6 +144,7 @@ WinCLIP: Zero-/Few-Shot Anomaly Classification and Segmentation
 ./dsr
 ./efficient_ad
 ./fastflow
+./fre
 ./ganomaly
 ./padim
 ./patchcore
diff --git a/docs/source/markdown/guides/reference/models/image/vlm_ad.md b/docs/source/markdown/guides/reference/models/image/vlm_ad.md
new file mode 100644
index 0000000000..3869f74ebc
--- /dev/null
+++ b/docs/source/markdown/guides/reference/models/image/vlm_ad.md
@@ -0,0 +1,8 @@
+# VLM-AD
+
+```{eval-rst}
+.. automodule:: anomalib.models.image.vlm_ad
+   :members:
+   :show-inheritance:
+   :special-members: __all__
+```
diff --git a/docs/source/markdown/guides/reference/models/index.md b/docs/source/markdown/guides/reference/models/index.md
index a8ad7ffa9d..bb705c403e 100644
--- a/docs/source/markdown/guides/reference/models/index.md
+++ b/docs/source/markdown/guides/reference/models/index.md
@@ -8,21 +8,30 @@
 :link: ./components/index
 :link-type: doc
 
-Learn more about components to design your own anomaly detection models.
+Core building blocks and utilities for creating custom anomaly detection models, including feature extractors, anomaly scoring functions, and visualization tools.
+
++++
+[Learn more »](./components/index)
 :::
 
 :::{grid-item-card} {octicon}`file-media` Image Models
 :link: ./image/index
 :link-type: doc
 
-Learn more about image anomaly detection models.
+Collection of state-of-the-art deep learning models for detecting anomalies in images, including both reconstruction and embedding-based approaches.
+
++++
+[Learn more »](./image/index)
 :::
 
 :::{grid-item-card} {octicon}`video` Video Models
 :link: ./video/index
 :link-type: doc
 
-Learn more about video anomaly detection models.
+Advanced models designed specifically for anomaly detection in video sequences, leveraging temporal information and motion patterns.
+
++++
+[Learn more »](./video/index)
 :::
 
 ::::
diff --git a/docs/source/markdown/guides/reference/post_processing/index.md b/docs/source/markdown/guides/reference/post_processing/index.md
new file mode 100644
index 0000000000..02bdb4d638
--- /dev/null
+++ b/docs/source/markdown/guides/reference/post_processing/index.md
@@ -0,0 +1,46 @@
+# Post-processing
+
+::::{grid} 1 2 2 2
+:gutter: 3
+:padding: 2
+
+:::{grid-item-card} {octicon}`gear` Base Post-processor
+:link: base-post-processor
+:link-type: ref
+
+Base class for post-processing.
+
++++
+[Learn more »](base-post-processor)
+:::
+
+:::{grid-item-card} {octicon}`gear` One-class Post-processor
+:link: one-class-post-processor
+:link-type: ref
+
+Post-processor for one-class anomaly detection.
+
++++
+[Learn more »](one-class-post-processor)
+:::
+::::
+
+(base-post-processor)=
+
+## Base Post-processor
+
+```{eval-rst}
+.. automodule:: anomalib.post_processing.base
+   :members:
+   :show-inheritance:
+```
+
+(one-class-post-processor)=
+
+## One-class Post-processor
+
+```{eval-rst}
+.. automodule:: anomalib.post_processing.one_class
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/reference/pre_processing/index.md b/docs/source/markdown/guides/reference/pre_processing/index.md
new file mode 100644
index 0000000000..23738e9fe5
--- /dev/null
+++ b/docs/source/markdown/guides/reference/pre_processing/index.md
@@ -0,0 +1,7 @@
+# Pre-processing
+
+```{eval-rst}
+.. automodule:: anomalib.pre_processing
+   :members:
+   :show-inheritance:
+```
diff --git a/docs/source/markdown/guides/topic/index.md b/docs/source/markdown/guides/topic/index.md
deleted file mode 100644
index bd8a29d718..0000000000
--- a/docs/source/markdown/guides/topic/index.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Topic Guide
-
-This section contains design documents and other internals of anomalib.
-
-```{warning}
-This section is under construction 🚧
-```
diff --git a/pyproject.toml b/pyproject.toml
index efdad6e41c..5d72ebd91b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -68,7 +68,7 @@ loggers = [
 ]
 notebooks = ["gitpython", "ipykernel", "ipywidgets", "notebook"]
 docs = [
-    "myst-parser",
+    "myst-parser[linkify]",
     "nbsphinx",
     "pandoc",
     "sphinx",
diff --git a/src/anomalib/__init__.py b/src/anomalib/__init__.py
index 281e5df759..dde3a9da26 100644
--- a/src/anomalib/__init__.py
+++ b/src/anomalib/__init__.py
@@ -1,4 +1,33 @@
-"""Anomalib library for research and benchmarking."""
+"""Anomalib library for research and benchmarking.
+
+This library provides tools and utilities for anomaly detection research and
+benchmarking. The key components include:
+
+    - Multiple state-of-the-art anomaly detection models
+    - Standardized training and evaluation pipelines
+    - Support for various data formats and tasks
+    - Visualization and analysis tools
+    - Benchmarking utilities
+
+Example:
+    >>> from anomalib.models import Padim
+    >>> # Create and train model
+    >>> model = Padim()
+    >>> model.train(train_dataloader)
+    >>> # Generate predictions
+    >>> predictions = model.predict(test_dataloader)
+
+The library supports:
+    - Classification and segmentation tasks
+    - One-class, zero-shot, and few-shot learning
+    - Multiple input formats (images, videos)
+    - Custom dataset integration
+    - Extensive configuration options
+
+Note:
+    The library is designed for both research and production use cases,
+    with a focus on reproducibility and ease of use.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -9,7 +38,24 @@
 
 
 class LearningType(str, Enum):
-    """Learning type defining how the model learns from the dataset samples."""
+    """Learning type defining how the model learns from the dataset samples.
+
+    This enum defines the different learning paradigms supported by anomalib models:
+
+        - ``ONE_CLASS``: Model learns from a single class of normal samples
+        - ``ZERO_SHOT``: Model learns without any task-specific training samples
+        - ``FEW_SHOT``: Model learns from a small number of training samples
+
+    Example:
+        >>> from anomalib import LearningType
+        >>> learning_type = LearningType.ONE_CLASS
+        >>> print(learning_type)
+        'one_class'
+
+    Note:
+        The learning type affects how the model is trained and what kind of data
+        it expects during training.
+    """
 
     ONE_CLASS = "one_class"
     ZERO_SHOT = "zero_shot"
@@ -17,7 +63,26 @@ class LearningType(str, Enum):
 
 
 class TaskType(str, Enum):
-    """Task type used when generating predictions on the dataset."""
+    """Task type defining the model's prediction output format.
+
+    This enum defines the different task types supported by anomalib models:
+
+        - ``CLASSIFICATION``: Model predicts anomaly scores at the image level
+        - ``SEGMENTATION``: Model predicts pixel-wise anomaly scores and masks
+
+    Example:
+        >>> from anomalib import TaskType
+        >>> task_type = TaskType.CLASSIFICATION
+        >>> print(task_type)
+        'classification'
+
+    Note:
+        The task type determines:
+            - The model architecture and output format
+            - Required ground truth annotation format
+            - Evaluation metrics used
+            - Visualization methods available
+    """
 
     CLASSIFICATION = "classification"
     SEGMENTATION = "segmentation"
diff --git a/src/anomalib/callbacks/__init__.py b/src/anomalib/callbacks/__init__.py
index 38c9537ca4..087e36d620 100644
--- a/src/anomalib/callbacks/__init__.py
+++ b/src/anomalib/callbacks/__init__.py
@@ -1,6 +1,40 @@
-"""Callbacks for Anomalib models."""
+"""Callbacks for Anomalib models.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides various callbacks used in Anomalib for model training, logging, and optimization.
+The callbacks include model checkpointing, graph logging, model loading, tiler configuration, and timing.
+
+The module exports the following callbacks:
+
+- :class:`ModelCheckpoint`: Save model checkpoints during training
+- :class:`GraphLogger`: Log model computation graphs
+- :class:`LoadModelCallback`: Load pre-trained model weights
+- :class:`TilerConfigurationCallback`: Configure image tiling settings
+- :class:`TimerCallback`: Track training/inference timing
+
+Example:
+    Get default callbacks based on configuration:
+
+    >>> from anomalib.callbacks import get_callbacks
+    >>> from omegaconf import DictConfig
+    >>> config = DictConfig({"trainer": {}, "project": {"path": "/tmp"}})
+    >>> callbacks = get_callbacks(config)
+    >>> isinstance(callbacks, list)
+    True
+
+    Use callbacks in trainer:
+
+    >>> import lightning.pytorch as pl
+    >>> trainer = pl.Trainer(callbacks=callbacks)
+
+See Also:
+    - :mod:`anomalib.callbacks.checkpoint`: Model checkpoint callback
+    - :mod:`anomalib.callbacks.graph`: Graph logging callback
+    - :mod:`anomalib.callbacks.model_loader`: Model loading callback
+    - :mod:`anomalib.callbacks.tiler_configuration`: Tiler configuration callback
+    - :mod:`anomalib.callbacks.timer`: Timer callback
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
@@ -31,13 +65,51 @@
 
 
 def get_callbacks(config: DictConfig | ListConfig | Namespace) -> list[Callback]:
-    """Return base callbacks for all the lightning models.
+    """Get default callbacks for Anomalib models based on configuration.
+
+    This function returns a list of callbacks based on the provided configuration.
+    It automatically adds:
+
+    - Model loading callback if checkpoint path is specified
+    - NNCF optimization callback if NNCF optimization is enabled
 
     Args:
-        config (DictConfig | ListConfig | Namespace): Model config
+        config (DictConfig | ListConfig | Namespace): Configuration object containing model and training settings.
+            Expected to have the following structure:
+
+            .. code-block:: yaml
+
+                trainer:
+                    ckpt_path: Optional[str]  # Path to model checkpoint
+                optimization:
+                    nncf:
+                        apply: bool  # Whether to apply NNCF optimization
+                        # Other NNCF config options
+                project:
+                    path: str  # Project directory path
+
+    Returns:
+        list[Callback]: List of PyTorch Lightning callbacks to be used during training.
+            May include:
+
+            - :class:`LoadModelCallback`: For loading model checkpoints
+            - :class:`NNCFCallback`: For neural network compression
+            - Other default callbacks
+
+    Example:
+        >>> from omegaconf import DictConfig
+        >>> config = DictConfig({
+        ...     "trainer": {"ckpt_path": None},
+        ...     "project": {"path": "/tmp"},
+        ...     "optimization": {"nncf": {"apply": False}}
+        ... })
+        >>> callbacks = get_callbacks(config)
+        >>> isinstance(callbacks, list)
+        True
 
-    Return:
-        (list[Callback]): List of callbacks.
+    Note:
+        NNCF is imported dynamically only when required since it conflicts with
+        some kornia JIT operations.
     """
     logger.info("Loading the callbacks")
 
diff --git a/src/anomalib/callbacks/checkpoint.py b/src/anomalib/callbacks/checkpoint.py
index 7d7b4bb7d5..30114b1b99 100644
--- a/src/anomalib/callbacks/checkpoint.py
+++ b/src/anomalib/callbacks/checkpoint.py
@@ -1,4 +1,27 @@
-"""Anomalib Model Checkpoint Callback."""
+"""Anomalib Model Checkpoint Callback.
+
+This module provides the :class:`ModelCheckpoint` callback that extends PyTorch Lightning's
+:class:`~lightning.pytorch.callbacks.ModelCheckpoint` to support zero-shot and few-shot learning scenarios.
+
+The callback enables checkpoint saving without requiring training steps, which is particularly useful for
+zero-shot and few-shot learning models where the training process may only involve validation.
+
+Example:
+    Create and use a checkpoint callback:
+
+    >>> from anomalib.callbacks import ModelCheckpoint
+    >>> checkpoint_callback = ModelCheckpoint(
+    ...     dirpath="checkpoints",
+    ...     filename="best",
+    ...     monitor="val_loss"
+    ... )
+    >>> from lightning.pytorch import Trainer
+    >>> trainer = Trainer(callbacks=[checkpoint_callback])
+
+Note:
+    This callback is particularly important for zero-shot and few-shot models where
+    traditional training-based checkpoint saving strategies may not be appropriate.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -11,29 +34,61 @@
 
 
 class ModelCheckpoint(LightningCheckpoint):
-    """Anomalib Model Checkpoint Callback.
-
-    This class overrides the Lightning ModelCheckpoint callback to enable saving checkpoints without running any
-    training steps. This is useful for zero-/few-shot models, where the fit sequence only consists of validation.
-
-    To enable saving checkpoints without running any training steps, we need to override two checks which are being
-    called in the ``on_validation_end`` method of the parent class:
-    - ``_should_save_on_train_epoch_end``: This method checks whether the checkpoint should be saved at the end of a
-        training epoch, or at the end of the validation sequence. We modify this method to default to saving at the end
-        of the validation sequence when the model is of zero- or few-shot type, unless ``save_on_train_epoch_end`` is
-        specifically set by the user.
-    - ``_should_skip_saving_checkpoint``: This method checks whether the checkpoint should be saved at all. We modify
-        this method to allow saving during both the ``FITTING`` and ``VALIDATING`` states. In addition, we allow saving
-        if the global step has not changed since the last checkpoint, but only for zero- and few-shot models. This is
-        needed because both the last global step and the last checkpoint remain unchanged during zero-/few-shot
-        training, which would otherwise prevent saving checkpoints during validation.
+    """Custom ModelCheckpoint callback for Anomalib.
+
+    This callback extends PyTorch Lightning's
+    :class:`~lightning.pytorch.callbacks.ModelCheckpoint` to enable checkpoint saving
+    without requiring training steps. This is particularly useful for zero-shot and few-shot
+    learning models where the training process may only involve validation.
+
+    The callback overrides two key methods from the parent class:
+
+    1. :meth:`_should_save_on_train_epoch_end`: Controls whether checkpoints are saved at the end
+       of training epochs or validation sequences. For zero-shot and few-shot models, it defaults
+       to saving at validation end unless explicitly configured otherwise.
+
+    2. :meth:`_should_skip_saving_checkpoint`: Determines if checkpoint saving should be skipped.
+       Modified to:
+
+       - Allow saving during both ``FITTING`` and ``VALIDATING`` states
+       - Permit saving even when global step hasn't changed (for zero-shot/few-shot models)
+       - Maintain standard checkpoint skipping conditions (``fast_dev_run``, sanity checking)
+
+    Example:
+        Create and use a checkpoint callback:
+
+        >>> from anomalib.callbacks import ModelCheckpoint
+        >>> # Create a checkpoint callback
+        >>> checkpoint_callback = ModelCheckpoint(
+        ...     dirpath="checkpoints",
+        ...     filename="best",
+        ...     monitor="val_loss"
+        ... )
+        >>> # Use it with Lightning Trainer
+        >>> from lightning.pytorch import Trainer
+        >>> trainer = Trainer(callbacks=[checkpoint_callback])
+
+    Note:
+        All arguments from PyTorch Lightning's :class:`~lightning.pytorch.callbacks.ModelCheckpoint` are supported.
+        See :class:`~lightning.pytorch.callbacks.ModelCheckpoint` for details.
     """
 
     def _should_skip_saving_checkpoint(self, trainer: Trainer) -> bool:
-        """Checks whether the checkpoint should be saved.
+        """Determine if checkpoint saving should be skipped.
+
+        Args:
+            trainer (:class:`~lightning.pytorch.Trainer`): PyTorch Lightning trainer instance.
+
+        Returns:
+            bool: ``True`` if checkpoint saving should be skipped, ``False`` otherwise.
 
-        Overrides the parent method to allow saving during both the ``FITTING`` and ``VALIDATING`` states, and to allow
-        saving when the global step and last_global_step_saved are both 0 (only for zero-/few-shot models).
+        Note:
+            The method considers the following conditions:
+
+            - Skips if ``fast_dev_run`` is enabled
+            - Skips if not in ``FITTING`` or ``VALIDATING`` state
+            - Skips during sanity checking
+            - For non-zero/few-shot models, skips if global step hasn't changed
         """
         is_zero_or_few_shot = trainer.lightning_module.learning_type in {LearningType.ZERO_SHOT, LearningType.FEW_SHOT}
         return (
@@ -44,10 +99,20 @@ def _should_skip_saving_checkpoint(self, trainer: Trainer) -> bool:
         )
 
     def _should_save_on_train_epoch_end(self, trainer: Trainer) -> bool:
-        """Checks whether the checkpoint should be saved at the end of a training epoch or validation sequence.
+        """Determine if checkpoint should be saved at training epoch end.
+
+        Args:
+            trainer (:class:`~lightning.pytorch.Trainer`): PyTorch Lightning trainer instance.
+
+        Returns:
+            bool: ``True`` if checkpoint should be saved at training epoch end, ``False`` otherwise.
+
+        Note:
+            The method follows this decision flow:
 
-        Overrides the parent method to default to saving at the end of the validation sequence when the model is of
-        zero- or few-shot type, unless ``save_on_train_epoch_end`` is specifically set by the user.
+            - Returns user-specified value if ``_save_on_train_epoch_end`` is set
+            - For zero/few-shot models, defaults to ``False`` (save at validation end)
+            - Otherwise, follows parent class behavior
         """
         if self._save_on_train_epoch_end is not None:
             return self._save_on_train_epoch_end
diff --git a/src/anomalib/callbacks/graph.py b/src/anomalib/callbacks/graph.py
index 38864245f6..e73b1b9cdf 100644
--- a/src/anomalib/callbacks/graph.py
+++ b/src/anomalib/callbacks/graph.py
@@ -1,6 +1,38 @@
-"""Log model graph to respective logger."""
+"""Graph logging callback for model visualization.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides the :class:`GraphLogger` callback for visualizing model architectures in various logging backends.
+The callback supports TensorBoard, Comet, and Weights & Biases (W&B) logging.
+
+The callback automatically detects which logger is being used and
+handles the graph logging appropriately for each backend.
+
+Example:
+    Log model graph to TensorBoard:
+
+    >>> from anomalib.callbacks import GraphLogger
+    >>> from anomalib.loggers import AnomalibTensorBoardLogger
+    >>> from anomalib.engine import Engine
+    >>> logger = AnomalibTensorBoardLogger()
+    >>> callbacks = [GraphLogger()]
+    >>> engine = Engine(logger=logger, callbacks=callbacks)
+
+    Log model graph to Comet:
+
+    >>> from anomalib.callbacks import GraphLogger
+    >>> from anomalib.loggers import AnomalibCometLogger
+    >>> from anomalib.engine import Engine
+    >>> logger = AnomalibCometLogger()
+    >>> callbacks = [GraphLogger()]
+    >>> engine = Engine(logger=logger, callbacks=callbacks)
+
+Note:
+    For TensorBoard and Comet, the graph is logged at the end of training.
+    For W&B, the graph is logged at the start of training but requires one backward pass
+    to be populated. This means it may not work for models that don't require training
+    (e.g., :class:`PaDiM`).
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import torch
@@ -12,34 +44,45 @@
 class GraphLogger(Callback):
     """Log model graph to respective logger.
 
-    Examples:
-        Log model graph to Tensorboard
+    This callback logs the model architecture graph to the configured logger. It supports multiple
+    logging backends including TensorBoard, Comet, and Weights & Biases (W&B).
+
+    The callback automatically detects which logger is being used and handles the graph logging
+    appropriately for each backend.
+
+    Example:
+        Create and use a graph logger:
 
         >>> from anomalib.callbacks import GraphLogger
         >>> from anomalib.loggers import AnomalibTensorBoardLogger
-        >>> from anomalib.engine import Engine
-        ...
+        >>> from lightning.pytorch import Trainer
         >>> logger = AnomalibTensorBoardLogger()
-        >>> callbacks = [GraphLogger()]
-        >>> engine = Engine(logger=logger, callbacks=callbacks)
+        >>> graph_logger = GraphLogger()
+        >>> trainer = Trainer(logger=logger, callbacks=[graph_logger])
 
-        Log model graph to Comet
-
-        >>> from anomalib.loggers import AnomalibCometLogger
-        >>> from anomalib.engine import Engine
-        ...
-        >>> logger = AnomalibCometLogger()
-        >>> callbacks = [GraphLogger()]
-        >>> engine = Engine(logger=logger, callbacks=callbacks)
+    Note:
+        - For TensorBoard and Comet, the graph is logged at the end of training
+        - For W&B, the graph is logged at the start of training but requires one backward pass
+          to be populated. This means it may not work for models that don't require training
+          (e.g., :class:`PaDiM`)
     """
 
     @staticmethod
     def on_train_start(trainer: Trainer, pl_module: LightningModule) -> None:
-        """Log model graph to respective logger.
+        """Log model graph to respective logger at training start.
+
+        This method is called automatically at the start of training. For W&B logger,
+        it sets up model watching with graph logging enabled.
 
         Args:
-            trainer: Trainer object which contans reference to loggers.
-            pl_module: LightningModule object which is logged.
+            trainer (Trainer): PyTorch Lightning trainer instance containing logger references.
+            pl_module (LightningModule): Lightning module instance to be logged.
+
+        Example:
+            >>> from anomalib.callbacks import GraphLogger
+            >>> callback = GraphLogger()
+            >>> # Called automatically by trainer
+            >>> # callback.on_train_start(trainer, model)
         """
         for logger in trainer.loggers:
             if isinstance(logger, AnomalibWandbLogger):
@@ -50,11 +93,21 @@ def on_train_start(trainer: Trainer, pl_module: LightningModule) -> None:
 
     @staticmethod
     def on_train_end(trainer: Trainer, pl_module: LightningModule) -> None:
-        """Unwatch model if configured for wandb and log it model graph in Tensorboard if specified.
+        """Log model graph at training end and cleanup.
+
+        This method is called automatically at the end of training. It:
+        - Logs the model graph for TensorBoard and Comet loggers
+        - Unwatches the model for W&B logger
 
         Args:
-            trainer: Trainer object which contans reference to loggers.
-            pl_module: LightningModule object which is logged.
+            trainer (Trainer): PyTorch Lightning trainer instance containing logger references.
+            pl_module (LightningModule): Lightning module instance to be logged.
+
+        Example:
+            >>> from anomalib.callbacks import GraphLogger
+            >>> callback = GraphLogger()
+            >>> # Called automatically by trainer
+            >>> # callback.on_train_end(trainer, model)
         """
         for logger in trainer.loggers:
             if isinstance(logger, AnomalibCometLogger | AnomalibTensorBoardLogger):
diff --git a/src/anomalib/callbacks/model_loader.py b/src/anomalib/callbacks/model_loader.py
index 8c688b3127..f977882106 100644
--- a/src/anomalib/callbacks/model_loader.py
+++ b/src/anomalib/callbacks/model_loader.py
@@ -1,6 +1,26 @@
-"""Callback that loads model weights from the state dict."""
+"""Model loader callback.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides the :class:`LoadModelCallback` for loading pre-trained model weights from a state dict.
+
+The callback loads model weights from a specified path when inference begins. This is useful for loading
+pre-trained models for inference or fine-tuning.
+
+Example:
+    Load pre-trained weights and create a trainer:
+
+    >>> from anomalib.callbacks import LoadModelCallback
+    >>> from anomalib.engine import Engine
+    >>> from anomalib.models import Padim
+    >>> model = Padim()
+    >>> callbacks = [LoadModelCallback(weights_path="path/to/weights.pt")]
+    >>> engine = Engine(model=model, callbacks=callbacks)
+
+Note:
+    The weights file should be a PyTorch state dict saved with either a ``.pt`` or ``.pth`` extension.
+    The state dict should contain a ``"state_dict"`` key with the model weights.
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
@@ -14,14 +34,29 @@
 
 
 class LoadModelCallback(Callback):
-    """Callback that loads the model weights from the state dict.
+    """Callback that loads model weights from a state dict.
+
+    This callback loads pre-trained model weights from a specified path when inference begins.
+    The weights are loaded into the model's state dict using the device specified by the model.
+
+    Args:
+        weights_path (str): Path to the model weights file (``.pt`` or ``.pth``).
+            The file should contain a state dict with a ``"state_dict"`` key.
 
     Examples:
+        Create a callback and use it with a trainer:
+
         >>> from anomalib.callbacks import LoadModelCallback
         >>> from anomalib.engine import Engine
-        ...
-        >>> callbacks = [LoadModelCallback(weights_path="path/to/weights.pt")]
-        >>> engine = Engine(callbacks=callbacks)
+        >>> from anomalib.models import Padim
+        >>> model = Padim()
+        >>> # Create callback with path to weights
+        >>> callback = LoadModelCallback(weights_path="path/to/weights.pt")
+        >>> # Use callback with engine
+        >>> engine = Engine(model=model, callbacks=[callback])
+
+    Note:
+        The callback automatically handles device mapping when loading weights.
     """
 
     def __init__(self, weights_path: str) -> None:
@@ -30,7 +65,18 @@ def __init__(self, weights_path: str) -> None:
     def setup(self, trainer: Trainer, pl_module: AnomalibModule, stage: str | None = None) -> None:
         """Call when inference begins.
 
-        Loads the model weights from ``weights_path`` into the PyTorch module.
+        This method is called by PyTorch Lightning when inference begins. It loads the model
+        weights from the specified path into the module's state dict.
+
+        Args:
+            trainer (Trainer): PyTorch Lightning trainer instance.
+            pl_module (AnomalibModule): The module to load weights into.
+            stage (str | None, optional): Current stage of execution. Defaults to ``None``.
+
+        Note:
+            The weights are loaded using ``torch.load`` with automatic device mapping based on
+            the module's device. The state dict is expected to have a ``"state_dict"`` key
+            containing the model weights.
         """
         del trainer, stage  # These variables are not used.
 
diff --git a/src/anomalib/callbacks/nncf/__init__.py b/src/anomalib/callbacks/nncf/__init__.py
index 074a1bd861..6691729144 100644
--- a/src/anomalib/callbacks/nncf/__init__.py
+++ b/src/anomalib/callbacks/nncf/__init__.py
@@ -1,4 +1,4 @@
 """Integration NNCF."""
 
-# Copyright (C) 2022 Intel Corporation
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/callbacks/nncf/callback.py b/src/anomalib/callbacks/nncf/callback.py
index ce45f0a866..2372d1b972 100644
--- a/src/anomalib/callbacks/nncf/callback.py
+++ b/src/anomalib/callbacks/nncf/callback.py
@@ -1,6 +1,15 @@
-"""Callbacks for NNCF optimization."""
+"""NNCF optimization callback.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides the `NNCFCallback` for optimizing neural networks using Intel's Neural Network
+Compression Framework (NNCF). The callback handles model compression techniques like quantization
+and pruning.
+
+Note:
+    The callback assumes that the Lightning module contains a 'model' attribute which is the
+    PyTorch module to be compressed.
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import subprocess  # nosec B404
@@ -19,15 +28,45 @@
 
 
 class NNCFCallback(Callback):
-    """Callback for NNCF compression.
+    """Callback for NNCF model compression.
 
-    Assumes that the pl module contains a 'model' attribute, which is
-    the PyTorch module that must be compressed.
+    This callback handles the compression of PyTorch models using NNCF during training.
+    It supports various compression techniques like quantization and pruning.
 
     Args:
-        config (dict): NNCF Configuration
-        export_dir (Str): Path where the export `onnx` and the OpenVINO `xml` and `bin` IR are saved.
-                          If None model will not be exported.
+        config (dict): NNCF configuration dictionary that specifies the compression
+            parameters and algorithms to be applied. See the NNCF documentation for
+            details on configuration options.
+        export_dir (str | None, optional): Directory path where the exported models will be saved.
+            If provided, the following files will be exported:
+
+            - ONNX model file (`model_nncf.onnx`)
+            - OpenVINO IR files (`model_nncf.xml` and `model_nncf.bin`)
+
+            If ``None``, model export will be skipped. Defaults to ``None``.
+
+    Examples:
+        Configure NNCF quantization:
+
+        >>> nncf_config = {
+        ...     "input_info": {"sample_size": [1, 3, 224, 224]},
+        ...     "compression": {"algorithm": "quantization"}
+        ... }
+        >>> callback = NNCFCallback(config=nncf_config, export_dir="./compressed_models")
+        >>> trainer = pl.Trainer(callbacks=[callback])
+
+    Note:
+        - The callback assumes that the Lightning module contains a ``model`` attribute which is the
+          PyTorch module to be compressed.
+        - The compression is initialized using the validation dataloader since it contains both normal
+          and anomalous samples, unlike the training set which only has normal samples.
+        - Model export requires OpenVINO's Model Optimizer (``mo``) to be available in the system PATH.
+
+    See Also:
+        - :class:`lightning.pytorch.Callback`: Base callback class
+        - :class:`nncf.NNCFConfig`: NNCF configuration class
+        - :func:`nncf.torch.register_default_init_args`: Register initialization arguments
+        - :func:`anomalib.callbacks.nncf.utils.wrap_nncf_model`: Wrap model for NNCF compression
     """
 
     def __init__(self, config: dict, export_dir: str | None = None) -> None:
@@ -36,10 +75,15 @@ def __init__(self, config: dict, export_dir: str | None = None) -> None:
         self.nncf_ctrl: CompressionAlgorithmController | None = None
 
     def setup(self, trainer: pl.Trainer, pl_module: pl.LightningModule, stage: str | None = None) -> None:
-        """Call when fit or test begins.
+        """Initialize NNCF compression when training begins.
 
-        Takes the pytorch model and wraps it using the compression controller
-        so that it is ready for nncf fine-tuning.
+        This method is called when training or testing begins. It wraps the PyTorch model
+        using the NNCF compression controller to prepare it for compression during training.
+
+        Args:
+            trainer (pl.Trainer): PyTorch Lightning trainer instance
+            pl_module (pl.LightningModule): The Lightning module containing the model to compress
+            stage (str | None, optional): Current stage of training. Defaults to ``None``.
         """
         del stage  # `stage` variable is not used.
 
@@ -66,9 +110,17 @@ def on_train_batch_start(
         batch_idx: int,
         unused: int = 0,
     ) -> None:
-        """Call when the train batch begins.
+        """Prepare compression before each training batch.
+
+        Called at the beginning of each training batch to update the compression
+        scheduler for the next step.
 
-        Prepare compression method to continue training the model in the next step.
+        Args:
+            trainer (pl.Trainer): PyTorch Lightning trainer instance
+            pl_module (pl.LightningModule): The Lightning module being trained
+            batch (Any): Current batch of data
+            batch_idx (int): Index of current batch
+            unused (int, optional): Unused parameter. Defaults to ``0``.
         """
         del trainer, pl_module, batch, batch_idx, unused  # These variables are not used.
 
@@ -76,9 +128,14 @@ def on_train_batch_start(
             self.nncf_ctrl.scheduler.step()
 
     def on_train_epoch_start(self, trainer: pl.Trainer, pl_module: pl.LightningModule) -> None:
-        """Call when the train epoch starts.
+        """Prepare compression before each training epoch.
 
-        Prepare compression method to continue training the model in the next epoch.
+        Called at the beginning of each training epoch to update the compression
+        scheduler for the next epoch.
+
+        Args:
+            trainer (pl.Trainer): PyTorch Lightning trainer instance
+            pl_module (pl.LightningModule): The Lightning module being trained
         """
         del trainer, pl_module  # `trainer` and `pl_module` variables are not used.
 
@@ -86,9 +143,20 @@ def on_train_epoch_start(self, trainer: pl.Trainer, pl_module: pl.LightningModul
             self.nncf_ctrl.scheduler.epoch_step()
 
     def on_train_end(self, trainer: pl.Trainer, pl_module: pl.LightningModule) -> None:
-        """Call when the train ends.
+        """Export the compressed model when training ends.
+
+        This method handles the export of the compressed model to ONNX format and
+        optionally converts it to OpenVINO IR format if the export directory is specified.
+
+        Args:
+            trainer (pl.Trainer): PyTorch Lightning trainer instance
+            pl_module (pl.LightningModule): The trained Lightning module
 
-        Exports onnx model and if compression controller is not None, uses the onnx model to generate the OpenVINO IR.
+        Note:
+            - Requires OpenVINO's Model Optimizer (``mo``) to be available in the system PATH
+            - Creates the export directory if it doesn't exist
+            - Exports ONNX model as ``model_nncf.onnx``
+            - Converts ONNX to OpenVINO IR format using ``mo``
         """
         del trainer, pl_module  # `trainer` and `pl_module` variables are not used.
 
diff --git a/src/anomalib/callbacks/nncf/utils.py b/src/anomalib/callbacks/nncf/utils.py
index 99f1db6aaa..6f0a783a77 100644
--- a/src/anomalib/callbacks/nncf/utils.py
+++ b/src/anomalib/callbacks/nncf/utils.py
@@ -1,6 +1,17 @@
-"""Utils for NNCf optimization."""
+"""Utilities for Neural Network Compression Framework (NNCF) optimization.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides utility functions and classes for working with Intel's Neural Network
+Compression Framework (NNCF). It includes functionality for model initialization, state
+management, and configuration handling.
+
+The module contains:
+
+- ``InitLoader``: A data loader class for NNCF initialization
+- Functions for wrapping PyTorch models with NNCF compression
+- Utilities for handling NNCF model states and configurations
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
@@ -24,19 +35,67 @@
 
 
 class InitLoader(PTInitializingDataLoader):
-    """Initializing data loader for NNCF to be used with unsupervised training algorithms."""
+    """Initializing data loader for NNCF to be used with unsupervised training algorithms.
+
+    This class extends NNCF's ``PTInitializingDataLoader`` to handle unsupervised training data.
+    It provides methods for iterating through the data and extracting inputs for model initialization.
+
+    Args:
+        data_loader (DataLoader): PyTorch ``DataLoader`` containing the initialization data.
+
+    Examples:
+        Create an initialization loader from a PyTorch dataloader:
+
+        >>> from torch.utils.data import DataLoader, TensorDataset
+        >>> import torch
+        >>> dataset = TensorDataset(torch.randn(10, 3, 32, 32))
+        >>> dataloader = DataLoader(dataset)
+        >>> init_loader = InitLoader(dataloader)
+
+        Iterate through the loader:
+
+        >>> for batch in init_loader:
+        ...     assert isinstance(batch, torch.Tensor)
+        ...     assert batch.shape[1:] == (3, 32, 32)
+
+    Note:
+        The loader expects the dataloader to return dictionaries with an ``"image"`` key
+        containing the input tensor.
+    """
 
     def __init__(self, data_loader: DataLoader) -> None:
         super().__init__(data_loader)
         self._data_loader_iter: Iterator
 
     def __iter__(self) -> "InitLoader":
-        """Create iterator for dataloader."""
+        """Create iterator for dataloader.
+
+        Returns:
+            InitLoader: Self reference for iteration.
+
+        Example:
+            >>> from torch.utils.data import DataLoader, TensorDataset
+            >>> loader = InitLoader(DataLoader(TensorDataset(torch.randn(1,3,32,32))))
+            >>> iterator = iter(loader)
+            >>> isinstance(iterator, InitLoader)
+            True
+        """
         self._data_loader_iter = iter(self._data_loader)
         return self
 
     def __next__(self) -> torch.Tensor:
-        """Return next item from dataloader iterator."""
+        """Return next item from dataloader iterator.
+
+        Returns:
+            torch.Tensor: Next image tensor from the dataloader.
+
+        Example:
+            >>> from torch.utils.data import DataLoader, TensorDataset
+            >>> loader = InitLoader(DataLoader(TensorDataset(torch.randn(1,3,32,32))))
+            >>> batch = next(iter(loader))
+            >>> isinstance(batch, torch.Tensor)
+            True
+        """
         loaded_item = next(self._data_loader_iter)
         return loaded_item["image"]
 
@@ -44,9 +103,20 @@ def __next__(self) -> torch.Tensor:
     def get_inputs(dataloader_output: dict[str, str | torch.Tensor]) -> tuple[tuple, dict]:
         """Get input to model.
 
+        Args:
+            dataloader_output (dict[str, str | torch.Tensor]): Output from the dataloader
+                containing the input tensor.
+
         Returns:
-            (dataloader_output,), {}: tuple[tuple, dict]: The current model call to be made during
-            the initialization process
+            tuple[tuple, dict]: A tuple containing:
+                - A tuple with the dataloader output
+                - An empty dict for additional arguments
+
+        Example:
+            >>> output = {"image": torch.randn(1,3,32,32)}
+            >>> args, kwargs = InitLoader.get_inputs(output)
+            >>> isinstance(args, tuple) and isinstance(kwargs, dict)
+            True
         """
         return (dataloader_output,), {}
 
@@ -54,10 +124,15 @@ def get_inputs(dataloader_output: dict[str, str | torch.Tensor]) -> tuple[tuple,
     def get_target(_) -> None:  # noqa: ANN001
         """Return structure for ground truth in loss criterion based on dataloader output.
 
-        This implementation does not do anything and is a placeholder.
+        This implementation is a placeholder that returns ``None`` since ground truth
+        is not used in unsupervised training.
 
         Returns:
-            None
+            None: Always returns ``None`` as targets are not used.
+
+        Example:
+            >>> InitLoader.get_target(None) is None
+            True
         """
         return
 
@@ -68,13 +143,32 @@ def wrap_nncf_model(
     dataloader: DataLoader,
     init_state_dict: dict,
 ) -> tuple[CompressionAlgorithmController, NNCFNetwork]:
-    """Wrap model by NNCF.
+    """Wrap PyTorch model with NNCF compression.
 
-    :param model: Anomalib model.
-    :param config: NNCF config.
-    :param dataloader: Dataloader for initialization of NNCF model.
-    :param init_state_dict: Opti
-    :return: compression controller, compressed model
+    Args:
+        model (nn.Module): Anomalib model to be compressed.
+        config (dict): NNCF configuration dictionary.
+        dataloader (DataLoader): DataLoader for NNCF model initialization.
+        init_state_dict (dict): Initial state dictionary for model initialization.
+
+    Returns:
+        tuple[CompressionAlgorithmController, NNCFNetwork]: A tuple containing:
+            - The compression controller
+            - The compressed model
+
+    Warning:
+        Either ``dataloader`` or ``init_state_dict`` must be provided for proper quantizer initialization.
+
+    Example:
+        >>> import torch.nn as nn
+        >>> from torch.utils.data import DataLoader, TensorDataset
+        >>> model = nn.Linear(10, 2)
+        >>> config = {"input_info": {"sample_size": [1, 10]}}
+        >>> data = torch.randn(100, 10)
+        >>> dataloader = DataLoader(TensorDataset(data))
+        >>> controller, compressed = wrap_nncf_model(model, config, dataloader, {})
+        >>> isinstance(compressed, NNCFNetwork)
+        True
     """
     nncf_config = NNCFConfig.from_dict(config)
 
@@ -109,16 +203,53 @@ def wrap_nncf_model(
 
 
 def is_state_nncf(state: dict) -> bool:
-    """Check if state is the result of NNCF-compressed model."""
+    """Check if state is the result of NNCF-compressed model.
+
+    Args:
+        state (dict): Model state dictionary to check.
+
+    Returns:
+        bool: ``True`` if the state is from an NNCF-compressed model, ``False`` otherwise.
+
+    Example:
+        >>> state = {"meta": {"nncf_enable_compression": True}}
+        >>> is_state_nncf(state)
+        True
+        >>> state = {"meta": {}}
+        >>> is_state_nncf(state)
+        False
+    """
     return bool(state.get("meta", {}).get("nncf_enable_compression", False))
 
 
 def compose_nncf_config(nncf_config: dict, enabled_options: list[str]) -> dict:
-    """Compose NNCf config by selected options.
+    """Compose NNCF config by selected options.
+
+    This function merges different parts of the NNCF configuration based on enabled options.
+    It supports ordered application of configuration parts through the ``order_of_parts`` field.
+
+    Args:
+        nncf_config (dict): Base NNCF configuration dictionary.
+        enabled_options (list[str]): List of enabled optimization options.
 
-    :param nncf_config:
-    :param enabled_options:
-    :return: config
+    Returns:
+        dict: Composed NNCF configuration.
+
+    Raises:
+        TypeError: If ``order_of_parts`` is not a list.
+        ValueError: If an enabled option is not in ``order_of_parts``.
+        KeyError: If ``base`` part or any enabled option is missing from config.
+        RuntimeError: If there's an error during config merging.
+
+    Example:
+        >>> config = {
+        ...     "base": {"epochs": 1},
+        ...     "quantization": {"epochs": 2},
+        ...     "order_of_parts": ["quantization"]
+        ... }
+        >>> result = compose_nncf_config(config, ["quantization"])
+        >>> result["epochs"]
+        2
     """
     optimisation_parts = nncf_config
     optimisation_parts_to_choose = []
@@ -169,14 +300,26 @@ def merge_dicts_and_lists_b_into_a(
     a: dict[Any, Any] | list[Any],
     b: dict[Any, Any] | list[Any],
 ) -> dict[Any, Any] | list[Any]:
-    """Merge dict configs.
+    """Merge two configuration dictionaries or lists.
+
+    This function provides the public interface for merging configurations.
+    It delegates to the internal ``_merge_dicts_and_lists_b_into_a`` function.
 
     Args:
-        a (dict[Any, Any] | list[Any]): First dict or list.
-        b (dict[Any, Any] | list[Any]): Second dict or list.
+        a (dict[Any, Any] | list[Any]): First dictionary or list to merge.
+        b (dict[Any, Any] | list[Any]): Second dictionary or list to merge into first.
 
     Returns:
-        dict[Any, Any] | list[Any]: Merged dict or list.
+        dict[Any, Any] | list[Any]: Merged configuration.
+
+    Example:
+        >>> a = {"x": 1, "y": [1, 2]}
+        >>> b = {"y": [3], "z": 2}
+        >>> result = merge_dicts_and_lists_b_into_a(a, b)
+        >>> result["y"]
+        [1, 2, 3]
+        >>> result["z"]
+        2
     """
     return _merge_dicts_and_lists_b_into_a(a, b, "")
 
@@ -186,30 +329,37 @@ def _merge_dicts_and_lists_b_into_a(
     b: dict[Any, Any] | list[Any],
     cur_key: int | str | None = None,
 ) -> dict[Any, Any] | list[Any]:
-    """Merge dict configs.
+    """Recursively merge two configuration dictionaries or lists.
 
-        * works with usual dicts and lists and derived types
-        * supports merging of lists (by concatenating the lists)
-        * makes recursive merging for dict + dict case
-        * overwrites when merging scalar into scalar
-        Note that we merge b into a (whereas Config makes merge a into b),
-        since otherwise the order of list merging is counter-intuitive.
+    This function implements the following merge behavior:
+    - Works with standard dicts, lists and their derived types
+    - Merges lists by concatenation
+    - Performs recursive merging for nested dictionaries
+    - Overwrites scalar values when merging
 
     Args:
-        a (dict[Any, Any] | list[Any]): First dict or list.
-        b (dict[Any, Any] | list[Any]): Second dict or list.
-        cur_key (int | str | None, optional): key for current level of recursion. Defaults to None.
+        a (dict[Any, Any] | list[Any]): First dictionary or list to merge.
+        b (dict[Any, Any] | list[Any]): Second dictionary or list to merge into first.
+        cur_key (int | str | None, optional): Current key in recursive merge. Defaults to None.
 
     Returns:
-        dict[Any, Any] | list[Any]: Merged dict or list.
+        dict[Any, Any] | list[Any]: Merged configuration.
+
+    Raises:
+        TypeError: If inputs are not dictionaries or lists, or if types are incompatible.
+
+    Example:
+        >>> a = {"x": {"y": [1]}}
+        >>> b = {"x": {"y": [2]}}
+        >>> result = _merge_dicts_and_lists_b_into_a(a, b)
+        >>> result["x"]["y"]
+        [1, 2]
     """
 
     def _err_str(_a: dict | list, _b: dict | list, _key: int | str | None = None) -> str:
         _key_str = "of whole structures" if _key is None else f"during merging for key=`{_key}`"
         return (
-            f"Error in merging parts of config: different types {_key_str},"
-            f" type(a) = {type(_a)},"
-            f" type(b) = {type(_b)}"
+            f"Error in merging parts of config: different types {_key_str}, type(a) = {type(_a)}, type(b) = {type(_b)}"
         )
 
     if not (isinstance(a, dict | list)):
diff --git a/src/anomalib/callbacks/tiler_configuration.py b/src/anomalib/callbacks/tiler_configuration.py
index f44a4d679f..9e3d92d5d7 100644
--- a/src/anomalib/callbacks/tiler_configuration.py
+++ b/src/anomalib/callbacks/tiler_configuration.py
@@ -1,6 +1,32 @@
-"""Tiler Callback."""
+"""Tiler configuration callback.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides the :class:`TilerConfigurationCallback` for configuring image tiling operations
+in Anomalib models. Tiling allows processing large images by splitting them into smaller tiles,
+which is useful when dealing with high-resolution images that don't fit in GPU memory.
+
+The callback configures tiling parameters such as tile size, stride, and upscaling mode for
+models that support tiling operations.
+
+Example:
+    Configure tiling with custom parameters:
+
+    >>> from anomalib.callbacks import TilerConfigurationCallback
+    >>> from anomalib.data.utils.tiler import ImageUpscaleMode
+    >>> callback = TilerConfigurationCallback(
+    ...     enable=True,
+    ...     tile_size=512,
+    ...     stride=256,
+    ...     mode=ImageUpscaleMode.PADDING
+    ... )
+    >>> from lightning.pytorch import Trainer
+    >>> trainer = Trainer(callbacks=[callback])
+
+Note:
+    The model must support tiling operations for this callback to work.
+    It will raise a :exc:`ValueError` if used with a model that doesn't support tiling.
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from collections.abc import Sequence
@@ -15,7 +41,53 @@
 
 
 class TilerConfigurationCallback(Callback):
-    """Tiler Configuration Callback."""
+    """Callback for configuring image tiling operations.
+
+    This callback configures the tiling operation for models that support it. Tiling is useful
+    when working with high-resolution images that need to be processed in smaller chunks.
+
+    Args:
+        enable (bool): Whether to enable tiling operation. Defaults to ``False``.
+        tile_size (int | Sequence): Size of each tile. Can be a single integer for square tiles
+            or a sequence of two integers for rectangular tiles. Defaults to ``256``.
+        stride (int | Sequence | None): Stride between tiles. Can be a single integer or a sequence
+            of two integers. If ``None``, uses ``tile_size``. Defaults to ``None``.
+        remove_border_count (int): Number of pixels to remove from the image border before
+            tiling. Useful for removing artifacts at image boundaries. Defaults to ``0``.
+        mode (ImageUpscaleMode): Method to use when combining overlapping tiles.
+            Options are defined in :class:`~anomalib.data.utils.tiler.ImageUpscaleMode`.
+            Defaults to ``ImageUpscaleMode.PADDING``.
+
+    Examples:
+        Create a basic tiling configuration:
+
+        >>> callback = TilerConfigurationCallback(enable=True)
+
+        Configure tiling with custom tile size and stride:
+
+        >>> callback = TilerConfigurationCallback(
+        ...     enable=True,
+        ...     tile_size=512,
+        ...     stride=256
+        ... )
+
+        Use rectangular tiles with custom upscale mode:
+
+        >>> from anomalib.data.utils.tiler import ImageUpscaleMode
+        >>> callback = TilerConfigurationCallback(
+        ...     enable=True,
+        ...     tile_size=(512, 256),
+        ...     mode=ImageUpscaleMode.AVERAGE
+        ... )
+
+    Raises:
+        ValueError: If used with a model that doesn't support tiling operations.
+
+    Note:
+        - The model must have a ``tiler`` attribute to support tiling operations
+        - Smaller stride values result in more overlap between tiles but increase computation
+        - The upscale mode affects how overlapping regions are combined
+    """
 
     def __init__(
         self,
@@ -25,21 +97,7 @@ def __init__(
         remove_border_count: int = 0,
         mode: ImageUpscaleMode = ImageUpscaleMode.PADDING,
     ) -> None:
-        """Set tiling configuration from the command line.
-
-        Args:
-            enable (bool): Boolean to enable tiling operation.
-                Defaults to False.
-            tile_size ([int | Sequence]): Tile size.
-                Defaults to 256.
-            stride ([int | Sequence]): Stride to move tiles on the image.
-            remove_border_count (int, optional): Number of pixels to remove from the image before
-                tiling. Defaults to 0.
-            mode (str, optional): Up-scaling mode when untiling overlapping tiles.
-                Defaults to "padding".
-            tile_count (SupportsIndex, optional): Number of random tiles to sample from the image.
-                Defaults to 4.
-        """
+        """Initialize tiling configuration."""
         self.enable = enable
         self.tile_size = tile_size
         self.stride = stride
@@ -49,14 +107,18 @@ def __init__(
     def setup(self, trainer: pl.Trainer, pl_module: pl.LightningModule, stage: str | None = None) -> None:
         """Set Tiler object within Anomalib Model.
 
+        This method is called by PyTorch Lightning during setup. It configures the tiling
+        parameters if tiling is enabled and the model supports it.
+
         Args:
-            trainer (pl.Trainer): PyTorch Lightning Trainer
-            pl_module (pl.LightningModule): Anomalib Model that inherits pl LightningModule.
-            stage (str | None, optional): fit, validate, test or predict. Defaults to None.
+            trainer (pl.Trainer): PyTorch Lightning Trainer instance.
+            pl_module (pl.LightningModule): The Anomalib model being trained/tested.
+            stage (str | None, optional): Current stage - ``"fit"``, ``"validate"``,
+                ``"test"`` or ``"predict"``. Defaults to ``None``.
 
         Raises:
-            ValueError: When Anomalib Model doesn't contain ``Tiler`` object, it means the model
-                doesn not support tiling operation.
+            ValueError: If tiling is enabled but the model doesn't support tiling operations
+                (i.e., doesn't have a ``tiler`` attribute).
         """
         del trainer, stage  # These variables are not used.
 
diff --git a/src/anomalib/callbacks/timer.py b/src/anomalib/callbacks/timer.py
index 3cbf516dc0..04554f1ef7 100644
--- a/src/anomalib/callbacks/timer.py
+++ b/src/anomalib/callbacks/timer.py
@@ -1,6 +1,27 @@
-"""Callback to measure training and testing time of a PyTorch Lightning module."""
+"""Timer callback.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides the :class:`TimerCallback` for measuring training and testing time of
+Anomalib models. The callback tracks execution time and calculates throughput metrics.
+
+Example:
+    Add timer callback to track performance:
+
+    >>> from anomalib.callbacks import TimerCallback
+    >>> from lightning.pytorch import Trainer
+    >>> callback = TimerCallback()
+    >>> trainer = Trainer(callbacks=[callback])
+
+    The callback will automatically log:
+    - Total training time when training completes
+    - Total testing time and throughput (FPS) when testing completes
+
+Note:
+    - The callback handles both single and multiple test dataloaders
+    - Throughput is calculated as total number of images / total testing time
+    - Batch size is included in throughput logging for reference
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
@@ -13,63 +34,80 @@
 
 
 class TimerCallback(Callback):
-    """Callback that measures the training and testing time of a PyTorch Lightning module.
+    """Callback for measuring model training and testing time.
+
+    This callback tracks execution time metrics:
+    - Training time: Total time taken for model training
+    - Testing time: Total time taken for model testing
+    - Testing throughput: Images processed per second during testing
+
+    Example:
+        Add timer to track performance:
 
-    Examples:
         >>> from anomalib.callbacks import TimerCallback
-        >>> from anomalib.engine import Engine
-        ...
-        >>> callbacks = [TimerCallback()]
-        >>> engine = Engine(callbacks=callbacks)
+        >>> from lightning.pytorch import Trainer
+        >>> callback = TimerCallback()
+        >>> trainer = Trainer(callbacks=[callback])
+
+    Note:
+        - The callback automatically handles both single and multiple test dataloaders
+        - Throughput is calculated as: ``num_test_images / testing_time``
+        - All metrics are logged using the logger specified in the trainer
     """
 
     def __init__(self) -> None:
+        """Initialize timer callback.
+
+        The callback initializes:
+        - ``start``: Timestamp for tracking execution segments
+        - ``num_images``: Counter for total test images
+        """
         self.start: float
         self.num_images: int = 0
 
     def on_fit_start(self, trainer: Trainer, pl_module: LightningModule) -> None:
-        """Call when fit begins.
+        """Called when fit begins.
 
-        Sets the start time to the time training started.
+        Records the start time of the training process.
 
         Args:
-            trainer (Trainer): PyTorch Lightning trainer.
-            pl_module (LightningModule): Current training module.
+            trainer (Trainer): PyTorch Lightning trainer instance
+            pl_module (LightningModule): The current training module
 
-        Returns:
-            None
+        Note:
+            The trainer and module arguments are not used but kept for callback signature compatibility
         """
         del trainer, pl_module  # These variables are not used.
-
         self.start = time.time()
 
     def on_fit_end(self, trainer: Trainer, pl_module: LightningModule) -> None:
-        """Call when fit ends.
+        """Called when fit ends.
 
-        Prints the time taken for training.
+        Calculates and logs the total training time.
 
         Args:
-            trainer (Trainer): PyTorch Lightning trainer.
-            pl_module (LightningModule): Current training module.
+            trainer (Trainer): PyTorch Lightning trainer instance
+            pl_module (LightningModule): The current training module
 
-        Returns:
-            None
+        Note:
+            The trainer and module arguments are not used but kept for callback signature compatibility
         """
         del trainer, pl_module  # Unused arguments.
         logger.info("Training took %5.2f seconds", (time.time() - self.start))
 
     def on_test_start(self, trainer: Trainer, pl_module: LightningModule) -> None:
-        """Call when the test begins.
+        """Called when test begins.
 
-        Sets the start time to the time testing started.
-        Goes over all the test dataloaders and adds the number of images in each.
+        Records test start time and counts total number of test images.
 
         Args:
-            trainer (Trainer): PyTorch Lightning trainer.
-            pl_module (LightningModule): Current training module.
+            trainer (Trainer): PyTorch Lightning trainer instance
+            pl_module (LightningModule): The current training module
 
-        Returns:
-            None
+        Note:
+            - Records start timestamp for testing phase
+            - Counts total images across all test dataloaders if multiple are present
+            - The module argument is not used but kept for callback signature compatibility
         """
         del pl_module  # Unused argument.
 
@@ -84,16 +122,19 @@ def on_test_start(self, trainer: Trainer, pl_module: LightningModule) -> None:
                     self.num_images += len(dataloader.dataset)
 
     def on_test_end(self, trainer: Trainer, pl_module: LightningModule) -> None:
-        """Call when the test ends.
+        """Called when test ends.
 
-        Prints the time taken for testing and the throughput in frames per second.
+        Calculates and logs testing time and throughput metrics.
 
         Args:
-            trainer (Trainer): PyTorch Lightning trainer.
-            pl_module (LightningModule): Current training module.
-
-        Returns:
-            None
+            trainer (Trainer): PyTorch Lightning trainer instance
+            pl_module (LightningModule): The current training module
+
+        Note:
+            - Calculates total testing time
+            - Computes throughput in frames per second (FPS)
+            - Logs batch size along with throughput for reference
+            - The module argument is not used but kept for callback signature compatibility
         """
         del pl_module  # Unused argument.
 
diff --git a/src/anomalib/callbacks/visualizer.py b/src/anomalib/callbacks/visualizer.py
index 9b0b78dfa0..a118c93ae4 100644
--- a/src/anomalib/callbacks/visualizer.py
+++ b/src/anomalib/callbacks/visualizer.py
@@ -1,6 +1,28 @@
-"""Visualizer Callback.
+"""Visualizer callback.
 
-This is assigned by Anomalib Engine internally.
+This module provides the :class:`_VisualizationCallback` for generating and managing visualizations
+in Anomalib. This callback is assigned by the Anomalib Engine internally.
+
+The callback handles:
+- Generating visualizations during model testing and prediction
+- Saving visualizations to disk
+- Showing visualizations interactively
+- Logging visualizations to various logging backends
+
+Example:
+    Create visualization callback with multiple visualizers::
+
+        >>> from anomalib.utils.visualization import ImageVisualizer, MetricsVisualizer
+        >>> visualizers = [ImageVisualizer(), MetricsVisualizer()]
+        >>> visualization_callback = _VisualizationCallback(
+        ...     visualizers=visualizers,
+        ...     save=True,
+        ...     root="results/images"
+        ... )
+
+Note:
+    This callback is used internally by the Anomalib Engine and should not be
+    instantiated directly by users.
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -17,11 +39,7 @@
 from anomalib.loggers import AnomalibWandbLogger
 from anomalib.loggers.base import ImageLoggerBase
 from anomalib.models import AnomalibModule
-from anomalib.utils.visualization import (
-    BaseVisualizer,
-    GeneratorResult,
-    VisualizationStep,
-)
+from anomalib.utils.visualization import BaseVisualizer, GeneratorResult, VisualizationStep
 
 logger = logging.getLogger(__name__)
 
@@ -29,32 +47,35 @@
 class _VisualizationCallback(Callback):
     """Callback for visualization that is used internally by the Engine.
 
+    This callback handles the generation and management of visualizations during model
+    testing and prediction. It supports saving, showing, and logging visualizations
+    to various backends.
+
     Args:
-        visualizers (BaseVisualizer | list[BaseVisualizer]):
-            Visualizer objects that are used for computing the visualizations. Defaults to None.
-        save (bool, optional): Save the image. Defaults to False.
-        root (Path | None, optional): The path to save the images. Defaults to None.
-        log (bool, optional): Log the images into the loggers. Defaults to False.
-        show (bool, optional): Show the images. Defaults to False.
-
-    Example:
-        >>> visualizers = [ImageVisualizer(), MetricsVisualizer()]
-        >>> visualization_callback = _VisualizationCallback(
-        ... visualizers=visualizers,
-        ...   save=True,
-        ...   root="results/images"
-        ... )
+        visualizers (BaseVisualizer | list[BaseVisualizer]): Visualizer objects that
+            are used for computing the visualizations.
+        save (bool, optional): Save the visualizations. Defaults to ``False``.
+        root (Path | None, optional): The path to save the visualizations. Defaults to ``None``.
+        log (bool, optional): Log the visualizations to the loggers. Defaults to ``False``.
+        show (bool, optional): Show the visualizations. Defaults to ``False``.
+
+    Examples:
+        Create visualization callback with multiple visualizers::
 
-        CLI
-        $ anomalib train --model Padim --data MVTec \
-            --visualization.visualizers ImageVisualizer \
-            --visualization.visualizers+=MetricsVisualizer
-        or
-        $ anomalib train --model Padim --data MVTec \
-            --visualization.visualizers '[ImageVisualizer, MetricsVisualizer]'
+            >>> from anomalib.utils.visualization import ImageVisualizer, MetricsVisualizer
+            >>> visualizers = [ImageVisualizer(), MetricsVisualizer()]
+            >>> visualization_callback = _VisualizationCallback(
+            ...     visualizers=visualizers,
+            ...     save=True,
+            ...     root="results/images"
+            ... )
+
+    Note:
+        This callback is used internally by the Anomalib Engine and should not be
+        instantiated directly by users.
 
     Raises:
-        ValueError: Incase `root` is None and `save` is True.
+        ValueError: If ``root`` is ``None`` and ``save`` is ``True``.
     """
 
     def __init__(
@@ -83,6 +104,30 @@ def on_test_batch_end(
         batch_idx: int,
         dataloader_idx: int = 0,
     ) -> None:
+        """Generate visualizations at the end of a test batch.
+
+        Args:
+            trainer (Trainer): PyTorch Lightning trainer instance.
+            pl_module (AnomalibModule): The current module being tested.
+            outputs (STEP_OUTPUT | None): Outputs from the test step.
+            batch (Any): Current batch of data.
+            batch_idx (int): Index of the current batch.
+            dataloader_idx (int, optional): Index of the dataloader. Defaults to 0.
+
+        Example:
+            Generate visualizations for a test batch::
+
+                >>> from anomalib.utils.visualization import ImageVisualizer
+                >>> callback = _VisualizationCallback(
+                ...     visualizers=ImageVisualizer(),
+                ...     save=True,
+                ...     root="results/images"
+                ... )
+                >>> callback.on_test_batch_end(trainer, model, outputs, batch, 0)
+
+        Raises:
+            ValueError: If ``save`` is ``True`` but ``file_name`` is ``None``.
+        """
         for generator in self.generators:
             if generator.visualize_on == VisualizationStep.BATCH:
                 for result in generator(
@@ -115,6 +160,26 @@ def on_test_batch_end(
                         self._add_to_logger(result, pl_module, trainer)
 
     def on_test_end(self, trainer: Trainer, pl_module: AnomalibModule) -> None:
+        """Generate visualizations at the end of testing.
+
+        Args:
+            trainer (Trainer): PyTorch Lightning trainer instance.
+            pl_module (AnomalibModule): The module that was tested.
+
+        Example:
+            Generate visualizations at the end of testing::
+
+                >>> from anomalib.utils.visualization import MetricsVisualizer
+                >>> callback = _VisualizationCallback(
+                ...     visualizers=MetricsVisualizer(),
+                ...     save=True,
+                ...     root="results/metrics"
+                ... )
+                >>> callback.on_test_end(trainer, model)
+
+        Raises:
+            ValueError: If ``save`` is ``True`` but ``file_name`` is ``None``.
+        """
         for generator in self.generators:
             if generator.visualize_on == VisualizationStep.STAGE_END:
                 for result in generator(trainer=trainer, pl_module=pl_module):
@@ -141,9 +206,31 @@ def on_predict_batch_end(
         batch_idx: int,
         dataloader_idx: int = 0,
     ) -> None:
+        """Generate visualizations at the end of a prediction batch.
+
+        Args:
+            trainer (Trainer): PyTorch Lightning trainer instance.
+            pl_module (AnomalibModule): The module being used for prediction.
+            outputs (STEP_OUTPUT | None): Outputs from the prediction step.
+            batch (Any): Current batch of data.
+            batch_idx (int): Index of the current batch.
+            dataloader_idx (int, optional): Index of the dataloader. Defaults to 0.
+
+        Note:
+            This method calls :meth:`on_test_batch_end` internally.
+        """
         return self.on_test_batch_end(trainer, pl_module, outputs, batch, batch_idx, dataloader_idx)
 
     def on_predict_end(self, trainer: Trainer, pl_module: AnomalibModule) -> None:
+        """Generate visualizations at the end of prediction.
+
+        Args:
+            trainer (Trainer): PyTorch Lightning trainer instance.
+            pl_module (AnomalibModule): The module that was used for prediction.
+
+        Note:
+            This method calls :meth:`on_test_end` internally.
+        """
         return self.on_test_end(trainer, pl_module)
 
     @staticmethod
@@ -152,12 +239,21 @@ def _add_to_logger(
         module: AnomalibModule,
         trainer: Trainer,
     ) -> None:
-        """Add image to logger.
+        """Add visualization to logger.
 
         Args:
-            result (GeneratorResult): Output from the generators.
+            result (GeneratorResult): Output from the visualization generators.
             module (AnomalibModule): LightningModule from which the global step is extracted.
-            trainer (Trainer): Trainer object.
+            trainer (Trainer): Trainer object containing the loggers.
+
+        Example:
+            Add visualization to logger::
+
+                >>> result = generator.generate(...)  # Generate visualization
+                >>> _VisualizationCallback._add_to_logger(result, model, trainer)
+
+        Raises:
+            ValueError: If ``file_name`` is ``None`` when attempting to log.
         """
         # Store names of logger and the logger in a dict
         available_loggers = {
diff --git a/src/anomalib/cli/__init__.py b/src/anomalib/cli/__init__.py
index 78b54e5988..0c5fd02f80 100644
--- a/src/anomalib/cli/__init__.py
+++ b/src/anomalib/cli/__init__.py
@@ -1,6 +1,6 @@
 """Anomalib CLI."""
 
-# Copyright (C) 2022 Intel Corporation
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .cli import AnomalibCLI
diff --git a/src/anomalib/cli/cli.py b/src/anomalib/cli/cli.py
index 2bb61d7af5..88a9bf9fc7 100644
--- a/src/anomalib/cli/cli.py
+++ b/src/anomalib/cli/cli.py
@@ -1,4 +1,8 @@
-"""Anomalib CLI."""
+"""Anomalib Command Line Interface.
+
+This module provides the `AnomalibCLI` class for configuring and running Anomalib from the command line.
+The CLI supports configuration via both command line arguments and configuration files (.yaml or .json).
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -38,16 +42,30 @@
 
 
 class AnomalibCLI:
-    """Implementation of a fully configurable CLI tool for anomalib.
+    """Implementation of a fully configurable CLI tool for Anomalib.
+
+    This class provides a flexible command-line interface that can be configured through
+    both CLI arguments and configuration files. It supports various subcommands for
+    training, testing, and exporting models.
+
+    Args:
+        args (Sequence[str] | None): Command line arguments. Defaults to None.
+        run (bool): Whether to run the subcommand immediately. Defaults to True.
+
+    Examples:
+        Run from command line:
+
+        >>> import sys
+        >>> sys.argv = ["anomalib", "train", "--model", "Padim", "--data", "MVTec"]
+
+        Run programmatically:
 
-    The advantage of this tool is its flexibility to configure the pipeline
-    from both the CLI and a configuration file (.yaml or .json). It is even
-    possible to use both the CLI and a configuration file simultaneously.
-    For more details, the reader could refer to PyTorch Lightning CLI
-    documentation.
+        >>> from anomalib.cli import AnomalibCLI
+        >>> cli = AnomalibCLI(["train", "--model", "Padim", "--data", "MVTec"], run=False)
 
-    ``save_config_kwargs`` is set to ``overwrite=True`` so that the
-    ``SaveConfigCallback`` overwrites the config if it already exists.
+    Note:
+        The CLI supports both YAML and JSON configuration files. Configuration can be
+        provided via both files and command line arguments simultaneously.
     """
 
     def __init__(self, args: Sequence[str] | None = None, run: bool = True) -> None:
diff --git a/src/anomalib/cli/install.py b/src/anomalib/cli/install.py
index d114c8e168..755b856b50 100644
--- a/src/anomalib/cli/install.py
+++ b/src/anomalib/cli/install.py
@@ -1,4 +1,8 @@
-"""Anomalib install subcommand code."""
+"""Anomalib installation subcommand.
+
+This module provides the `anomalib_install` function for installing Anomalib and its dependencies.
+It supports installing different dependency sets based on the user's needs.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -9,11 +13,7 @@
 from rich.console import Console
 from rich.logging import RichHandler
 
-from anomalib.cli.utils.installation import (
-    get_requirements,
-    get_torch_install_args,
-    parse_requirements,
-)
+from anomalib.cli.utils.installation import get_requirements, get_torch_install_args, parse_requirements
 
 logger = logging.getLogger("pip")
 logger.setLevel(logging.WARNING)  # setLevel: CRITICAL, ERROR, WARNING, INFO, DEBUG, NOTSET
@@ -29,15 +29,27 @@
 def anomalib_install(option: str = "full", verbose: bool = False) -> int:
     """Install Anomalib requirements.
 
+    This function handles the installation of Anomalib dependencies based on the
+    specified option. It can install the full package or specific dependency sets.
+
     Args:
-        option (str | None): Optional-dependency to install requirements for.
-        verbose (bool): Set pip logger level to INFO
+        option (str): Optional-dependency to install requirements for.
+            Options: "full", "core", "dev", "loggers", "notebooks", "openvino".
+            Defaults to "full".
+        verbose (bool): Set pip logger level to INFO. Defaults to False.
+
+    Examples:
+        Install full package::
+        >>> anomalib_install("full")
+
+        Install core dependencies only::
+        >>> anomalib_install("core")
 
     Raises:
-        ValueError: When the task is not supported.
+        ValueError: When the option is not supported.
 
     Returns:
-        int: Status code of the pip install command.
+        int: Status code of the pip install command (0 for success).
     """
     from pip._internal.commands import create_command
 
diff --git a/src/anomalib/cli/pipelines.py b/src/anomalib/cli/pipelines.py
index ba6030491b..5a937f56d9 100644
--- a/src/anomalib/cli/pipelines.py
+++ b/src/anomalib/cli/pipelines.py
@@ -1,4 +1,8 @@
-"""Subcommand for pipelines."""
+"""Anomalib pipeline subcommands.
+
+This module provides functionality for managing and running Anomalib pipelines through
+the CLI. It includes support for benchmarking and other pipeline operations.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -22,14 +26,39 @@
 
 
 def pipeline_subcommands() -> dict[str, dict[str, str]]:
-    """Return subcommands for pipelines."""
+    """Get available pipeline subcommands.
+
+    Returns:
+        dict[str, dict[str, str]]: Dictionary mapping subcommand names to their descriptions.
+
+    Example:
+        Pipeline subcommands are available only if the pipelines are installed::
+
+        >>> pipeline_subcommands()
+        {
+            'benchmark': {
+                'description': 'Run benchmarking pipeline for model evaluation'
+            }
+        }
+    """
     if PIPELINE_REGISTRY is not None:
         return {name: {"description": get_short_docstring(pipeline)} for name, pipeline in PIPELINE_REGISTRY.items()}
     return {}
 
 
 def run_pipeline(args: Namespace) -> None:
-    """Run pipeline."""
+    """Run a pipeline with the provided arguments.
+
+    Args:
+        args (Namespace): Arguments for the pipeline, including the subcommand
+            and configuration.
+
+    Raises:
+        ValueError: If pipelines are not available in the current installation.
+
+    Note:
+        This feature is experimental and may change or be removed in future versions.
+    """
     logger.warning("This feature is experimental. It may change or be removed in the future.")
     if PIPELINE_REGISTRY is not None:
         subcommand = args.subcommand
diff --git a/src/anomalib/cli/utils/__init__.py b/src/anomalib/cli/utils/__init__.py
index 028c972728..fbe47ff661 100644
--- a/src/anomalib/cli/utils/__init__.py
+++ b/src/anomalib/cli/utils/__init__.py
@@ -1,6 +1,6 @@
 """Anomalib CLI Utils."""
 
-# Copyright (C) 2023 Intel Corporation
+# Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .help_formatter import CustomHelpFormatter
diff --git a/src/anomalib/cli/utils/help_formatter.py b/src/anomalib/cli/utils/help_formatter.py
index 4535011b09..f31ea1174b 100644
--- a/src/anomalib/cli/utils/help_formatter.py
+++ b/src/anomalib/cli/utils/help_formatter.py
@@ -1,6 +1,10 @@
-"""Custom Help Formatters for Anomalib CLI."""
+"""Custom help formatters for Anomalib CLI.
 
-# Copyright (C) 2023 Intel Corporation
+This module provides custom help formatting functionality for the Anomalib CLI,
+including rich text formatting and customized help output for different verbosity levels.
+"""
+
+# Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import argparse
@@ -38,13 +42,25 @@
 
 
 def get_short_docstring(component: type) -> str:
-    """Get the short description from the docstring.
+    """Get the short description from a component's docstring.
 
     Args:
-        component (type): The component to get the docstring from
+        component (type): The component to extract the docstring from.
 
     Returns:
-        str: The short description
+        str: The short description from the docstring, or empty string if no docstring.
+
+    Example:
+        >>> class MyClass:
+        ...     '''My class description.
+        ...
+        ...     More details here.
+        ...     '''
+        ...     pass
+
+        >>> output = get_short_docstring(MyClass)
+        >>> print(output)
+        My class description.
     """
     if component.__doc__ is None:
         return ""
@@ -53,12 +69,15 @@ def get_short_docstring(component: type) -> str:
 
 
 def get_verbosity_subcommand() -> dict:
-    """Parse command line arguments and returns a dictionary of key-value pairs.
+    """Parse command line arguments for verbosity and subcommand.
 
     Returns:
-        A dictionary containing the parsed command line arguments.
+        dict: Dictionary containing:
+            - subcommand: The subcommand being run
+            - help: Whether help was requested
+            - verbosity: Verbosity level (0-2)
 
-    Examples:
+    Example:
         >>> import sys
         >>> sys.argv = ['anomalib', 'train', '-h', '-v']
         >>> get_verbosity_subcommand()
@@ -79,12 +98,18 @@ def get_verbosity_subcommand() -> dict:
 
 
 def get_intro() -> Markdown:
-    """Return a Markdown object containing the introduction text for Anomalib CLI Guide.
-
-    The introduction text includes a brief description of the guide and links to the Github repository and documentation
+    """Get the introduction text for the Anomalib CLI guide.
 
     Returns:
-        A Markdown object containing the introduction text for Anomalib CLI Guide.
+        Markdown: A Markdown object containing the introduction text with links
+            to the Github repository and documentation.
+
+    Example:
+        >>> intro = get_intro()
+        >>> print(intro)
+        # Anomalib CLI Guide
+        Github Repository: https://github.com/openvinotoolkit/anomalib
+        Documentation: https://anomalib.readthedocs.io/
     """
     intro_markdown = (
         "# Anomalib CLI Guide\n\n"
@@ -96,15 +121,44 @@ def get_intro() -> Markdown:
 
 
 def get_verbose_usage(subcommand: str = "train") -> str:
-    """Return a string containing verbose usage information for the specified subcommand.
+    """Get verbose usage information for a subcommand.
+
+    This function generates a formatted string containing usage instructions for running
+    an Anomalib CLI subcommand with different verbosity levels. The instructions show
+    how to access more detailed help information using the -v and -vv flags.
 
     Args:
-    ----
-        subcommand (str): The name of the subcommand to get verbose usage information for. Defaults to "train".
+        subcommand (str, optional): The subcommand to get usage information for.
+            Defaults to "train".
 
     Returns:
-    -------
-        str: A string containing verbose usage information for the specified subcommand.
+        str: A formatted string containing verbose usage information with examples
+            showing different verbosity levels.
+
+    Example:
+        Get usage information for the "train" subcommand:
+
+        >>> usage = get_verbose_usage("train")
+        >>> print(usage)  # doctest: +NORMALIZE_WHITESPACE
+        To get more overridable argument information, run the command below.
+        ```python
+        # Verbosity Level 1
+        anomalib train [optional_arguments] -h -v
+        # Verbosity Level 2
+        anomalib train [optional_arguments] -h -vv
+        ```
+
+        Get usage for a different subcommand:
+
+        >>> usage = get_verbose_usage("export")  # doctest: +NORMALIZE_WHITESPACE
+        >>> print(usage)
+        To get more overridable argument information, run the command below.
+        ```python
+        # Verbosity Level 1
+        anomalib export [optional_arguments] -h -v
+        # Verbosity Level 2
+        anomalib export [optional_arguments] -h -vv
+        ```
     """
     return (
         "To get more overridable argument information, run the command below.\n"
@@ -118,29 +172,49 @@ def get_verbose_usage(subcommand: str = "train") -> str:
 
 
 def get_cli_usage_docstring(component: object | None) -> str | None:
-    r"""Get the cli usage from the docstring.
+    """Extract CLI usage instructions from a component's docstring.
+
+    This function searches for a "CLI Usage:" section in the component's docstring and
+    extracts its contents. The section should be delimited by either double newlines
+    or the end of the docstring.
 
     Args:
-    ----
-        component (Optional[object]): The component to get the docstring from
+        component: The object to extract the CLI usage from. Can be None.
 
     Returns:
-    -------
-        Optional[str]: The quick-start guide as Markdown format.
+        The CLI usage instructions as a string with normalized whitespace, or None if:
+        - The component is None
+        - The component has no docstring
+        - The docstring has no "CLI Usage:" section
 
-    Example:
-    -------
-        component.__doc__ = '''
-            
-
-            CLI Usage:
-                1. First Step.
-                2. Second Step.
-
-            
-        '''
-        >>> get_cli_usage_docstring(component)
-        "1. First Step.\n2. Second Step."
+    Examples:
+        A docstring with CLI usage section:
+
+        >>> class MyComponent:
+        ...     '''My component description.
+        ...
+        ...     CLI Usage:
+        ...         1. Run this command
+        ...         2. Then this command
+        ...
+        ...     Other sections...
+        ...     '''
+        >>> component = MyComponent()
+        >>> print(get_cli_usage_docstring(component))
+        1. Run this command
+        2. Then this command
+
+        A docstring without CLI usage returns None:
+
+        >>> class NoUsage:
+        ...     '''Just a description'''
+        >>> print(get_cli_usage_docstring(NoUsage()))
+        None
+
+        None input returns None:
+
+        >>> print(get_cli_usage_docstring(None))
+        None
     """
     if component is None or component.__doc__ is None or "CLI Usage" not in component.__doc__:
         return None
@@ -154,16 +228,34 @@ def get_cli_usage_docstring(component: object | None) -> str | None:
     return None
 
 
-def render_guide(subcommand: str | None = None) -> list:
+def render_guide(subcommand: str | None = None) -> list[Panel | Markdown]:
     """Render a guide for the specified subcommand.
 
+    This function generates a formatted guide containing usage instructions and examples
+    for a given CLI subcommand.
+
     Args:
-    ----
-        subcommand (Optional[str]): The subcommand to render the guide for.
+        subcommand: The subcommand to render the guide for. If None or not found in
+            DOCSTRING_USAGE, returns an empty list.
 
     Returns:
-    -------
-        list: A list of contents to be displayed in the guide.
+        A list containing rich formatting elements (Panel, Markdown) to be displayed
+        in the guide.
+
+    Examples:
+        >>> # Empty list for invalid subcommand
+        >>> render_guide("invalid")
+        []
+
+        >>> # Guide with intro and usage for valid subcommand
+        >>> guide = render_guide("train")
+        >>> len(guide) > 0
+        True
+
+    Notes:
+        - The guide includes an introduction section from `get_intro()`
+        - For valid subcommands, adds CLI usage from docstrings and verbose usage info
+        - Usage is formatted in a Panel with "Quick-Start" title
     """
     if subcommand is None or subcommand not in DOCSTRING_USAGE:
         return []
@@ -183,19 +275,28 @@ class CustomHelpFormatter(RichHelpFormatter, DefaultHelpFormatter):
     This formatter extends the RichHelpFormatter and DefaultHelpFormatter classes to provide
     a more detailed and customizable help output for Anomalib CLI.
 
+    Args:
+        *args: Variable length argument list passed to parent classes.
+        **kwargs: Arbitrary keyword arguments passed to parent classes.
+
     Attributes:
-    verbosity_level : int
-        The level of verbosity for the help output.
-    subcommand : str | None
-        The subcommand to render the guide for.
-
-    Methods:
-    add_usage(usage, actions, *args, **kwargs)
-        Add usage information to the help output.
-    add_argument(action)
-        Add an argument to the help output.
-    format_help()
-        Format the help output.
+        verbosity_dict (dict): Dictionary containing verbosity level and subcommand.
+        verbosity_level (int): The level of verbosity for the help output.
+        subcommand (str | None): The subcommand to render the guide for.
+
+    Example:
+        >>> from argparse import ArgumentParser
+        >>> parser = ArgumentParser(formatter_class=CustomHelpFormatter)
+        >>> parser.add_argument('--test')
+        >>> help_text = parser.format_help()
+        >>> isinstance(help_text, str)
+        True
+
+    Note:
+        The formatter supports different verbosity levels:
+        - Level 0: Shows only quick-start guide
+        - Level 1: Shows required arguments
+        - Level 2+: Shows all arguments
     """
 
     verbosity_dict = get_verbosity_subcommand()
@@ -205,16 +306,20 @@ class CustomHelpFormatter(RichHelpFormatter, DefaultHelpFormatter):
     def add_usage(self, usage: str | None, actions: list, *args, **kwargs) -> None:
         """Add usage information to the formatter.
 
-        Args:
-        ----
-            usage (str | None): A string describing the usage of the program.
-            actions (list): An list of argparse.Action objects.
-            *args (Any): Additional positional arguments to pass to the superclass method.
-            **kwargs (Any): Additional keyword arguments to pass to the superclass method.
+        Filters the actions shown in the usage section based on verbosity level
+        and required arguments for the current subcommand.
 
-        Returns:
-        -------
-            None
+        Args:
+            usage: A string describing the usage of the program.
+            actions: A list of argparse.Action objects.
+            *args: Additional positional arguments passed to parent method.
+            **kwargs: Additional keyword arguments passed to parent method.
+
+        Example:
+            >>> formatter = CustomHelpFormatter()
+            >>> formatter.add_usage("usage:", [], groups=[])
+            >>> True  # Method completes without error
+            True
         """
         if self.subcommand in REQUIRED_ARGUMENTS:
             if self.verbosity_level == 0:
@@ -227,12 +332,25 @@ def add_usage(self, usage: str | None, actions: list, *args, **kwargs) -> None:
     def add_argument(self, action: argparse.Action) -> None:
         """Add an argument to the help formatter.
 
-        If the verbose level is set to 0, the argument is not added.
-        If the verbose level is set to 1 and the argument is not in the non-skip list, the argument is not added.
+        Controls which arguments are displayed based on verbosity level and
+        whether they are required for the current subcommand.
 
         Args:
-        ----
-            action (argparse.Action): The action to add to the help formatter.
+            action: The argparse.Action object to potentially add to the help output.
+
+        Example:
+            >>> from argparse import Action, ArgumentParser
+            >>> parser = ArgumentParser()
+            >>> action = parser.add_argument('--test')
+            >>> formatter = CustomHelpFormatter()
+            >>> formatter.add_argument(action)
+            >>> True  # Method completes without error
+            True
+
+        Note:
+            - At verbosity level 0, no arguments are shown
+            - At verbosity level 1, only required arguments are shown
+            - At higher verbosity levels, all arguments are shown
         """
         if self.subcommand in REQUIRED_ARGUMENTS:
             if self.verbosity_level == 0:
@@ -242,13 +360,25 @@ def add_argument(self, action: argparse.Action) -> None:
         super().add_argument(action)
 
     def format_help(self) -> str:
-        """Format the help message for the current command and returns it as a string.
+        """Format the complete help message.
 
-        The help message includes information about the command's arguments and options,
-        as well as any additional information provided by the command's help guide.
+        Generates a formatted help message that includes command arguments, options,
+        and additional guide information based on the current verbosity level.
 
         Returns:
-            str: A string containing the formatted help message.
+            str: The formatted help message as a string.
+
+        Example:
+            >>> formatter = CustomHelpFormatter()
+            >>> help_text = formatter.format_help()
+            >>> isinstance(help_text, str)
+            True
+
+        Note:
+            The output format depends on verbosity level:
+            - Level 0-1: Shows quick-start guide for supported subcommands
+            - Level 1+: Includes argument section in a panel
+            - All levels: Maintains consistent spacing and formatting
         """
         with self.console.capture() as capture:
             section = self._root_section
diff --git a/src/anomalib/cli/utils/installation.py b/src/anomalib/cli/utils/installation.py
index 01c2f9d288..a9df2dff6e 100644
--- a/src/anomalib/cli/utils/installation.py
+++ b/src/anomalib/cli/utils/installation.py
@@ -1,4 +1,8 @@
-"""Anomalib installation util functions."""
+"""Anomalib installation utilities.
+
+This module provides utilities for managing Anomalib package installation,
+including dependency resolution and hardware-specific package selection.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -25,20 +29,32 @@
 
 
 def get_requirements(module: str = "anomalib") -> dict[str, list[Requirement]]:
-    """Get requirements of module from importlib.metadata.
+    """Get package requirements from importlib.metadata.
 
-    This function returns list of required packages from importlib_metadata.
+    Args:
+        module (str): Name of the module to get requirements for. Defaults to "anomalib".
+
+    Returns:
+        dict[str, list[Requirement]]: Dictionary mapping requirement groups to their
+            package requirements.
 
     Example:
-        >>> get_requirements("anomalib")
+        ```python
+        get_requirements("anomalib")
+        # Returns:
         {
             "base": ["jsonargparse==4.27.1", ...],
             "core": ["torch==2.1.1", ...],
             ...
         }
-
-    Returns:
-        dict[str, list[Requirement]]: List of required packages for each optional-extras.
+        ```
+
+    Test:
+        >>> result = get_requirements("anomalib")
+        >>> isinstance(result, dict)
+        True
+        >>> all(isinstance(v, list) for v in result.values())
+        True
     """
     requirement_list: list[str] | None = requires(module)
     extra_requirement: dict[str, list[Requirement]] = {}
@@ -62,26 +78,37 @@ def parse_requirements(
     requirements: list[Requirement],
     skip_torch: bool = False,
 ) -> tuple[str | None, list[str]]:
-    """Parse requirements and returns torch and other requirements.
+    """Parse requirements into torch and other requirements.
 
     Args:
-        requirements (list[Requirement]): List of requirements.
+        requirements (list[Requirement]): List of requirements to parse.
         skip_torch (bool): Whether to skip torch requirement. Defaults to False.
 
-    Raises:
-        ValueError: If torch requirement is not found.
+    Returns:
+        tuple[str | None, list[str]]: Tuple containing:
+            - Torch requirement string or None if skipped
+            - List of other requirement strings
 
-    Examples:
-        >>> requirements = [
-        ...     Requirement.parse("torch==1.13.0"),
-        ...     Requirement.parse("onnx>=1.8.1"),
-        ... ]
-        >>> parse_requirements(requirements=requirements)
-        (Requirement.parse("torch==1.13.0"),
-        Requirement.parse("onnx>=1.8.1"))
+    Raises:
+        ValueError: If torch requirement is not found and skip_torch is False.
 
-    Returns:
-        tuple[str, list[str], list[str]]: Tuple of torch and other requirements.
+    Example:
+        ```python
+        requirements = [
+            Requirement.parse("torch==1.13.0"),
+            Requirement.parse("onnx>=1.8.1"),
+        ]
+        parse_requirements(requirements)
+        # Returns: ('torch==1.13.0', ['onnx>=1.8.1'])
+        ```
+
+    Test:
+        >>> reqs = [Requirement.parse("torch==1.13.0"), Requirement.parse("onnx>=1.8.1")]
+        >>> torch_req, other_reqs = parse_requirements(reqs)
+        >>> torch_req == "torch==1.13.0"
+        True
+        >>> other_reqs == ["onnx>=1.8.1"]
+        True
     """
     torch_requirement: str | None = None
     other_requirements: list[str] = []
@@ -115,17 +142,27 @@ def parse_requirements(
 def get_cuda_version() -> str | None:
     """Get CUDA version installed on the system.
 
-    Examples:
-        >>> # Assume that CUDA version is 11.2
-        >>> get_cuda_version()
-        "11.2"
-
-        >>> # Assume that CUDA is not installed on the system
-        >>> get_cuda_version()
-        None
-
     Returns:
-        str | None: CUDA version installed on the system.
+        str | None: CUDA version string (e.g., "11.8") or None if not found.
+
+    Example:
+        ```python
+        # System with CUDA 11.8 installed
+        get_cuda_version()
+        # Returns: "11.8"
+
+        # System without CUDA
+        get_cuda_version()
+        # Returns: None
+        ```
+
+    Test:
+        >>> version = get_cuda_version()
+        >>> version is None or isinstance(version, str)
+        True
+        >>> if version is not None:
+        ...     version.count('.') == 1 and all(part.isdigit() for part in version.split('.'))
+        ...     True
     """
     # 1. Check CUDA_HOME Environment variable
     cuda_home = os.environ.get("CUDA_HOME", "/usr/local/cuda")
@@ -157,30 +194,20 @@ def get_cuda_version() -> str | None:
 
 
 def update_cuda_version_with_available_torch_cuda_build(cuda_version: str, torch_version: str) -> str:
-    """Update the installed CUDA version with the highest supported CUDA version by PyTorch.
+    """Update CUDA version to match PyTorch's supported versions.
 
     Args:
         cuda_version (str): The installed CUDA version.
         torch_version (str): The PyTorch version.
 
-    Raises:
-        Warning: If the installed CUDA version is not supported by PyTorch.
-
-    Examples:
-        >>> update_cuda_version_with_available_torch_cuda_builds("11.1", "1.13.0")
-        "11.6"
-
-        >>> update_cuda_version_with_available_torch_cuda_builds("11.7", "1.13.0")
-        "11.7"
-
-        >>> update_cuda_version_with_available_torch_cuda_builds("11.8", "1.13.0")
-        "11.7"
-
-        >>> update_cuda_version_with_available_torch_cuda_builds("12.1", "2.0.1")
-        "11.8"
-
     Returns:
-        str: The updated CUDA version.
+        str: The updated CUDA version that's compatible with PyTorch.
+
+    Example:
+        ```python
+        update_cuda_version_with_available_torch_cuda_build("12.1", "2.0.1")
+        # Returns: "11.8"  # PyTorch 2.0.1 only supports up to CUDA 11.8
+        ```
     """
     max_supported_cuda = max(AVAILABLE_TORCH_VERSIONS[torch_version]["cuda"])
     min_supported_cuda = min(AVAILABLE_TORCH_VERSIONS[torch_version]["cuda"])
@@ -204,63 +231,58 @@ def get_cuda_suffix(cuda_version: str) -> str:
     """Get CUDA suffix for PyTorch versions.
 
     Args:
-        cuda_version (str): CUDA version installed on the system.
-
-    Note:
-        The CUDA version of PyTorch is not always the same as the CUDA version
-            that is installed on the system. For example, the latest PyTorch
-            version (1.10.0) supports CUDA 11.3, but the latest CUDA version
-            that is available for download is 11.2. Therefore, we need to use
-            the latest available CUDA version for PyTorch instead of the CUDA
-            version that is installed on the system. Therefore, this function
-            shoudl be regularly updated to reflect the latest available CUDA.
-
-    Examples:
-        >>> get_cuda_suffix(cuda_version="11.2")
-        "cu112"
-
-        >>> get_cuda_suffix(cuda_version="11.8")
-        "cu118"
+        cuda_version (str): CUDA version string (e.g., "11.8").
 
     Returns:
-        str: CUDA suffix for PyTorch or mmX version.
+        str: CUDA suffix for PyTorch (e.g., "cu118").
+
+    Example:
+        ```python
+        get_cuda_suffix("11.8")
+        # Returns: "cu118"
+        ```
+
+    Test:
+        >>> get_cuda_suffix("11.8")
+        'cu118'
+        >>> get_cuda_suffix("12.1")
+        'cu121'
     """
     return f"cu{cuda_version.replace('.', '')}"
 
 
 def get_hardware_suffix(with_available_torch_build: bool = False, torch_version: str | None = None) -> str:
-    """Get hardware suffix for PyTorch or mmX versions.
+    """Get hardware suffix for PyTorch package names.
 
     Args:
-        with_available_torch_build (bool): Whether to use the latest available
-            PyTorch build or not. If True, the latest available PyTorch build
-            will be used. If False, the installed PyTorch build will be used.
-            Defaults to False.
-        torch_version (str | None): PyTorch version. This is only used when the
-            ``with_available_torch_build`` is True.
-
-    Examples:
-        >>> # Assume that CUDA version is 11.2
-        >>> get_hardware_suffix()
-        "cu112"
-
-        >>> # Assume that CUDA is not installed on the system
-        >>> get_hardware_suffix()
-        "cpu"
-
-        Assume that that installed CUDA version is 12.1.
-        However, the latest available CUDA version for PyTorch v2.0 is 11.8.
-        Therefore, we use 11.8 instead of 12.1. This is because PyTorch does not
-        support CUDA 12.1 yet. In this case, we could correct the CUDA version
-        by setting `with_available_torch_build` to True.
-
-        >>> cuda_version = get_cuda_version()
-        "12.1"
-        >>> get_hardware_suffix(with_available_torch_build=True, torch_version="2.0.1")
-        "cu118"
+        with_available_torch_build (bool): Whether to use available PyTorch builds
+            to determine the suffix. Defaults to False.
+        torch_version (str | None): PyTorch version to check against. Required if
+            with_available_torch_build is True.
 
     Returns:
-        str: Hardware suffix for PyTorch or mmX version.
+        str: Hardware suffix (e.g., "cu118" or "cpu").
+
+    Raises:
+        ValueError: If torch_version is not provided when with_available_torch_build is True.
+
+    Example:
+        ```python
+        # System with CUDA 11.8
+        get_hardware_suffix()
+        # Returns: "cu118"
+
+        # System without CUDA
+        get_hardware_suffix()
+        # Returns: "cpu"
+        ```
+
+    Test:
+        >>> suffix = get_hardware_suffix()
+        >>> isinstance(suffix, str)
+        True
+        >>> suffix in {'cpu'} or suffix.startswith('cu')
+        True
     """
     cuda_version = get_cuda_version()
     if cuda_version:
@@ -277,26 +299,38 @@ def get_hardware_suffix(with_available_torch_build: bool = False, torch_version:
 
 
 def get_torch_install_args(requirement: str | Requirement) -> list[str]:
-    """Get the install arguments for Torch requirement.
-
-    This function will return the install arguments for the Torch requirement
-    and its corresponding torchvision requirement.
+    """Get pip install arguments for PyTorch packages.
 
     Args:
-        requirement (str | Requirement): The torch requirement.
+        requirement (str | Requirement): The torch requirement specification.
+
+    Returns:
+        list[str]: List of pip install arguments.
 
     Raises:
         RuntimeError: If the OS is not supported.
 
     Example:
-        >>> from pkg_resources import Requirement
-        >>> requriment = "torch>=1.13.0"
-        >>> get_torch_install_args(requirement)
-        ['--extra-index-url', 'https://download.pytorch.org/whl/cpu',
-        'torch>=1.13.0', 'torchvision==0.14.0']
-
-    Returns:
-        list[str]: The install arguments.
+        ```python
+        requirement = "torch>=2.0.0"
+        get_torch_install_args(requirement)
+        # Returns:
+        [
+            '--extra-index-url',
+            'https://download.pytorch.org/whl/cu118',
+            'torch>=2.0.0',
+            'torchvision==0.15.1'
+        ]
+        ```
+
+    Test:
+        >>> args = get_torch_install_args("torch>=2.0.0")
+        >>> isinstance(args, list)
+        True
+        >>> all(isinstance(arg, str) for arg in args)
+        True
+        >>> any('torch' in arg for arg in args)
+        True
     """
     if isinstance(requirement, str):
         requirement = Requirement.parse(requirement)
diff --git a/src/anomalib/cli/utils/openvino.py b/src/anomalib/cli/utils/openvino.py
index 50a894c304..00c2fda1ae 100644
--- a/src/anomalib/cli/utils/openvino.py
+++ b/src/anomalib/cli/utils/openvino.py
@@ -1,6 +1,10 @@
-"""Utils for OpenVINO parser."""
+"""OpenVINO CLI utilities.
 
-# Copyright (C) 2023 Intel Corporation
+This module provides utilities for adding OpenVINO-specific arguments to the Anomalib CLI.
+It handles the integration of OpenVINO Model Optimizer parameters into the command line interface.
+"""
+
+# Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
@@ -18,7 +22,43 @@
 
 
 def add_openvino_export_arguments(parser: ArgumentParser) -> None:
-    """Add OpenVINO arguments to parser under --mo key."""
+    """Add OpenVINO Model Optimizer arguments to the parser.
+
+    This function adds OpenVINO-specific export arguments to the parser under the `ov_args` prefix.
+    If OpenVINO is not installed, it logs an informational message and skips adding the arguments.
+
+    The function adds Model Optimizer arguments like data_type, mean_values, etc. as optional
+    parameters that can be used during model export to OpenVINO format.
+
+    Args:
+        parser (ArgumentParser): The argument parser to add OpenVINO arguments to.
+            This should be an instance of jsonargparse.ArgumentParser.
+
+    Examples:
+        Add OpenVINO arguments to a parser:
+
+        >>> from jsonargparse import ArgumentParser
+        >>> parser = ArgumentParser()
+        >>> add_openvino_export_arguments(parser)
+
+        The parser will now accept OpenVINO arguments like:
+
+        >>> # parser.parse_args(['--ov_args.data_type', 'FP16'])
+        >>> # parser.parse_args(['--ov_args.mean_values', '[123.675,116.28,103.53]'])
+
+    Notes:
+        - Requires OpenVINO to be installed to add the arguments
+        - Automatically skips redundant arguments that are handled elsewhere:
+            - help
+            - input_model
+            - output_dir
+        - Arguments are added under the 'ov_args' prefix for namespacing
+        - All OpenVINO arguments are made optional
+
+    See Also:
+        - OpenVINO Model Optimizer docs: https://docs.openvino.ai/latest/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html
+        - OpenVINO Python API: https://docs.openvino.ai/latest/api/python_api.html
+    """
     if get_common_cli_parser is not None:
         group = parser.add_argument_group("OpenVINO Model Optimizer arguments (optional)")
         ov_parser = get_common_cli_parser()
diff --git a/src/anomalib/data/__init__.py b/src/anomalib/data/__init__.py
index 9c9be7eb5b..3f7389647f 100644
--- a/src/anomalib/data/__init__.py
+++ b/src/anomalib/data/__init__.py
@@ -1,4 +1,28 @@
-"""Anomalib Datasets."""
+"""Anomalib Datasets.
+
+This module provides datasets and data modules for anomaly detection tasks.
+
+The module contains:
+    - Data classes for representing different types of data (images, videos, etc.)
+    - Dataset classes for loading and processing data
+    - Data modules for use with PyTorch Lightning
+    - Helper functions for data loading and validation
+
+Example:
+    >>> from anomalib.data import get_datamodule
+    >>> from omegaconf import DictConfig
+    >>> config = DictConfig({
+    ...     "data": {
+    ...         "class_path": "MVTec",
+    ...         "init_args": {
+    ...             "root": "./datasets/MVTec",
+    ...             "category": "bottle",
+    ...             "image_size": (256, 256)
+    ...         }
+    ...     }
+    ... })
+    >>> datamodule = get_datamodule(config)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -51,17 +75,34 @@
 )
 
 
-class UnknownDatamoduleError(ModuleNotFoundError): ...
+class UnknownDatamoduleError(ModuleNotFoundError):
+    """Raised when a datamodule cannot be found."""
 
 
 def get_datamodule(config: DictConfig | ListConfig | dict) -> AnomalibDataModule:
-    """Get Anomaly Datamodule.
+    """Get Anomaly Datamodule from config.
 
     Args:
-        config (DictConfig | ListConfig | dict): Configuration of the anomaly model.
+        config: Configuration for the anomaly model. Can be either:
+            - DictConfig from OmegaConf
+            - ListConfig from OmegaConf
+            - Python dictionary
 
     Returns:
-        PyTorch Lightning DataModule
+        PyTorch Lightning DataModule configured according to the input.
+
+    Raises:
+        UnknownDatamoduleError: If the specified datamodule cannot be found.
+
+    Example:
+        >>> from omegaconf import DictConfig
+        >>> config = DictConfig({
+        ...     "data": {
+        ...         "class_path": "MVTec",
+        ...         "init_args": {"root": "./datasets/MVTec"}
+        ...     }
+        ... })
+        >>> datamodule = get_datamodule(config)
     """
     logger.info("Loading the datamodule")
 
diff --git a/src/anomalib/data/dataclasses/__init__.py b/src/anomalib/data/dataclasses/__init__.py
index a7f8516ae5..f0f08e3e54 100644
--- a/src/anomalib/data/dataclasses/__init__.py
+++ b/src/anomalib/data/dataclasses/__init__.py
@@ -1,45 +1,82 @@
 """Anomalib dataclasses.
 
-This module provides a collection of dataclasses used throughout the Anomalib library
-for representing and managing various types of data related to anomaly detection tasks.
+This module provides a collection of dataclasses used throughout the Anomalib
+library for representing and managing various types of data related to anomaly
+detection tasks.
 
 The dataclasses are organized into two main categories:
-1. Numpy-based dataclasses for handling numpy array data.
-2. Torch-based dataclasses for handling PyTorch tensor data.
+1. Numpy-based dataclasses for handling numpy array data
+2. Torch-based dataclasses for handling PyTorch tensor data
 
-Key components:
+Key Components
+-------------
 
-Numpy Dataclasses:
-    ``NumpyImageItem``: Represents a single image item as numpy arrays.
-    ``NumpyImageBatch``: Represents a batch of image data as numpy arrays.
-    ``NumpyVideoItem``: Represents a single video item as numpy arrays.
-    ``NumpyVideoBatch``: Represents a batch of video data as numpy arrays.
+Numpy Dataclasses
+~~~~~~~~~~~~~~~~
 
-Torch Dataclasses:
-    ``Batch``: Base class for torch-based batch data.
-    ``DatasetItem``: Base class for torch-based dataset items.
-    ``DepthItem``: Represents a single depth data item.
-    ``DepthBatch``: Represents a batch of depth data.
-    ``ImageItem``: Represents a single image item as torch tensors.
-    ``ImageBatch``: Represents a batch of image data as torch tensors.
-    ``VideoItem``: Represents a single video item as torch tensors.
-    ``VideoBatch``: Represents a batch of video data as torch tensors.
-    ``InferenceBatch``: Specialized batch class for inference results.
+- :class:`NumpyImageItem`: Single image item as numpy arrays
+    - Data shape: ``(H, W, C)`` or ``(H, W)`` for grayscale
+    - Labels: Binary classification (0: normal, 1: anomalous)
+    - Masks: Binary segmentation masks ``(H, W)``
+
+- :class:`NumpyImageBatch`: Batch of image data as numpy arrays
+    - Data shape: ``(N, H, W, C)`` or ``(N, H, W)`` for grayscale
+    - Labels: ``(N,)`` binary labels
+    - Masks: ``(N, H, W)`` binary masks
+
+- :class:`NumpyVideoItem`: Single video item as numpy arrays
+    - Data shape: ``(T, H, W, C)`` or ``(T, H, W)`` for grayscale
+    - Labels: Binary classification per video
+    - Masks: ``(T, H, W)`` temporal segmentation masks
+
+- :class:`NumpyVideoBatch`: Batch of video data as numpy arrays
+    - Data shape: ``(N, T, H, W, C)`` or ``(N, T, H, W)`` for grayscale
+    - Labels: ``(N,)`` binary labels
+    - Masks: ``(N, T, H, W)`` batch of temporal masks
+
+Torch Dataclasses
+~~~~~~~~~~~~~~~~
+
+- :class:`Batch`: Base class for torch-based batch data
+- :class:`DatasetItem`: Base class for torch-based dataset items
+- :class:`DepthItem`: Single depth data item
+    - RGB image: ``(3, H, W)``
+    - Depth map: ``(H, W)``
+- :class:`DepthBatch`: Batch of depth data
+    - RGB images: ``(N, 3, H, W)``
+    - Depth maps: ``(N, H, W)``
+- :class:`ImageItem`: Single image as torch tensors
+    - Data shape: ``(C, H, W)``
+- :class:`ImageBatch`: Batch of images as torch tensors
+    - Data shape: ``(N, C, H, W)``
+- :class:`VideoItem`: Single video as torch tensors
+    - Data shape: ``(T, C, H, W)``
+- :class:`VideoBatch`: Batch of videos as torch tensors
+    - Data shape: ``(N, T, C, H, W)``
+- :class:`InferenceBatch`: Specialized batch for inference results
+    - Predictions: Scores, labels, anomaly maps and masks
 
 These dataclasses provide a structured way to handle various types of data
 in anomaly detection tasks, ensuring type consistency and easy data manipulation
 across different components of the Anomalib library.
+
+Example:
+-------
+>>> from anomalib.data.dataclasses import ImageItem
+>>> import torch
+>>> item = ImageItem(
+...     image=torch.rand(3, 224, 224),
+...     gt_label=torch.tensor(0),
+...     image_path="path/to/image.jpg"
+... )
+>>> item.image.shape
+torch.Size([3, 224, 224])
 """
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from .numpy import (
-    NumpyImageBatch,
-    NumpyImageItem,
-    NumpyVideoBatch,
-    NumpyVideoItem,
-)
+from .numpy import NumpyImageBatch, NumpyImageItem, NumpyVideoBatch, NumpyVideoItem
 from .torch import (
     Batch,
     DatasetItem,
diff --git a/src/anomalib/data/dataclasses/generic.py b/src/anomalib/data/dataclasses/generic.py
index 5f9dca9dc9..3ee82153fd 100644
--- a/src/anomalib/data/dataclasses/generic.py
+++ b/src/anomalib/data/dataclasses/generic.py
@@ -4,6 +4,30 @@
 to define and validate various types of data fields used in Anomalib.
 The dataclasses are designed to be flexible and extensible, allowing for easy
 customization and validation of input and output data.
+
+The module contains several key components:
+
+- Field descriptors for validation
+- Base input field classes for images, videos and depth data
+- Output field classes for predictions
+- Mixins for updating and batch iteration
+- Generic item and batch classes
+
+Example:
+    >>> from anomalib.data.dataclasses import _InputFields
+    >>> from torchvision.tv_tensors import Image, Mask
+    >>>
+    >>> class MyInput(_InputFields[int, Image, Mask, str]):
+    ...     def validate_image(self, image):
+    ...         return image
+    ...     # Implement other validation methods
+    ...
+    >>> input_data = MyInput(
+    ...     image=torch.rand(3,224,224),
+    ...     gt_label=1,
+    ...     gt_mask=None,
+    ...     mask_path=None
+    ... )
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -37,12 +61,21 @@ class FieldDescriptor(Generic[Value]):
     validated before being set. This allows validation of the input data not
     only when it is first set, but also when it is updated.
 
-    Attributes:
-        validator_name (str | None): The name of the validator method to be
-            called when setting the value.
-            Defaults to ``None``.
-        default (Value | None): The default value for the field.
+    Args:
+        validator_name: Name of the validator method to call when setting value.
             Defaults to ``None``.
+        default: Default value for the field. Defaults to ``None``.
+
+    Example:
+        >>> class MyClass:
+        ...     field = FieldDescriptor(validator_name="validate_field")
+        ...     def validate_field(self, value):
+        ...         return value
+        ...
+        >>> obj = MyClass()
+        >>> obj.field = 42
+        >>> obj.field
+        42
     """
 
     def __init__(self, validator_name: str | None = None, default: Value | None = None) -> None:
@@ -51,15 +84,26 @@ def __init__(self, validator_name: str | None = None, default: Value | None = No
         self.default = default
 
     def __set_name__(self, owner: type[Instance], name: str) -> None:
-        """Set the name of the descriptor."""
+        """Set the name of the descriptor.
+
+        Args:
+            owner: Class that owns the descriptor
+            name: Name of the descriptor in the owner class
+        """
         self.name = name
 
     def __get__(self, instance: Instance | None, owner: type[Instance]) -> Value | None:
         """Get the value of the descriptor.
 
+        Args:
+            instance: Instance the descriptor is accessed from
+            owner: Class that owns the descriptor
+
         Returns:
-            - The default value if available and if the instance is None (method is called from class).
-            - The value of the attribute if the instance is not None (method is called from instance).
+            Default value if instance is None, otherwise the stored value
+
+        Raises:
+            AttributeError: If no default value and field is not optional
         """
         if instance is None:
             if self.default is not None or self.is_optional(owner):
@@ -71,7 +115,11 @@ def __get__(self, instance: Instance | None, owner: type[Instance]) -> Value | N
     def __set__(self, instance: object, value: Value) -> None:
         """Set the value of the descriptor.
 
-        First calls the validator method if available, then sets the value of the attribute.
+        First calls the validator method if available, then sets the value.
+
+        Args:
+            instance: Instance to set the value on
+            value: Value to set
         """
         if self.validator_name is not None:
             validator = getattr(instance, self.validator_name)
@@ -79,7 +127,17 @@ def __set__(self, instance: object, value: Value) -> None:
         instance.__dict__[self.name] = value
 
     def get_types(self, owner: type[Instance]) -> tuple[type, ...]:
-        """Get the types of the descriptor."""
+        """Get the types of the descriptor.
+
+        Args:
+            owner: Class that owns the descriptor
+
+        Returns:
+            Tuple of valid types for this field
+
+        Raises:
+            TypeError: If types cannot be determined
+        """
         try:
             types = get_args(get_type_hints(owner)[self.name])
             return get_args(types[0]) if hasattr(types[0], "__args__") else (types[0],)
@@ -88,7 +146,14 @@ def get_types(self, owner: type[Instance]) -> tuple[type, ...]:
             raise TypeError(msg) from e
 
     def is_optional(self, owner: type[Instance]) -> bool:
-        """Check if the descriptor is optional."""
+        """Check if the descriptor is optional.
+
+        Args:
+            owner: Class that owns the descriptor
+
+        Returns:
+            True if field can be None, False otherwise
+        """
         return NoneType in self.get_types(owner)
 
 
@@ -96,36 +161,28 @@ def is_optional(self, owner: type[Instance]) -> bool:
 class _InputFields(Generic[T, ImageT, MaskT, PathT], ABC):
     """Generic dataclass that defines the standard input fields for Anomalib.
 
-    This abstract base class provides a structure for input data used in Anomalib,
-    a library for anomaly detection in images and videos. It defines common fields
-    used across various anomaly detection tasks and data types in Anomalib.
+    This abstract base class provides a structure for input data used in Anomalib.
+    It defines common fields used across various anomaly detection tasks and data
+    types.
 
-    Subclasses must implement the abstract validation methods to define the
-    specific validation logic for each field based on the requirements of different
-    Anomalib models and data processing pipelines.
-
-    Examples:
-        Assuming a concrete implementation `DummyInput`:
-
-        >>> class DummyInput(_InputFields[int, Image, Mask, str]):
-        ...     # Implement actual validation
+    Attributes:
+        image: Input image or video
+        gt_label: Ground truth label
+        gt_mask: Ground truth segmentation mask
+        mask_path: Path to mask file
 
-        >>> # Create an input instance
-        >>> input_item = DummyInput(
-        ...     image=torch.rand(3, 224, 224),
+    Example:
+        >>> class MyInput(_InputFields[int, Image, Mask, str]):
+        ...     def validate_image(self, image):
+        ...         return image
+        ...     # Implement other validation methods
+        ...
+        >>> input_data = MyInput(
+        ...     image=torch.rand(3,224,224),
         ...     gt_label=1,
-        ...     gt_mask=torch.rand(224, 224) > 0.5,
-        ...     mask_path="path/to/mask.png"
+        ...     gt_mask=None,
+        ...     mask_path=None
         ... )
-
-        >>> # Access fields
-        >>> image = input_item.image
-        >>> label = input_item.gt_label
-
-    Note:
-        This is an abstract base class and is not intended to be instantiated
-        directly. Concrete subclasses should implement all required validation
-        methods.
     """
 
     image: FieldDescriptor[ImageT] = FieldDescriptor(validator_name="validate_image")
@@ -136,25 +193,65 @@ class _InputFields(Generic[T, ImageT, MaskT, PathT], ABC):
     @staticmethod
     @abstractmethod
     def validate_image(image: ImageT) -> ImageT:
-        """Validate the image."""
+        """Validate the image.
+
+        Args:
+            image: Input image to validate
+
+        Returns:
+            Validated image
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_gt_mask(gt_mask: MaskT) -> MaskT | None:
-        """Validate the ground truth mask."""
+        """Validate the ground truth mask.
+
+        Args:
+            gt_mask: Ground truth mask to validate
+
+        Returns:
+            Validated mask or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_mask_path(mask_path: PathT) -> PathT | None:
-        """Validate the mask path."""
+        """Validate the mask path.
+
+        Args:
+            mask_path: Path to mask file to validate
+
+        Returns:
+            Validated path or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_gt_label(gt_label: T) -> T | None:
-        """Validate the ground truth label."""
+        """Validate the ground truth label.
+
+        Args:
+            gt_label: Ground truth label to validate
+
+        Returns:
+            Validated label or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
 
@@ -163,35 +260,17 @@ class _ImageInputFields(Generic[PathT], ABC):
     """Generic dataclass for image-specific input fields in Anomalib.
 
     This class extends standard input fields with an ``image_path`` attribute for
-    image-based anomaly detection tasks. It allows Anomalib to work efficiently
-    with disk-stored image datasets, facilitating custom data loading strategies.
-
-    The ``image_path`` field uses a ``FieldDescriptor`` with a validation method.
-    Subclasses must implement ``validate_image_path`` to ensure path validity
-    according to specific Anomalib model or dataset requirements.
-
-    This class is designed to complement ``_InputFields`` for comprehensive
-    image-based anomaly detection input in Anomalib.
-
-    Examples:
-        Assuming a concrete implementation ``DummyImageInput``:
-        >>> class DummyImageInput(_ImageInputFields):
-        ...     def validate_image_path(self, image_path):
-        ...         return image_path  # Implement actual validation
-        ...     # Implement other required methods
-
-        >>> # Create an image input instance
-        >>> image_input = DummyImageInput(
-        ...     image_path="path/to/image.jpg"
-        ... )
+    image-based anomaly detection tasks.
 
-        >>> # Access image-specific field
-        >>> path = image_input.image_path
-
-    Note:
-        This is an abstract base class and is not intended to be instantiated
-        directly. Concrete subclasses should implement all required validation
-        methods.
+    Attributes:
+        image_path: Path to input image file
+
+    Example:
+        >>> class MyImageInput(_ImageInputFields[str]):
+        ...     def validate_image_path(self, path):
+        ...         return path
+        ...
+        >>> input_data = MyImageInput(image_path="path/to/image.jpg")
     """
 
     image_path: FieldDescriptor[PathT | None] = FieldDescriptor(validator_name="validate_image_path")
@@ -199,7 +278,17 @@ class _ImageInputFields(Generic[PathT], ABC):
     @staticmethod
     @abstractmethod
     def validate_image_path(image_path: PathT) -> PathT | None:
-        """Validate the image path."""
+        """Validate the image path.
+
+        Args:
+            image_path: Path to validate
+
+        Returns:
+            Validated path or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
 
@@ -207,45 +296,29 @@ def validate_image_path(image_path: PathT) -> PathT | None:
 class _VideoInputFields(Generic[T, ImageT, MaskT, PathT], ABC):
     """Generic dataclass that defines the video input fields for Anomalib.
 
-    This class extends standard input fields with attributes specific to video-based
-    anomaly detection tasks. It includes fields for original images, video paths,
-    target frames, frame sequences, and last frames.
-
-    Each field uses a ``FieldDescriptor`` with a corresponding validation method.
-    Subclasses must implement these abstract validation methods to ensure data
-    consistency with Anomalib's video processing requirements.
-
-    This class is designed to work alongside other input field classes to provide
-    comprehensive support for video-based anomaly detection in Anomalib.
-
-    Examples:
-        Assuming a concrete implementation ``DummyVideoInput``:
-
-        >>> class DummyVideoInput(_VideoInputFields):
-        ...     def validate_original_image(self, original_image):
-        ...         return original_image  # Implement actual validation
-        ...     # Implement other required methods
+    This class extends standard input fields with attributes specific to
+    video-based anomaly detection tasks.
 
-        >>> # Create a video input instance
-        >>> video_input = DummyVideoInput(
-        ...     original_image=torch.rand(3, 224, 224),
-        ...     video_path="path/to/video.mp4",
+    Attributes:
+        original_image: Original frame from video
+        video_path: Path to input video file
+        target_frame: Frame number to process
+        frames: Sequence of video frames
+        last_frame: Last frame in sequence
+
+    Example:
+        >>> class MyVideoInput(_VideoInputFields[int, Image, Mask, str]):
+        ...     def validate_original_image(self, image):
+        ...         return image
+        ...     # Implement other validation methods
+        ...
+        >>> input_data = MyVideoInput(
+        ...     original_image=torch.rand(3,224,224),
+        ...     video_path="video.mp4",
         ...     target_frame=10,
-        ...     frames=torch.rand(3, 224, 224),
-        ...     last_frame=torch.rand(3, 224, 224)
+        ...     frames=None,
+        ...     last_frame=None
         ... )
-
-        >>> # Access video-specific fields
-        >>> original_image = video_input.original_image
-        >>> path = video_input.video_path
-        >>> target_frame = video_input.target_frame
-        >>> frames = video_input.frames
-        >>> last_frame = video_input.last_frame
-
-    Note:
-        This is an abstract base class and is not intended to be instantiated
-        directly. Concrete subclasses should implement all required validation
-        methods.
     """
 
     original_image: FieldDescriptor[ImageT | None] = FieldDescriptor(validator_name="validate_original_image")
@@ -257,31 +330,81 @@ class _VideoInputFields(Generic[T, ImageT, MaskT, PathT], ABC):
     @staticmethod
     @abstractmethod
     def validate_original_image(original_image: ImageT) -> ImageT | None:
-        """Validate the original image."""
+        """Validate the original image.
+
+        Args:
+            original_image: Image to validate
+
+        Returns:
+            Validated image or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_video_path(video_path: PathT) -> PathT | None:
-        """Validate the video path."""
+        """Validate the video path.
+
+        Args:
+            video_path: Path to validate
+
+        Returns:
+            Validated path or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_target_frame(target_frame: T) -> T | None:
-        """Validate the target frame."""
+        """Validate the target frame.
+
+        Args:
+            target_frame: Frame number to validate
+
+        Returns:
+            Validated frame number or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_frames(frames: T) -> T | None:
-        """Validate the frames."""
+        """Validate the frames.
+
+        Args:
+            frames: Frame sequence to validate
+
+        Returns:
+            Validated frames or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_last_frame(last_frame: T) -> T | None:
-        """Validate the last frame."""
+        """Validate the last frame.
+
+        Args:
+            last_frame: Frame to validate
+
+        Returns:
+            Validated frame or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
 
@@ -289,41 +412,26 @@ def validate_last_frame(last_frame: T) -> T | None:
 class _DepthInputFields(Generic[T, PathT], _ImageInputFields[PathT], ABC):
     """Generic dataclass that defines the depth input fields for Anomalib.
 
-    This class extends the standard input fields with a ``depth_map`` and
-    ``depth_path`` attribute for depth-based anomaly detection tasks. It allows
-    Anomalib to work efficiently with depth-based anomaly detection tasks,
-    facilitating custom data loading strategies.
-
-    The ``depth_map`` and ``depth_path`` fields use a ``FieldDescriptor`` with
-    corresponding validation methods. Subclasses must implement these abstract
-    validation methods to ensure data consistency with Anomalib's depth processing
-    requirements.
-
-    Examples:
-        Assuming a concrete implementation ``DummyDepthInput``:
-
-        >>> class DummyDepthInput(_DepthInputFields):
-        ...     def validate_depth_map(self, depth_map):
-        ...         return depth_map  # Implement actual validation
-        ...     def validate_depth_path(self, depth_path):
-        ...         return depth_path  # Implement actual validation
-        ...     # Implement other required methods
-
-        >>> # Create a depth input instance
-        >>> depth_input = DummyDepthInput(
-        ...     image_path="path/to/image.jpg",
-        ...     depth_map=torch.rand(224, 224),
-        ...     depth_path="path/to/depth.png"
-        ... )
+    This class extends standard input fields with depth-specific attributes for
+    depth-based anomaly detection tasks.
 
-        >>> # Access depth-specific fields
-        >>> depth_map = depth_input.depth_map
-        >>> depth_path = depth_input.depth_path
-
-    Note:
-        This is an abstract base class and is not intended to be instantiated
-        directly. Concrete subclasses should implement all required validation
-        methods.
+    Attributes:
+        depth_map: Depth map image
+        depth_path: Path to depth map file
+
+    Example:
+        >>> class MyDepthInput(_DepthInputFields[torch.Tensor, str]):
+        ...     def validate_depth_map(self, depth):
+        ...         return depth
+        ...     def validate_depth_path(self, path):
+        ...         return path
+        ...     # Implement other validation methods
+        ...
+        >>> input_data = MyDepthInput(
+        ...     image_path="rgb.jpg",
+        ...     depth_map=torch.rand(224,224),
+        ...     depth_path="depth.png"
+        ... )
     """
 
     depth_map: FieldDescriptor[T | None] = FieldDescriptor(validator_name="validate_depth_map")
@@ -332,13 +440,33 @@ class _DepthInputFields(Generic[T, PathT], _ImageInputFields[PathT], ABC):
     @staticmethod
     @abstractmethod
     def validate_depth_map(depth_map: ImageT) -> ImageT | None:
-        """Validate the depth map."""
+        """Validate the depth map.
+
+        Args:
+            depth_map: Depth map to validate
+
+        Returns:
+            Validated depth map or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_depth_path(depth_path: PathT) -> PathT | None:
-        """Validate the depth path."""
+        """Validate the depth path.
+
+        Args:
+            depth_path: Path to validate
+
+        Returns:
+            Validated path or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
 
@@ -347,43 +475,28 @@ class _OutputFields(Generic[T, MaskT, PathT], ABC):
     """Generic dataclass that defines the standard output fields for Anomalib.
 
     This class defines the standard output fields used in Anomalib, including
-    anomaly maps, predicted scores, predicted masks, and predicted labels.
-
-    Each field uses a ``FieldDescriptor`` with a corresponding validation method.
-    Subclasses must implement these abstract validation methods to ensure data
-    consistency with Anomalib's anomaly detection tasks.
-
-    Examples:
-        Assuming a concrete implementation ``DummyOutput``:
-
-        >>> class DummyOutput(_OutputFields):
-        ...     def validate_anomaly_map(self, anomaly_map):
-        ...         return anomaly_map  # Implement actual validation
-        ...     def validate_pred_score(self, pred_score):
-        ...         return pred_score  # Implement actual validation
-        ...     def validate_pred_mask(self, pred_mask):
-        ...         return pred_mask  # Implement actual validation
-        ...     def validate_pred_label(self, pred_label):
-        ...         return pred_label  # Implement actual validation
-
-        >>> # Create an output instance with predictions
-        >>> output = DummyOutput(
-        ...     anomaly_map=torch.rand(224, 224),
+    anomaly maps, predicted scores, masks, and labels.
+
+    Attributes:
+        anomaly_map: Predicted anomaly heatmap
+        pred_score: Predicted anomaly score
+        pred_mask: Predicted segmentation mask
+        pred_label: Predicted label
+        explanation: Path to explanation visualization
+
+    Example:
+        >>> class MyOutput(_OutputFields[float, Mask, str]):
+        ...     def validate_anomaly_map(self, amap):
+        ...         return amap
+        ...     # Implement other validation methods
+        ...
+        >>> output = MyOutput(
+        ...     anomaly_map=torch.rand(224,224),
         ...     pred_score=0.7,
-        ...     pred_mask=torch.rand(224, 224) > 0.5,
-        ...     pred_label=1
+        ...     pred_mask=None,
+        ...     pred_label=1,
+        ...     explanation=None
         ... )
-
-        >>> # Access individual fields
-        >>> anomaly_map = output.anomaly_map
-        >>> score = output.pred_score
-        >>> mask = output.pred_mask
-        >>> label = output.pred_label
-
-    Note:
-        This is an abstract base class and is not intended to be instantiated
-        directly. Concrete subclasses should implement all required validation
-        methods.
     """
 
     anomaly_map: FieldDescriptor[MaskT | None] = FieldDescriptor(validator_name="validate_anomaly_map")
@@ -395,70 +508,118 @@ class _OutputFields(Generic[T, MaskT, PathT], ABC):
     @staticmethod
     @abstractmethod
     def validate_anomaly_map(anomaly_map: MaskT) -> MaskT | None:
-        """Validate the anomaly map."""
+        """Validate the anomaly map.
+
+        Args:
+            anomaly_map: Anomaly map to validate
+
+        Returns:
+            Validated anomaly map or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_pred_score(pred_score: T) -> T | None:
-        """Validate the predicted score."""
+        """Validate the predicted score.
+
+        Args:
+            pred_score: Score to validate
+
+        Returns:
+            Validated score or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_pred_mask(pred_mask: MaskT) -> MaskT | None:
-        """Validate the predicted mask."""
+        """Validate the predicted mask.
+
+        Args:
+            pred_mask: Mask to validate
+
+        Returns:
+            Validated mask or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_pred_label(pred_label: T) -> T | None:
-        """Validate the predicted label."""
+        """Validate the predicted label.
+
+        Args:
+            pred_label: Label to validate
+
+        Returns:
+            Validated label or None
+
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def validate_explanation(explanation: PathT) -> PathT | None:
-        """Validate the explanation."""
-        raise NotImplementedError
+        """Validate the explanation.
 
+        Args:
+            explanation: Explanation to validate
 
-@dataclass
-class UpdateMixin:
-    """Mixin class for dataclasses that allows for in-place replacement of attributes.
-
-    This mixin class provides a method for updating dataclass instances in place or
-    by creating a new instance. It ensures that the updated instance is reinitialized
-    by calling the ``__post_init__`` method if it exists.
-
-    Examples:
-        Assuming a dataclass `DummyItem` that uses UpdateMixin:
-
-        >>> item = DummyItem(image=torch.rand(3, 224, 224), label=0)
-
-        >>> # In-place update
-        >>> item.update(label=1, pred_score=0.9)
-        >>> print(item.label, item.pred_score)
-        1 0.9
+        Returns:
+            Validated explanation or None
 
-        >>> # Create a new instance with updates
-        >>> new_item = item.update(in_place=False, image=torch.rand(3, 224, 224))
-        >>> print(id(item) != id(new_item))
-        True
+        Raises:
+            NotImplementedError: Must be implemented by subclass
+        """
+        raise NotImplementedError
 
-        >>> # Update with multiple fields
-        >>> item.update(label=2, pred_score=0.8, anomaly_map=torch.rand(224, 224))
 
-    The `update` method can be used to modify single or multiple fields, either
-    in-place or by creating a new instance. This flexibility is particularly useful
-    in data processing pipelines and when working with model predictions in Anomalib.
+@dataclass
+class UpdateMixin:
+    """Mixin class for dataclasses that allows for in-place replacement of attrs.
+
+    This mixin provides methods for updating dataclass instances in place or by
+    creating a new instance.
+
+    Example:
+        >>> @dataclass
+        ... class MyItem(UpdateMixin):
+        ...     field1: int
+        ...     field2: str
+        ...
+        >>> item = MyItem(field1=1, field2="a")
+        >>> item.update(field1=2)  # In-place update
+        >>> item.field1
+        2
+        >>> new_item = item.update(in_place=False, field2="b")
+        >>> new_item.field2
+        'b'
     """
 
     def update(self, in_place: bool = True, **changes) -> Any:  # noqa: ANN401
-        """Replace fields in place and call __post_init__ to reinitialize the instance.
+        """Replace fields in place and call __post_init__ to reinitialize.
 
-        Parameters:
-        changes (dict): A dictionary of field names and their new values.
+        Args:
+            in_place: Whether to modify in place or return new instance
+            **changes: Field names and new values to update
+
+        Returns:
+            Updated instance (self if in_place=True, new instance otherwise)
+
+        Raises:
+            TypeError: If instance is not a dataclass
         """
         if not is_dataclass(self):
             msg = "replace can only be used with dataclass instances"
@@ -483,43 +644,23 @@ class _GenericItem(
 ):
     """Generic dataclass for a single item in Anomalib datasets.
 
-    This class combines input and output fields for anomaly detection tasks,
-    providing a comprehensive representation of a single data item. It inherits
-    from ``_InputFields`` for standard input data and ``_OutputFields`` for
-    prediction results.
-
-    The class also includes the ``UpdateMixin``, allowing for easy updates of
-    field values. This is particularly useful during data processing pipelines
-    and when working with model predictions.
-
-    By using generic types, this class can accommodate various data types used
-    in different Anomalib models and datasets, ensuring flexibility and
-    reusability across the library.
-
-    Examples:
-        Assuming a concrete implementation ``DummyItem``:
+    This class combines input and output fields for anomaly detection tasks.
+    It inherits from ``_InputFields`` for standard input data and
+    ``_OutputFields`` for prediction results.
 
-        >>> class DummyItem(_GenericItem):
+    Example:
+        >>> class MyItem(_GenericItem[int, Image, Mask, str]):
         ...     def validate_image(self, image):
-        ...         return image  # Implement actual validation
-        ...     # Implement other required methods
-
-        >>> # Create a generic item instance
-        >>> item = DummyItem(
-        ...     image=torch.rand(3, 224, 224),
+        ...         return image
+        ...     # Implement other validation methods
+        ...
+        >>> item = MyItem(
+        ...     image=torch.rand(3,224,224),
         ...     gt_label=0,
         ...     pred_score=0.3,
-        ...     anomaly_map=torch.rand(224, 224)
+        ...     anomaly_map=torch.rand(224,224)
         ... )
-
-        >>> # Access and update fields
-        >>> image = item.image
-        >>> item.update(pred_score=0.8, pred_label=1)
-
-    Note:
-        This is an abstract base class and is not intended to be instantiated
-        directly. Concrete subclasses should implement all required validation
-        methods.
+        >>> item.update(pred_score=0.8)
     """
 
 
@@ -533,43 +674,19 @@ class _GenericBatch(
     """Generic dataclass for a batch of items in Anomalib datasets.
 
     This class represents a batch of data items, combining both input and output
-    fields for anomaly detection tasks. It inherits from ``_InputFields`` for
-    input data and ``_OutputFields`` for prediction results, allowing it to
-    handle both training data and model outputs.
-
-    The class includes the ``UpdateMixin``, enabling easy updates of field values
-    across the entire batch. This is particularly useful for in-place modifications
-    during data processing or when updating predictions.
-
-    Examples:
-        Assuming a concrete implementation ``DummyBatch``:
+    fields for anomaly detection tasks.
 
-        >>> class DummyBatch(_GenericBatch):
+    Example:
+        >>> class MyBatch(_GenericBatch[int, Image, Mask, str]):
         ...     def validate_image(self, image):
-        ...         return image  # Implement actual validation
-        ...     # Implement other required methods
-
-        >>> # Create a batch with input data
-        >>> batch = DummyBatch(
-        ...     image=torch.rand(32, 3, 224, 224),
-        ...     gt_label=torch.randint(0, 2, (32,))
-        ... )
-
-        >>> # Update the entire batch with new predictions
-        >>> batch.update(
-        ...     pred_score=torch.rand(32),
-        ...     anomaly_map=torch.rand(32, 224, 224)
+        ...         return image
+        ...     # Implement other validation methods
+        ...
+        >>> batch = MyBatch(
+        ...     image=torch.rand(32,3,224,224),
+        ...     gt_label=torch.zeros(32),
+        ...     pred_score=torch.rand(32)
         ... )
-
-        >>> # Access individual fields
-        >>> images = batch.image
-        >>> labels = batch.gt_label
-        >>> predictions = batch.pred_score
-
-    Note:
-        This is an abstract base class and is not intended to be instantiated
-        directly. Concrete subclasses should implement all required validation
-        methods.
     """
 
 
@@ -581,55 +698,54 @@ class BatchIterateMixin(Generic[ItemT]):
     """Mixin class for iterating over batches of items in Anomalib datasets.
 
     This class provides functionality to iterate over individual items within a
-    batch, convert batches to lists of items, and determine batch sizes. It's
-    designed to work with Anomalib's batch processing pipelines.
-
-    The mixin requires subclasses to define an ``item_class`` attribute, which
-    specifies the class used for individual items in the batch. This ensures
-    type consistency when iterating or converting batches.
+    batch and convert batches to lists of items.
 
-    Key features include:
-    - Iteration over batch items
-    - Conversion of batches to lists of individual items
-    - Batch size determination
-    - A class method for collating individual items into a batch
-
-    Examples:
-        Assuming a subclass `DummyBatch` with `DummyItem` as its item_class:
-
-        >>> batch = DummyBatch(images=[...], labels=[...])
+    Attributes:
+        item_class: Class to use for individual items in the batch
+
+    Example:
+        >>> @dataclass
+        ... class MyBatch(BatchIterateMixin):
+        ...     item_class = MyItem
+        ...     data: torch.Tensor
+        ...
+        >>> batch = MyBatch(data=torch.rand(32,3,224,224))
         >>> for item in batch:
-        ...     process_item(item)  # Iterate over items
-
-        >>> item_list = batch.items  # Convert batch to list of items
-        >>> type(item_list[0])
-        
-
-        >>> batch_size = len(batch)  # Get batch size
-
-        >>> items = [DummyItem(...) for _ in range(5)]
-        >>> new_batch = DummyBatch.collate(items)  # Collate items into a batch
-
-    This mixin enhances batch handling capabilities in Anomalib, facilitating
-    efficient data processing and model interactions.
+        ...     process_item(item)
+        >>> items = batch.items  # Convert to list of items
     """
 
     item_class: ClassVar[Callable]
 
     def __init_subclass__(cls, **kwargs) -> None:
-        """Ensure that the subclass has the required attributes."""
+        """Ensure that the subclass has the required attributes.
+
+        Args:
+            **kwargs: Additional keyword arguments
+
+        Raises:
+            AttributeError: If item_class is not defined
+        """
         super().__init_subclass__(**kwargs)
         if not (hasattr(cls, "item_class") or issubclass(cls, ABC)):
             msg = f"{cls.__name__} must have an 'item_class' attribute."
             raise AttributeError(msg)
 
     def __iter__(self) -> Iterator[ItemT]:
-        """Iterate over the batch."""
+        """Iterate over the batch.
+
+        Yields:
+            Individual items from the batch
+        """
         yield from self.items
 
     @property
     def items(self) -> list[ItemT]:
-        """Convert the batch to a list of DatasetItem objects."""
+        """Convert the batch to a list of DatasetItem objects.
+
+        Returns:
+            List of individual items from the batch
+        """
         batch_dict = asdict(self)
         return [
             self.item_class(
@@ -639,22 +755,40 @@ def items(self) -> list[ItemT]:
         ]
 
     def __len__(self) -> int:
-        """Get the batch size."""
+        """Get the batch size.
+
+        Returns:
+            Number of items in batch
+        """
         return self.batch_size
 
     @property
     def batch_size(self) -> int:
-        """Get the batch size."""
+        """Get the batch size.
+
+        Returns:
+            Number of items in batch
+
+        Raises:
+            AttributeError: If image attribute is not set
+        """
         try:
             image = getattr(self, "image")  # noqa: B009
             return len(image)
         except (KeyError, AttributeError) as e:
-            msg = "Cannot determine batch size because 'image' attribute has not been set."
+            msg = "Cannot determine batch size because 'image' attribute not set."
             raise AttributeError(msg) from e
 
     @classmethod
     def collate(cls: type["BatchIterateMixin"], items: list[ItemT]) -> "BatchIterateMixin":
-        """Convert a list of DatasetItem objects to a Batch object."""
+        """Convert a list of DatasetItem objects to a Batch object.
+
+        Args:
+            items: List of items to collate into a batch
+
+        Returns:
+            New batch containing the items
+        """
         keys = [key for key, value in asdict(items[0]).items() if value is not None]
         out_dict = {key: default_collate([getattr(item, key) for item in items]) for key in keys}
         return cls(**out_dict)
diff --git a/src/anomalib/data/dataclasses/numpy/__init__.py b/src/anomalib/data/dataclasses/numpy/__init__.py
index 717e3d6c6e..7b1520d424 100644
--- a/src/anomalib/data/dataclasses/numpy/__init__.py
+++ b/src/anomalib/data/dataclasses/numpy/__init__.py
@@ -1,17 +1,53 @@
 """Numpy-based dataclasses for Anomalib.
 
-This module provides numpy-based implementations of the generic dataclasses
-used in Anomalib. These classes are designed to work with numpy arrays for
-efficient data handling and processing in anomaly detection tasks.
+This module provides numpy-based implementations of the generic dataclasses used in
+Anomalib. These classes are designed to work with numpy arrays for efficient data
+handling and processing in anomaly detection tasks.
 
 The module includes the following main classes:
 
-- NumpyItem: Represents a single item in Anomalib datasets using numpy arrays.
-- NumpyBatch: Represents a batch of items in Anomalib datasets using numpy arrays.
-- NumpyImageItem: Represents a single image item with additional image-specific fields.
-- NumpyImageBatch: Represents a batch of image items with batch operations.
-- NumpyVideoItem: Represents a single video item with video-specific fields.
-- NumpyVideoBatch: Represents a batch of video items with video-specific operations.
+- :class:`NumpyItem`: Base class representing a single item in Anomalib datasets
+  using numpy arrays. Contains common fields like ``data``, ``label``,
+  ``label_index``, ``split``, and ``metadata``.
+
+- :class:`NumpyBatch`: Base class representing a batch of items in Anomalib
+  datasets using numpy arrays. Provides batch operations and collation
+  functionality.
+
+- :class:`NumpyImageItem`: Specialized class for image data that extends
+  :class:`NumpyItem` with image-specific fields like ``image_path``, ``mask``,
+  ``mask_path``, ``anomaly_maps``, and ``boxes``.
+
+- :class:`NumpyImageBatch`: Specialized batch class for image data that extends
+  :class:`NumpyBatch` with image-specific batch operations and collation.
+
+- :class:`NumpyVideoItem`: Specialized class for video data that extends
+  :class:`NumpyItem` with video-specific fields like ``video_path``, ``frames``,
+  ``frame_masks``, and ``frame_boxes``.
+
+- :class:`NumpyVideoBatch`: Specialized batch class for video data that extends
+  :class:`NumpyBatch` with video-specific batch operations and collation.
+
+Example:
+    Create and use a numpy image item:
+
+    >>> from anomalib.data.dataclasses.numpy import NumpyImageItem
+    >>> import numpy as np
+    >>> item = NumpyImageItem(
+    ...     data=np.random.rand(224, 224, 3),
+    ...     label=0,
+    ...     image_path="path/to/image.jpg"
+    ... )
+    >>> item.data.shape
+    (224, 224, 3)
+
+Note:
+    - All classes in this module use numpy arrays internally for efficient data
+      handling
+    - The batch classes provide automatic collation of items into batches suitable
+      for model input
+    - The classes are designed to be compatible with Anomalib's data pipeline and
+      model interfaces
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -21,4 +57,11 @@
 from .image import NumpyImageBatch, NumpyImageItem
 from .video import NumpyVideoBatch, NumpyVideoItem
 
-__all__ = ["NumpyBatch", "NumpyItem", "NumpyImageBatch", "NumpyImageItem", "NumpyVideoBatch", "NumpyVideoItem"]
+__all__ = [
+    "NumpyBatch",
+    "NumpyItem",
+    "NumpyImageBatch",
+    "NumpyImageItem",
+    "NumpyVideoBatch",
+    "NumpyVideoItem",
+]
diff --git a/src/anomalib/data/dataclasses/numpy/base.py b/src/anomalib/data/dataclasses/numpy/base.py
index a27496f697..3a3fb6ef86 100644
--- a/src/anomalib/data/dataclasses/numpy/base.py
+++ b/src/anomalib/data/dataclasses/numpy/base.py
@@ -1,8 +1,12 @@
 """Numpy-based dataclasses for Anomalib.
 
-This module provides numpy-based implementations of the generic dataclasses
-used in Anomalib. These classes are designed to work with numpy arrays for
-efficient data handling and processing in anomaly detection tasks.
+This module provides numpy-based implementations of the generic dataclasses used in
+Anomalib. These classes are designed to work with :class:`numpy.ndarray` objects
+for efficient data handling and processing in anomaly detection tasks.
+
+The module contains two main classes:
+    - :class:`NumpyItem`: For single data items
+    - :class:`NumpyBatch`: For batched data items
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -19,10 +23,18 @@
 class NumpyItem(_GenericItem[np.ndarray, np.ndarray, np.ndarray, str]):
     """Dataclass for a single item in Anomalib datasets using numpy arrays.
 
-    This class extends _GenericItem for numpy-based data representation. It includes
-    both input data (e.g., images, labels) and output data (e.g., predictions,
-    anomaly maps) as numpy arrays. It is suitable for numpy-based processing
-    pipelines in Anomalib.
+    This class extends :class:`_GenericItem` for numpy-based data representation.
+    It includes both input data (e.g., images, labels) and output data (e.g.,
+    predictions, anomaly maps) as numpy arrays.
+
+    The class uses the following type parameters:
+        - Image: :class:`numpy.ndarray`
+        - Label: :class:`numpy.ndarray`
+        - Mask: :class:`numpy.ndarray`
+        - Path: :class:`str`
+
+    This implementation is suitable for numpy-based processing pipelines in
+    Anomalib where GPU acceleration is not required.
     """
 
 
@@ -30,7 +42,16 @@ class NumpyItem(_GenericItem[np.ndarray, np.ndarray, np.ndarray, str]):
 class NumpyBatch(_GenericBatch[np.ndarray, np.ndarray, np.ndarray, list[str]]):
     """Dataclass for a batch of items in Anomalib datasets using numpy arrays.
 
-    This class extends _GenericBatch for batches of numpy-based data. It represents
-    multiple data points for batch processing in anomaly detection tasks. It includes
-    an additional dimension for batch size in all tensor-like fields.
+    This class extends :class:`_GenericBatch` for batches of numpy-based data.
+    It represents multiple data points for batch processing in anomaly detection
+    tasks.
+
+    The class uses the following type parameters:
+        - Image: :class:`numpy.ndarray` with shape ``(B, C, H, W)``
+        - Label: :class:`numpy.ndarray` with shape ``(B,)``
+        - Mask: :class:`numpy.ndarray` with shape ``(B, H, W)``
+        - Path: :class:`list` of :class:`str`
+
+    Where ``B`` represents the batch dimension that is prepended to all
+    tensor-like fields.
     """
diff --git a/src/anomalib/data/dataclasses/numpy/depth.py b/src/anomalib/data/dataclasses/numpy/depth.py
index f8bd924c84..2cdf77d1e8 100644
--- a/src/anomalib/data/dataclasses/numpy/depth.py
+++ b/src/anomalib/data/dataclasses/numpy/depth.py
@@ -1,4 +1,27 @@
-"""Numpy-based depth dataclasses for Anomalib."""
+"""Numpy-based depth dataclasses for Anomalib.
+
+This module provides numpy-based implementations of depth-specific dataclasses used in
+Anomalib. These classes are designed to work with depth data represented as numpy arrays
+for anomaly detection tasks.
+
+The module contains two main classes:
+    - :class:`NumpyDepthItem`: For single depth data items
+    - :class:`NumpyDepthBatch`: For batched depth data items
+
+Example:
+    Create and use a numpy depth item:
+
+    >>> from anomalib.data.dataclasses.numpy import NumpyDepthItem
+    >>> import numpy as np
+    >>> item = NumpyDepthItem(
+    ...     data=np.random.rand(224, 224, 1),
+    ...     depth=np.random.rand(224, 224),
+    ...     label=0,
+    ...     depth_path="path/to/depth.png"
+    ... )
+    >>> item.depth.shape
+    (224, 224)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -20,9 +43,25 @@ class NumpyDepthItem(
 ):
     """Dataclass for a single depth item in Anomalib datasets using numpy arrays.
 
-    This class combines _DepthInputFields and NumpyItem for depth-based anomaly detection.
-    It includes depth-specific fields and validation methods to ensure proper formatting
-    for Anomalib's depth-based models.
+    This class combines :class:`_DepthInputFields` and :class:`NumpyItem` for
+    depth-based anomaly detection. It includes depth-specific fields and validation
+    methods to ensure proper formatting for Anomalib's depth-based models.
+
+    The class uses the following type parameters:
+        - Image: :class:`numpy.ndarray` with shape ``(H, W, C)``
+        - Depth: :class:`numpy.ndarray` with shape ``(H, W)``
+        - Label: :class:`numpy.ndarray`
+        - Path: :class:`str`
+
+    Example:
+        >>> import numpy as np
+        >>> from anomalib.data.dataclasses.numpy import NumpyDepthItem
+        >>> item = NumpyDepthItem(
+        ...     data=np.random.rand(224, 224, 3),
+        ...     depth=np.random.rand(224, 224),
+        ...     label=0,
+        ...     depth_path="path/to/depth.png"
+        ... )
     """
 
 
@@ -32,6 +71,20 @@ class NumpyDepthBatch(
     _DepthInputFields[np.ndarray, list[str]],
     NumpyBatch,
 ):
-    """Dataclass for a batch of depth items in Anomalib datasets using numpy arrays."""
+    """Dataclass for a batch of depth items in Anomalib datasets using numpy arrays.
+
+    This class extends :class:`NumpyBatch` for batches of depth-based data. It
+    represents multiple depth data points for batch processing in anomaly detection
+    tasks.
+
+    The class uses the following type parameters:
+        - Image: :class:`numpy.ndarray` with shape ``(B, C, H, W)``
+        - Depth: :class:`numpy.ndarray` with shape ``(B, H, W)``
+        - Label: :class:`numpy.ndarray` with shape ``(B,)``
+        - Path: :class:`list` of :class:`str`
+
+    Where ``B`` represents the batch dimension that is prepended to all
+    tensor-like fields.
+    """
 
     item_class = NumpyDepthItem
diff --git a/src/anomalib/data/dataclasses/numpy/image.py b/src/anomalib/data/dataclasses/numpy/image.py
index ad71bb4bd8..774e44ff70 100644
--- a/src/anomalib/data/dataclasses/numpy/image.py
+++ b/src/anomalib/data/dataclasses/numpy/image.py
@@ -1,4 +1,26 @@
-"""Numpy-based image dataclasses for Anomalib."""
+"""Numpy-based image dataclasses for Anomalib.
+
+This module provides numpy-based implementations of image-specific dataclasses used in
+Anomalib. These classes are designed to work with image data represented as numpy arrays
+for anomaly detection tasks.
+
+The module contains two main classes:
+    - :class:`NumpyImageItem`: For single image data items
+    - :class:`NumpyImageBatch`: For batched image data items
+
+Example:
+    Create and use a numpy image item::
+
+        >>> from anomalib.data.dataclasses.numpy import NumpyImageItem
+        >>> import numpy as np
+        >>> item = NumpyImageItem(
+        ...     data=np.random.rand(224, 224, 3),
+        ...     label=0,
+        ...     image_path="path/to/image.jpg"
+        ... )
+        >>> item.data.shape
+        (224, 224, 3)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -18,25 +40,26 @@ class NumpyImageItem(
 ):
     """Dataclass for a single image item in Anomalib datasets using numpy arrays.
 
-    This class combines _ImageInputFields and NumpyItem for image-based anomaly detection.
-    It includes image-specific fields and validation methods to ensure proper formatting
-    for Anomalib's image-based models.
+    This class combines :class:`_ImageInputFields` and :class:`NumpyItem` for
+    image-based anomaly detection. It includes image-specific fields and validation
+    methods to ensure proper formatting for Anomalib's image-based models.
 
-    Examples:
+    The class uses the following type parameters:
+        - Image: :class:`numpy.ndarray` with shape ``(H, W, C)``
+        - Label: :class:`numpy.ndarray`
+        - Mask: :class:`numpy.ndarray` with shape ``(H, W)``
+        - Path: :class:`str`
+
+    Example:
+        >>> import numpy as np
+        >>> from anomalib.data.dataclasses.numpy import NumpyImageItem
         >>> item = NumpyImageItem(
-        ...     image=np.random.rand(224, 224, 3),
-        ...     gt_label=np.array(1),
-        ...     gt_mask=np.random.rand(224, 224) > 0.5,
-        ...     anomaly_map=np.random.rand(224, 224),
-        ...     pred_score=np.array(0.7),
-        ...     pred_label=np.array(1),
+        ...     data=np.random.rand(224, 224, 3),
+        ...     label=0,
         ...     image_path="path/to/image.jpg"
         ... )
-
-        >>> # Access fields
-        >>> image = item.image
-        >>> label = item.gt_label
-        >>> path = item.image_path
+        >>> item.data.shape
+        (224, 224, 3)
     """
 
 
@@ -49,29 +72,29 @@ class NumpyImageBatch(
 ):
     """Dataclass for a batch of image items in Anomalib datasets using numpy arrays.
 
-    This class combines BatchIterateMixin, _ImageInputFields, and NumpyBatch for batches
-    of image data. It supports batch operations and iteration over individual NumpyImageItems.
-    It ensures proper formatting for Anomalib's image-based models.
+    This class combines :class:`BatchIterateMixin`, :class:`_ImageInputFields`, and
+    :class:`NumpyBatch` for batches of image data. It supports batch operations and
+    iteration over individual :class:`NumpyImageItem` instances.
 
-    Examples:
-        >>> batch = NumpyImageBatch(
-        ...     image=np.random.rand(32, 224, 224, 3),
-        ...     gt_label=np.random.randint(0, 2, (32,)),
-        ...     gt_mask=np.random.rand(32, 224, 224) > 0.5,
-        ...     anomaly_map=np.random.rand(32, 224, 224),
-        ...     pred_score=np.random.rand(32),
-        ...     pred_label=np.random.randint(0, 2, (32,)),
-        ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)]
-        ... )
+    The class uses the following type parameters:
+        - Image: :class:`numpy.ndarray` with shape ``(B, H, W, C)``
+        - Label: :class:`numpy.ndarray` with shape ``(B,)``
+        - Mask: :class:`numpy.ndarray` with shape ``(B, H, W)``
+        - Path: :class:`list` of :class:`str`
 
-        >>> # Access batch fields
-        >>> images = batch.image
-        >>> labels = batch.gt_label
-        >>> paths = batch.image_path
+    Where ``B`` represents the batch dimension that is prepended to all tensor-like
+    fields.
 
-        >>> # Iterate over items in the batch
-        >>> for item in batch:
-        ...     process_item(item)
+    Example:
+        >>> import numpy as np
+        >>> from anomalib.data.dataclasses.numpy import NumpyImageBatch
+        >>> batch = NumpyImageBatch(
+        ...     data=np.random.rand(32, 224, 224, 3),
+        ...     label=np.zeros(32),
+        ...     image_path=[f"path/to/image_{i}.jpg" for i in range(32)]
+        ... )
+        >>> batch.data.shape
+        (32, 224, 224, 3)
     """
 
     item_class = NumpyImageItem
diff --git a/src/anomalib/data/dataclasses/numpy/video.py b/src/anomalib/data/dataclasses/numpy/video.py
index 34998c00d1..ec5820ef0e 100644
--- a/src/anomalib/data/dataclasses/numpy/video.py
+++ b/src/anomalib/data/dataclasses/numpy/video.py
@@ -1,4 +1,27 @@
-"""Numpy-based video dataclasses for Anomalib."""
+"""Numpy-based video dataclasses for Anomalib.
+
+This module provides numpy-based implementations of video-specific dataclasses used in
+Anomalib. These classes are designed to work with video data represented as numpy
+arrays for anomaly detection tasks.
+
+The module contains two main classes:
+    - :class:`NumpyVideoItem`: For single video data items
+    - :class:`NumpyVideoBatch`: For batched video data items
+
+Example:
+    Create and use a numpy video item:
+
+    >>> from anomalib.data.dataclasses.numpy import NumpyVideoItem
+    >>> import numpy as np
+    >>> item = NumpyVideoItem(
+    ...     data=np.random.rand(16, 224, 224, 3),  # (T, H, W, C)
+    ...     frames=np.random.rand(16, 224, 224, 3),
+    ...     label=0,
+    ...     video_path="path/to/video.mp4"
+    ... )
+    >>> item.frames.shape
+    (16, 224, 224, 3)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -20,9 +43,17 @@ class NumpyVideoItem(
 ):
     """Dataclass for a single video item in Anomalib datasets using numpy arrays.
 
-    This class combines _VideoInputFields and NumpyItem for video-based anomaly detection.
-    It includes video-specific fields and validation methods to ensure proper formatting
-    for Anomalib's video-based models.
+    This class combines :class:`_VideoInputFields` and :class:`NumpyItem` for
+    video-based anomaly detection. It includes video-specific fields and validation
+    methods to ensure proper formatting for Anomalib's video-based models.
+
+    The class uses the following type parameters:
+        - Video: :class:`numpy.ndarray` with shape ``(T, H, W, C)``
+        - Label: :class:`numpy.ndarray`
+        - Mask: :class:`numpy.ndarray` with shape ``(T, H, W)``
+        - Path: :class:`str`
+
+    Where ``T`` represents the temporal dimension (number of frames).
     """
 
 
@@ -35,9 +66,17 @@ class NumpyVideoBatch(
 ):
     """Dataclass for a batch of video items in Anomalib datasets using numpy arrays.
 
-    This class combines BatchIterateMixin, _VideoInputFields, and NumpyBatch for batches
-    of video data. It supports batch operations and iteration over individual NumpyVideoItems.
-    It ensures proper formatting for Anomalib's video-based models.
+    This class combines :class:`BatchIterateMixin`, :class:`_VideoInputFields`, and
+    :class:`NumpyBatch` for batches of video data. It supports batch operations
+    and iteration over individual :class:`NumpyVideoItem` instances.
+
+    The class uses the following type parameters:
+        - Video: :class:`numpy.ndarray` with shape ``(B, T, H, W, C)``
+        - Label: :class:`numpy.ndarray` with shape ``(B,)``
+        - Mask: :class:`numpy.ndarray` with shape ``(B, T, H, W)``
+        - Path: :class:`list` of :class:`str`
+
+    Where ``B`` represents the batch dimension and ``T`` the temporal dimension.
     """
 
     item_class = NumpyVideoItem
diff --git a/src/anomalib/data/dataclasses/torch/base.py b/src/anomalib/data/dataclasses/torch/base.py
index 77b0cc5022..9139b42f86 100644
--- a/src/anomalib/data/dataclasses/torch/base.py
+++ b/src/anomalib/data/dataclasses/torch/base.py
@@ -1,8 +1,8 @@
 """Torch-based dataclasses for Anomalib.
 
-This module provides PyTorch-based implementations of the generic dataclasses
-used in Anomalib. These classes are designed to work with PyTorch tensors for
-efficient data handling and processing in anomaly detection tasks.
+This module provides PyTorch-based implementations of the generic dataclasses used
+in Anomalib. These classes are designed to work with PyTorch tensors for efficient
+data handling and processing in anomaly detection tasks.
 
 These classes extend the generic dataclasses defined in the Anomalib framework,
 providing concrete implementations that use PyTorch tensors for tensor-like data.
@@ -24,7 +24,18 @@
 
 
 class InferenceBatch(NamedTuple):
-    """Batch for use in torch and inference models."""
+    """Batch for use in torch and inference models.
+
+    Args:
+        pred_score (torch.Tensor | None): Predicted anomaly scores.
+            Defaults to ``None``.
+        pred_label (torch.Tensor | None): Predicted anomaly labels.
+            Defaults to ``None``.
+        anomaly_map (torch.Tensor | None): Generated anomaly maps.
+            Defaults to ``None``.
+        pred_mask (torch.Tensor | None): Predicted anomaly masks.
+            Defaults to ``None``.
+    """
 
     pred_score: torch.Tensor | None = None
     pred_label: torch.Tensor | None = None
@@ -36,9 +47,9 @@ class InferenceBatch(NamedTuple):
 class ToNumpyMixin(Generic[NumpyT]):
     """Mixin for converting torch-based dataclasses to numpy.
 
-    This mixin provides functionality to convert PyTorch tensor data to numpy arrays.
-    It requires the subclass to define a 'numpy_class' attribute specifying the
-    corresponding numpy-based class.
+    This mixin provides functionality to convert PyTorch tensor data to numpy
+    arrays. It requires the subclass to define a ``numpy_class`` attribute
+    specifying the corresponding numpy-based class.
 
     Examples:
         >>> from anomalib.dataclasses.numpy import NumpyImageItem
@@ -47,8 +58,11 @@ class ToNumpyMixin(Generic[NumpyT]):
         ...     numpy_class = NumpyImageItem
         ...     image: torch.Tensor
         ...     gt_label: torch.Tensor
-
-        >>> torch_item = TorchImageItem(image=torch.rand(3, 224, 224), gt_label=torch.tensor(1))
+        ...
+        >>> torch_item = TorchImageItem(
+        ...     image=torch.rand(3, 224, 224),
+        ...     gt_label=torch.tensor(1)
+        ... )
         >>> numpy_item = torch_item.to_numpy()
         >>> isinstance(numpy_item, NumpyImageItem)
         True
@@ -57,14 +71,25 @@ class ToNumpyMixin(Generic[NumpyT]):
     numpy_class: ClassVar[Callable]
 
     def __init_subclass__(cls, **kwargs) -> None:
-        """Ensure that the subclass has the required attributes."""
+        """Ensure that the subclass has the required attributes.
+
+        Args:
+            **kwargs: Additional keyword arguments passed to the parent class.
+
+        Raises:
+            AttributeError: If the subclass does not define ``numpy_class``.
+        """
         super().__init_subclass__(**kwargs)
         if not hasattr(cls, "numpy_class"):
             msg = f"{cls.__name__} must have a 'numpy_class' attribute."
             raise AttributeError(msg)
 
     def to_numpy(self) -> NumpyT:
-        """Convert the batch to a NumpyBatch object."""
+        """Convert the batch to a NumpyBatch object.
+
+        Returns:
+            NumpyT: The converted numpy batch object.
+        """
         batch_dict = asdict(self)
         for key, value in batch_dict.items():
             if isinstance(value, torch.Tensor):
@@ -76,41 +101,37 @@ def to_numpy(self) -> NumpyT:
 
 @dataclass
 class DatasetItem(Generic[ImageT], _GenericItem[torch.Tensor, ImageT, Mask, str]):
-    """Base dataclass for individual items in Anomalib datasets using PyTorch tensors.
+    """Base dataclass for individual items in Anomalib datasets using PyTorch.
 
-    This class extends the generic _GenericItem class to provide a PyTorch-specific
-    implementation for single data items in Anomalib datasets. It is designed to
-    handle various types of data (e.g., images, labels, masks) represented as
+    This class extends the generic ``_GenericItem`` class to provide a
+    PyTorch-specific implementation for single data items in Anomalib datasets.
+    It handles various types of data (e.g., images, labels, masks) represented as
     PyTorch tensors.
 
     The class uses generic types to allow flexibility in the image representation,
-    which can vary depending on the specific use case (e.g., standard images, video clips).
-
-    Attributes:
-        Inherited from _GenericItem, with PyTorch tensor and Mask types.
+    which can vary depending on the specific use case (e.g., standard images,
+    video clips).
 
     Note:
         This class is typically subclassed to create more specific item types
-        (e.g., ImageItem, VideoItem) with additional fields and methods.
+        (e.g., ``ImageItem``, ``VideoItem``) with additional fields and methods.
     """
 
 
 @dataclass
 class Batch(Generic[ImageT], _GenericBatch[torch.Tensor, ImageT, Mask, list[str]]):
-    """Base dataclass for batches of items in Anomalib datasets using PyTorch tensors.
+    """Base dataclass for batches of items in Anomalib datasets using PyTorch.
 
-    This class extends the generic _GenericBatch class to provide a PyTorch-specific
-    implementation for batches of data in Anomalib datasets. It is designed to
-    handle collections of data items (e.g., multiple images, labels, masks)
+    This class extends the generic ``_GenericBatch`` class to provide a
+    PyTorch-specific implementation for batches of data in Anomalib datasets.
+    It handles collections of data items (e.g., multiple images, labels, masks)
     represented as PyTorch tensors.
 
     The class uses generic types to allow flexibility in the image representation,
-    which can vary depending on the specific use case (e.g., standard images, video clips).
-
-    Attributes:
-        Inherited from _GenericBatch, with PyTorch tensor and Mask types.
+    which can vary depending on the specific use case (e.g., standard images,
+    video clips).
 
     Note:
         This class is typically subclassed to create more specific batch types
-        (e.g., ImageBatch, VideoBatch) with additional fields and methods.
+        (e.g., ``ImageBatch``, ``VideoBatch``) with additional fields and methods.
     """
diff --git a/src/anomalib/data/dataclasses/torch/depth.py b/src/anomalib/data/dataclasses/torch/depth.py
index 209d5eaf9d..ff9aac8f61 100644
--- a/src/anomalib/data/dataclasses/torch/depth.py
+++ b/src/anomalib/data/dataclasses/torch/depth.py
@@ -26,13 +26,22 @@ class DepthItem(
     _DepthInputFields[torch.Tensor, str],
     DatasetItem[Image],
 ):
-    """Dataclass for individual depth items in Anomalib datasets using PyTorch tensors.
+    """Dataclass for individual depth items in Anomalib datasets using PyTorch.
 
-    This class represents a single depth item in Anomalib datasets using PyTorch tensors.
-    It combines the functionality of ToNumpyMixin, _DepthInputFields, and DatasetItem
-    to handle depth data, including depth maps, labels, and metadata.
+    This class represents a single depth item in Anomalib datasets using PyTorch
+    tensors. It combines the functionality of ``ToNumpyMixin``,
+    ``_DepthInputFields``, and ``DatasetItem`` to handle depth data, including
+    depth maps, labels, and metadata.
+
+    Args:
+        image (torch.Tensor): Image tensor of shape ``(C, H, W)``.
+        gt_label (torch.Tensor): Ground truth label tensor.
+        depth_map (torch.Tensor): Depth map tensor of shape ``(H, W)``.
+        image_path (str): Path to the source image file.
+        depth_path (str): Path to the depth map file.
 
     Examples:
+        >>> import torch
         >>> item = DepthItem(
         ...     image=torch.rand(3, 224, 224),
         ...     gt_label=torch.tensor(1),
@@ -40,7 +49,6 @@ class DepthItem(
         ...     image_path="path/to/image.jpg",
         ...     depth_path="path/to/depth.png"
         ... )
-
         >>> print(item.image.shape, item.depth_map.shape)
         torch.Size([3, 224, 224]) torch.Size([224, 224])
     """
@@ -55,13 +63,22 @@ class DepthBatch(
     _DepthInputFields[torch.Tensor, list[str]],
     Batch[Image],
 ):
-    """Dataclass for batches of depth items in Anomalib datasets using PyTorch tensors.
+    """Dataclass for batches of depth items in Anomalib datasets using PyTorch.
+
+    This class represents a batch of depth items in Anomalib datasets using
+    PyTorch tensors. It combines the functionality of ``BatchIterateMixin``,
+    ``_DepthInputFields``, and ``Batch`` to handle batches of depth data,
+    including depth maps, labels, and metadata.
 
-    This class represents a batch of depth items in Anomalib datasets using PyTorch tensors.
-    It combines the functionality of BatchIterateMixin, _DepthInputFields, and Batch
-    to handle batches of depth data, including depth maps, labels, and metadata.
+    Args:
+        image (torch.Tensor): Batch of images of shape ``(B, C, H, W)``.
+        gt_label (torch.Tensor): Batch of ground truth labels of shape ``(B,)``.
+        depth_map (torch.Tensor): Batch of depth maps of shape ``(B, H, W)``.
+        image_path (list[str]): List of paths to the source image files.
+        depth_path (list[str]): List of paths to the depth map files.
 
     Examples:
+        >>> import torch
         >>> batch = DepthBatch(
         ...     image=torch.rand(32, 3, 224, 224),
         ...     gt_label=torch.randint(0, 2, (32,)),
@@ -69,10 +86,8 @@ class DepthBatch(
         ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)],
         ...     depth_path=["path/to/depth_{}.png".format(i) for i in range(32)]
         ... )
-
         >>> print(batch.image.shape, batch.depth_map.shape)
         torch.Size([32, 3, 224, 224]) torch.Size([32, 224, 224])
-
         >>> for item in batch:
         ...     print(item.image.shape, item.depth_map.shape)
         torch.Size([3, 224, 224]) torch.Size([224, 224])
diff --git a/src/anomalib/data/dataclasses/torch/image.py b/src/anomalib/data/dataclasses/torch/image.py
index 3f9cdcc9f0..162fb70042 100644
--- a/src/anomalib/data/dataclasses/torch/image.py
+++ b/src/anomalib/data/dataclasses/torch/image.py
@@ -3,6 +3,23 @@
 This module provides PyTorch-based implementations of the generic dataclasses
 used in Anomalib for image data. These classes are designed to work with PyTorch
 tensors for efficient data handling and processing in anomaly detection tasks.
+
+The module contains two main classes:
+    - :class:`ImageItem`: For single image data items
+    - :class:`ImageBatch`: For batched image data items
+
+Example:
+    Create and use a torch image item::
+
+        >>> from anomalib.data.dataclasses.torch import ImageItem
+        >>> import torch
+        >>> item = ImageItem(
+        ...     image=torch.rand(3, 224, 224),
+        ...     gt_label=torch.tensor(0),
+        ...     image_path="path/to/image.jpg"
+        ... )
+        >>> item.image.shape
+        torch.Size([3, 224, 224])
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -25,36 +42,33 @@ class ImageItem(
     _ImageInputFields[str],
     DatasetItem[Image],
 ):
-    """Dataclass for individual image items in Anomalib datasets using PyTorch tensors.
-
-    This class combines the functionality of ToNumpyMixin, _ImageInputFields, and
-    DatasetItem to represent single image data points in Anomalib. It includes
-    image-specific fields and provides methods for data validation and conversion
-    to numpy format.
+    """Dataclass for individual image items in Anomalib datasets using PyTorch.
 
-    The class is designed to work with PyTorch tensors and includes fields for
-    the image data, ground truth labels and masks, anomaly maps, and related metadata.
+    This class combines :class:`_ImageInputFields` and :class:`DatasetItem` for
+    image-based anomaly detection. It includes image-specific fields and validation
+    methods to ensure proper formatting for Anomalib's image-based models.
 
-    Attributes:
-        Inherited from _ImageInputFields and DatasetItem.
+    The class uses the following type parameters:
+        - Image: :class:`torch.Tensor` with shape ``(C, H, W)``
+        - Label: :class:`torch.Tensor`
+        - Mask: :class:`torch.Tensor` with shape ``(H, W)``
+        - Path: :class:`str`
 
-    Methods:
-        Inherited from ToNumpyMixin, including to_numpy() for conversion to numpy format.
-
-    Examples:
+    Example:
+        >>> import torch
+        >>> from anomalib.data.dataclasses.torch import ImageItem
         >>> item = ImageItem(
         ...     image=torch.rand(3, 224, 224),
-        ...     gt_label=torch.tensor(1),
-        ...     gt_mask=torch.rand(224, 224) > 0.5,
+        ...     gt_label=torch.tensor(0),
         ...     image_path="path/to/image.jpg"
         ... )
-
-        >>> print(item.image.shape)
+        >>> item.image.shape
         torch.Size([3, 224, 224])
 
+        Convert to numpy format:
         >>> numpy_item = item.to_numpy()
-        >>> print(type(numpy_item))
-        
+        >>> type(numpy_item).__name__
+        'NumpyImageItem'
     """
 
     numpy_class = NumpyImageItem
@@ -68,34 +82,39 @@ class ImageBatch(
     _ImageInputFields[list[str]],
     Batch[Image],
 ):
-    """Dataclass for batches of image items in Anomalib datasets using PyTorch tensors.
+    """Dataclass for batches of image items in Anomalib datasets using PyTorch.
 
-    This class combines the functionality of ``ToNumpyMixin``, ``BatchIterateMixin``,
-    ``_ImageInputFields``, and ``Batch`` to represent collections of image data points in Anomalib.
-    It includes image-specific fields and provides methods for batch operations,
-    iteration over individual items, and conversion to numpy format.
+    This class combines :class:`_ImageInputFields` and :class:`Batch` for batches
+    of image data. It includes image-specific fields and methods for batch
+    operations and iteration.
 
-    The class is designed to work with PyTorch tensors and includes fields for
-    batches of image data, ground truth labels and masks, anomaly maps, and related metadata.
+    The class uses the following type parameters:
+        - Image: :class:`torch.Tensor` with shape ``(B, C, H, W)``
+        - Label: :class:`torch.Tensor` with shape ``(B,)``
+        - Mask: :class:`torch.Tensor` with shape ``(B, H, W)``
+        - Path: :class:`list` of :class:`str`
 
-    Examples:
+    Where ``B`` represents the batch dimension.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.data.dataclasses.torch import ImageBatch
         >>> batch = ImageBatch(
         ...     image=torch.rand(32, 3, 224, 224),
         ...     gt_label=torch.randint(0, 2, (32,)),
-        ...     gt_mask=torch.rand(32, 224, 224) > 0.5,
-        ...     image_path=["path/to/image_{}.jpg".format(i) for i in range(32)]
+        ...     image_path=[f"path/to/image_{i}.jpg" for i in range(32)]
         ... )
-
-        >>> print(batch.image.shape)
+        >>> batch.image.shape
         torch.Size([32, 3, 224, 224])
 
+        Iterate over batch:
         >>> for item in batch:
-        ...     print(item.image.shape)
-        torch.Size([3, 224, 224])
+        ...     assert item.image.shape == torch.Size([3, 224, 224])
 
+        Convert to numpy format:
         >>> numpy_batch = batch.to_numpy()
-        >>> print(type(numpy_batch))
-        
+        >>> type(numpy_batch).__name__
+        'NumpyImageBatch'
     """
 
     item_class = ImageItem
diff --git a/src/anomalib/data/dataclasses/torch/video.py b/src/anomalib/data/dataclasses/torch/video.py
index 324fb45ca1..baad5ee118 100644
--- a/src/anomalib/data/dataclasses/torch/video.py
+++ b/src/anomalib/data/dataclasses/torch/video.py
@@ -3,6 +3,23 @@
 This module provides PyTorch-based implementations of the generic dataclasses
 used in Anomalib for video data. These classes are designed to work with PyTorch
 tensors for efficient data handling and processing in anomaly detection tasks.
+
+The module contains two main classes:
+    - :class:`VideoItem`: For single video data items
+    - :class:`VideoBatch`: For batched video data items
+
+Example:
+    Create and use a torch video item::
+
+        >>> from anomalib.data.dataclasses.torch import VideoItem
+        >>> import torch
+        >>> item = VideoItem(
+        ...     image=torch.rand(10, 3, 224, 224),  # 10 frames
+        ...     gt_label=torch.tensor(0),
+        ...     video_path="path/to/video.mp4"
+        ... )
+        >>> item.image.shape
+        torch.Size([10, 3, 224, 224])
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -27,26 +44,36 @@ class VideoItem(
     _VideoInputFields[torch.Tensor, Video, Mask, str],
     DatasetItem[Video],
 ):
-    """Dataclass for individual video items in Anomalib datasets using PyTorch tensors.
+    """Dataclass for individual video items in Anomalib datasets using PyTorch.
+
+    This class combines :class:`_VideoInputFields` and :class:`DatasetItem` for
+    video-based anomaly detection. It includes video-specific fields and
+    validation methods to ensure proper formatting for Anomalib's video-based
+    models.
 
-    This class represents a single video item in Anomalib datasets using PyTorch tensors.
-    It combines the functionality of ToNumpyMixin, _VideoInputFields, and DatasetItem
-    to handle video data, including frames, labels, masks, and metadata.
+    The class uses the following type parameters:
+        - Video: :class:`torch.Tensor` with shape ``(T, C, H, W)``
+        - Label: :class:`torch.Tensor`
+        - Mask: :class:`torch.Tensor` with shape ``(T, H, W)``
+        - Path: :class:`str`
 
-    Examples:
+    Where ``T`` represents the temporal dimension (number of frames).
+
+    Example:
+        >>> import torch
+        >>> from anomalib.data.dataclasses.torch import VideoItem
         >>> item = VideoItem(
         ...     image=torch.rand(10, 3, 224, 224),  # 10 frames
-        ...     gt_label=torch.tensor(1),
-        ...     gt_mask=torch.rand(10, 224, 224) > 0.5,
+        ...     gt_label=torch.tensor(0),
         ...     video_path="path/to/video.mp4"
         ... )
-
-        >>> print(item.image.shape)
+        >>> item.image.shape
         torch.Size([10, 3, 224, 224])
 
+        Convert to numpy format:
         >>> numpy_item = item.to_numpy()
-        >>> print(type(numpy_item))
-        
+        >>> type(numpy_item).__name__
+        'NumpyVideoItem'
     """
 
     numpy_class = NumpyVideoItem
@@ -65,30 +92,39 @@ class VideoBatch(
     _VideoInputFields[torch.Tensor, Video, Mask, list[str]],
     Batch[Video],
 ):
-    """Dataclass for batches of video items in Anomalib datasets using PyTorch tensors.
+    """Dataclass for batches of video items in Anomalib datasets using PyTorch.
 
-    This class represents a batch of video items in Anomalib datasets using PyTorch tensors.
-    It combines the functionality of ToNumpyMixin, BatchIterateMixin, _VideoInputFields,
-    and Batch to handle batches of video data, including frames, labels, masks, and metadata.
+    This class represents batches of video data for batch processing in anomaly
+    detection tasks. It combines functionality from multiple mixins to handle
+    batched video data efficiently.
 
-    Examples:
+    The class uses the following type parameters:
+        - Video: :class:`torch.Tensor` with shape ``(B, T, C, H, W)``
+        - Label: :class:`torch.Tensor` with shape ``(B,)``
+        - Mask: :class:`torch.Tensor` with shape ``(B, T, H, W)``
+        - Path: :class:`list` of :class:`str`
+
+    Where ``B`` represents the batch dimension and ``T`` the temporal dimension.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.data.dataclasses.torch import VideoBatch
         >>> batch = VideoBatch(
-        ...     image=torch.rand(32, 10, 3, 224, 224),  # 32 videos, 10 frames each
+        ...     image=torch.rand(32, 10, 3, 224, 224),  # 32 videos, 10 frames
         ...     gt_label=torch.randint(0, 2, (32,)),
-        ...     gt_mask=torch.rand(32, 10, 224, 224) > 0.5,
-        ...     video_path=["path/to/video_{}.mp4".format(i) for i in range(32)]
+        ...     video_path=["video_{}.mp4".format(i) for i in range(32)]
         ... )
-
-        >>> print(batch.image.shape)
+        >>> batch.image.shape
         torch.Size([32, 10, 3, 224, 224])
 
-        >>> for item in batch:
-        ...     print(item.image.shape)
+        Iterate over items in batch:
+        >>> next(iter(batch)).image.shape
         torch.Size([10, 3, 224, 224])
 
+        Convert to numpy format:
         >>> numpy_batch = batch.to_numpy()
-        >>> print(type(numpy_batch))
-        
+        >>> type(numpy_batch).__name__
+        'NumpyVideoBatch'
     """
 
     item_class = VideoItem
diff --git a/src/anomalib/data/datamodules/base/image.py b/src/anomalib/data/datamodules/base/image.py
index 5c28cd4557..87bbfc17c6 100644
--- a/src/anomalib/data/datamodules/base/image.py
+++ b/src/anomalib/data/datamodules/base/image.py
@@ -1,4 +1,26 @@
-"""Anomalib datamodule base class."""
+"""Base Anomalib data module.
+
+This module provides the base data module class used across Anomalib. It handles
+dataset splitting, validation set creation, and dataloader configuration.
+
+The module contains:
+    - :class:`AnomalibDataModule`: Base class for all Anomalib data modules
+
+Example:
+    Create a datamodule from a config file::
+
+        >>> from anomalib.data import AnomalibDataModule
+        >>> data_config = "configs/data/mvtec.yaml"
+        >>> datamodule = AnomalibDataModule.from_config(config_path=data_config)
+
+    Override config with additional arguments::
+
+        >>> override_kwargs = {"data.train_batch_size": 8}
+        >>> datamodule = AnomalibDataModule.from_config(
+        ...     config_path=data_config,
+        ...     **override_kwargs
+        ... )
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -28,19 +50,29 @@
 class AnomalibDataModule(LightningDataModule, ABC):
     """Base Anomalib data module.
 
+    This class extends PyTorch Lightning's ``LightningDataModule`` to provide
+    common functionality for anomaly detection datasets.
+
     Args:
-        train_batch_size (int): Batch size used by the train dataloader.
-        eval_batch_size (int): Batch size used by the val and test dataloaders.
-        num_workers (int): Number of workers used by the train, val and test dataloaders.
-        val_split_mode (ValSplitMode): Determines how the validation split is obtained.
-            Options: [none, same_as_test, from_test, synthetic]
-        val_split_ratio (float): Fraction of the train or test images held our for validation.
-        test_split_mode (Optional[TestSplitMode], optional): Determines how the test split is obtained.
-            Options: [none, from_dir, synthetic].
+        train_batch_size (int): Batch size for training dataloader
+        eval_batch_size (int): Batch size for validation/test dataloaders
+        num_workers (int): Number of workers for all dataloaders
+        val_split_mode (ValSplitMode | str): Method to obtain validation set.
+            Options:
+                - ``none``: No validation set
+                - ``same_as_test``: Use test set as validation
+                - ``from_test``: Sample from test set
+                - ``synthetic``: Generate synthetic anomalies
+        val_split_ratio (float): Fraction of data to use for validation
+        test_split_mode (TestSplitMode | str | None): Method to obtain test set.
+            Options:
+                - ``none``: No test split
+                - ``from_dir``: Use separate test directory
+                - ``synthetic``: Generate synthetic anomalies
             Defaults to ``None``.
-        test_split_ratio (float): Fraction of the train images held out for testing.
+        test_split_ratio (float | None): Fraction of data to use for testing.
             Defaults to ``None``.
-        seed (int | None, optional): Seed used during random subset splitting.
+        seed (int | None): Random seed for reproducible splitting.
             Defaults to ``None``.
     """
 
@@ -72,18 +104,25 @@ def __init__(
         self._samples: DataFrame | None = None
         self._category: str = ""
 
-        self._is_setup = False  # flag to track if setup has been called from the trainer
+        self._is_setup = False  # flag to track if setup has been called
 
     @property
     def name(self) -> str:
-        """Name of the datamodule."""
+        """Name of the datamodule.
+
+        Returns:
+            str: Class name of the datamodule
+        """
         return self.__class__.__name__
 
     def setup(self, stage: str | None = None) -> None:
         """Set up train, validation and test data.
 
+        This method handles the data splitting logic based on the configured
+        modes.
+
         Args:
-            stage: str | None:  Train/Val/Test stages.
+            stage (str | None): Current stage (fit/validate/test/predict).
                 Defaults to ``None``.
         """
         has_subset = any(hasattr(self, subset) for subset in ["train_data", "val_data", "test_data"])
@@ -92,37 +131,57 @@ def setup(self, stage: str | None = None) -> None:
             self._create_test_split()
             self._create_val_split()
             if isinstance(stage, TrainerFn):
-                # only set the flag if the stage is a TrainerFn, which means the setup has been called from a trainer
+                # only set flag if called from trainer
                 self._is_setup = True
 
     @abstractmethod
     def _setup(self, _stage: str | None = None) -> None:
         """Set up the datasets and perform dynamic subset splitting.
 
-        This method may be overridden in subclass for custom splitting behaviour.
+        This method should be implemented by subclasses to define dataset-specific
+        setup logic.
 
         Note:
-            The stage argument is not used here. This is because, for a given instance of an AnomalibDataModule
-            subclass, all three subsets are created at the first call of setup(). This is to accommodate the subset
-            splitting behaviour of anomaly tasks, where the validation set is usually extracted from the test set, and
-            the test set must therefore be created as early as the `fit` stage.
+            The ``stage`` argument is not used since all subsets are created on
+            first call to accommodate validation set extraction from test set.
 
+        Args:
+            _stage (str | None): Current stage (unused).
+                Defaults to ``None``.
+
+        Raises:
+            NotImplementedError: When not implemented by subclass
         """
         raise NotImplementedError
 
     @property
     def category(self) -> str:
-        """Get the category of the datamodule."""
+        """Get dataset category name.
+
+        Returns:
+            str: Name of the current category
+        """
         return self._category
 
     @category.setter
     def category(self, category: str) -> None:
-        """Set the category of the datamodule."""
+        """Set dataset category name.
+
+        Args:
+            category (str): Category name to set
+        """
         self._category = category
 
     @property
     def task(self) -> TaskType:
-        """Get the task type of the datamodule."""
+        """Get the task type.
+
+        Returns:
+            TaskType: Type of anomaly task (classification/segmentation)
+
+        Raises:
+            AttributeError: If no datasets have been set up yet
+        """
         if hasattr(self, "train_data"):
             return self.train_data.task
         if hasattr(self, "val_data"):
@@ -133,19 +192,26 @@ def task(self) -> TaskType:
         raise AttributeError(msg)
 
     def _create_test_split(self) -> None:
-        """Obtain the test set based on the settings in the config."""
+        """Create the test split based on configured mode.
+
+        This handles splitting normal/anomalous samples and optionally creating
+        synthetic anomalies.
+        """
         if self.test_data.has_normal:
-            # split the test data into normal and anomalous so these can be processed separately
+            # split test data into normal and anomalous
             normal_test_data, self.test_data = split_by_label(self.test_data)
         elif self.test_split_mode != TestSplitMode.NONE:
-            # when the user did not provide any normal images for testing, we sample some from the training set,
-            # except when the user explicitly requested no test splitting.
+            # sample normal images from training set if none provided
             logger.info(
-                "No normal test images found. Sampling from training set using a split ratio of %0.2f",
+                "No normal test images found. Sampling from training set using ratio of %0.2f",
                 self.test_split_ratio,
             )
             if self.test_split_ratio is not None:
-                self.train_data, normal_test_data = random_split(self.train_data, self.test_split_ratio, seed=self.seed)
+                self.train_data, normal_test_data = random_split(
+                    self.train_data,
+                    self.test_split_ratio,
+                    seed=self.seed,
+                )
 
         if self.test_split_mode == TestSplitMode.FROM_DIR:
             self.test_data += normal_test_data
@@ -156,9 +222,13 @@ def _create_test_split(self) -> None:
             raise ValueError(msg)
 
     def _create_val_split(self) -> None:
-        """Obtain the validation set based on the settings in the config."""
+        """Create validation split based on configured mode.
+
+        This handles sampling from train/test sets and optionally creating
+        synthetic anomalies.
+        """
         if self.val_split_mode == ValSplitMode.FROM_TRAIN:
-            # randomly sampled from train set
+            # randomly sample from train set
             self.train_data, self.val_data = random_split(
                 self.train_data,
                 self.val_split_ratio,
@@ -166,7 +236,7 @@ def _create_val_split(self) -> None:
                 seed=self.seed,
             )
         elif self.val_split_mode == ValSplitMode.FROM_TEST:
-            # randomly sampled from test set
+            # randomly sample from test set
             self.test_data, self.val_data = random_split(
                 self.test_data,
                 self.val_split_ratio,
@@ -174,18 +244,26 @@ def _create_val_split(self) -> None:
                 seed=self.seed,
             )
         elif self.val_split_mode == ValSplitMode.SAME_AS_TEST:
-            # equal to test set
+            # use test set as validation
             self.val_data = self.test_data
         elif self.val_split_mode == ValSplitMode.SYNTHETIC:
-            # converted from random training sample
-            self.train_data, normal_val_data = random_split(self.train_data, self.val_split_ratio, seed=self.seed)
+            # create synthetic anomalies from training samples
+            self.train_data, normal_val_data = random_split(
+                self.train_data,
+                self.val_split_ratio,
+                seed=self.seed,
+            )
             self.val_data = SyntheticAnomalyDataset.from_dataset(normal_val_data)
         elif self.val_split_mode != ValSplitMode.NONE:
             msg = f"Unknown validation split mode: {self.val_split_mode}"
             raise ValueError(msg)
 
     def train_dataloader(self) -> TRAIN_DATALOADERS:
-        """Get train dataloader."""
+        """Get training dataloader.
+
+        Returns:
+            DataLoader: Training dataloader
+        """
         return DataLoader(
             dataset=self.train_data,
             shuffle=True,
@@ -195,7 +273,11 @@ def train_dataloader(self) -> TRAIN_DATALOADERS:
         )
 
     def val_dataloader(self) -> EVAL_DATALOADERS:
-        """Get validation dataloader."""
+        """Get validation dataloader.
+
+        Returns:
+            DataLoader: Validation dataloader
+        """
         return DataLoader(
             dataset=self.val_data,
             shuffle=False,
@@ -205,7 +287,11 @@ def val_dataloader(self) -> EVAL_DATALOADERS:
         )
 
     def test_dataloader(self) -> EVAL_DATALOADERS:
-        """Get test dataloader."""
+        """Get test dataloader.
+
+        Returns:
+            DataLoader: Test dataloader
+        """
         return DataLoader(
             dataset=self.test_data,
             shuffle=False,
@@ -215,7 +301,13 @@ def test_dataloader(self) -> EVAL_DATALOADERS:
         )
 
     def predict_dataloader(self) -> EVAL_DATALOADERS:
-        """Use the test dataloader for inference unless overridden."""
+        """Get prediction dataloader.
+
+        By default uses the test dataloader.
+
+        Returns:
+            DataLoader: Prediction dataloader
+        """
         return self.test_dataloader()
 
     @classmethod
@@ -224,27 +316,31 @@ def from_config(
         config_path: str | Path,
         **kwargs,
     ) -> "AnomalibDataModule":
-        """Create a datamodule instance from the configuration.
+        """Create datamodule instance from config file.
 
         Args:
-            config_path (str | Path): Path to the data configuration file.
-            **kwargs (dict): Additional keyword arguments.
+            config_path (str | Path): Path to config file
+            **kwargs: Additional args to override config
 
         Returns:
-            AnomalibDataModule: Datamodule instance.
+            AnomalibDataModule: Instantiated datamodule
+
+        Raises:
+            FileNotFoundError: If config file not found
+            ValueError: If instantiated object is not AnomalibDataModule
 
         Example:
-            The following example shows how to get datamodule from mvtec.yaml:
+            Load from config file::
 
-            .. code-block:: python
-                >>> data_config = "configs/data/mvtec.yaml"
-                >>> datamodule = AnomalibDataModule.from_config(config_path=data_config)
+                >>> config_path = "configs/data/mvtec.yaml"
+                >>> datamodule = AnomalibDataModule.from_config(config_path)
 
-            The following example shows overriding the configuration file with additional keyword arguments:
+            Override config values::
 
-            .. code-block:: python
-                >>> override_kwargs = {"data.train_batch_size": 8}
-                >>> datamodule = AnomalibDataModule.from_config(config_path=data_config, **override_kwargs)
+                >>> datamodule = AnomalibDataModule.from_config(
+                ...     config_path,
+                ...     data_train_batch_size=8
+                ... )
         """
         from jsonargparse import ArgumentParser
 
diff --git a/src/anomalib/data/datamodules/base/video.py b/src/anomalib/data/datamodules/base/video.py
index 3bc7af6772..3e86d4f09b 100644
--- a/src/anomalib/data/datamodules/base/video.py
+++ b/src/anomalib/data/datamodules/base/video.py
@@ -1,4 +1,18 @@
-"""Base Video Data Module."""
+"""Base Video Data Module.
+
+This module provides the base data module class for video datasets in Anomalib.
+It extends :class:`AnomalibDataModule` with video-specific functionality.
+
+The module contains:
+    - :class:`AnomalibVideoDataModule`: Base class for all video data modules
+
+Example:
+    Create a video datamodule from a config file::
+
+        >>> from anomalib.data import AnomalibVideoDataModule
+        >>> data_config = "configs/data/ucsd_ped.yaml"
+        >>> datamodule = AnomalibVideoDataModule.from_config(config_path=data_config)
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -9,17 +23,33 @@
 
 
 class AnomalibVideoDataModule(AnomalibDataModule):
-    """Base class for video data modules."""
+    """Base class for video data modules.
+
+    This class extends :class:`AnomalibDataModule` to handle video datasets.
+    Unlike image datasets, video datasets do not support dynamic test split
+    assignment or synthetic anomaly generation.
+    """
 
     def _create_test_split(self) -> None:
-        """Video datamodules do not support dynamic assignment of the test split."""
+        """Video datamodules do not support dynamic assignment of test split.
+
+        Video datasets typically come with predefined train/test splits due to
+        temporal dependencies between frames.
+        """
 
     def _setup(self, _stage: str | None = None) -> None:
-        """Set up the datasets and perform dynamic subset splitting.
+        """Set up video datasets and perform validation split.
+
+        This method initializes the train and test datasets and creates the
+        validation split if specified. It ensures that both train and test
+        datasets are properly defined and configured.
 
-        This method may be overridden in subclass for custom splitting behaviour.
+        Args:
+            _stage: Current stage of training. Defaults to ``None``.
 
-        Video datamodules are not compatible with synthetic anomaly generation.
+        Raises:
+            ValueError: If ``train_data`` or ``test_data`` is ``None``.
+            ValueError: If ``val_split_mode`` is set to ``SYNTHETIC``.
         """
         if self.train_data is None:
             msg = "self.train_data cannot be None."
diff --git a/src/anomalib/data/datamodules/depth/__init__.py b/src/anomalib/data/datamodules/depth/__init__.py
index b7f24ab8d1..0f4c5199a7 100644
--- a/src/anomalib/data/datamodules/depth/__init__.py
+++ b/src/anomalib/data/datamodules/depth/__init__.py
@@ -1,6 +1,6 @@
 """Anomalib Depth Data Modules."""
 
-# Copyright (C) 2023 Intel Corporation
+# Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from enum import Enum
diff --git a/src/anomalib/data/datamodules/depth/folder_3d.py b/src/anomalib/data/datamodules/depth/folder_3d.py
index f475c26bd8..fd1fd7afff 100644
--- a/src/anomalib/data/datamodules/depth/folder_3d.py
+++ b/src/anomalib/data/datamodules/depth/folder_3d.py
@@ -1,6 +1,18 @@
-"""Custom Folder Datamodule.
+"""Custom Folder Datamodule for 3D data.
 
-This script creates a custom datamodule from a folder.
+This module provides a custom datamodule for handling 3D data organized in folders.
+The datamodule supports RGB and depth image pairs for anomaly detection tasks.
+
+Example:
+    Create a folder 3D datamodule::
+
+        >>> from anomalib.data import Folder3D
+        >>> datamodule = Folder3D(
+        ...     name="my_dataset",
+        ...     root="path/to/dataset",
+        ...     normal_dir="normal",
+        ...     abnormal_dir="abnormal"
+        ... )
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -14,47 +26,45 @@
 
 
 class Folder3D(AnomalibDataModule):
-    """Folder DataModule.
+    """Folder DataModule for 3D data.
+
+    This class extends :class:`AnomalibDataModule` to handle datasets containing
+    RGB and depth image pairs organized in folders.
 
     Args:
-        name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
-        normal_dir (str | Path): Name of the directory containing normal images.
-        root (str | Path | None): Path to the root folder containing normal and abnormal dirs.
-            Defaults to ``None``.
-        abnormal_dir (str | Path | None): Name of the directory containing abnormal images.
-            Defaults to ``abnormal``.
-        normal_test_dir (str | Path | None, optional): Path to the directory containing normal images for the test
-            dataset.
-            Defaults to ``None``.
-        mask_dir (str | Path | None, optional): Path to the directory containing the mask annotations.
-            Defaults to ``None``.
-        normal_depth_dir (str | Path | None, optional): Path to the directory containing
-            normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir`
-        abnormal_depth_dir (str | Path | None, optional): Path to the directory containing
-            abnormal depth images for the test dataset.
-        normal_test_depth_dir (str | Path | None, optional): Path to the directory containing
-            normal depth images for the test dataset. Normal test images will be a split of `normal_dir`
-            if `None`. Defaults to None.
-        normal_split_ratio (float, optional): Ratio to split normal training images and add to the
-            test set in case test set doesn't contain any normal images.
-            Defaults to 0.2.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the
-            directory. Defaults to None.
+        name (str): Name of the dataset used for logging and saving.
+        normal_dir (str | Path): Directory containing normal RGB images.
+        root (str | Path): Root folder containing normal and abnormal dirs.
+        abnormal_dir (str | Path | None, optional): Directory containing abnormal
+            RGB images. Defaults to ``None``.
+        normal_test_dir (str | Path | None, optional): Directory containing normal
+            RGB images for testing. Defaults to ``None``.
+        mask_dir (str | Path | None, optional): Directory containing mask
+            annotations. Defaults to ``None``.
+        normal_depth_dir (str | Path | None, optional): Directory containing
+            normal depth images. Defaults to ``None``.
+        abnormal_depth_dir (str | Path | None, optional): Directory containing
+            abnormal depth images. Defaults to ``None``.
+        normal_test_depth_dir (str | Path | None, optional): Directory containing
+            normal depth images for testing. If ``None``, uses split from
+            ``normal_dir``. Defaults to ``None``.
+        extensions (tuple[str, ...] | None, optional): Image file extensions to
+            read. Defaults to ``None``.
         train_batch_size (int, optional): Training batch size.
             Defaults to ``32``.
-        eval_batch_size (int, optional): Test batch size.
+        eval_batch_size (int, optional): Evaluation batch size.
             Defaults to ``32``.
-        num_workers (int, optional): Number of workers.
+        num_workers (int, optional): Number of workers for data loading.
             Defaults to ``8``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
-            Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+        test_split_mode (TestSplitMode | str, optional): Method to create test
+            set. Defaults to ``TestSplitMode.FROM_DIR``.
+        test_split_ratio (float, optional): Fraction of data for testing.
             Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-            Defaults to ``ValSplitMode.FROM_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+        val_split_mode (ValSplitMode | str, optional): Method to create validation
+            set. Defaults to ``ValSplitMode.FROM_TEST``.
+        val_split_ratio (float, optional): Fraction of data for validation.
             Defaults to ``0.5``.
-        seed (int | None, optional): Seed used during random subset splitting.
+        seed (int | None, optional): Random seed for splitting.
             Defaults to ``None``.
     """
 
@@ -101,6 +111,12 @@ def __init__(
         self.extensions = extensions
 
     def _setup(self, _stage: str | None = None) -> None:
+        """Set up train and test datasets.
+
+        Args:
+            _stage (str | None, optional): Stage of setup. Not used.
+                Defaults to ``None``.
+        """
         self.train_data = Folder3DDataset(
             name=self.name,
             split=Split.TRAIN,
@@ -131,8 +147,9 @@ def _setup(self, _stage: str | None = None) -> None:
 
     @property
     def name(self) -> str:
-        """Name of the datamodule.
+        """Get name of the datamodule.
 
-        Folder3D datamodule overrides the name property to provide a custom name.
+        Returns:
+            str: Name of the datamodule.
         """
         return self._name
diff --git a/src/anomalib/data/datamodules/depth/mvtec_3d.py b/src/anomalib/data/datamodules/depth/mvtec_3d.py
index 400b1d3139..afdf981d96 100644
--- a/src/anomalib/data/datamodules/depth/mvtec_3d.py
+++ b/src/anomalib/data/datamodules/depth/mvtec_3d.py
@@ -1,19 +1,30 @@
-"""MVTec 3D-AD Datamodule (CC BY-NC-SA 4.0).
+"""MVTec 3D-AD Datamodule.
 
-Description:
-    This script contains PyTorch Dataset, Dataloader and PyTorch Lightning DataModule for the MVTec 3D-AD dataset.
-    If the dataset is not on the file system, the script downloads and extracts the dataset and create PyTorch data
-    objects.
+This module provides a PyTorch Lightning DataModule for the MVTec 3D-AD dataset.
+The dataset contains RGB and depth image pairs for anomaly detection tasks.
+
+Example:
+    Create a MVTec3D datamodule::
+
+        >>> from anomalib.data import MVTec3D
+        >>> datamodule = MVTec3D(
+        ...     root="./datasets/MVTec3D",
+        ...     category="bagel"
+        ... )
 
 License:
-    MVTec 3D-AD dataset is released under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
-        License (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
+    MVTec 3D-AD dataset is released under the Creative Commons
+    Attribution-NonCommercial-ShareAlike 4.0 International License
+    (CC BY-NC-SA 4.0).
+    https://creativecommons.org/licenses/by-nc-sa/4.0/
 
 Reference:
-    - Paul Bergmann, Xin Jin, David Sattlegger, Carsten Steger: The MVTec 3D-AD Dataset for Unsupervised 3D Anomaly
-        Detection and Localization in: Proceedings of the 17th International Joint Conference on Computer Vision,
-        Imaging and Computer Graphics Theory and Applications - Volume 5: VISAPP, 202-213, 2022, DOI: 10.5220/
-        0010865000003124.
+    Paul Bergmann, Xin Jin, David Sattlegger, Carsten Steger:
+    The MVTec 3D-AD Dataset for Unsupervised 3D Anomaly Detection and
+    Localization. In: Proceedings of the 17th International Joint Conference
+    on Computer Vision, Imaging and Computer Graphics Theory and Applications
+    - Volume 5: VISAPP, 202-213, 2022.
+    DOI: 10.5220/0010865000003124
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -38,28 +49,28 @@
 
 
 class MVTec3D(AnomalibDataModule):
-    """MVTec Datamodule.
+    """MVTec 3D-AD Datamodule.
 
     Args:
-        root (Path | str): Path to the root of the dataset
+        root (Path | str): Path to the root of the dataset.
             Defaults to ``"./datasets/MVTec3D"``.
-        category (str): Category of the MVTec dataset (e.g. "bottle" or "cable").
-            Defaults to ``bagel``.
+        category (str): Category of the MVTec3D dataset (e.g. ``"bottle"`` or
+            ``"cable"``). Defaults to ``"bagel"``.
         train_batch_size (int, optional): Training batch size.
             Defaults to ``32``.
         eval_batch_size (int, optional): Test batch size.
             Defaults to ``32``.
-        num_workers (int, optional): Number of workers.
+        num_workers (int, optional): Number of workers for data loading.
             Defaults to ``8``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+        test_split_mode (TestSplitMode | str): Method to create test set.
             Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+        test_split_ratio (float): Fraction of data to use for testing.
             Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+        val_split_mode (ValSplitMode | str): Method to create validation set.
             Defaults to ``ValSplitMode.SAME_AS_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+        val_split_ratio (float): Fraction of data to use for validation.
             Defaults to ``0.5``.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+        seed (int | None, optional): Random seed for reproducibility.
             Defaults to ``None``.
     """
 
@@ -91,6 +102,12 @@ def __init__(
         self.category = category
 
     def _setup(self, _stage: str | None = None) -> None:
+        """Set up the datasets.
+
+        Args:
+            _stage (str | None, optional): Stage of setup. Not used.
+                Defaults to ``None``.
+        """
         self.train_data = MVTec3DDataset(
             split=Split.TRAIN,
             root=self.root,
diff --git a/src/anomalib/data/datamodules/image/__init__.py b/src/anomalib/data/datamodules/image/__init__.py
index 69221f863c..deb98863ed 100644
--- a/src/anomalib/data/datamodules/image/__init__.py
+++ b/src/anomalib/data/datamodules/image/__init__.py
@@ -1,4 +1,24 @@
-"""Anomalib Image Data Modules."""
+"""Anomalib Image Data Modules.
+
+This module contains data modules for loading and processing image datasets for
+anomaly detection. The following data modules are available:
+
+- ``BTech``: BTech Surface Defect Dataset
+- ``Datumaro``: Dataset in Datumaro format (Intel Geti™ export)
+- ``Folder``: Custom folder structure with normal/abnormal images
+- ``Kolektor``: Kolektor Surface-Defect Dataset
+- ``MVTec``: MVTec Anomaly Detection Dataset
+- ``Visa``: Visual Inspection for Steel Anomaly Dataset
+
+Example:
+    Load the MVTec dataset::
+
+        >>> from anomalib.data import MVTec
+        >>> datamodule = MVTec(
+        ...     root="./datasets/MVTec",
+        ...     category="bottle"
+        ... )
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -14,7 +34,19 @@
 
 
 class ImageDataFormat(str, Enum):
-    """Supported Image Dataset Types."""
+    """Supported Image Dataset Types.
+
+    The following dataset formats are supported:
+
+    - ``BTECH``: BTech Surface Defect Dataset
+    - ``DATUMARO``: Dataset in Datumaro format
+    - ``FOLDER``: Custom folder structure
+    - ``FOLDER_3D``: Custom folder structure for 3D images
+    - ``KOLEKTOR``: Kolektor Surface-Defect Dataset
+    - ``MVTEC``: MVTec AD Dataset
+    - ``MVTEC_3D``: MVTec 3D AD Dataset
+    - ``VISA``: Visual Inspection for Steel Anomaly Dataset
+    """
 
     BTECH = "btech"
     DATUMARO = "datumaro"
diff --git a/src/anomalib/data/datamodules/image/btech.py b/src/anomalib/data/datamodules/image/btech.py
index 4ec0527f16..367b6a1489 100644
--- a/src/anomalib/data/datamodules/image/btech.py
+++ b/src/anomalib/data/datamodules/image/btech.py
@@ -1,9 +1,38 @@
 """BTech Data Module.
 
-This script contains PyTorch Lightning DataModule for the BTech dataset.
+This module provides a PyTorch Lightning DataModule for the BTech dataset. If the
+dataset is not available locally, it will be downloaded and extracted
+automatically.
 
-If the dataset is not on the file system, the script downloads and
-extracts the dataset and create PyTorch data objects.
+Example:
+    Create a BTech datamodule::
+
+        >>> from anomalib.data import BTech
+        >>> datamodule = BTech(
+        ...     root="./datasets/BTech",
+        ...     category="01"
+        ... )
+
+Notes:
+    The dataset will be automatically downloaded and converted to the required
+    format when first used. The directory structure after preparation will be::
+
+        datasets/
+        └── BTech/
+            ├── 01/
+            ├── 02/
+            └── 03/
+
+License:
+    BTech dataset is released under the Creative Commons
+    Attribution-NonCommercial-ShareAlike 4.0 International License
+    (CC BY-NC-SA 4.0).
+    https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+Reference:
+    Mishra, Pankaj, et al. "BTAD—A Large Scale Dataset and Benchmark for
+    Real-World Industrial Anomaly Detection." Pattern Recognition 136 (2024):
+    109542.
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -33,63 +62,70 @@ class BTech(AnomalibDataModule):
     """BTech Lightning Data Module.
 
     Args:
-        root (Path | str): Path to the BTech dataset.
+        root (Path | str): Path to the root of the dataset.
             Defaults to ``"./datasets/BTech"``.
-        category (str): Name of the BTech category.
+        category (str): Category of the BTech dataset (e.g. ``"01"``, ``"02"``,
+            or ``"03"``).
             Defaults to ``"01"``.
         train_batch_size (int, optional): Training batch size.
             Defaults to ``32``.
-        eval_batch_size (int, optional): Eval batch size.
+        eval_batch_size (int, optional): Test batch size.
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        test_split_mode (TestSplitMode, optional): Setting that determines how the testing subset is obtained.
+        test_split_mode (TestSplitMode): Setting that determines how the testing
+            subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float, optional): Fraction of images from the train set that will be reserved for testing.
+        test_split_ratio (float): Fraction of images from the train set that will
+            be reserved for testing.
             Defaults to ``0.2``.
-        val_split_mode (ValSplitMode, optional): Setting that determines how the validation subset is obtained.
+        val_split_mode (ValSplitMode): Setting that determines how the validation
+            subset is obtained.
             Defaults to ``ValSplitMode.SAME_AS_TEST``.
-        val_split_ratio (float, optional): Fraction of train or test images that will be reserved for validation.
+        val_split_ratio (float): Fraction of train or test images that will be
+            reserved for validation.
             Defaults to ``0.5``.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+        seed (int | None, optional): Seed which may be set to a fixed value for
+            reproducibility.
             Defaults to ``None``.
 
-    Examples:
-        To create the BTech datamodule, we need to instantiate the class, and call the ``setup`` method.
-
-        >>> from anomalib.data import BTech
-        >>> datamodule = BTech(
-        ...     root="./datasets/BTech",
-        ...     category="01",
-        ...     train_batch_size=32,
-        ...     eval_batch_size=32,
-        ...     num_workers=8,
-        ... )
-        >>> datamodule.setup()
-
-        To get the train dataloader and the first batch of data:
-
-        >>> i, data = next(enumerate(datamodule.train_dataloader()))
-        >>> data.keys()
-        dict_keys(['image'])
-        >>> data["image"].shape
-        torch.Size([32, 3, 256, 256])
-
-        To access the validation dataloader and the first batch of data:
-
-        >>> i, data = next(enumerate(datamodule.val_dataloader()))
-        >>> data.keys()
-        dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
-        >>> data["image"].shape, data["mask"].shape
-        (torch.Size([32, 3, 256, 256]), torch.Size([32, 256, 256]))
-
-        Similarly, to access the test dataloader and the first batch of data:
-
-        >>> i, data = next(enumerate(datamodule.test_dataloader()))
-        >>> data.keys()
-        dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
-        >>> data["image"].shape, data["mask"].shape
-        (torch.Size([32, 3, 256, 256]), torch.Size([32, 256, 256]))
+    Example:
+        To create the BTech datamodule, instantiate the class and call
+        ``setup``::
+
+            >>> from anomalib.data import BTech
+            >>> datamodule = BTech(
+            ...     root="./datasets/BTech",
+            ...     category="01",
+            ...     train_batch_size=32,
+            ...     eval_batch_size=32,
+            ...     num_workers=8,
+            ... )
+            >>> datamodule.setup()
+
+        Get the train dataloader and first batch::
+
+            >>> i, data = next(enumerate(datamodule.train_dataloader()))
+            >>> data.keys()
+            dict_keys(['image'])
+            >>> data["image"].shape
+            torch.Size([32, 3, 256, 256])
+
+        Access the validation dataloader and first batch::
+
+            >>> i, data = next(enumerate(datamodule.val_dataloader()))
+            >>> data.keys()
+            dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
+            >>> data["image"].shape, data["mask"].shape
+            (torch.Size([32, 3, 256, 256]), torch.Size([32, 256, 256]))
+
+        Access the test dataloader and first batch::
+
+            >>> i, data = next(enumerate(datamodule.test_dataloader()))
+            >>> data.keys()
+            dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
+            >>> data["image"].shape, data["mask"].shape
+            (torch.Size([32, 3, 256, 256]), torch.Size([32, 256, 256]))
     """
 
     def __init__(
@@ -134,34 +170,26 @@ def _setup(self, _stage: str | None = None) -> None:
     def prepare_data(self) -> None:
         """Download the dataset if not available.
 
-        This method checks if the specified dataset is available in the file system.
-        If not, it downloads and extracts the dataset into the appropriate directory.
+        This method checks if the specified dataset is available in the file
+        system. If not, it downloads and extracts the dataset into the
+        appropriate directory.
 
         Example:
             Assume the dataset is not available on the file system.
-            Here's how the directory structure looks before and after calling the
-            `prepare_data` method:
-
-            Before:
-
-            .. code-block:: bash
+            Here's how the directory structure looks before and after calling
+            ``prepare_data``::
 
+                # Before
                 $ tree datasets
                 datasets
                 ├── dataset1
                 └── dataset2
 
-            Calling the method:
-
-            .. code-block:: python
-
-                >> datamodule = BTech(root="./datasets/BTech", category="01")
-                >> datamodule.prepare_data()
-
-            After:
-
-            .. code-block:: bash
+                # Calling prepare_data
+                >>> datamodule = BTech(root="./datasets/BTech", category="01")
+                >>> datamodule.prepare_data()
 
+                # After
                 $ tree datasets
                 datasets
                 ├── dataset1
@@ -178,9 +206,12 @@ def prepare_data(self) -> None:
 
             # rename folder and convert images
             logger.info("Renaming the dataset directory")
-            shutil.move(src=str(self.root.parent / "BTech_Dataset_transformed"), dst=str(self.root))
-            logger.info("Convert the bmp formats to png to have consistent image extensions")
-            for filename in tqdm(self.root.glob("**/*.bmp"), desc="Converting bmp to png"):
+            shutil.move(
+                src=str(self.root.parent / "BTech_Dataset_transformed"),
+                dst=str(self.root),
+            )
+            logger.info("Convert the bmp formats to png for consistent extensions")
+            for filename in tqdm(self.root.glob("**/*.bmp"), desc="Converting"):
                 image = cv2.imread(str(filename))
                 cv2.imwrite(str(filename.with_suffix(".png")), image)
                 filename.unlink()
diff --git a/src/anomalib/data/datamodules/image/datumaro.py b/src/anomalib/data/datamodules/image/datumaro.py
index fb37bc7ee7..8865ad7c91 100644
--- a/src/anomalib/data/datamodules/image/datumaro.py
+++ b/src/anomalib/data/datamodules/image/datumaro.py
@@ -1,6 +1,38 @@
 """DataModule for Datumaro format.
 
-Note: This currently only works for annotations exported from Intel Geti™.
+This module provides a PyTorch Lightning DataModule for datasets in Datumaro
+format. Currently only supports annotations exported from Intel Geti™.
+
+Example:
+    Create a Datumaro datamodule::
+
+        >>> from pathlib import Path
+        >>> from anomalib.data import Datumaro
+        >>> datamodule = Datumaro(
+        ...     root="./datasets/datumaro",
+        ...     train_batch_size=32,
+        ...     eval_batch_size=32,
+        ...     num_workers=8,
+        ... )
+        >>> datamodule.setup()
+        >>> i, data = next(enumerate(datamodule.train_dataloader()))
+        >>> data.keys()
+        dict_keys(['image_path', 'label', 'image'])
+
+Notes:
+    The directory structure should be organized as follows::
+
+        root/
+        ├── annotations/
+        │   ├── train.json
+        │   └── test.json
+        └── images/
+            ├── train/
+            │   ├── image1.jpg
+            │   └── image2.jpg
+            └── test/
+                ├── image3.jpg
+                └── image4.jpg
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -17,46 +49,41 @@ class Datumaro(AnomalibDataModule):
     """Datumaro datamodule.
 
     Args:
-        root (str | Path): Path to the dataset root directory.
-        train_batch_size (int): Batch size for training dataloader.
+        root (Path | str): Path to the dataset root directory.
+        train_batch_size (int, optional): Training batch size.
             Defaults to ``32``.
-        eval_batch_size (int): Batch size for evaluation dataloader.
+        eval_batch_size (int, optional): Test batch size.
             Defaults to ``32``.
-        num_workers (int): Number of workers for dataloaders.
+        num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+        test_split_mode (TestSplitMode): Setting that determines how the testing
+            subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+        test_split_ratio (float): Fraction of images from the train set that will
+            be reserved for testing.
             Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+        val_split_mode (ValSplitMode): Setting that determines how the validation
+            subset is obtained.
             Defaults to ``ValSplitMode.SAME_AS_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+        val_split_ratio (float): Fraction of train or test images that will be
+            reserved for validation.
             Defaults to ``0.5``.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
-            Defualts to ``None``.
-
-    Examples:
-        To create a Datumaro datamodule
+        seed (int | None, optional): Seed which may be set to a fixed value for
+            reproducibility.
+            Defaults to ``None``.
 
-        >>> from pathlib import Path
-        >>> from torchvision.transforms.v2 import Resize
-        >>> root = Path("path/to/dataset")
-        >>> datamodule = Datumaro(root, transform=Resize((256, 256)))
+    Example:
+        >>> from anomalib.data import Datumaro
+        >>> datamodule = Datumaro(
+        ...     root="./datasets/datumaro",
+        ...     train_batch_size=32,
+        ...     eval_batch_size=32,
+        ...     num_workers=8,
+        ... )
         >>> datamodule.setup()
         >>> i, data = next(enumerate(datamodule.train_dataloader()))
         >>> data.keys()
         dict_keys(['image_path', 'label', 'image'])
-
-        >>> data["image"].shape
-        torch.Size([32, 3, 256, 256])
     """
 
     def __init__(
diff --git a/src/anomalib/data/datamodules/image/folder.py b/src/anomalib/data/datamodules/image/folder.py
index bd3c3fedd0..9cb2d0e430 100644
--- a/src/anomalib/data/datamodules/image/folder.py
+++ b/src/anomalib/data/datamodules/image/folder.py
@@ -1,6 +1,32 @@
 """Custom Folder Data Module.
 
-This script creates a custom Lightning DataModule from a folder.
+This script creates a custom Lightning DataModule from a folder containing normal
+and abnormal images.
+
+Example:
+    Create a folder datamodule::
+
+        >>> from anomalib.data import Folder
+        >>> datamodule = Folder(
+        ...     name="custom_folder",
+        ...     root="./datasets/custom",
+        ...     normal_dir="good",
+        ...     abnormal_dir="defect"
+        ... )
+
+Notes:
+    The directory structure should be organized as follows::
+
+        root/
+        ├── normal_dir/
+        │   ├── image1.png
+        │   └── image2.png
+        ├── abnormal_dir/
+        │   ├── image3.png
+        │   └── image4.png
+        └── mask_dir/
+            ├── mask3.png
+            └── mask4.png
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -18,92 +44,62 @@ class Folder(AnomalibDataModule):
     """Folder DataModule.
 
     Args:
-        name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
-        normal_dir (str | Path | Sequence): Name of the directory containing normal images.
-        root (str | Path | None): Path to the root folder containing normal and abnormal dirs.
-            Defaults to ``None``.
-        abnormal_dir (str | Path | None | Sequence): Name of the directory containing abnormal images.
-            Defaults to ``None``.
-        normal_test_dir (str | Path | Sequence | None, optional): Path to the directory containing
-            normal images for the test dataset.
-            Defaults to ``None``.
-        mask_dir (str | Path | Sequence | None, optional): Path to the directory containing
-            the mask annotations.
-            Defaults to ``None``.
-        normal_split_ratio (float, optional): Ratio to split normal training images and add to the
-            test set in case test set doesn't contain any normal images.
-            Defaults to 0.2.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the
-            directory.
+        name (str): Name of the dataset. Used for logging/saving.
+        normal_dir (str | Path | Sequence): Directory containing normal images.
+        root (str | Path | None): Root folder containing normal and abnormal
+            directories. Defaults to ``None``.
+        abnormal_dir (str | Path | None | Sequence): Directory containing
+            abnormal images. Defaults to ``None``.
+        normal_test_dir (str | Path | Sequence | None): Directory containing
+            normal test images. Defaults to ``None``.
+        mask_dir (str | Path | Sequence | None): Directory containing mask
+            annotations. Defaults to ``None``.
+        normal_split_ratio (float): Ratio to split normal training images for
+            test set when no normal test images exist.
+            Defaults to ``0.2``.
+        extensions (tuple[str, ...] | None): Image extensions to include.
             Defaults to ``None``.
-        train_batch_size (int, optional): Training batch size.
+        train_batch_size (int): Training batch size.
             Defaults to ``32``.
-        eval_batch_size (int, optional): Validation, test and predict batch size.
+        eval_batch_size (int): Validation/test batch size.
             Defaults to ``32``.
-        num_workers (int, optional): Number of workers.
+        num_workers (int): Number of workers for data loading.
             Defaults to ``8``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+        test_split_mode (TestSplitMode): Method to obtain test subset.
             Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+        test_split_ratio (float): Fraction of train images for testing.
             Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+        val_split_mode (ValSplitMode): Method to obtain validation subset.
             Defaults to ``ValSplitMode.FROM_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+        val_split_ratio (float): Fraction of images for validation.
             Defaults to ``0.5``.
-        seed (int | None, optional): Seed used during random subset splitting.
+        seed (int | None): Random seed for splitting.
             Defaults to ``None``.
 
-    Examples:
-        The following code demonstrates how to use the ``Folder`` datamodule. Assume that the dataset is structured
-        as follows:
-
-        .. code-block:: bash
-
-            $ tree sample_dataset
-            sample_dataset
-            ├── colour
-            │   ├── 00.jpg
-            │   ├── ...
-            │   └── x.jpg
-            ├── crack
-            │   ├── 00.jpg
-            │   ├── ...
-            │   └── y.jpg
-            ├── good
-            │   ├── ...
-            │   └── z.jpg
-            ├── LICENSE
-            └── mask
-                ├── colour
-                │   ├── ...
-                │   └── x.jpg
-                └── crack
-                    ├── ...
-                    └── y.jpg
-
-        .. code-block:: python
-
-            folder_datamodule = Folder(
-                root=dataset_root,
-                normal_dir="good",
-                abnormal_dir="crack",
-                mask_dir=dataset_root / "mask" / "crack",
-            )
-            folder_datamodule.setup()
-
-        To access the training images,
-
-        .. code-block:: python
-
-            >> i, data = next(enumerate(folder_datamodule.train_dataloader()))
-            >> print(data.keys(), data["image"].shape)
-
-        To access the test images,
-
-        .. code-block:: python
-
-            >> i, data = next(enumerate(folder_datamodule.test_dataloader()))
-            >> print(data.keys(), data["image"].shape)
+    Example:
+        Create and setup a folder datamodule::
+
+            >>> from anomalib.data import Folder
+            >>> datamodule = Folder(
+            ...     name="custom",
+            ...     root="./datasets/custom",
+            ...     normal_dir="good",
+            ...     abnormal_dir="defect",
+            ...     mask_dir="mask"
+            ... )
+            >>> datamodule.setup()
+
+        Get a batch from train dataloader::
+
+            >>> batch = next(iter(datamodule.train_dataloader()))
+            >>> batch.keys()
+            dict_keys(['image', 'label', 'mask', 'image_path', 'mask_path'])
+
+        Get a batch from test dataloader::
+
+            >>> batch = next(iter(datamodule.test_dataloader()))
+            >>> batch.keys()
+            dict_keys(['image', 'label', 'mask', 'image_path', 'mask_path'])
     """
 
     def __init__(
@@ -172,8 +168,9 @@ def _setup(self, _stage: str | None = None) -> None:
 
     @property
     def name(self) -> str:
-        """Name of the datamodule.
+        """Get name of the datamodule.
 
-        Folder datamodule overrides the name property to provide a custom name.
+        Returns:
+            Name of the datamodule.
         """
         return self._name
diff --git a/src/anomalib/data/datamodules/image/kolektor.py b/src/anomalib/data/datamodules/image/kolektor.py
index fe767c3a94..980e0ac4b4 100644
--- a/src/anomalib/data/datamodules/image/kolektor.py
+++ b/src/anomalib/data/datamodules/image/kolektor.py
@@ -1,17 +1,20 @@
 """Kolektor Surface-Defect Data Module.
 
 Description:
-    This script provides a PyTorch DataModule for the Kolektor
-    Surface-Defect dataset. The dataset can be accessed at `Kolektor Surface-Defect Dataset `_.
+    This script provides a PyTorch DataModule for the Kolektor Surface-Defect
+    dataset. The dataset can be accessed at `Kolektor Surface-Defect Dataset
+    `_.
 
 License:
-    The Kolektor Surface-Defect dataset is released under the Creative Commons Attribution-NonCommercial-ShareAlike
-    4.0 International License (CC BY-NC-SA 4.0). For more details, visit
-    `Creative Commons License `_.
+    The Kolektor Surface-Defect dataset is released under the Creative Commons
+    Attribution-NonCommercial-ShareAlike 4.0 International License
+    (CC BY-NC-SA 4.0). For more details, visit `Creative Commons License
+    `_.
 
 Reference:
-    Tabernik, Domen, Samo Šela, Jure Skvarč, and Danijel Skočaj. "Segmentation-based deep-learning approach
-    for surface-defect detection." Journal of Intelligent Manufacturing 31, no. 3 (2020): 759-776.
+    Tabernik, Domen, Samo Šela, Jure Skvarč, and Danijel Skočaj.
+    "Segmentation-based deep-learning approach for surface-defect detection."
+    Journal of Intelligent Manufacturing 31, no. 3 (2020): 759-776.
 """
 
 # Copyright (C) 2023-2024 Intel Corporation
@@ -35,26 +38,45 @@
 
 
 class Kolektor(AnomalibDataModule):
-    """Kolektor Datamodule.
+    """Kolektor Surface-Defect DataModule.
 
     Args:
-        root (Path | str): Path to the root of the dataset
+        root (Path | str): Path to the root of the dataset.
+            Defaults to ``"./datasets/kolektor"``.
         train_batch_size (int, optional): Training batch size.
             Defaults to ``32``.
         eval_batch_size (int, optional): Test batch size.
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
-            Defaults to ``TestSplitMode.FROM_DIR``
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
-            Defaults to ``0.2``
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-            Defaults to ``ValSplitMode.SAME_AS_TEST``
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-            Defaults to ``0.5``
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+        test_split_mode (TestSplitMode): Setting that determines how the testing
+            subset is obtained.
+            Defaults to ``TestSplitMode.FROM_DIR``.
+        test_split_ratio (float): Fraction of images from the train set that will
+            be reserved for testing.
+            Defaults to ``0.2``.
+        val_split_mode (ValSplitMode): Setting that determines how the validation
+            subset is obtained.
+            Defaults to ``ValSplitMode.SAME_AS_TEST``.
+        val_split_ratio (float): Fraction of train or test images that will be
+            reserved for validation.
+            Defaults to ``0.5``.
+        seed (int | None, optional): Seed which may be set to a fixed value for
+            reproducibility.
             Defaults to ``None``.
+
+    Example:
+        >>> from anomalib.data import Kolektor
+        >>> datamodule = Kolektor(
+        ...     root="./datasets/kolektor",
+        ...     train_batch_size=32,
+        ...     eval_batch_size=32,
+        ...     num_workers=8,
+        ... )
+        >>> datamodule.setup()
+        >>> i, data = next(enumerate(datamodule.train_dataloader()))
+        >>> data.keys()
+        dict_keys(['image', 'label', 'mask', 'image_path', 'mask_path'])
     """
 
     def __init__(
@@ -95,17 +117,16 @@ def _setup(self, _stage: str | None = None) -> None:
     def prepare_data(self) -> None:
         """Download the dataset if not available.
 
-        This method checks if the specified dataset is available in the file system.
-        If not, it downloads and extracts the dataset into the appropriate directory.
+        This method checks if the specified dataset is available in the file
+        system. If not, it downloads and extracts the dataset into the
+        appropriate directory.
 
         Example:
             Assume the dataset is not available on the file system.
-            Here's how the directory structure looks before and after calling the
-            `prepare_data` method:
-
-            Before:
+            Here's how the directory structure looks before and after calling
+            the ``prepare_data`` method:
 
-            .. code-block:: bash
+            Before::
 
                 $ tree datasets
                 datasets
@@ -114,14 +135,10 @@ def prepare_data(self) -> None:
 
             Calling the method:
 
-            .. code-block:: python
-
-                >> datamodule = Kolektor(root="./datasets/kolektor")
-                >> datamodule.prepare_data()
-
-            After:
+            >>> datamodule = Kolektor(root="./datasets/kolektor")
+            >>> datamodule.prepare_data()
 
-            .. code-block:: bash
+            After::
 
                 $ tree datasets
                 datasets
diff --git a/src/anomalib/data/datamodules/image/mvtec.py b/src/anomalib/data/datamodules/image/mvtec.py
index 9e7b2fce89..b412e38c04 100644
--- a/src/anomalib/data/datamodules/image/mvtec.py
+++ b/src/anomalib/data/datamodules/image/mvtec.py
@@ -1,25 +1,45 @@
 """MVTec AD Data Module.
 
-Description:
-    This script contains PyTorch Lightning DataModule for the MVTec AD dataset.
-    If the dataset is not on the file system, the script downloads and extracts
-    the dataset and create PyTorch data objects.
+This module provides a PyTorch Lightning DataModule for the MVTec AD dataset. If
+the dataset is not available locally, it will be downloaded and extracted
+automatically.
+
+Example:
+    Create a MVTec datamodule::
+
+        >>> from anomalib.data import MVTec
+        >>> datamodule = MVTec(
+        ...     root="./datasets/mvtec",
+        ...     category="bottle"
+        ... )
+
+Notes:
+    The dataset will be automatically downloaded and converted to the required
+    format when first used. The directory structure after preparation will be::
+
+        datasets/
+        └── mvtec/
+            ├── bottle/
+            ├── cable/
+            └── ...
 
 License:
     MVTec AD dataset is released under the Creative Commons
     Attribution-NonCommercial-ShareAlike 4.0 International License
-    (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
-
-References:
-    - Paul Bergmann, Kilian Batzner, Michael Fauser, David Sattlegger, Carsten Steger:
-      The MVTec Anomaly Detection Dataset: A Comprehensive Real-World Dataset for
-      Unsupervised Anomaly Detection; in: International Journal of Computer Vision
-      129(4):1038-1059, 2021, DOI: 10.1007/s11263-020-01400-4.
-
-    - Paul Bergmann, Michael Fauser, David Sattlegger, Carsten Steger: MVTec AD —
-      A Comprehensive Real-World Dataset for Unsupervised Anomaly Detection;
-      in: IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR),
-      9584-9592, 2019, DOI: 10.1109/CVPR.2019.00982.
+    (CC BY-NC-SA 4.0).
+    https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+Reference:
+    Paul Bergmann, Kilian Batzner, Michael Fauser, David Sattlegger,
+    Carsten Steger: The MVTec Anomaly Detection Dataset: A Comprehensive
+    Real-World Dataset for Unsupervised Anomaly Detection; in: International
+    Journal of Computer Vision 129(4):1038-1059, 2021,
+    DOI: 10.1007/s11263-020-01400-4.
+
+    Paul Bergmann, Michael Fauser, David Sattlegger, Carsten Steger: MVTec AD —
+    A Comprehensive Real-World Dataset for Unsupervised Anomaly Detection;
+    in: IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR),
+    9584-9592, 2019, DOI: 10.1109/CVPR.2019.00982.
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -37,8 +57,8 @@
 
 DOWNLOAD_INFO = DownloadInfo(
     name="mvtec",
-    url="https://www.mydrive.ch/shares/38536/3830184030e49fe74747669442f0f282/download/420938113-1629952094"
-    "/mvtec_anomaly_detection.tar.xz",
+    url="https://www.mydrive.ch/shares/38536/3830184030e49fe74747669442f0f282/"
+    "download/420938113-1629952094/mvtec_anomaly_detection.tar.xz",
     hashsum="cf4313b13603bec67abb49ca959488f7eedce2a9f7795ec54446c649ac98cd3d",
 )
 
@@ -49,53 +69,54 @@ class MVTec(AnomalibDataModule):
     Args:
         root (Path | str): Path to the root of the dataset.
             Defaults to ``"./datasets/MVTec"``.
-        category (str): Category of the MVTec dataset (e.g. "bottle" or "cable").
-            Defaults to ``"bottle"``.
+        category (str): Category of the MVTec dataset (e.g. ``"bottle"`` or
+            ``"cable"``). Defaults to ``"bottle"``.
         train_batch_size (int, optional): Training batch size.
             Defaults to ``32``.
         eval_batch_size (int, optional): Test batch size.
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+        test_split_mode (TestSplitMode): Method to create test set.
             Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+        test_split_ratio (float): Fraction of data to use for testing.
             Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+        val_split_mode (ValSplitMode): Method to create validation set.
             Defaults to ``ValSplitMode.SAME_AS_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+        val_split_ratio (float): Fraction of data to use for validation.
             Defaults to ``0.5``.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
-            Defualts to ``None``.
-
-    Examples:
-        To create an MVTec AD datamodule with default settings:
+        seed (int | None, optional): Seed for reproducibility.
+            Defaults to ``None``.
 
-        >>> datamodule = MVTec()
-        >>> datamodule.setup()
-        >>> i, data = next(enumerate(datamodule.train_dataloader()))
-        >>> data.keys()
-        dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask'])
+    Example:
+        Create MVTec datamodule with default settings::
 
-        >>> data["image"].shape
-        torch.Size([32, 3, 256, 256])
+            >>> datamodule = MVTec()
+            >>> datamodule.setup()
+            >>> i, data = next(enumerate(datamodule.train_dataloader()))
+            >>> data.keys()
+            dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask'])
 
-        To change the category of the dataset:
+            >>> data["image"].shape
+            torch.Size([32, 3, 256, 256])
 
-        >>> datamodule = MVTec(category="cable")
+        Change the category::
 
-        MVTec AD dataset does not provide a validation set. If you would like
-        to use a separate validation set, you can use the ``val_split_mode`` and
-        ``val_split_ratio`` arguments to create a validation set.
+            >>> datamodule = MVTec(category="cable")
 
-        >>> datamodule = MVTec(val_split_mode=ValSplitMode.FROM_TEST, val_split_ratio=0.1)
+        Create validation set from test data::
 
-        This will subsample the test set by 10% and use it as the validation set.
-        If you would like to create a validation set synthetically that would
-        not change the test set, you can use the ``ValSplitMode.SYNTHETIC`` option.
+            >>> datamodule = MVTec(
+            ...     val_split_mode=ValSplitMode.FROM_TEST,
+            ...     val_split_ratio=0.1
+            ... )
 
-        >>> datamodule = MVTec(val_split_mode=ValSplitMode.SYNTHETIC, val_split_ratio=0.2)
+        Create synthetic validation set::
 
+            >>> datamodule = MVTec(
+            ...     val_split_mode=ValSplitMode.SYNTHETIC,
+            ...     val_split_ratio=0.2
+            ... )
     """
 
     def __init__(
@@ -131,11 +152,12 @@ def _setup(self, _stage: str | None = None) -> None:
         This method may be overridden in subclass for custom splitting behaviour.
 
         Note:
-            The stage argument is not used here. This is because, for a given instance of an AnomalibDataModule
-            subclass, all three subsets are created at the first call of setup(). This is to accommodate the subset
-            splitting behaviour of anomaly tasks, where the validation set is usually extracted from the test set, and
-            the test set must therefore be created as early as the `fit` stage.
-
+            The stage argument is not used here. This is because, for a given
+            instance of an AnomalibDataModule subclass, all three subsets are
+            created at the first call of setup(). This is to accommodate the
+            subset splitting behaviour of anomaly tasks, where the validation set
+            is usually extracted from the test set, and the test set must
+            therefore be created as early as the `fit` stage.
         """
         self.train_data = MVTecDataset(
             split=Split.TRAIN,
@@ -151,42 +173,26 @@ def _setup(self, _stage: str | None = None) -> None:
     def prepare_data(self) -> None:
         """Download the dataset if not available.
 
-        This method checks if the specified dataset is available in the file system.
-        If not, it downloads and extracts the dataset into the appropriate directory.
+        This method checks if the specified dataset is available in the file
+        system. If not, it downloads and extracts the dataset into the
+        appropriate directory.
 
         Example:
-            Assume the dataset is not available on the file system.
-            Here's how the directory structure looks before and after calling the
-            `prepare_data` method:
-
-            Before:
-
-            .. code-block:: bash
-
-                $ tree datasets
-                datasets
-                ├── dataset1
-                └── dataset2
-
-            Calling the method:
-
-            .. code-block:: python
-
-                >> datamodule = MVTec(root="./datasets/MVTec", category="bottle")
-                >> datamodule.prepare_data()
+            Assume the dataset is not available on the file system::
 
-            After:
+                >>> datamodule = MVTec(
+                ...     root="./datasets/MVTec",
+                ...     category="bottle"
+                ... )
+                >>> datamodule.prepare_data()
 
-            .. code-block:: bash
+            Directory structure after download::
 
-                $ tree datasets
-                datasets
-                ├── dataset1
-                ├── dataset2
-                └── MVTec
-                    ├── bottle
-                    ├── ...
-                    └── zipper
+                datasets/
+                └── MVTec/
+                    ├── bottle/
+                    ├── cable/
+                    └── ...
         """
         if (self.root / self.category).is_dir():
             logger.info("Found the dataset.")
diff --git a/src/anomalib/data/datamodules/image/visa.py b/src/anomalib/data/datamodules/image/visa.py
index 553d0dcc03..c359eb7600 100644
--- a/src/anomalib/data/datamodules/image/visa.py
+++ b/src/anomalib/data/datamodules/image/visa.py
@@ -1,19 +1,41 @@
 """Visual Anomaly (VisA) Data Module.
 
-Description:
-    This script contains PyTorch Lightning DataModule for the Visual Anomal
-    (VisA) dataset. If the dataset is not on the file system, the script
-    downloads and extracts the dataset and create PyTorch data objects.
+This module provides a PyTorch Lightning DataModule for the Visual Anomaly (VisA)
+dataset. If the dataset is not available locally, it will be downloaded and
+extracted automatically.
+
+Example:
+    Create a VisA datamodule::
+
+        >>> from anomalib.data import Visa
+        >>> datamodule = Visa(
+        ...     root="./datasets/visa",
+        ...     category="capsules"
+        ... )
+
+Notes:
+    The dataset will be automatically downloaded and converted to the required
+    format when first used. The directory structure after preparation will be::
+
+        datasets/
+        └── visa/
+            ├── visa_pytorch/
+            │   ├── candle/
+            │   ├── capsules/
+            │   └── ...
+            └── VisA_20220922.tar
 
 License:
     The VisA dataset is released under the Creative Commons
     Attribution-NonCommercial-ShareAlike 4.0 International License
-    (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
+    (CC BY-NC-SA 4.0).
+    https://creativecommons.org/licenses/by-nc-sa/4.0/
 
 Reference:
-    - Zou, Y., Jeong, J., Pemula, L., Zhang, D., & Dabeer, O. (2022). SPot-the-Difference
-      Self-supervised Pre-training for Anomaly Detection and Segmentation. In European
-      Conference on Computer Vision (pp. 392-408). Springer, Cham.
+    Zou, Y., Jeong, J., Pemula, L., Zhang, D., & Dabeer, O. (2022).
+    SPot-the-Difference Self-supervised Pre-training for Anomaly Detection
+    and Segmentation. In European Conference on Computer Vision (pp. 392-408).
+    Springer, Cham.
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -46,25 +68,25 @@ class Visa(AnomalibDataModule):
     """VisA Datamodule.
 
     Args:
-        root (Path | str): Path to the root of the dataset
+        root (Path | str): Path to the root of the dataset.
             Defaults to ``"./datasets/visa"``.
-        category (str): Category of the Visa dataset such as ``candle``.
-            Defaults to ``"candle"``.
+        category (str): Category of the VisA dataset (e.g. ``"candle"``).
+            Defaults to ``"capsules"``.
         train_batch_size (int, optional): Training batch size.
             Defaults to ``32``.
         eval_batch_size (int, optional): Test batch size.
             Defaults to ``32``.
-        num_workers (int, optional): Number of workers.
+        num_workers (int, optional): Number of workers for data loading.
             Defaults to ``8``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
+        test_split_mode (TestSplitMode | str): Method to create test set.
             Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
+        test_split_ratio (float): Fraction of data to use for testing.
             Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
+        val_split_mode (ValSplitMode | str): Method to create validation set.
             Defaults to ``ValSplitMode.SAME_AS_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-            Defatuls to ``0.5``.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+        val_split_ratio (float): Fraction of data to use for validation.
+            Defaults to ``0.5``.
+        seed (int | None, optional): Random seed for reproducibility.
             Defaults to ``None``.
     """
 
@@ -109,61 +131,32 @@ def _setup(self, _stage: str | None = None) -> None:
         )
 
     def prepare_data(self) -> None:
-        """Download the dataset if not available.
-
-        This method checks if the specified dataset is available in the file system.
-        If not, it downloads and extracts the dataset into the appropriate directory.
-
-        Example:
-            Assume the dataset is not available on the file system.
-            Here's how the directory structure looks before and after calling the
-            `prepare_data` method:
-
-            Before:
-
-            .. code-block:: bash
-
-                $ tree datasets
-                datasets
-                ├── dataset1
-                └── dataset2
-
-            Calling the method:
-
-            .. code-block:: python
-
-                >> datamodule = Visa()
-                >> datamodule.prepare_data()
-
-            After:
-
-            .. code-block:: bash
-
-                $ tree datasets
-                datasets
-                ├── dataset1
-                ├── dataset2
-                └── visa
-                    ├── candle
-                    ├── ...
-                    ├── pipe_fryum
-                    │   ├── Data
-                    │   └── image_anno.csv
-                    ├── split_csv
-                    │   ├── 1cls.csv
-                    │   ├── 2cls_fewshot.csv
-                    │   └── 2cls_highshot.csv
-                    ├── VisA_20220922.tar
-                    └── visa_pytorch
-                        ├── candle
-                        ├── ...
-                        ├── pcb4
-                        └── pipe_fryum
-
-            ``prepare_data`` ensures that the dataset is converted to MVTec
-            format. ``visa_pytorch`` is the directory that contains the dataset
-            in the MVTec format. ``visa`` is the directory that contains the
-            original dataset.
+        """Download and prepare the dataset if not available.
+
+        This method checks if the dataset exists and is properly formatted.
+        If not, it downloads and prepares the data in the following steps:
+
+        1. If the processed dataset exists (``visa_pytorch/{category}``), do
+           nothing
+        2. If the raw dataset exists but isn't processed, apply the train/test
+           split
+        3. If the dataset doesn't exist, download, extract, and process it
+
+        The final directory structure will be::
+
+            datasets/
+            └── visa/
+                ├── visa_pytorch/
+                │   ├── candle/
+                │   │   ├── train/
+                │   │   │   └── good/
+                │   │   ├── test/
+                │   │   │   ├── good/
+                │   │   │   └── bad/
+                │   │   └── ground_truth/
+                │   │       └── bad/
+                │   └── ...
+                └── VisA_20220922.tar
         """
         if (self.split_root / self.category).is_dir():
             # dataset is available, and split has been applied
@@ -181,7 +174,7 @@ def prepare_data(self) -> None:
     def apply_cls1_split(self) -> None:
         """Apply the 1-class subset splitting using the fixed split in the csv file.
 
-        adapted from https://github.com/amazon-science/spot-diff
+        Adapted from https://github.com/amazon-science/spot-diff.
         """
         logger.info("preparing data")
         categories = [
diff --git a/src/anomalib/data/datamodules/video/__init__.py b/src/anomalib/data/datamodules/video/__init__.py
index f9b3763525..efdffd73a9 100644
--- a/src/anomalib/data/datamodules/video/__init__.py
+++ b/src/anomalib/data/datamodules/video/__init__.py
@@ -1,4 +1,22 @@
-"""Anomalib Video Data Modules."""
+"""Anomalib Video Data Modules.
+
+This module contains data modules for loading and processing video datasets for
+anomaly detection. The following data modules are available:
+
+- ``Avenue``: CUHK Avenue Dataset for abnormal event detection
+- ``ShanghaiTech``: ShanghaiTech Campus Dataset for anomaly detection
+- ``UCSDped``: UCSD Pedestrian Dataset for anomaly detection
+
+Example:
+    Load the Avenue dataset::
+
+        >>> from anomalib.data import Avenue
+        >>> datamodule = Avenue(
+        ...     root="./datasets/avenue",
+        ...     clip_length_in_frames=2,
+        ...     frames_between_clips=1
+        ... )
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -11,7 +29,14 @@
 
 
 class VideoDataFormat(str, Enum):
-    """Supported Video Dataset Types."""
+    """Supported Video Dataset Types.
+
+    The following dataset formats are supported:
+
+    - ``UCSDPED``: UCSD Pedestrian Dataset
+    - ``AVENUE``: CUHK Avenue Dataset
+    - ``SHANGHAITECH``: ShanghaiTech Campus Dataset
+    """
 
     UCSDPED = "ucsdped"
     AVENUE = "avenue"
diff --git a/src/anomalib/data/datamodules/video/avenue.py b/src/anomalib/data/datamodules/video/avenue.py
index 446b4b6c37..f91f5dd384 100644
--- a/src/anomalib/data/datamodules/video/avenue.py
+++ b/src/anomalib/data/datamodules/video/avenue.py
@@ -1,16 +1,56 @@
 """CUHK Avenue Data Module.
 
-Description:
-    This module provides a PyTorch Lightning DataModule for the CUHK Avenue dataset.
-    If the dataset is not already present on the file system, the DataModule class will download and
-    extract the dataset, converting the .mat mask files to .png format.
+This module provides a PyTorch Lightning DataModule for the CUHK Avenue dataset. If
+the dataset is not already present on the file system, the DataModule class will
+download and extract the dataset, converting the ``.mat`` mask files to ``.png``
+format.
+
+Example:
+    Create an Avenue datamodule::
+
+        >>> from anomalib.data import Avenue
+        >>> datamodule = Avenue(
+        ...     root="./datasets/avenue",
+        ...     clip_length_in_frames=2,
+        ...     frames_between_clips=1,
+        ... )
+        >>> datamodule.setup()
+        >>> i, data = next(enumerate(datamodule.train_dataloader()))
+        >>> data.keys()
+        dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image'])
+
+Notes:
+    The directory structure after preparation will be::
+
+        root/
+        ├── ground_truth_demo/
+        │   ├── ground_truth_show.m
+        │   ├── Readme.txt
+        │   ├── testing_label_mask/
+        │   └── testing_videos/
+        ├── testing_videos/
+        │   ├── ...
+        │   └── 21.avi
+        ├── testing_vol/
+        │   ├── ...
+        │   └── vol21.mat
+        ├── training_videos/
+        │   ├── ...
+        │   └── 16.avi
+        └── training_vol/
+            ├── ...
+            └── vol16.mat
+
+License:
+    The CUHK Avenue dataset is released for academic research only. For licensing
+    details, see the original dataset website.
 
 Reference:
-    - Lu, Cewu, Jianping Shi, and Jiaya Jia. "Abnormal event detection at 150 fps in Matlab."
-      In Proceedings of the IEEE International Conference on Computer Vision, 2013.
+    Lu, Cewu, Jianping Shi, and Jiaya Jia. "Abnormal event detection at 150 fps
+    in Matlab." In Proceedings of the IEEE International Conference on Computer
+    Vision, 2013.
 """
 
-
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
@@ -45,73 +85,47 @@ class Avenue(AnomalibVideoDataModule):
     """Avenue DataModule class.
 
     Args:
-        root (Path | str): Path to the root  of the dataset
-            Defaults to ``./datasets/avenue``.
-        gt_dir (Path | str): Path to the ground truth files
-            Defaults to ``./datasets/avenue/ground_truth_demo``.
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
+        root (Path | str): Path to the root of the dataset.
+            Defaults to ``"./datasets/avenue"``.
+        gt_dir (Path | str): Path to the ground truth files.
+            Defaults to ``"./datasets/avenue/ground_truth_demo"``.
+        clip_length_in_frames (int): Number of video frames in each clip.
             Defaults to ``2``.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
+        frames_between_clips (int): Number of frames between consecutive clips.
             Defaults to ``1``.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
-            Defaults to ``VideoTargetFrame.LAST``.
-        train_batch_size (int, optional): Training batch size.
+        target_frame (VideoTargetFrame | str): Target frame in clip for ground
+            truth. Defaults to ``VideoTargetFrame.LAST``.
+        train_batch_size (int): Training batch size.
             Defaults to ``32``.
-        eval_batch_size (int, optional): Test batch size.
+        eval_batch_size (int): Test batch size.
             Defaults to ``32``.
-        num_workers (int, optional): Number of workers.
+        num_workers (int): Number of workers.
             Defaults to ``8``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-            Defaults to ``ValSplitMode.FROM_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
+        val_split_mode (ValSplitMode | str): How validation subset is obtained.
+            Defaults to ``ValSplitMode.SAME_AS_TEST``.
+        val_split_ratio (float): Fraction of data reserved for validation.
             Defaults to ``0.5``.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+        seed (int | None): Seed for reproducibility.
             Defaults to ``None``.
 
-    Examples:
-        To create a DataModule for Avenue dataset with default parameters:
-
-        .. code-block:: python
-
-            datamodule = Avenue()
-            datamodule.setup()
-
-            i, data = next(enumerate(datamodule.train_dataloader()))
-            data.keys()
-            # Output: dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image'])
-
-            i, data = next(enumerate(datamodule.test_dataloader()))
-            data.keys()
-            # Output: dict_keys(['image', 'mask', 'video_path', 'frames', 'last_frame', 'original_image', 'label'])
-
-            data["image"].shape
-            # Output: torch.Size([32, 2, 3, 256, 256])
-
-        Note that it is important to note that the dataloader returns a batch of clips, where each clip is a sequence of
-        frames. The number of frames in each clip is determined by the ``clip_length_in_frames`` parameter. The
-        ``frames_between_clips`` parameter determines the number of frames between each consecutive clip. The
-        ``target_frame`` parameter determines which frame in the clip is used for ground truth retrieval. For example,
-        if ``clip_length_in_frames=2``, ``frames_between_clips=1`` and ``target_frame=VideoTargetFrame.LAST``, then the
-        dataloader will return a batch of clips where each clip contains two consecutive frames from the video. The
-        second frame in each clip will be used as the ground truth for the first frame in the clip. The following code
-        shows how to create a dataloader for classification:
-
-        .. code-block:: python
-
-            datamodule = Avenue(
-                clip_length_in_frames=2,
-                frames_between_clips=1,
-                target_frame=VideoTargetFrame.LAST
-            )
-            datamodule.setup()
-
-            i, data = next(enumerate(datamodule.train_dataloader()))
-            data.keys()
-            # Output: dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image'])
-
-            data["image"].shape
-            # Output: torch.Size([32, 2, 3, 256, 256])
-
+    Example:
+        Create a dataloader for classification::
+
+            >>> datamodule = Avenue(
+            ...     clip_length_in_frames=2,
+            ...     frames_between_clips=1,
+            ...     target_frame=VideoTargetFrame.LAST
+            ... )
+            >>> datamodule.setup()
+            >>> i, data = next(enumerate(datamodule.train_dataloader()))
+            >>> data["image"].shape
+            torch.Size([32, 2, 3, 256, 256])
+
+    Notes:
+        The dataloader returns batches of clips, where each clip contains
+        ``clip_length_in_frames`` consecutive frames. ``frames_between_clips``
+        determines frame spacing between clips. ``target_frame`` specifies which
+        frame provides ground truth.
     """
 
     def __init__(
@@ -165,54 +179,35 @@ def _setup(self, _stage: str | None = None) -> None:
     def prepare_data(self) -> None:
         """Download the dataset if not available.
 
-        This method checks if the specified dataset is available in the file system.
-        If not, it downloads and extracts the dataset into the appropriate directory.
+        This method checks if the specified dataset is available in the file
+        system. If not, it downloads and extracts the dataset into the appropriate
+        directory.
 
         Example:
-            Assume the dataset is not available on the file system.
-            Here's how the directory structure looks before and after calling the
-            `prepare_data` method:
-
-            Before:
-
-            .. code-block:: bash
-
-                $ tree datasets
-                datasets
-                ├── dataset1
-                └── dataset2
-
-            Calling the method:
-
-            .. code-block:: python
-
-                >> datamodule = Avenue()
-                >> datamodule.prepare_data()
+            Assume the dataset is not available on the file system::
 
-            After:
+                >>> datamodule = Avenue()
+                >>> datamodule.prepare_data()
 
-            .. code-block:: bash
+            The directory structure after preparation will be::
 
-                $ tree datasets
-                datasets
-                ├── dataset1
-                ├── dataset2
-                └── avenue
-                    ├── ground_truth_demo
+                datasets/
+                └── avenue/
+                    ├── ground_truth_demo/
                     │   ├── ground_truth_show.m
                     │   ├── Readme.txt
-                    │   ├── testing_label_mask
-                    │   └── testing_videos
-                    ├── testing_videos
+                    │   ├── testing_label_mask/
+                    │   └── testing_videos/
+                    ├── testing_videos/
                     │   ├── ...
                     │   └── 21.avi
-                    ├── testing_vol
+                    ├── testing_vol/
                     │   ├── ...
                     │   └── vol21.mat
-                    ├── training_videos
+                    ├── training_videos/
                     │   ├── ...
                     │   └── 16.avi
-                    └── training_vol
+                    └── training_vol/
                         ├── ...
                         └── vol16.mat
         """
@@ -235,10 +230,11 @@ def prepare_data(self) -> None:
 
     @staticmethod
     def _convert_masks(gt_dir: Path) -> None:
-        """Convert mask files to .png.
+        """Convert mask files from ``.mat`` to ``.png`` format.
 
-        The masks in the Avenue datasets are provided as matlab (.mat) files. To speed up data loading, we convert the
-        masks into a sepaarte .png file for every video frame in the dataset.
+        The masks in the Avenue datasets are provided as matlab (``.mat``) files.
+        To speed up data loading, we convert the masks into a separate ``.png``
+        file for every video frame in the dataset.
 
         Args:
             gt_dir (Path): Ground truth folder of the dataset.
diff --git a/src/anomalib/data/datamodules/video/shanghaitech.py b/src/anomalib/data/datamodules/video/shanghaitech.py
index f5e5cd0036..babd338fc0 100644
--- a/src/anomalib/data/datamodules/video/shanghaitech.py
+++ b/src/anomalib/data/datamodules/video/shanghaitech.py
@@ -1,16 +1,45 @@
 """ShanghaiTech Campus Data Module.
 
-Description:
-    This module contains PyTorch Lightning DataModule for the ShanghaiTech Campus dataset.
-    If the dataset is not on the file system, the DataModule class downloads and
-    extracts the dataset and converts video files to a format that is readable by pyav.
+This module provides a PyTorch Lightning DataModule for the ShanghaiTech Campus
+dataset. If the dataset is not available locally, it will be downloaded and
+extracted automatically. The video files are also converted to a format readable
+by pyav.
+
+Example:
+    Create a ShanghaiTech datamodule::
+
+        >>> from anomalib.data import ShanghaiTech
+        >>> datamodule = ShanghaiTech(
+        ...     root="./datasets/shanghaitech",
+        ...     scene=1,
+        ...     clip_length_in_frames=2,
+        ...     frames_between_clips=1,
+        ... )
+        >>> datamodule.setup()
+        >>> i, data = next(enumerate(datamodule.train_dataloader()))
+        >>> data.keys()
+        dict_keys(['image', 'video_path', 'frames', 'label'])
+
+Notes:
+    The directory structure after preparation will be::
+
+        root/
+        ├── testing/
+        │   ├── frames/
+        │   ├── test_frame_mask/
+        │   └── test_pixel_mask/
+        └── training/
+            ├── frames/
+            ├── converted_videos/
+            └── videos/
 
 License:
     ShanghaiTech Campus Dataset is released under the BSD 2-Clause License.
 
 Reference:
-    - W. Liu and W. Luo, D. Lian and S. Gao. "Future Frame Prediction for Anomaly Detection -- A New Baseline."
-      IEEE Conference on Computer Vision and Pattern Recognition (CVPR). 2018.
+    Liu, W., Luo, W., Lian, D., & Gao, S. (2018). Future frame prediction for
+    anomaly detection--a new baseline. In Proceedings of the IEEE conference on
+    computer vision and pattern recognition (pp. 6536-6545).
 """
 
 # Copyright (C) 2023-2024 Intel Corporation
@@ -39,17 +68,31 @@ class ShanghaiTech(AnomalibVideoDataModule):
     """ShanghaiTech DataModule class.
 
     Args:
-        root (Path | str): Path to the root of the dataset
-        scene (int): Index of the dataset scene (category) in range [1, 13]
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
-        train_batch_size (int, optional): Training batch size. Defaults to 32.
-        eval_batch_size (int, optional): Test batch size. Defaults to 32.
-        num_workers (int, optional): Number of workers. Defaults to 8.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+        root (Path | str): Path to the root directory of the dataset.
+            Defaults to ``"./datasets/shanghaitech"``.
+        scene (int): Scene index in range [1, 13].
+            Defaults to ``1``.
+        clip_length_in_frames (int): Number of frames in each video clip.
+            Defaults to ``2``.
+        frames_between_clips (int): Number of frames between consecutive clips.
+            Defaults to ``1``.
+        target_frame (VideoTargetFrame): Specifies which frame in the clip should
+            be used for ground truth.
+            Defaults to ``VideoTargetFrame.LAST``.
+        train_batch_size (int): Training batch size.
+            Defaults to ``32``.
+        eval_batch_size (int): Test batch size.
+            Defaults to ``32``.
+        num_workers (int): Number of workers for data loading.
+            Defaults to ``8``.
+        val_split_mode (ValSplitMode): Setting that determines how validation
+            subset is obtained.
+            Defaults to ``ValSplitMode.SAME_AS_TEST``.
+        val_split_ratio (float): Fraction of train or test images that will be
+            reserved for validation.
+            Defaults to ``0.5``.
+        seed (int | None): Random seed for reproducibility.
+            Defaults to ``None``.
     """
 
     def __init__(
@@ -125,19 +168,25 @@ def prepare_data(self) -> None:
 
     @staticmethod
     def _convert_training_videos(video_folder: Path, target_folder: Path) -> None:
-        """Re-code the training videos to ensure correct reading of frames by torchvision.
+        """Re-code training videos for correct frame reading by torchvision.
 
-        The encoding of the raw video files in the ShanghaiTech dataset causes some problems when
-        reading the frames using pyav. To prevent this, we read the frames from the video files using opencv,
-        and write them to a new video file that can be parsed correctly with pyav.
+        The encoding of the raw video files in the ShanghaiTech dataset causes
+        issues when reading frames using pyav. To prevent this, frames are read
+        using opencv and written to new video files that can be parsed correctly
+        with pyav.
 
         Args:
-            video_folder (Path): Path to the folder of training videos.
-            target_folder (Path): File system location where the converted videos will be stored.
+            video_folder (Path): Path to the folder containing training videos.
+            target_folder (Path): Path where converted videos will be stored.
         """
         training_videos = sorted(video_folder.glob("*"))
         for video_idx, video_path in enumerate(training_videos):
-            logger.info("Converting training video %s (%i/%i)...", video_path.name, video_idx + 1, len(training_videos))
+            logger.info(
+                "Converting training video %s (%i/%i)...",
+                video_path.name,
+                video_idx + 1,
+                len(training_videos),
+            )
             file_name = video_path.name
             target_path = target_folder / file_name
             convert_video(video_path, target_path, codec="XVID")
diff --git a/src/anomalib/data/datamodules/video/ucsd_ped.py b/src/anomalib/data/datamodules/video/ucsd_ped.py
index e08bfd1ca6..e4bd9cf15e 100644
--- a/src/anomalib/data/datamodules/video/ucsd_ped.py
+++ b/src/anomalib/data/datamodules/video/ucsd_ped.py
@@ -1,4 +1,9 @@
-"""UCSD Pedestrian Data Module."""
+"""UCSD Pedestrian Data Module.
+
+This module provides a PyTorch Lightning data module for the UCSD Pedestrian dataset.
+The dataset consists of surveillance videos of pedestrians, with anomalies defined as
+non-pedestrian entities like cars, bikes, etc.
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -22,20 +27,35 @@
 
 
 class UCSDped(AnomalibVideoDataModule):
-    """UCSDped DataModule class.
+    """UCSD Pedestrian DataModule Class.
 
     Args:
-        root (Path | str): Path to the root of the dataset
-        category (str): Sub-category of the dataset, e.g. "UCSDped1" or "UCSDped2"
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval
-        train_batch_size (int, optional): Training batch size. Defaults to 32.
-        eval_batch_size (int, optional): Test batch size. Defaults to 32.
-        num_workers (int, optional): Number of workers. Defaults to 8.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
+        root (Path | str): Path to the root directory where the dataset will be
+            downloaded and extracted. Defaults to ``"./datasets/ucsd"``.
+        category (str): Dataset subcategory. Must be either ``"UCSDped1"`` or
+            ``"UCSDped2"``. Defaults to ``"UCSDped2"``.
+        clip_length_in_frames (int): Number of frames in each video clip.
+            Defaults to ``2``.
+        frames_between_clips (int): Number of frames between consecutive video
+            clips. Defaults to ``10``.
+        target_frame (VideoTargetFrame): Specifies which frame in the clip should
+            be used for ground truth. Defaults to ``VideoTargetFrame.LAST``.
+        train_batch_size (int): Batch size for training. Defaults to ``8``.
+        eval_batch_size (int): Batch size for validation and testing.
+            Defaults to ``8``.
+        num_workers (int): Number of workers for data loading. Defaults to ``8``.
+        val_split_mode (ValSplitMode): Determines how validation set is created.
+            Defaults to ``ValSplitMode.SAME_AS_TEST``.
+        val_split_ratio (float): Fraction of data to use for validation.
+            Must be between 0 and 1. Defaults to ``0.5``.
+        seed (int | None): Random seed for reproducibility. Defaults to ``None``.
+
+    Example:
+        >>> datamodule = UCSDped(root="./datasets/ucsd")
+        >>> datamodule.setup()  # Downloads and prepares the dataset
+        >>> train_loader = datamodule.train_dataloader()
+        >>> val_loader = datamodule.val_dataloader()
+        >>> test_loader = datamodule.test_dataloader()
     """
 
     def __init__(
@@ -69,6 +89,11 @@ def __init__(
         self.target_frame = VideoTargetFrame(target_frame)
 
     def _setup(self, _stage: str | None = None) -> None:
+        """Set up train and test datasets.
+
+        Args:
+            _stage (str | None): Stage for Lightning. Can be "fit" or "test".
+        """
         self.train_data = UCSDpedDataset(
             clip_length_in_frames=self.clip_length_in_frames,
             frames_between_clips=self.frames_between_clips,
@@ -88,7 +113,11 @@ def _setup(self, _stage: str | None = None) -> None:
         )
 
     def prepare_data(self) -> None:
-        """Download the dataset if not available."""
+        """Download and extract the dataset if not already available.
+
+        The method checks if the dataset directory exists. If not, it downloads
+        and extracts the dataset to the specified root directory.
+        """
         if (self.root / self.category).is_dir():
             logger.info("Found the dataset.")
         else:
diff --git a/src/anomalib/data/datasets/__init__.py b/src/anomalib/data/datasets/__init__.py
index 32e3995ea5..7011b7373a 100644
--- a/src/anomalib/data/datasets/__init__.py
+++ b/src/anomalib/data/datasets/__init__.py
@@ -1,4 +1,37 @@
-"""Torch Dataset Implementations of Anomalib Datasets."""
+"""PyTorch Dataset implementations for anomaly detection.
+
+This module provides dataset implementations for various anomaly detection tasks:
+
+Base Classes:
+    - ``AnomalibDataset``: Base class for all Anomalib datasets
+    - ``AnomalibDepthDataset``: Base class for 3D/depth datasets
+    - ``AnomalibVideoDataset``: Base class for video datasets
+
+Depth Datasets:
+    - ``Folder3DDataset``: Custom RGB-D dataset from folder structure
+    - ``MVTec3DDataset``: MVTec 3D AD dataset with industrial objects
+
+Image Datasets:
+    - ``BTechDataset``: BTech dataset containing industrial objects
+    - ``DatumaroDataset``: Dataset in Datumaro format (Intel Geti™ export)
+    - ``FolderDataset``: Custom dataset from folder structure
+    - ``KolektorDataset``: Kolektor surface defect dataset
+    - ``MVTecDataset``: MVTec AD dataset with industrial objects
+    - ``VisaDataset``: Visual Inspection of Surface Anomalies dataset
+
+Video Datasets:
+    - ``AvenueDataset``: CUHK Avenue dataset for abnormal event detection
+    - ``ShanghaiTechDataset``: ShanghaiTech Campus surveillance dataset
+    - ``UCSDpedDataset``: UCSD Pedestrian dataset for anomaly detection
+
+Example:
+    >>> from anomalib.data.datasets import MVTecDataset
+    >>> dataset = MVTecDataset(
+    ...     root="./datasets/MVTec",
+    ...     category="bottle",
+    ...     split="train"
+    ... )
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/datasets/base/__init__.py b/src/anomalib/data/datasets/base/__init__.py
index b39af32f4c..5a72b52378 100644
--- a/src/anomalib/data/datasets/base/__init__.py
+++ b/src/anomalib/data/datasets/base/__init__.py
@@ -1,4 +1,15 @@
-"""Base Classes for Torch Datasets."""
+"""Base Classes for Torch Datasets.
+
+This module contains the base dataset classes used in anomalib for different data
+modalities:
+
+- ``AnomalibDataset``: Base class for image datasets
+- ``AnomalibVideoDataset``: Base class for video datasets
+- ``AnomalibDepthDataset``: Base class for depth/3D datasets
+
+These classes extend PyTorch's Dataset class with additional functionality specific
+to anomaly detection tasks.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/datasets/base/depth.py b/src/anomalib/data/datasets/base/depth.py
index 5dd4683b6c..d15bcdac1b 100644
--- a/src/anomalib/data/datasets/base/depth.py
+++ b/src/anomalib/data/datasets/base/depth.py
@@ -1,4 +1,8 @@
-"""Base Depth Dataset."""
+"""Base Depth Dataset.
+
+This module implements the base depth dataset class for anomaly detection tasks that
+use RGB-D (RGB + Depth) data.
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -22,9 +26,22 @@
 class AnomalibDepthDataset(AnomalibDataset, ABC):
     """Base depth anomalib dataset class.
 
+    This class extends ``AnomalibDataset`` to handle RGB-D data for anomaly
+    detection tasks. It supports both classification and segmentation tasks.
+
     Args:
-        transform (Transform, optional): Transforms that should be applied to the input images.
+        transform (Transform | None, optional): Transforms to be applied to the
+            input images and depth maps. If ``None``, no transforms are applied.
             Defaults to ``None``.
+
+    Example:
+        >>> from anomalib.data.datasets import AnomalibDepthDataset
+        >>> dataset = AnomalibDepthDataset(transform=None)
+        >>> item = dataset[0]
+        >>> item.image.shape
+        torch.Size([3, H, W])
+        >>> item.depth_map.shape
+        torch.Size([1, H, W])
     """
 
     def __init__(self, transform: Transform | None = None) -> None:
@@ -33,13 +50,24 @@ def __init__(self, transform: Transform | None = None) -> None:
         self.transform = transform
 
     def __getitem__(self, index: int) -> DepthItem:
-        """Return rgb image, depth image and mask.
+        """Get dataset item for the given index.
 
         Args:
-            index (int): Index of the item to be returned.
+            index (int): Index of the item to retrieve.
 
         Returns:
-            dict[str, str | torch.Tensor]: Dictionary containing the image, depth image and mask.
+            DepthItem: Dataset item containing the following fields:
+                - image (Tensor): RGB image
+                - depth_map (Tensor): Depth map
+                - gt_mask (Tensor | None): Ground truth mask for segmentation
+                - gt_label (int): Ground truth label (0: normal, 1: anomalous)
+                - image_path (str): Path to the RGB image
+                - depth_path (str): Path to the depth map
+                - mask_path (str | None): Path to the ground truth mask
+
+        Raises:
+            ValueError: If the task type is neither classification nor
+                segmentation.
         """
         image_path = self.samples.iloc[index].image_path
         mask_path = self.samples.iloc[index].mask_path
@@ -83,5 +111,9 @@ def __getitem__(self, index: int) -> DepthItem:
 
     @property
     def collate_fn(self) -> Callable:
-        """Return the collate function for depth batches."""
+        """Get the collate function for creating depth batches.
+
+        Returns:
+            Callable: Collate function that creates ``DepthBatch`` objects.
+        """
         return DepthBatch.collate
diff --git a/src/anomalib/data/datasets/base/image.py b/src/anomalib/data/datasets/base/image.py
index 9bc8c45e74..4c5267ea2c 100644
--- a/src/anomalib/data/datasets/base/image.py
+++ b/src/anomalib/data/datasets/base/image.py
@@ -1,4 +1,30 @@
-"""Anomalib dataset base class."""
+"""Anomalib dataset base class.
+
+This module provides the base dataset class for Anomalib datasets. The dataset is based on a
+dataframe that contains the information needed by the dataloader to load each dataset item
+into memory.
+
+The samples dataframe must be set from the subclass using the setter of the ``samples``
+property.
+
+The DataFrame must include at least the following columns:
+    - ``split`` (str): The subset to which the dataset item is assigned (e.g., 'train',
+      'test').
+    - ``image_path`` (str): Path to the file system location where the image is stored.
+    - ``label_index`` (int): Index of the anomaly label, typically 0 for 'normal' and 1 for
+      'anomalous'.
+    - ``mask_path`` (str, optional): Path to the ground truth masks (for anomalous images
+      only). Required if task is 'segmentation'.
+
+Example DataFrame:
+    >>> df = pd.DataFrame({
+    ...     'image_path': ['path/to/image.png'],
+    ...     'label': ['anomalous'],
+    ...     'label_index': [1],
+    ...     'mask_path': ['path/to/mask.png'],
+    ...     'split': ['train']
+    ... })
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -26,34 +52,27 @@
 
 
 class AnomalibDataset(Dataset, ABC):
-    """Anomalib dataset.
+    """Base class for Anomalib datasets.
 
-    The dataset is based on a dataframe that contains the information needed by the dataloader to load each of
-    the dataset items into memory.
+    The dataset is designed to work with image-based anomaly detection tasks. It supports
+    both classification and segmentation tasks.
 
-    The samples dataframe must be set from the subclass using the setter of the `samples` property.
-
-    The DataFrame must, at least, include the following columns:
-        - `split` (str): The subset to which the dataset item is assigned (e.g., 'train', 'test').
-        - `image_path` (str): Path to the file system location where the image is stored.
-        - `label_index` (int): Index of the anomaly label, typically 0 for 'normal' and 1 for 'anomalous'.
-        - `mask_path` (str, optional): Path to the ground truth masks (for the anomalous images only).
-        Required if task is 'segmentation'.
+    Args:
+        transform (Transform | None, optional): Transforms to be applied to the input images.
+            Defaults to ``None``.
 
-    Example DataFrame:
-        +---+-------------------+-----------+-------------+------------------+-------+
-        |   | image_path        | label     | label_index | mask_path        | split |
-        +---+-------------------+-----------+-------------+------------------+-------+
-        | 0 | path/to/image.png | anomalous | 1           | path/to/mask.png | train |
-        +---+-------------------+-----------+-------------+------------------+-------+
+    Example:
+        >>> from torchvision.transforms.v2 import Resize
+        >>> dataset = AnomalibDataset(transform=Resize((256, 256)))
+        >>> len(dataset)  # Get dataset length
+        100
+        >>> item = dataset[0]  # Get first item
+        >>> item.image.shape
+        torch.Size([3, 256, 256])
 
     Note:
-        The example above is illustrative and may need to be adjusted based on the specific dataset structure.
-
-    Args:
-        task (str): Task type, either 'classification' or 'segmentation'
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
+        This is an abstract base class. Subclasses must implement the required methods and
+        set the samples DataFrame.
     """
 
     def __init__(self, transform: Transform | None = None) -> None:
@@ -64,7 +83,17 @@ def __init__(self, transform: Transform | None = None) -> None:
 
     @property
     def name(self) -> str:
-        """Name of the dataset."""
+        """Get the name of the dataset.
+
+        Returns:
+            str: Name of the dataset derived from the class name, with 'Dataset' suffix
+                removed if present.
+
+        Example:
+            >>> dataset = AnomalibDataset()
+            >>> dataset.name
+            'Anomalib'
+        """
         class_name = self.__class__.__name__
 
         # Remove the `_dataset` suffix from the class name
@@ -74,16 +103,35 @@ def name(self) -> str:
         return class_name
 
     def __len__(self) -> int:
-        """Get length of the dataset."""
+        """Get length of the dataset.
+
+        Returns:
+            int: Number of samples in the dataset.
+
+        Raises:
+            RuntimeError: If samples DataFrame is not set.
+        """
         return len(self.samples)
 
     def subsample(self, indices: Sequence[int], inplace: bool = False) -> "AnomalibDataset":
-        """Subsamples the dataset at the provided indices.
+        """Create a subset of the dataset using the provided indices.
 
         Args:
             indices (Sequence[int]): Indices at which the dataset is to be subsampled.
-            inplace (bool): When true, the subsampling will be performed on the instance itself.
-                Defaults to ``False``.
+            inplace (bool, optional): When true, modify the instance itself. Defaults to
+                ``False``.
+
+        Returns:
+            AnomalibDataset: Subsampled dataset.
+
+        Raises:
+            ValueError: If duplicate indices are provided.
+
+        Example:
+            >>> dataset = AnomalibDataset()
+            >>> subset = dataset.subsample([0, 1, 2])
+            >>> len(subset)
+            3
         """
         if len(set(indices)) != len(indices):
             msg = "No duplicates allowed in indices."
@@ -94,21 +142,41 @@ def subsample(self, indices: Sequence[int], inplace: bool = False) -> "AnomalibD
 
     @property
     def samples(self) -> DataFrame:
-        """Get the samples dataframe."""
+        """Get the samples DataFrame.
+
+        Returns:
+            DataFrame: DataFrame containing dataset samples.
+
+        Raises:
+            RuntimeError: If samples DataFrame has not been set.
+        """
         if self._samples is None:
             msg = (
-                "Dataset does not have a samples dataframe. Ensure that a dataframe has been assigned to "
-                "`dataset.samples`."
+                "Dataset does not have a samples dataframe. Ensure that a dataframe has "
+                "been assigned to `dataset.samples`."
             )
             raise RuntimeError(msg)
         return self._samples
 
     @samples.setter
     def samples(self, samples: DataFrame) -> None:
-        """Overwrite the samples with a new dataframe.
+        """Set the samples DataFrame.
 
         Args:
-            samples (DataFrame): DataFrame with new samples.
+            samples (DataFrame): DataFrame containing dataset samples.
+
+        Raises:
+            TypeError: If samples is not a pandas DataFrame.
+            ValueError: If required columns are missing.
+            FileNotFoundError: If any image paths do not exist.
+
+        Example:
+            >>> df = pd.DataFrame({
+            ...     'image_path': ['image.png'],
+            ...     'split': ['train']
+            ... })
+            >>> dataset = AnomalibDataset()
+            >>> dataset.samples = df
         """
         # validate the passed samples by checking the
         if not isinstance(samples, DataFrame):
@@ -127,37 +195,69 @@ def samples(self, samples: DataFrame) -> None:
 
     @property
     def category(self) -> str | None:
-        """Get the category of the dataset."""
+        """Get the category of the dataset.
+
+        Returns:
+            str | None: Dataset category if set, else None.
+        """
         return self._category
 
     @category.setter
     def category(self, category: str) -> None:
-        """Set the category of the dataset."""
+        """Set the category of the dataset.
+
+        Args:
+            category (str): Category to assign to the dataset.
+        """
         self._category = category
 
     @property
     def has_normal(self) -> bool:
-        """Check if the dataset contains any normal samples."""
+        """Check if the dataset contains normal samples.
+
+        Returns:
+            bool: True if dataset contains normal samples, False otherwise.
+        """
         return LabelName.NORMAL in list(self.samples.label_index)
 
     @property
     def has_anomalous(self) -> bool:
-        """Check if the dataset contains any anomalous samples."""
+        """Check if the dataset contains anomalous samples.
+
+        Returns:
+            bool: True if dataset contains anomalous samples, False otherwise.
+        """
         return LabelName.ABNORMAL in list(self.samples.label_index)
 
     @property
     def task(self) -> TaskType:
-        """Infer the task type from the dataset."""
+        """Get the task type from the dataset.
+
+        Returns:
+            TaskType: Type of task (classification or segmentation).
+
+        Raises:
+            ValueError: If task type is unknown.
+        """
         return TaskType(self.samples.attrs["task"])
 
     def __getitem__(self, index: int) -> DatasetItem:
-        """Get dataset item for the index ``index``.
+        """Get dataset item for the given index.
 
         Args:
             index (int): Index to get the item.
 
         Returns:
-            DatasetItem: DatasetItem instance containing image and ground truth (if available).
+            DatasetItem: Dataset item containing image and ground truth (if available).
+
+        Raises:
+            ValueError: If task type is unknown.
+
+        Example:
+            >>> dataset = AnomalibDataset()
+            >>> item = dataset[0]
+            >>> isinstance(item.image, torch.Tensor)
+            True
         """
         image_path = self.samples.iloc[index].image_path
         mask_path = self.samples.iloc[index].mask_path
@@ -198,6 +298,14 @@ def __add__(self, other_dataset: "AnomalibDataset") -> "AnomalibDataset":
 
         Returns:
             AnomalibDataset: Concatenated dataset.
+
+        Raises:
+            TypeError: If datasets are not of the same type.
+
+        Example:
+            >>> dataset1 = AnomalibDataset()
+            >>> dataset2 = AnomalibDataset()
+            >>> combined = dataset1 + dataset2
         """
         if not isinstance(other_dataset, self.__class__):
             msg = "Cannot concatenate datasets that are not of the same type."
@@ -208,9 +316,13 @@ def __add__(self, other_dataset: "AnomalibDataset") -> "AnomalibDataset":
 
     @property
     def collate_fn(self) -> Callable:
-        """Get the collate function for the items returned by this dataset.
+        """Get the collate function for batching dataset items.
+
+        Returns:
+            Callable: Collate function from ImageBatch.
 
-        By default, the dataset is an image dataset, so we will return the ImageBatch's collate function.
-        Other dataset types should override this property.
+        Note:
+            By default, this returns ImageBatch's collate function. Override this property
+            for other dataset types.
         """
         return ImageBatch.collate
diff --git a/src/anomalib/data/datasets/base/video.py b/src/anomalib/data/datasets/base/video.py
index 4b8366aae4..2e675aa717 100644
--- a/src/anomalib/data/datasets/base/video.py
+++ b/src/anomalib/data/datasets/base/video.py
@@ -1,4 +1,21 @@
-"""Base Torch Video Dataset."""
+"""Base Torch Video Dataset.
+
+This module implements the base video dataset class for anomaly detection tasks that
+use video data. The dataset is designed to work with video clips and supports both
+classification and segmentation tasks.
+
+Example:
+    >>> from anomalib.data.datasets import AnomalibVideoDataset
+    >>> dataset = AnomalibVideoDataset(
+    ...     clip_length_in_frames=8,
+    ...     frames_between_clips=1,
+    ...     transform=None,
+    ...     target_frame="last"
+    ... )
+    >>> item = dataset[0]
+    >>> item.image.shape
+    torch.Size([C, H, W])
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -22,7 +39,14 @@
 class VideoTargetFrame(str, Enum):
     """Target frame for a video-clip.
 
-    Used in multi-frame models to determine which frame's ground truth information will be used.
+    Used in multi-frame models to determine which frame's ground truth information
+    will be used.
+
+    Args:
+        FIRST: Use the first frame in the clip as target
+        LAST: Use the last frame in the clip as target
+        MID: Use the middle frame in the clip as target
+        ALL: Use all frames in the clip as target
     """
 
     FIRST = "first"
@@ -34,13 +58,30 @@ class VideoTargetFrame(str, Enum):
 class AnomalibVideoDataset(AnomalibDataset, ABC):
     """Base video anomalib dataset class.
 
+    This class extends ``AnomalibDataset`` to handle video data for anomaly
+    detection tasks. It supports both classification and segmentation tasks.
+
     Args:
         clip_length_in_frames (int): Number of video frames in each clip.
-        frames_between_clips (int): Number of frames between each consecutive video clip.
-        transform (Transform, optional): Transforms that should be applied to the input clips.
-            Defaults to ``None``.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
+        frames_between_clips (int): Number of frames between each consecutive
+            video clip.
+        transform (Transform | None, optional): Transforms to be applied to the
+            input clips. Defaults to ``None``.
+        target_frame (VideoTargetFrame, optional): Specifies the target frame in
+            the video clip, used for ground truth retrieval.
             Defaults to ``VideoTargetFrame.LAST``.
+
+    Example:
+        >>> from torchvision.transforms.v2 import Resize
+        >>> dataset = AnomalibVideoDataset(
+        ...     clip_length_in_frames=8,
+        ...     frames_between_clips=1,
+        ...     transform=Resize((256, 256)),
+        ...     target_frame="last"
+        ... )
+        >>> item = dataset[0]
+        >>> item.image.shape
+        torch.Size([C, H, W])
     """
 
     def __init__(
@@ -62,7 +103,14 @@ def __init__(
         self.target_frame = target_frame
 
     def __len__(self) -> int:
-        """Get length of the dataset."""
+        """Get length of the dataset.
+
+        Returns:
+            int: Number of clips in the dataset.
+
+        Raises:
+            TypeError: If ``self.indexer`` is not an instance of ``ClipsIndexer``.
+        """
         if not isinstance(self.indexer, ClipsIndexer):
             msg = "self.indexer must be an instance of ClipsIndexer."
             raise TypeError(msg)
@@ -70,7 +118,11 @@ def __len__(self) -> int:
 
     @property
     def samples(self) -> DataFrame:
-        """Get the samples dataframe."""
+        """Get the samples dataframe.
+
+        Returns:
+            DataFrame: DataFrame containing dataset samples.
+        """
         return super().samples
 
     @samples.setter
@@ -89,7 +141,10 @@ def samples(self, samples: DataFrame) -> None:
     def _setup_clips(self) -> None:
         """Compute the video and frame indices of the subvideos.
 
-        Should be called after each change to self._samples
+        Should be called after each change to ``self._samples``.
+
+        Raises:
+            TypeError: If ``self.indexer_cls`` is not callable.
         """
         if not callable(self.indexer_cls):
             msg = "self.indexer_cls must be callable."
@@ -105,13 +160,13 @@ def _select_targets(self, item: VideoItem) -> VideoItem:
         """Select the target frame from the clip.
 
         Args:
-            item (DatasetItem): Item containing the clip information.
+            item (VideoItem): Item containing the clip information.
+
+        Returns:
+            VideoItem: Selected item from the clip.
 
         Raises:
             ValueError: If the target frame is not one of the supported options.
-
-        Returns:
-            DatasetItem: Selected item from the clip.
         """
         if self.target_frame == VideoTargetFrame.FIRST:
             idx = 0
@@ -134,13 +189,17 @@ def _select_targets(self, item: VideoItem) -> VideoItem:
         return item
 
     def __getitem__(self, index: int) -> VideoItem:
-        """Get the dataset item for the index ``index``.
+        """Get the dataset item for the index.
 
         Args:
             index (int): Index of the item to be returned.
 
         Returns:
-            DatasetItem: Dictionary containing the mask, clip and file system information.
+            VideoItem: Dataset item containing the mask, clip and file system
+                information.
+
+        Raises:
+            TypeError: If ``self.indexer`` is not an instance of ``ClipsIndexer``.
         """
         if not isinstance(self.indexer, ClipsIndexer):
             msg = "self.indexer must be an instance of ClipsIndexer."
@@ -169,5 +228,9 @@ def __getitem__(self, index: int) -> VideoItem:
 
     @property
     def collate_fn(self) -> Callable:
-        """Return the collate function for video batches."""
+        """Return the collate function for video batches.
+
+        Returns:
+            Callable: Collate function for creating video batches.
+        """
         return VideoBatch.collate
diff --git a/src/anomalib/data/datasets/depth/__init__.py b/src/anomalib/data/datasets/depth/__init__.py
index 7d7c5361ee..f77d0ead0d 100644
--- a/src/anomalib/data/datasets/depth/__init__.py
+++ b/src/anomalib/data/datasets/depth/__init__.py
@@ -1,4 +1,26 @@
-"""Torch Dataset Implementations of Anomalib Depth Datasets."""
+"""Torch Dataset Implementations of Anomalib Depth Datasets.
+
+This module provides dataset implementations for working with RGB-D (depth) data in
+anomaly detection tasks. The following datasets are available:
+
+- ``Folder3DDataset``: Custom dataset for loading RGB-D data from a folder structure
+- ``MVTec3DDataset``: Implementation of the MVTec 3D-AD dataset
+
+Example:
+    >>> from anomalib.data.datasets import Folder3DDataset
+    >>> dataset = Folder3DDataset(
+    ...     name="custom",
+    ...     root="datasets/custom",
+    ...     normal_dir="normal",
+    ...     normal_depth_dir="normal_depth"
+    ... )
+
+    >>> from anomalib.data.datasets import MVTec3DDataset
+    >>> dataset = MVTec3DDataset(
+    ...     root="datasets/MVTec3D",
+    ...     category="bagel"
+    ... )
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/datasets/depth/folder_3d.py b/src/anomalib/data/datasets/depth/folder_3d.py
index 0e5247c7bc..5e5d15b3b8 100644
--- a/src/anomalib/data/datasets/depth/folder_3d.py
+++ b/src/anomalib/data/datasets/depth/folder_3d.py
@@ -1,6 +1,29 @@
-"""Custom Folder Dataset.
-
-This script creates a custom dataset from a folder.
+"""Custom Folder Dataset for 3D anomaly detection.
+
+This module provides a custom dataset class that loads RGB-D data from a folder
+structure. The dataset supports both classification and segmentation tasks.
+
+The folder structure should contain RGB images and their corresponding depth maps.
+The dataset can be configured with separate directories for:
+
+- Normal training samples
+- Normal test samples (optional)
+- Abnormal test samples (optional)
+- Mask annotations (optional, for segmentation)
+- Depth maps for each image type
+
+Example:
+    >>> from pathlib import Path
+    >>> from anomalib.data.datasets import Folder3DDataset
+    >>> dataset = Folder3DDataset(
+    ...     name="custom",
+    ...     root="datasets/custom",
+    ...     normal_dir="normal",
+    ...     abnormal_dir="abnormal",
+    ...     normal_depth_dir="normal_depth",
+    ...     abnormal_depth_dir="abnormal_depth",
+    ...     mask_dir="ground_truth"
+    ... )
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -18,38 +41,43 @@
 
 
 class Folder3DDataset(AnomalibDepthDataset):
-    """Folder dataset.
+    """Dataset class for loading RGB-D data from a custom folder structure.
 
     Args:
-        name (str): Name of the dataset.
-        transform (Transform): Transforms that should be applied to the input images.
-        normal_dir (str | Path): Path to the directory containing normal images.
-        root (str | Path | None): Root folder of the dataset.
-            Defaults to ``None``.
-        abnormal_dir (str | Path | None, optional): Path to the directory containing abnormal images.
-            Defaults to ``None``.
-        normal_test_dir (str | Path | None, optional): Path to the directory containing
-            normal images for the test dataset.
-            Defaults to ``None``.
-        mask_dir (str | Path | None, optional): Path to the directory containing
-            the mask annotations.
-            Defaults to ``None``.
-        normal_depth_dir (str | Path | None, optional): Path to the directory containing
-            normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir`
+        name (str): Name of the dataset
+        normal_dir (str | Path): Path to directory containing normal images
+        root (str | Path | None, optional): Root directory of the dataset.
             Defaults to ``None``.
-        abnormal_depth_dir (str | Path | None, optional): Path to the directory containing abnormal depth images for
-            the test dataset.
-            Defaults to ``None``.
-        normal_test_depth_dir (str | Path | None, optional): Path to the directory containing
-            normal depth images for the test dataset. Normal test images will be a split of `normal_dir` if `None`.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Fixed subset split that follows from folder structure on file system.
-            Choose from [Split.FULL, Split.TRAIN, Split.TEST]
-            Defaults to ``None``.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
+        abnormal_dir (str | Path | None, optional): Path to directory containing
+            abnormal images. Defaults to ``None``.
+        normal_test_dir (str | Path | None, optional): Path to directory
+            containing normal test images. If not provided, normal test images
+            will be split from ``normal_dir``. Defaults to ``None``.
+        mask_dir (str | Path | None, optional): Path to directory containing
+            ground truth masks. Required for segmentation. Defaults to ``None``.
+        normal_depth_dir (str | Path | None, optional): Path to directory
+            containing depth maps for normal images. Defaults to ``None``.
+        abnormal_depth_dir (str | Path | None, optional): Path to directory
+            containing depth maps for abnormal images. Defaults to ``None``.
+        normal_test_depth_dir (str | Path | None, optional): Path to directory
+            containing depth maps for normal test images. Defaults to ``None``.
+        transform (Transform | None, optional): Transforms to apply to the images.
             Defaults to ``None``.
+        split (str | Split | None, optional): Dataset split to load.
+            One of ``["train", "test", "full"]``. Defaults to ``None``.
+        extensions (tuple[str, ...] | None, optional): Image file extensions to
+            include. Defaults to ``None``.
+
+    Example:
+        >>> dataset = Folder3DDataset(
+        ...     name="custom",
+        ...     root="./datasets/custom",
+        ...     normal_dir="train/good",
+        ...     abnormal_dir="test/defect",
+        ...     mask_dir="test/ground_truth",
+        ...     normal_depth_dir="train/good_depth",
+        ...     abnormal_depth_dir="test/defect_depth"
+        ... )
     """
 
     def __init__(
@@ -96,9 +124,10 @@ def __init__(
 
     @property
     def name(self) -> str:
-        """Name of the dataset.
+        """Get dataset name.
 
-        Folder3D dataset overrides the name property to provide a custom name.
+        Returns:
+            str: Name of the dataset
         """
         return self._name
 
@@ -115,35 +144,38 @@ def make_folder3d_dataset(
     split: str | Split | None = None,
     extensions: tuple[str, ...] | None = None,
 ) -> DataFrame:
-    """Make Folder Dataset.
+    """Create a dataset by collecting files from a folder structure.
+
+    The function creates a DataFrame containing paths to RGB images, depth maps,
+    and masks (if available) along with their corresponding labels.
 
     Args:
-        normal_dir (str | Path): Path to the directory containing normal images.
-        root (str | Path | None): Path to the root directory of the dataset.
-            Defaults to ``None``.
-        abnormal_dir (str | Path | None, optional): Path to the directory containing abnormal images.
-            Defaults to ``None``.
-        normal_test_dir (str | Path | None, optional): Path to the directory containing normal images for the test
-        dataset. Normal test images will be a split of `normal_dir` if `None`.
-            Defaults to ``None``.
-        mask_dir (str | Path | None, optional): Path to the directory containing the mask annotations.
-            Defaults to ``None``.
-        normal_depth_dir (str | Path | None, optional): Path to the directory containing
-            normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir`
-            Defaults to ``None``.
-        abnormal_depth_dir (str | Path | None, optional): Path to the directory containing abnormal depth images for
-            the test dataset.
-            Defaults to ``None``.
-        normal_test_depth_dir (str | Path | None, optional): Path to the directory containing normal depth images for
-            the test dataset. Normal test images will be a split of `normal_dir` if `None`.
-            Defaults to ``None``.
-        split (str | Split | None, optional): Dataset split (ie., Split.FULL, Split.TRAIN or Split.TEST).
-            Defaults to ``None``.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
+        normal_dir (str | Path): Directory containing normal images
+        root (str | Path | None, optional): Root directory. Defaults to ``None``.
+        abnormal_dir (str | Path | None, optional): Directory containing abnormal
+            images. Defaults to ``None``.
+        normal_test_dir (str | Path | None, optional): Directory containing
+            normal test images. Defaults to ``None``.
+        mask_dir (str | Path | None, optional): Directory containing ground truth
+            masks. Defaults to ``None``.
+        normal_depth_dir (str | Path | None, optional): Directory containing
+            depth maps for normal images. Defaults to ``None``.
+        abnormal_depth_dir (str | Path | None, optional): Directory containing
+            depth maps for abnormal images. Defaults to ``None``.
+        normal_test_depth_dir (str | Path | None, optional): Directory containing
+            depth maps for normal test images. Defaults to ``None``.
+        split (str | Split | None, optional): Dataset split to return.
             Defaults to ``None``.
+        extensions (tuple[str, ...] | None, optional): Image file extensions to
+            include. Defaults to ``None``.
 
     Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+        DataFrame: Dataset samples with columns for paths and labels
+
+    Raises:
+        ValueError: If ``normal_dir`` is not a directory
+        FileNotFoundError: If depth maps or mask files are missing
+        MisMatchError: If depth maps don't match their RGB images
     """
     normal_dir = validate_and_resolve_path(normal_dir, root)
     abnormal_dir = validate_and_resolve_path(abnormal_dir, root) if abnormal_dir else None
diff --git a/src/anomalib/data/datasets/depth/mvtec_3d.py b/src/anomalib/data/datasets/depth/mvtec_3d.py
index 6dd8ed3752..52873a0e8d 100644
--- a/src/anomalib/data/datasets/depth/mvtec_3d.py
+++ b/src/anomalib/data/datasets/depth/mvtec_3d.py
@@ -1,19 +1,20 @@
-"""MVTec 3D-AD Datamodule (CC BY-NC-SA 4.0).
+"""MVTec 3D-AD Datamodule.
 
-Description:
-    This script contains PyTorch Dataset, Dataloader and PyTorch Lightning DataModule for the MVTec 3D-AD dataset.
-    If the dataset is not on the file system, the script downloads and extracts the dataset and create PyTorch data
-    objects.
+This module provides PyTorch Dataset, Dataloader and PyTorch Lightning DataModule for
+the MVTec 3D-AD dataset. If the dataset is not available locally, it will be
+downloaded and extracted automatically.
 
 License:
-    MVTec 3D-AD dataset is released under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
-        License (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
+    MVTec 3D-AD dataset is released under the Creative Commons
+    Attribution-NonCommercial-ShareAlike 4.0 International License (CC BY-NC-SA 4.0)
+    https://creativecommons.org/licenses/by-nc-sa/4.0/
 
 Reference:
-    - Paul Bergmann, Xin Jin, David Sattlegger, Carsten Steger: The MVTec 3D-AD Dataset for Unsupervised 3D Anomaly
-        Detection and Localization in: Proceedings of the 17th International Joint Conference on Computer Vision,
-        Imaging and Computer Graphics Theory and Applications - Volume 5: VISAPP, 202-213, 2022, DOI: 10.5220/
-        0010865000003124.
+    Paul Bergmann, Xin Jin, David Sattlegger, Carsten Steger: The MVTec 3D-AD
+    Dataset for Unsupervised 3D Anomaly Detection and Localization. In: Proceedings
+    of the 17th International Joint Conference on Computer Vision, Imaging and
+    Computer Graphics Theory and Applications - Volume 5: VISAPP, 202-213, 2022
+    DOI: 10.5220/0010865000003124
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -30,21 +31,40 @@
 from anomalib.data.utils import LabelName, Split, validate_path
 
 IMG_EXTENSIONS = [".png", ".PNG", ".tiff"]
-CATEGORIES = ("bagel", "cable_gland", "carrot", "cookie", "dowel", "foam", "peach", "potato", "rope", "tire")
+CATEGORIES = (
+    "bagel",
+    "cable_gland",
+    "carrot",
+    "cookie",
+    "dowel",
+    "foam",
+    "peach",
+    "potato",
+    "rope",
+    "tire",
+)
 
 
 class MVTec3DDataset(AnomalibDepthDataset):
     """MVTec 3D dataset class.
 
     Args:
-        root (Path | str): Path to the root of the dataset
+        root (Path | str): Path to the root of the dataset.
             Defaults to ``"./datasets/MVTec3D"``.
-        category (str): Sub-category of the dataset, e.g. 'bagel'
+        category (str): Category name, e.g. ``"bagel"``.
             Defaults to ``"bagel"``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+        transform (Transform, optional): Transforms applied to input images.
             Defaults to ``None``.
+        split (str | Split | None): Dataset split - usually ``Split.TRAIN`` or
+            ``Split.TEST``. Defaults to ``None``.
+
+    Example:
+        >>> from pathlib import Path
+        >>> dataset = MVTec3DDataset(
+        ...     root=Path("./datasets/MVTec3D"),
+        ...     category="bagel",
+        ...     split="train"
+        ... )
     """
 
     def __init__(
@@ -58,7 +78,11 @@ def __init__(
 
         self.root_category = Path(root) / Path(category)
         self.split = split
-        self.samples = make_mvtec_3d_dataset(self.root_category, split=self.split, extensions=IMG_EXTENSIONS)
+        self.samples = make_mvtec_3d_dataset(
+            self.root_category,
+            split=self.split,
+            extensions=IMG_EXTENSIONS,
+        )
 
 
 def make_mvtec_3d_dataset(
@@ -66,45 +90,44 @@ def make_mvtec_3d_dataset(
     split: str | Split | None = None,
     extensions: Sequence[str] | None = None,
 ) -> DataFrame:
-    """Create MVTec 3D-AD samples by parsing the MVTec AD data file structure.
+    """Create MVTec 3D-AD samples by parsing the data directory structure.
 
-    The files are expected to follow this structure:
-    - `path/to/dataset/split/category/image_filename.png`
-    - `path/to/dataset/ground_truth/category/mask_filename.png`
+    The files are expected to follow this structure::
 
-    This function creates a DataFrame to store the parsed information. The DataFrame follows this format:
+        path/to/dataset/split/category/image_filename.png
+        path/to/dataset/ground_truth/category/mask_filename.png
 
-    +---+---------------+-------+---------+---------------+---------------------------------------+-------------+
-    |   | path          | split | label   | image_path    | mask_path                             | label_index |
-    +---+---------------+-------+---------+---------------+---------------------------------------+-------------+
-    | 0 | datasets/name | test  | defect  | filename.png  | ground_truth/defect/filename_mask.png | 1           |
-    +---+---------------+-------+---------+---------------+---------------------------------------+-------------+
+    The function creates a DataFrame with the following format::
+
+        +---+---------------+-------+---------+---------------+--------------------+
+        |   | path          | split | label   | image_path    | mask_path         |
+        +---+---------------+-------+---------+---------------+--------------------+
+        | 0 | datasets/name | test  | defect  | filename.png  | defect/mask.png   |
+        +---+---------------+-------+---------+---------------+--------------------+
 
     Args:
-        root (Path): Path to the dataset.
-        split (str | Split | None, optional): Dataset split (e.g., 'train' or 'test').
-            Defaults to ``None``.
-        extensions (Sequence[str] | None, optional): List of file extensions to be included in the dataset.
+        root (Path | str): Path to the dataset root directory.
+        split (str | Split | None, optional): Dataset split (e.g., ``"train"`` or
+            ``"test"``). Defaults to ``None``.
+        extensions (Sequence[str] | None, optional): List of valid file extensions.
             Defaults to ``None``.
 
-    Examples:
-        The following example shows how to get training samples from the MVTec 3D-AD 'bagel' category:
+    Returns:
+        DataFrame: DataFrame containing the dataset samples.
 
+    Example:
         >>> from pathlib import Path
-        >>> root = Path('./MVTec3D')
-        >>> category = 'bagel'
-        >>> path = root / category
-        >>> print(path)
-        PosixPath('MVTec3D/bagel')
-
-        >>> samples = create_mvtec_3d_ad_samples(path, split='train')
-        >>> print(samples.head())
-            path          split label image_path                          mask_path                        label_index
-            MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/105.png MVTec3D/bagel/ground_truth/good/gt/105.png 0
-            MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/017.png MVTec3D/bagel/ground_truth/good/gt/017.png 0
-
-    Returns:
-        DataFrame: An output DataFrame containing the samples of the dataset.
+        >>> root = Path("./datasets/MVTec3D/bagel")
+        >>> samples = make_mvtec_3d_dataset(root, split="train")
+        >>> samples.head()
+           path     split label image_path                  mask_path
+        0  MVTec3D  train good  train/good/rgb/105.png     gt/105.png
+        1  MVTec3D  train good  train/good/rgb/017.png     gt/017.png
+
+    Raises:
+        RuntimeError: If no images are found in the root directory.
+        MisMatchError: If there is a mismatch between images and their
+            corresponding mask/depth files.
     """
     if extensions is None:
         extensions = IMG_EXTENSIONS
@@ -115,7 +138,10 @@ def make_mvtec_3d_dataset(
         msg = f"Found 0 images in {root}"
         raise RuntimeError(msg)
 
-    samples = DataFrame(samples_list, columns=["path", "split", "label", "type", "file_name"])
+    samples = DataFrame(
+        samples_list,
+        columns=["path", "split", "label", "type", "file_name"],
+    )
 
     # Modify image_path column by converting to absolute path
     samples.loc[(samples.type == "rgb"), "image_path"] = (
@@ -159,9 +185,11 @@ def make_mvtec_3d_dataset(
         .all()
     )
     if not mismatch_masks:
-        msg = """Mismatch between anomalous images and ground truth masks. Make sure the mask files
-          in 'ground_truth' folder follow the same naming convention as the anomalous images in
-          the dataset (e.g. image: '000.png', mask: '000.png' or '000_mask.png')."""
+        msg = (
+            "Mismatch between anomalous images and ground truth masks. Ensure mask "
+            "files in 'ground_truth' folder follow the same naming convention as "
+            "the anomalous images (e.g. image: '000.png', mask: '000.png')."
+        )
         raise MisMatchError(msg)
 
     mismatch_depth = (
@@ -170,9 +198,11 @@ def make_mvtec_3d_dataset(
         .all()
     )
     if not mismatch_depth:
-        msg = """Mismatch between anomalous images and depth images. Make sure the mask files in
-          'xyz' folder follow the same naming convention as the anomalous images in the dataset
-          (e.g. image: '000.png', depth: '000.tiff')."""
+        msg = (
+            "Mismatch between anomalous images and depth images. Ensure depth "
+            "files in 'xyz' folder follow the same naming convention as the "
+            "anomalous images (e.g. image: '000.png', depth: '000.tiff')."
+        )
         raise MisMatchError(msg)
 
     # infer the task type
diff --git a/src/anomalib/data/datasets/image/__init__.py b/src/anomalib/data/datasets/image/__init__.py
index b7749dad18..e319b8a36f 100644
--- a/src/anomalib/data/datasets/image/__init__.py
+++ b/src/anomalib/data/datasets/image/__init__.py
@@ -1,4 +1,23 @@
-"""Torch Dataset Implementations of Anomalib Image Datasets."""
+"""PyTorch Dataset implementations for anomaly detection in images.
+
+This module provides dataset implementations for various image anomaly detection
+datasets:
+
+- ``BTechDataset``: BTech dataset containing industrial objects
+- ``DatumaroDataset``: Dataset in Datumaro format (Intel Geti™ export)
+- ``FolderDataset``: Custom dataset from folder structure
+- ``KolektorDataset``: Kolektor surface defect dataset
+- ``MVTecDataset``: MVTec AD dataset with industrial objects
+- ``VisaDataset``: Visual Inspection of Surface Anomalies dataset
+
+Example:
+    >>> from anomalib.data.datasets import MVTecDataset
+    >>> dataset = MVTecDataset(
+    ...     root="./datasets/MVTec",
+    ...     category="bottle",
+    ...     split="train"
+    ... )
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/datasets/image/btech.py b/src/anomalib/data/datasets/image/btech.py
index 3078c99e12..04e4278491 100644
--- a/src/anomalib/data/datasets/image/btech.py
+++ b/src/anomalib/data/datasets/image/btech.py
@@ -1,9 +1,21 @@
 """BTech Dataset.
 
-This script contains PyTorch Dataset for the BTech dataset.
-
-If the dataset is not on the file system, the script downloads and
-extracts the dataset and create PyTorch data objects.
+This module provides PyTorch Dataset implementation for the BTech dataset. The
+dataset will be downloaded and extracted automatically if not found locally.
+
+The dataset contains 3 categories of industrial objects with both normal and
+anomalous samples. Each category includes RGB images and pixel-level ground truth
+masks for anomaly segmentation.
+
+License:
+    BTech dataset is released under the Creative Commons
+    Attribution-NonCommercial-ShareAlike 4.0 International License
+    (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+Reference:
+    Mishra, P., Verk, C., Fornasier, D., & Piciarelli, C. (2021). VT-ADL: A
+    Vision Transformer Network for Image Anomaly Detection and Localization. In
+    IEEE International Conference on Image Processing (ICIP), 2021.
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -22,41 +34,38 @@
 
 
 class BTechDataset(AnomalibDataset):
-    """Btech Dataset class.
+    """BTech dataset class.
+
+    Dataset class for loading and processing BTech dataset images. Supports both
+    classification and segmentation tasks.
 
     Args:
-        root: Path to the BTech dataset
-        category: Name of the BTech category.
-        transform (Transform, optional): Transforms that should be applied to the input images.
+        root (Path | str): Path to root directory containing the dataset.
+        category (str): Category name, must be one of ``CATEGORIES``.
+        transform (Transform | None, optional): Transforms to apply to the images.
             Defaults to ``None``.
-        split: 'train', 'val' or 'test'
-        create_validation_set: Create a validation subset in addition to the train and test subsets
+        split (str | Split | None, optional): Dataset split - usually
+            ``Split.TRAIN`` or ``Split.TEST``. Defaults to ``None``.
 
-    Examples:
-        >>> from anomalib.data.image.btech import BTechDataset
-        >>> from anomalib.data.utils.transforms import get_transforms
-        >>> transform = get_transforms(image_size=256)
+    Example:
+        >>> from pathlib import Path
+        >>> from anomalib.data.datasets import BTechDataset
         >>> dataset = BTechDataset(
-        ...     transform=transform,
-        ...     root='./datasets/BTech',
-        ...     category='01',
+        ...     root=Path("./datasets/btech"),
+        ...     category="01",
+        ...     split="train"
         ... )
         >>> dataset[0].keys()
-        >>> dataset.setup()
         dict_keys(['image'])
 
         >>> dataset.split = "test"
         >>> dataset[0].keys()
         dict_keys(['image', 'image_path', 'label'])
 
-        >>> dataset.split = "train"
-        >>> dataset[0].keys()
-        dict_keys(['image'])
-
+        >>> # For segmentation task
         >>> dataset.split = "test"
         >>> dataset[0].keys()
         dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
-
         >>> dataset[0]["image"].shape, dataset[0]["mask"].shape
         (torch.Size([3, 256, 256]), torch.Size([256, 256]))
     """
@@ -80,36 +89,35 @@ def make_btech_dataset(path: Path, split: str | Split | None = None) -> DataFram
 
     The files are expected to follow the structure:
 
-        .. code-block:: bash
+    .. code-block:: bash
 
-            path/to/dataset/split/category/image_filename.png
-            path/to/dataset/ground_truth/category/mask_filename.png
+        path/to/dataset/
+        ├── split/
+        │   └── category/
+        │       └── image_filename.png
+        └── ground_truth/
+            └── category/
+                └── mask_filename.png
 
     Args:
-        path (Path): Path to dataset
-        split (str | Split | None, optional): Dataset split (ie., either train or test).
-            Defaults to ``None``.
+        path (Path): Path to dataset directory.
+        split (str | Split | None, optional): Dataset split - usually
+            ``Split.TRAIN`` or ``Split.TEST``. Defaults to ``None``.
 
     Example:
-        The following example shows how to get training samples from BTech 01 category:
-
-        .. code-block:: python
-
-            >>> root = Path('./BTech')
-            >>> category = '01'
-            >>> path = root / category
-            >>> path
-            PosixPath('BTech/01')
-
-            >>> samples = make_btech_dataset(path, split='train')
-            >>> samples.head()
-            path     split label image_path                  mask_path                     label_index
-            0  BTech/01 train 01    BTech/01/train/ok/105.bmp BTech/01/ground_truth/ok/105.png      0
-            1  BTech/01 train 01    BTech/01/train/ok/017.bmp BTech/01/ground_truth/ok/017.png      0
-            ...
+        >>> from pathlib import Path
+        >>> path = Path("./datasets/btech/01")
+        >>> samples = make_btech_dataset(path, split="train")
+        >>> samples.head()
+           path        split label image_path              mask_path          label_index
+        0  BTech/01   train ok    BTech/01/train/ok/105.bmp BTech/01/gt/ok/105.png  0
+        1  BTech/01   train ok    BTech/01/train/ok/017.bmp BTech/01/gt/ok/017.png  0
 
     Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+        DataFrame: DataFrame containing samples for the requested split.
+
+    Raises:
+        RuntimeError: If no images are found in the dataset directory.
     """
     path = validate_path(path)
 
diff --git a/src/anomalib/data/datasets/image/datumaro.py b/src/anomalib/data/datasets/image/datumaro.py
index 9335f0a4b4..e6a65c0c54 100644
--- a/src/anomalib/data/datasets/image/datumaro.py
+++ b/src/anomalib/data/datasets/image/datumaro.py
@@ -1,6 +1,30 @@
 """Dataloader for Datumaro format.
 
-Note: This currently only works for annotations exported from Intel Geti™.
+This module provides PyTorch Dataset implementation for loading images and
+annotations in Datumaro format. Currently only supports annotations exported from
+Intel Geti™.
+
+The dataset expects the following directory structure::
+
+    dataset/
+    ├── annotations/
+    │    └── default.json
+    └── images/
+        └── default/
+                ├── image1.jpg
+                ├── image2.jpg
+                └── ...
+
+The ``default.json`` file contains image paths and label annotations in Datumaro
+format.
+
+Example:
+    >>> from pathlib import Path
+    >>> from anomalib.data.datasets import DatumaroDataset
+    >>> dataset = DatumaroDataset(
+    ...     root=Path("./datasets/datumaro"),
+    ...     split="train"
+    ... )
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -16,39 +40,33 @@
 from anomalib.data.utils import LabelName, Split
 
 
-def make_datumaro_dataset(root: str | Path, split: str | Split | None = None) -> pd.DataFrame:
-    """Make Datumaro Dataset.
-
-    Assumes the following directory structure:
-
-    dataset
-    ├── annotations
-    │    └── default.json
-    └── images
-        └── default
-                ├── image1.jpg
-                ├── image2.jpg
-                └── ...
+def make_datumaro_dataset(
+    root: str | Path,
+    split: str | Split | None = None,
+) -> pd.DataFrame:
+    """Create a DataFrame of image samples from a Datumaro dataset.
 
     Args:
         root (str | Path): Path to the dataset root directory.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST.
-            Defaults to ``None``.
-
-    Examples:
-        >>> root = Path("path/to/dataset")
-        >>> samples = make_datumaro_dataset(root)
-        >>> samples.head()
-            image_path	label	label_index	split	mask_path
-        0	path/to/dataset...	Normal	0	Split.TRAIN
-        1	path/to/dataset...	Normal	0	Split.TRAIN
-        2	path/to/dataset...	Normal	0	Split.TRAIN
-        3	path/to/dataset...	Normal	0	Split.TRAIN
-        4	path/to/dataset...	Normal	0	Split.TRAIN
-
+        split (str | Split | None, optional): Dataset split to load. Usually
+            ``Split.TRAIN`` or ``Split.TEST``. Defaults to ``None``.
 
     Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test).
+        pd.DataFrame: DataFrame containing samples with columns:
+            - ``image_path``: Path to the image file
+            - ``label``: Class label name
+            - ``label_index``: Numeric label index
+            - ``split``: Dataset split
+            - ``mask_path``: Path to mask file (empty for classification)
+
+    Example:
+        >>> root = Path("./datasets/datumaro")
+        >>> samples = make_datumaro_dataset(root)
+        >>> samples.head()  # doctest: +NORMALIZE_WHITESPACE
+           image_path  label  label_index      split mask_path
+        0  path/...   Normal           0  Split.TRAIN
+        1  path/...   Normal           0  Split.TRAIN
+        2  path/...   Normal           0  Split.TRAIN
     """
     annotation_file = Path(root) / "annotations" / "default.json"
     with annotation_file.open() as f:
@@ -67,7 +85,7 @@ def make_datumaro_dataset(root: str | Path, split: str | Split | None = None) ->
             "label": label,
             "label_index": label_index,
             "split": None,
-            "mask_path": "",  # mask is provided in the annotation file and is not on disk.
+            "mask_path": "",  # mask is provided in annotation file
         })
     samples_df = pd.DataFrame(
         samples,
@@ -75,7 +93,7 @@ def make_datumaro_dataset(root: str | Path, split: str | Split | None = None) ->
         index=range(len(samples)),
     )
     # Create test/train split
-    # By default assign all "Normal" samples to train and all "Anomalous" samples to test
+    # By default assign all "Normal" samples to train and all "Anomalous" to test
     samples_df.loc[samples_df["label_index"] == LabelName.NORMAL, "split"] = Split.TRAIN
     samples_df.loc[samples_df["label_index"] == LabelName.ABNORMAL, "split"] = Split.TEST
 
@@ -90,30 +108,24 @@ def make_datumaro_dataset(root: str | Path, split: str | Split | None = None) ->
 
 
 class DatumaroDataset(AnomalibDataset):
-    """Datumaro dataset class.
+    """Dataset class for loading Datumaro format datasets.
 
     Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
         root (str | Path): Path to the dataset root directory.
-        transform (Transform, optional): Transforms that should be applied to the input images.
+        transform (Transform | None, optional): Transforms to apply to the images.
             Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
-            Defaults to ``None``.
-
-
-    Examples:
-        .. code-block:: python
-
-            from anomalib.data.image.datumaro import DatumaroDataset
-            from torchvision.transforms.v2 import Resize
-
-            dataset = DatumaroDataset(root=root,
-                task="classification",
-                transform=Resize((256, 256)),
-            )
-            print(dataset[0].keys())
-            # Output: dict_keys(['dm_format_version', 'infos', 'categories', 'items'])
-
+        split (str | Split | None, optional): Dataset split to load. Usually
+            ``Split.TRAIN`` or ``Split.TEST``. Defaults to ``None``.
+
+    Example:
+        >>> from pathlib import Path
+        >>> from torchvision.transforms.v2 import Resize
+        >>> from anomalib.data.datasets import DatumaroDataset
+        >>> dataset = DatumaroDataset(
+        ...     root=Path("./datasets/datumaro"),
+        ...     transform=Resize((256, 256)),
+        ...     split="train"
+        ... )
     """
 
     def __init__(
diff --git a/src/anomalib/data/datasets/image/folder.py b/src/anomalib/data/datasets/image/folder.py
index 08e01d85c2..dc64e06af8 100644
--- a/src/anomalib/data/datasets/image/folder.py
+++ b/src/anomalib/data/datasets/image/folder.py
@@ -1,6 +1,22 @@
 """Custom Folder Dataset.
 
-This script creates a custom PyTorch Dataset from a folder.
+This module provides a custom PyTorch Dataset implementation for loading images
+from a folder structure. The dataset supports both classification and
+segmentation tasks.
+
+The folder structure should contain normal images and optionally abnormal images,
+test images, and mask annotations.
+
+Example:
+    >>> from pathlib import Path
+    >>> from anomalib.data.datasets import FolderDataset
+    >>> dataset = FolderDataset(
+    ...     name="custom",
+    ...     root="datasets/custom",
+    ...     normal_dir="normal",
+    ...     abnormal_dir="abnormal",
+    ...     mask_dir="ground_truth"
+    ... )
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -19,49 +35,55 @@
 
 
 class FolderDataset(AnomalibDataset):
-    """Folder dataset.
-
-    This class is used to create a dataset from a folder. The class utilizes the Torch Dataset class.
+    """Dataset class for loading images from a custom folder structure.
 
     Args:
-        name (str): Name of the dataset. This is used to name the datamodule, especially when logging/saving.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        normal_dir (str | Path | Sequence): Path to the directory containing normal images.
-        root (str | Path | None): Root folder of the dataset.
-            Defaults to ``None``.
-        abnormal_dir (str | Path | Sequence | None, optional): Path to the directory containing abnormal images.
+        name (str): Name of the dataset. Used for logging/saving.
+        normal_dir (str | Path | Sequence): Path to directory containing normal
+            images.
+        transform (Transform | None, optional): Transforms to apply to the images.
             Defaults to ``None``.
-        normal_test_dir (str | Path | Sequence | None, optional): Path to the directory containing
-            normal images for the test dataset.
+        root (str | Path | None, optional): Root directory of the dataset.
             Defaults to ``None``.
-        mask_dir (str | Path | Sequence | None, optional): Path to the directory containing
-            the mask annotations.
+        abnormal_dir (str | Path | Sequence | None, optional): Path to directory
+            containing abnormal images. Defaults to ``None``.
+        normal_test_dir (str | Path | Sequence | None, optional): Path to
+            directory containing normal test images. If not provided, normal test
+            images will be split from ``normal_dir``. Defaults to ``None``.
+        mask_dir (str | Path | Sequence | None, optional): Path to directory
+            containing ground truth masks. Required for segmentation.
             Defaults to ``None``.
-        split (str | Split | None): Fixed subset split that follows from folder structure on file system.
-            Choose from [Split.FULL, Split.TRAIN, Split.TEST]
-            Defaults to ``None``.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
+        split (str | Split | None, optional): Dataset split to load.
+            Choose from ``Split.FULL``, ``Split.TRAIN``, ``Split.TEST``.
             Defaults to ``None``.
+        extensions (tuple[str, ...] | None, optional): Image file extensions to
+            include. Defaults to ``None``.
 
     Examples:
-        Assume that we would like to use this ``FolderDataset`` to create a dataset from a folder for a classification
-        task. We could first create the transforms,
+        Create a classification dataset:
 
         >>> from anomalib.data.utils import InputNormalizationMethod, get_transforms
-        >>> transform = get_transforms(image_size=256, normalization=InputNormalizationMethod.NONE)
-
-        We could then create the dataset as follows,
-
-        .. code-block:: python
-
-            folder_dataset_classification_train = FolderDataset(
-                normal_dir=dataset_root / "good",
-                abnormal_dir=dataset_root / "crack",
-                split="train",
-                transform=transform,
-            )
-
+        >>> transform = get_transforms(
+        ...     image_size=256,
+        ...     normalization=InputNormalizationMethod.NONE
+        ... )
+        >>> dataset = FolderDataset(
+        ...     name="custom",
+        ...     normal_dir="datasets/custom/good",
+        ...     abnormal_dir="datasets/custom/defect",
+        ...     split="train",
+        ...     transform=transform
+        ... )
+
+        Create a segmentation dataset:
+
+        >>> dataset = FolderDataset(
+        ...     name="custom",
+        ...     normal_dir="datasets/custom/good",
+        ...     abnormal_dir="datasets/custom/defect",
+        ...     mask_dir="datasets/custom/ground_truth",
+        ...     split="test"
+        ... )
     """
 
     def __init__(
@@ -99,9 +121,10 @@ def __init__(
 
     @property
     def name(self) -> str:
-        """Name of the dataset.
+        """Get dataset name.
 
-        Folder dataset overrides the name property to provide a custom name.
+        Returns:
+            str: Name of the dataset
         """
         return self._name
 
@@ -115,64 +138,62 @@ def make_folder_dataset(
     split: str | Split | None = None,
     extensions: tuple[str, ...] | None = None,
 ) -> DataFrame:
-    """Make Folder Dataset.
+    """Create a dataset from a folder structure.
 
     Args:
-        normal_dir (str | Path | Sequence): Path to the directory containing normal images.
-        root (str | Path | None): Path to the root directory of the dataset.
+        normal_dir (str | Path | Sequence): Path to directory containing normal
+            images.
+        root (str | Path | None, optional): Root directory of the dataset.
             Defaults to ``None``.
-        abnormal_dir (str | Path | Sequence | None, optional): Path to the directory containing abnormal images.
+        abnormal_dir (str | Path | Sequence | None, optional): Path to directory
+            containing abnormal images. Defaults to ``None``.
+        normal_test_dir (str | Path | Sequence | None, optional): Path to
+            directory containing normal test images. If not provided, normal test
+            images will be split from ``normal_dir``. Defaults to ``None``.
+        mask_dir (str | Path | Sequence | None, optional): Path to directory
+            containing ground truth masks. Required for segmentation.
             Defaults to ``None``.
-        normal_test_dir (str | Path | Sequence | None, optional): Path to the directory containing normal images for
-            the test dataset. Normal test images will be a split of `normal_dir` if `None`.
-            Defaults to ``None``.
-        mask_dir (str | Path | Sequence | None, optional): Path to the directory containing the mask annotations.
-            Defaults to ``None``.
-        split (str | Split | None, optional): Dataset split (ie., Split.FULL, Split.TRAIN or Split.TEST).
-            Defaults to ``None``.
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory.
+        split (str | Split | None, optional): Dataset split to load.
+            Choose from ``Split.FULL``, ``Split.TRAIN``, ``Split.TEST``.
             Defaults to ``None``.
+        extensions (tuple[str, ...] | None, optional): Image file extensions to
+            include. Defaults to ``None``.
 
     Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test).
+        DataFrame: Dataset samples with columns for image paths, labels, splits
+            and mask paths (for segmentation).
 
     Examples:
-        Assume that we would like to use this ``make_folder_dataset`` to create a dataset from a folder.
-        We could then create the dataset as follows,
-
-        .. code-block:: python
-
-            folder_df = make_folder_dataset(
-                normal_dir=dataset_root / "good",
-                abnormal_dir=dataset_root / "crack",
-                split="train",
-            )
-            folder_df.head()
-
-        .. code-block:: bash
-
-                      image_path           label  label_index mask_path        split
-            0  ./toy/good/00.jpg  DirType.NORMAL            0            Split.TRAIN
-            1  ./toy/good/01.jpg  DirType.NORMAL            0            Split.TRAIN
-            2  ./toy/good/02.jpg  DirType.NORMAL            0            Split.TRAIN
-            3  ./toy/good/03.jpg  DirType.NORMAL            0            Split.TRAIN
-            4  ./toy/good/04.jpg  DirType.NORMAL            0            Split.TRAIN
+        Create a classification dataset:
+
+        >>> folder_df = make_folder_dataset(
+        ...     normal_dir="datasets/custom/good",
+        ...     abnormal_dir="datasets/custom/defect",
+        ...     split="train"
+        ... )
+        >>> folder_df.head()
+                  image_path           label  label_index mask_path    split
+        0  ./good/00.png     DirType.NORMAL            0            Split.TRAIN
+        1  ./good/01.png     DirType.NORMAL            0            Split.TRAIN
+        2  ./good/02.png     DirType.NORMAL            0            Split.TRAIN
+        3  ./good/03.png     DirType.NORMAL            0            Split.TRAIN
+        4  ./good/04.png     DirType.NORMAL            0            Split.TRAIN
     """
 
     def _resolve_path_and_convert_to_list(path: str | Path | Sequence[str | Path] | None) -> list[Path]:
         """Convert path to list of paths.
 
         Args:
-            path (str | Path | Sequence | None): Path to replace with Sequence[str | Path].
+            path (str | Path | Sequence | None): Path to convert.
+
+        Returns:
+            list[Path]: List of resolved paths.
 
         Examples:
             >>> _resolve_path_and_convert_to_list("dir")
             [Path("path/to/dir")]
             >>> _resolve_path_and_convert_to_list(["dir1", "dir2"])
             [Path("path/to/dir1"), Path("path/to/dir2")]
-
-        Returns:
-            list[Path]: The result of path replaced by Sequence[str | Path].
         """
         if isinstance(path, Sequence) and not isinstance(path, str):
             return [validate_and_resolve_path(dir_path, root) for dir_path in path]
@@ -232,15 +253,17 @@ def _resolve_path_and_convert_to_list(path: str | Path | Sequence[str | Path] |
             .apply(lambda x: Path(x.image_path).stem in Path(x.mask_path).stem, axis=1)
             .all()
         ):
-            msg = """Mismatch between anomalous images and mask images. Make sure the mask files "
-                     "folder follow the same naming convention as the anomalous images in the dataset "
-                     "(e.g. image: '000.png', mask: '000.png')."""
+            msg = """Mismatch between anomalous images and mask images. Make sure
+                the mask files folder follow the same naming convention as the
+                anomalous images in the dataset (e.g. image: '000.png',
+                mask: '000.png')."""
             raise MisMatchError(msg)
 
     else:
         samples["mask_path"] = ""
 
-    # remove all the rows with temporal image samples that have already been assigned
+    # remove all the rows with temporal image samples that have already been
+    # assigned
     samples = samples.loc[
         (samples.label == DirType.NORMAL) | (samples.label == DirType.ABNORMAL) | (samples.label == DirType.NORMAL_TEST)
     ]
@@ -253,7 +276,10 @@ def _resolve_path_and_convert_to_list(path: str | Path | Sequence[str | Path] |
     # By default, all the normal samples are assigned as train.
     #   and all the abnormal samples are test.
     samples.loc[(samples.label == DirType.NORMAL), "split"] = Split.TRAIN
-    samples.loc[(samples.label == DirType.ABNORMAL) | (samples.label == DirType.NORMAL_TEST), "split"] = Split.TEST
+    samples.loc[
+        (samples.label == DirType.ABNORMAL) | (samples.label == DirType.NORMAL_TEST),
+        "split",
+    ] = Split.TEST
 
     # infer the task type
     samples.attrs["task"] = "classification" if (samples["mask_path"] == "").all() else "segmentation"
diff --git a/src/anomalib/data/datasets/image/kolektor.py b/src/anomalib/data/datasets/image/kolektor.py
index 410d2191cf..a5ddfe6d97 100644
--- a/src/anomalib/data/datasets/image/kolektor.py
+++ b/src/anomalib/data/datasets/image/kolektor.py
@@ -1,17 +1,20 @@
 """Kolektor Surface-Defect Dataset.
 
 Description:
-    This script provides a PyTorch Dataset for the Kolektor
-    Surface-Defect dataset. The dataset can be accessed at `Kolektor Surface-Defect Dataset `_.
+    This module provides a PyTorch Dataset implementation for the Kolektor
+    Surface-Defect dataset. The dataset can be accessed at `Kolektor
+    Surface-Defect Dataset `_.
 
 License:
-    The Kolektor Surface-Defect dataset is released under the Creative Commons Attribution-NonCommercial-ShareAlike
-    4.0 International License (CC BY-NC-SA 4.0). For more details, visit
-    `Creative Commons License `_.
+    The Kolektor Surface-Defect dataset is released under the Creative Commons
+    Attribution-NonCommercial-ShareAlike 4.0 International License
+    (CC BY-NC-SA 4.0). For more details, visit `Creative Commons License
+    `_.
 
 Reference:
-    Tabernik, Domen, Samo Šela, Jure Skvarč, and Danijel Skočaj. "Segmentation-based deep-learning approach
-    for surface-defect detection." Journal of Intelligent Manufacturing 31, no. 3 (2020): 759-776.
+    Tabernik, Domen, Samo Šela, Jure Skvarč, and Danijel Skočaj.
+    "Segmentation-based deep-learning approach for surface-defect detection."
+    Journal of Intelligent Manufacturing 31, no. 3 (2020): 759-776.
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -34,13 +37,20 @@ class KolektorDataset(AnomalibDataset):
     """Kolektor dataset class.
 
     Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``
-        root (Path | str): Path to the root of the dataset
-            Defaults to ``./datasets/kolektor``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
-            Defaults to ``None``.
+        root (Path | str): Path to the root of the dataset.
+            Defaults to ``"./datasets/kolektor"``.
+        transform (Transform | None, optional): Transforms that should be applied
+            to the input images. Defaults to ``None``.
+        split (str | Split | None, optional): Split of the dataset, usually
+            ``Split.TRAIN`` or ``Split.TEST``. Defaults to ``None``.
+
+    Example:
+        >>> from pathlib import Path
+        >>> from anomalib.data.datasets import KolektorDataset
+        >>> dataset = KolektorDataset(
+        ...     root=Path("./datasets/kolektor"),
+        ...     split="train"
+        ... )
     """
 
     def __init__(
@@ -53,7 +63,11 @@ def __init__(
 
         self.root = root
         self.split = split
-        self.samples = make_kolektor_dataset(self.root, train_split_ratio=0.8, split=self.split)
+        self.samples = make_kolektor_dataset(
+            self.root,
+            train_split_ratio=0.8,
+            split=self.split,
+        )
 
 
 def make_kolektor_dataset(
@@ -64,40 +78,40 @@ def make_kolektor_dataset(
     """Create Kolektor samples by parsing the Kolektor data file structure.
 
     The files are expected to follow this structure:
-    - Image files: `path/to/dataset/item/image_filename.jpg`, `path/to/dataset/kos01/Part0.jpg`
-    - Mask files: `path/to/dataset/item/mask_filename.bmp`, `path/to/dataset/kos01/Part0_label.bmp`
-
-    This function creates a DataFrame to store the parsed information in the following format:
-
-    +---+-------------------+--------+-------+---------+-----------------------+------------------------+-------------+
-    |   | path              | item   | split | label   | image_path            | mask_path              | label_index |
-    +---+-------------------+--------+-------+---------+-----------------------+------------------------+-------------+
-    | 0 | KolektorSDD       | kos01  | test  | Bad     | /path/to/image_file   | /path/to/mask_file     | 1           |
-    +---+-------------------+--------+-------+---------+-----------------------+------------------------+-------------+
+        - Image files: ``path/to/dataset/item/image_filename.jpg``
+        - Mask files: ``path/to/dataset/item/mask_filename.bmp``
+
+    Example file paths:
+        - ``path/to/dataset/kos01/Part0.jpg``
+        - ``path/to/dataset/kos01/Part0_label.bmp``
+
+    This function creates a DataFrame with the following columns:
+        - ``path``: Base path to dataset
+        - ``item``: Item/component name
+        - ``split``: Dataset split (train/test)
+        - ``label``: Class label (Good/Bad)
+        - ``image_path``: Path to image file
+        - ``mask_path``: Path to mask file
+        - ``label_index``: Numeric label (0=good, 1=bad)
 
     Args:
-        root (Path): Path to the dataset.
-        train_split_ratio (float, optional): Ratio for splitting good images into train/test sets.
-            Defaults to ``0.8``.
-        split (str | Split | None, optional): Dataset split (either 'train' or 'test').
+        root (str | Path): Path to the dataset root directory.
+        train_split_ratio (float, optional): Ratio for splitting good images into
+            train/test sets. Defaults to ``0.8``.
+        split (str | Split | None, optional): Dataset split (train/test).
             Defaults to ``None``.
 
     Returns:
-        pandas.DataFrame: An output DataFrame containing the samples of the dataset.
+        DataFrame: DataFrame containing the dataset samples.
 
     Example:
-        The following example shows how to get training samples from the Kolektor Dataset:
-
         >>> from pathlib import Path
-        >>> root = Path('./KolektorSDD/')
-        >>> samples = create_kolektor_samples(root, train_split_ratio=0.8)
+        >>> root = Path('./datasets/kolektor')
+        >>> samples = make_kolektor_dataset(root, train_split_ratio=0.8)
         >>> samples.head()
-               path       item  split label   image_path                    mask_path                   label_index
-           0   KolektorSDD   kos01  train Good  KolektorSDD/kos01/Part0.jpg  KolektorSDD/kos01/Part0_label.bmp  0
-           1   KolektorSDD   kos01  train Good  KolektorSDD/kos01/Part1.jpg  KolektorSDD/kos01/Part1_label.bmp  0
-           2   KolektorSDD   kos01  train Good  KolektorSDD/kos01/Part2.jpg  KolektorSDD/kos01/Part2_label.bmp  0
-           3   KolektorSDD   kos01  test  Good  KolektorSDD/kos01/Part3.jpg  KolektorSDD/kos01/Part3_label.bmp  0
-           4   KolektorSDD   kos01  train Good  KolektorSDD/kos01/Part4.jpg  KolektorSDD/kos01/Part4_label.bmp  0
+           path     item  split label  image_path              mask_path   label_index
+        0  kolektor kos01 train  Good  kos01/Part0.jpg        Part0.bmp   0
+        1  kolektor kos01 train  Good  kos01/Part1.jpg        Part1.bmp   0
     """
     root = validate_path(root)
 
@@ -145,7 +159,17 @@ def make_kolektor_dataset(
     samples.loc[test_samples.index, "split"] = "test"
 
     # Reorder columns
-    samples = samples[["path", "item", "split", "label", "image_path", "mask_path", "label_index"]]
+    samples = samples[
+        [
+            "path",
+            "item",
+            "split",
+            "label",
+            "image_path",
+            "mask_path",
+            "label_index",
+        ]
+    ]
 
     # assert that the right mask files are associated with the right test images
     if not (
@@ -153,9 +177,10 @@ def make_kolektor_dataset(
         .apply(lambda x: Path(x.image_path).stem in Path(x.mask_path).stem, axis=1)
         .all()
     ):
-        msg = """Mismatch between anomalous images and ground truth masks. Make sure the mask files
-        follow the same naming convention as the anomalous images in the dataset
-        (e.g. image: 'Part0.jpg', mask: 'Part0_label.bmp')."""
+        msg = """Mismatch between anomalous images and ground truth masks. Make
+        sure the mask files follow the same naming convention as the anomalous
+        images in the dataset (e.g. image: 'Part0.jpg', mask:
+        'Part0_label.bmp')."""
         raise MisMatchError(msg)
 
     # infer the task type
@@ -175,14 +200,11 @@ def is_mask_anomalous(path: str) -> int:
         path (str): Path to the mask file.
 
     Returns:
-        int: 1 if the mask shows defects, 0 otherwise.
+        int: ``1`` if the mask shows defects, ``0`` otherwise.
 
     Example:
-        Assume that the following image is a mask for a defective image.
-        Then the function will return 1.
-
-        >>> from anomalib.data.image.kolektor import is_mask_anomalous
-        >>> path = './KolektorSDD/kos01/Part0_label.bmp'
+        >>> from anomalib.data.datasets.image.kolektor import is_mask_anomalous
+        >>> path = './datasets/kolektor/kos01/Part0_label.bmp'
         >>> is_mask_anomalous(path)
         1
     """
diff --git a/src/anomalib/data/datasets/image/mvtec.py b/src/anomalib/data/datasets/image/mvtec.py
index c07cdf34e4..63b95bee61 100644
--- a/src/anomalib/data/datasets/image/mvtec.py
+++ b/src/anomalib/data/datasets/image/mvtec.py
@@ -1,25 +1,27 @@
 """MVTec AD Dataset.
 
-Description:
-    This script contains PyTorch Dataset for the MVTec AD dataset.
-    If the dataset is not on the file system, the script downloads and extracts
-    the dataset and create PyTorch data objects.
+This module provides PyTorch Dataset implementation for the MVTec AD dataset. The
+dataset will be downloaded and extracted automatically if not found locally.
+
+The dataset contains 15 categories of industrial objects with both normal and
+anomalous samples. Each category includes RGB images and pixel-level ground truth
+masks for anomaly segmentation.
 
 License:
     MVTec AD dataset is released under the Creative Commons
     Attribution-NonCommercial-ShareAlike 4.0 International License
-    (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
-
-References:
-    - Paul Bergmann, Kilian Batzner, Michael Fauser, David Sattlegger, Carsten Steger:
-      The MVTec Anomaly Detection Dataset: A Comprehensive Real-World Dataset for
-      Unsupervised Anomaly Detection; in: International Journal of Computer Vision
-      129(4):1038-1059, 2021, DOI: 10.1007/s11263-020-01400-4.
-
-    - Paul Bergmann, Michael Fauser, David Sattlegger, Carsten Steger: MVTec AD —
-      A Comprehensive Real-World Dataset for Unsupervised Anomaly Detection;
-      in: IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR),
-      9584-9592, 2019, DOI: 10.1109/CVPR.2019.00982.
+    (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
+
+Reference:
+    Bergmann, P., Batzner, K., Fauser, M., Sattlegger, D., & Steger, C. (2021).
+    The MVTec Anomaly Detection Dataset: A Comprehensive Real-World Dataset for
+    Unsupervised Anomaly Detection. International Journal of Computer Vision,
+    129(4), 1038-1059.
+
+    Bergmann, P., Fauser, M., Sattlegger, D., & Steger, C. (2019). MVTec AD —
+    A Comprehensive Real-World Dataset for Unsupervised Anomaly Detection. In
+    IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR),
+    9584-9592.
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -58,49 +60,46 @@
 class MVTecDataset(AnomalibDataset):
     """MVTec dataset class.
 
+    Dataset class for loading and processing MVTec AD dataset images. Supports
+    both classification and segmentation tasks.
+
     Args:
-        root (Path | str): Path to the root of the dataset.
-            Defaults to ``./datasets/MVTec``.
-        category (str): Sub-category of the dataset, e.g. 'bottle'
-            Defaults to ``bottle``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+        root (Path | str): Path to root directory containing the dataset.
+            Defaults to ``"./datasets/MVTec"``.
+        category (str): Category name, must be one of ``CATEGORIES``.
+            Defaults to ``"bottle"``.
+        transform (Transform | None, optional): Transforms to apply to the images.
             Defaults to ``None``.
+        split (str | Split | None, optional): Dataset split - usually
+            ``Split.TRAIN`` or ``Split.TEST``. Defaults to ``None``.
 
-    Examples:
-        .. code-block:: python
-
-            from anomalib.data.image.mvtec import MVTecDataset
-            from anomalib.data.utils.transforms import get_transforms
-
-            transform = get_transforms(image_size=256)
-            dataset = MVTecDataset(
-                task="classification",
-                transform=transform,
-                root='./datasets/MVTec',
-                category='zipper',
-            )
-            dataset.setup()
-            print(dataset[0].keys())
-            # Output: dict_keys(['image_path', 'label', 'image'])
-
-        When the task is segmentation, the dataset will also contain the mask:
+    Example:
+        >>> from pathlib import Path
+        >>> from anomalib.data.datasets import MVTecDataset
+        >>> dataset = MVTecDataset(
+        ...     root=Path("./datasets/MVTec"),
+        ...     category="bottle",
+        ...     split="train"
+        ... )
 
-        .. code-block:: python
+        For classification tasks, each sample contains:
 
-            dataset.task = "segmentation"
-            dataset.setup()
-            print(dataset[0].keys())
-            # Output: dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask'])
+        >>> sample = dataset[0]
+        >>> list(sample.keys())
+        ['image_path', 'label', 'image']
 
-        The image is a torch tensor of shape (C, H, W) and the mask is a torch tensor of shape (H, W).
+        For segmentation tasks, samples also include mask paths and masks:
 
-        .. code-block:: python
+        >>> dataset.task = "segmentation"
+        >>> sample = dataset[0]
+        >>> list(sample.keys())
+        ['image_path', 'label', 'image', 'mask_path', 'mask']
 
-            print(dataset[0]["image"].shape, dataset[0]["mask"].shape)
-            # Output: (torch.Size([3, 256, 256]), torch.Size([256, 256]))
+        Images are PyTorch tensors with shape ``(C, H, W)``, masks have shape
+        ``(H, W)``:
 
+        >>> sample["image"].shape, sample["mask"].shape
+        (torch.Size([3, 256, 256]), torch.Size([256, 256]))
     """
 
     def __init__(
@@ -115,7 +114,11 @@ def __init__(
         self.root_category = Path(root) / Path(category)
         self.category = category
         self.split = split
-        self.samples = make_mvtec_dataset(self.root_category, split=self.split, extensions=IMG_EXTENSIONS)
+        self.samples = make_mvtec_dataset(
+            self.root_category,
+            split=self.split,
+            extensions=IMG_EXTENSIONS,
+        )
 
 
 def make_mvtec_dataset(
@@ -123,47 +126,39 @@ def make_mvtec_dataset(
     split: str | Split | None = None,
     extensions: Sequence[str] | None = None,
 ) -> DataFrame:
-    """Create MVTec AD samples by parsing the MVTec AD data file structure.
+    """Create MVTec AD samples by parsing the data directory structure.
 
     The files are expected to follow the structure:
-        path/to/dataset/split/category/image_filename.png
-        path/to/dataset/ground_truth/category/mask_filename.png
-
-    This function creates a dataframe to store the parsed information based on the following format:
-
-    +---+---------------+-------+---------+---------------+---------------------------------------+-------------+
-    |   | path          | split | label   | image_path    | mask_path                             | label_index |
-    +===+===============+=======+=========+===============+=======================================+=============+
-    | 0 | datasets/name | test  | defect  | filename.png  | ground_truth/defect/filename_mask.png | 1           |
-    +---+---------------+-------+---------+---------------+---------------------------------------+-------------+
+        ``path/to/dataset/split/category/image_filename.png``
+        ``path/to/dataset/ground_truth/category/mask_filename.png``
 
     Args:
-        root (Path): Path to dataset
-        split (str | Split | None, optional): Dataset split (ie., either train or test).
+        root (Path | str): Path to dataset root directory
+        split (str | Split | None, optional): Dataset split (train or test)
             Defaults to ``None``.
-        extensions (Sequence[str] | None, optional): List of file extensions to be included in the dataset.
+        extensions (Sequence[str] | None, optional): Valid file extensions
             Defaults to ``None``.
 
-    Examples:
-        The following example shows how to get training samples from MVTec AD bottle category:
-
-        >>> root = Path('./MVTec')
-        >>> category = 'bottle'
-        >>> path = root / category
-        >>> path
-        PosixPath('MVTec/bottle')
-
-        >>> samples = make_mvtec_dataset(path, split='train', split_ratio=0.1, seed=0)
+    Returns:
+        DataFrame: Dataset samples with columns:
+            - path: Base path to dataset
+            - split: Dataset split (train/test)
+            - label: Class label
+            - image_path: Path to image file
+            - mask_path: Path to mask file (if available)
+            - label_index: Numeric label (0=normal, 1=abnormal)
+
+    Example:
+        >>> root = Path("./datasets/MVTec/bottle")
+        >>> samples = make_mvtec_dataset(root, split="train")
         >>> samples.head()
-           path         split label image_path                           mask_path                   label_index
-        0  MVTec/bottle train good MVTec/bottle/train/good/105.png MVTec/bottle/ground_truth/good/105_mask.png 0
-        1  MVTec/bottle train good MVTec/bottle/train/good/017.png MVTec/bottle/ground_truth/good/017_mask.png 0
-        2  MVTec/bottle train good MVTec/bottle/train/good/137.png MVTec/bottle/ground_truth/good/137_mask.png 0
-        3  MVTec/bottle train good MVTec/bottle/train/good/152.png MVTec/bottle/ground_truth/good/152_mask.png 0
-        4  MVTec/bottle train good MVTec/bottle/train/good/109.png MVTec/bottle/ground_truth/good/109_mask.png 0
+           path                split label image_path           mask_path label_index
+        0  datasets/MVTec/bottle train good  [...]/good/105.png           0
+        1  datasets/MVTec/bottle train good  [...]/good/017.png           0
 
-    Returns:
-        DataFrame: an output dataframe containing the samples of the dataset.
+    Raises:
+        RuntimeError: If no valid images are found
+        MisMatchError: If anomalous images and masks don't match
     """
     if extensions is None:
         extensions = IMG_EXTENSIONS
@@ -185,8 +180,14 @@ def make_mvtec_dataset(
     samples.label_index = samples.label_index.astype(int)
 
     # separate masks from samples
-    mask_samples = samples.loc[samples.split == "ground_truth"].sort_values(by="image_path", ignore_index=True)
-    samples = samples[samples.split != "ground_truth"].sort_values(by="image_path", ignore_index=True)
+    mask_samples = samples.loc[samples.split == "ground_truth"].sort_values(
+        by="image_path",
+        ignore_index=True,
+    )
+    samples = samples[samples.split != "ground_truth"].sort_values(
+        by="image_path",
+        ignore_index=True,
+    )
 
     # assign mask paths to anomalous test images
     samples["mask_path"] = ""
@@ -199,11 +200,17 @@ def make_mvtec_dataset(
     abnormal_samples = samples.loc[samples.label_index == LabelName.ABNORMAL]
     if (
         len(abnormal_samples)
-        and not abnormal_samples.apply(lambda x: Path(x.image_path).stem in Path(x.mask_path).stem, axis=1).all()
+        and not abnormal_samples.apply(
+            lambda x: Path(x.image_path).stem in Path(x.mask_path).stem,
+            axis=1,
+        ).all()
     ):
-        msg = """Mismatch between anomalous images and ground truth masks. Make sure t
-        he mask files in 'ground_truth' folder follow the same naming convention as the
-        anomalous images in the dataset (e.g. image: '000.png', mask: '000.png' or '000_mask.png')."""
+        msg = (
+            "Mismatch between anomalous images and ground truth masks. Make sure "
+            "mask files in 'ground_truth' folder follow the same naming "
+            "convention as the anomalous images (e.g. image: '000.png', "
+            "mask: '000.png' or '000_mask.png')."
+        )
         raise MisMatchError(msg)
 
     # infer the task type
diff --git a/src/anomalib/data/datasets/image/visa.py b/src/anomalib/data/datasets/image/visa.py
index 70ee5352aa..fa182bfc19 100644
--- a/src/anomalib/data/datasets/image/visa.py
+++ b/src/anomalib/data/datasets/image/visa.py
@@ -1,19 +1,23 @@
 """Visual Anomaly (VisA) Dataset.
 
-Description:
-    This script contains PyTorch Dataset for the Visual Anomal
-    (VisA) dataset. If the dataset is not on the file system, the script
-    downloads and extracts the dataset and create PyTorch data objects.
+This module provides PyTorch Dataset implementation for the Visual Anomaly (VisA)
+dataset. The dataset will be downloaded and extracted automatically if not found
+locally.
+
+The dataset contains 12 categories of industrial objects with both normal and
+anomalous samples. Each category includes RGB images and pixel-level ground truth
+masks for anomaly segmentation.
 
 License:
     The VisA dataset is released under the Creative Commons
     Attribution-NonCommercial-ShareAlike 4.0 International License
-    (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
+    (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
 
 Reference:
-    - Zou, Y., Jeong, J., Pemula, L., Zhang, D., & Dabeer, O. (2022). SPot-the-Difference
-      Self-supervised Pre-training for Anomaly Detection and Segmentation. In European
-      Conference on Computer Vision (pp. 392-408). Springer, Cham.
+    Zou, Y., Jeong, J., Pemula, L., Zhang, D., & Dabeer, O. (2022).
+    SPot-the-Difference Self-supervised Pre-training for Anomaly Detection and
+    Segmentation. In European Conference on Computer Vision (pp. 392-408).
+    Springer, Cham.
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -47,35 +51,28 @@
 class VisaDataset(AnomalibDataset):
     """VisA dataset class.
 
+    Dataset class for loading and processing Visual Anomaly (VisA) dataset images.
+    Supports both classification and segmentation tasks.
+
     Args:
-        root (str | Path): Path to the root of the dataset
-        category (str): Sub-category of the dataset, e.g. 'candle'
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+        root (str | Path): Path to root directory containing the dataset.
+        category (str): Category name, must be one of ``CATEGORIES``.
+        transform (Transform | None, optional): Transforms to apply to the images.
             Defaults to ``None``.
-
-    Examples:
-        To create a Visa dataset for classification:
-
-        .. code-block:: python
-
-            from anomalib.data.image.visa import VisaDataset
-            from anomalib.data.utils.transforms import get_transforms
-
-            transform = get_transforms(image_size=256)
-            dataset = VisaDataset(
-                transform=transform,
-                split="train",
-                root="./datasets/visa/visa_pytorch/",
-                category="candle",
-            )
-            dataset.setup()
-            dataset[0].keys()
-
-            # Output
-            dict_keys(['image_path', 'label', 'image', 'mask'])
-
+        split (str | Split | None, optional): Dataset split - usually
+            ``Split.TRAIN`` or ``Split.TEST``. Defaults to ``None``.
+
+    Example:
+        >>> from pathlib import Path
+        >>> from anomalib.data.datasets import VisaDataset
+        >>> dataset = VisaDataset(
+        ...     root=Path("./datasets/visa"),
+        ...     category="candle",
+        ...     split="train"
+        ... )
+        >>> item = dataset[0]
+        >>> item.keys()
+        dict_keys(['image_path', 'label', 'image', 'mask'])
     """
 
     def __init__(
@@ -89,4 +86,8 @@ def __init__(
 
         self.root_category = Path(root) / category
         self.split = split
-        self.samples = make_mvtec_dataset(self.root_category, split=self.split, extensions=EXTENSIONS)
+        self.samples = make_mvtec_dataset(
+            self.root_category,
+            split=self.split,
+            extensions=EXTENSIONS,
+        )
diff --git a/src/anomalib/data/datasets/video/__init__.py b/src/anomalib/data/datasets/video/__init__.py
index 189841257a..94b08fd445 100644
--- a/src/anomalib/data/datasets/video/__init__.py
+++ b/src/anomalib/data/datasets/video/__init__.py
@@ -1,4 +1,19 @@
-"""Torch Dataset Implementations of Anomalib Video Datasets."""
+"""PyTorch Dataset implementations for anomaly detection in videos.
+
+This module provides dataset implementations for various video anomaly detection
+datasets:
+
+- ``AvenueDataset``: CUHK Avenue dataset for abnormal event detection
+- ``ShanghaiTechDataset``: ShanghaiTech Campus surveillance dataset
+- ``UCSDpedDataset``: UCSD Pedestrian dataset for anomaly detection
+
+Example:
+    >>> from anomalib.data.datasets import AvenueDataset
+    >>> dataset = AvenueDataset(
+    ...     root="./datasets/avenue",
+    ...     split="train"
+    ... )
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/datasets/video/avenue.py b/src/anomalib/data/datasets/video/avenue.py
index 03c07404a5..67c0b51efd 100644
--- a/src/anomalib/data/datasets/video/avenue.py
+++ b/src/anomalib/data/datasets/video/avenue.py
@@ -1,13 +1,41 @@
 """CUHK Avenue Dataset.
 
-Description:
-    This script contains PyTorch Dataset for the CUHK Avenue dataset.
-    If the dataset is not already present on the file system, the DataModule class will download and
-    extract the dataset, converting the .mat mask files to .png format.
+This module provides PyTorch Dataset implementation for the CUHK Avenue dataset
+for abnormal event detection. The dataset contains surveillance videos with both
+normal and abnormal events.
+
+If the dataset is not already present on the file system, the DataModule class
+will download and extract the dataset, converting the .mat mask files to .png
+format.
+
+Example:
+    Create a dataset for training:
+
+    >>> from anomalib.data.datasets import AvenueDataset
+    >>> dataset = AvenueDataset(
+    ...     root="./datasets/avenue",
+    ...     split="train"
+    ... )
+    >>> dataset.setup()
+    >>> dataset[0].keys()
+    dict_keys(['image', 'mask', 'video_path', 'frames', 'last_frame',
+    'original_image', 'label'])
+
+    Create an image dataset by setting ``clip_length_in_frames=1``:
+
+    >>> dataset = AvenueDataset(
+    ...     root="./datasets/avenue",
+    ...     split="test",
+    ...     clip_length_in_frames=1
+    ... )
+    >>> dataset.setup()
+    >>> dataset[0]["image"].shape
+    torch.Size([3, 256, 256])
 
 Reference:
-    - Lu, Cewu, Jianping Shi, and Jiaya Jia. "Abnormal event detection at 150 fps in Matlab."
-      In Proceedings of the IEEE International Conference on Computer Vision, 2013.
+    Lu, Cewu, Jianping Shi, and Jiaya Jia. "Abnormal event detection at 150 fps
+    in Matlab." In Proceedings of the IEEE International Conference on Computer
+    Vision, 2013.
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -31,58 +59,36 @@
 
 
 class AvenueDataset(AnomalibVideoDataset):
-    """Avenue Dataset class.
+    """CUHK Avenue dataset class.
 
     Args:
-        split (Split): Split of the dataset, usually Split.TRAIN or Split.TEST
-        root (Path | str): Path to the root of the dataset
-            Defaults to ``./datasets/avenue``.
-        gt_dir (Path | str): Path to the ground truth files
-            Defaults to ``./datasets/avenue/ground_truth_demo``.
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
-            Defaults to ``2``.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-            Defaults to ``1``.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
-            Defaults to ``VideoTargetFrame.LAST``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-
-    Examples:
-        To create an Avenue dataset to train a model:
-
-        .. code-block:: python
-
-            dataset = AvenueDataset(
-                transform=transform,
-                split="test",
-                root="./datasets/avenue/",
-            )
-
-            dataset.setup()
-            dataset[0].keys()
-
-            # Output: dict_keys(['image', 'mask', 'video_path', 'frames', 'last_frame', 'original_image', 'label'])
-
-        Avenue video dataset can also be used as an image dataset if you set the clip length to 1. This means that each
-        video frame will be treated as a separate sample. This is useful for training an image model on the
-        Avenue dataset. The following code shows how to create an image dataset:
-
-        .. code-block:: python
+        split (Split): Dataset split - usually ``Split.TRAIN`` or ``Split.TEST``
+        root (Path | str, optional): Path to the root directory containing the
+            dataset. Defaults to ``"./datasets/avenue"``.
+        gt_dir (Path | str, optional): Path to the ground truth directory.
+            Defaults to ``"./datasets/avenue/ground_truth_demo"``.
+        clip_length_in_frames (int, optional): Number of frames in each video
+            clip. Defaults to ``2``.
+        frames_between_clips (int, optional): Number of frames between
+            consecutive video clips. Defaults to ``1``.
+        target_frame (VideoTargetFrame, optional): Target frame in the video
+            clip for ground truth retrieval. Defaults to
+            ``VideoTargetFrame.LAST``.
+        transform (Transform | None, optional): Transforms to apply to the input
+            images. Defaults to ``None``.
 
-            dataset = AvenueDataset(
-                transform=transform,
-                split="test",
-                root="./datasets/avenue/",
-                clip_length_in_frames=1,
-            )
-
-            dataset.setup()
-            dataset[0].keys()
-            # Output: dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image', 'label'])
-
-            dataset[0]["image"].shape
-            # Output: torch.Size([3, 256, 256])
+    Example:
+        Create a dataset for testing:
+
+        >>> dataset = AvenueDataset(
+        ...     root="./datasets/avenue",
+        ...     split="test",
+        ...     transform=transform
+        ... )
+        >>> dataset.setup()
+        >>> dataset[0].keys()
+        dict_keys(['image', 'mask', 'video_path', 'frames', 'last_frame',
+        'original_image', 'label'])
     """
 
     def __init__(
@@ -109,33 +115,36 @@ def __init__(
         self.samples = make_avenue_dataset(self.root, self.gt_dir, self.split)
 
 
-def make_avenue_dataset(root: Path, gt_dir: Path, split: Split | str | None = None) -> DataFrame:
+def make_avenue_dataset(
+    root: Path,
+    gt_dir: Path,
+    split: Split | str | None = None,
+) -> DataFrame:
     """Create CUHK Avenue dataset by parsing the file structure.
 
     The files are expected to follow the structure:
-        - path/to/dataset/[training_videos|testing_videos]/video_filename.avi
-        - path/to/ground_truth/mask_filename.mat
+        path/to/dataset/[training_videos|testing_videos]/video_filename.avi
+        path/to/ground_truth/mask_filename.mat
 
     Args:
-        root (Path): Path to dataset
-        gt_dir (Path): Path to the ground truth
-        split (Split | str | None = None, optional): Dataset split (ie., either train or test).
+        root (Path): Path to dataset root directory
+        gt_dir (Path): Path to ground truth directory
+        split (Split | str | None, optional): Dataset split (train/test).
             Defaults to ``None``.
 
     Example:
-        The following example shows how to get testing samples from Avenue dataset:
+        Get testing samples from Avenue dataset:
 
-        >>> root = Path('./avenue')
-        >>> gt_dir = Path('./avenue/masks')
-        >>> samples = make_avenue_dataset(path, gt_dir, split='test')
+        >>> root = Path("./avenue")
+        >>> gt_dir = Path("./avenue/masks")
+        >>> samples = make_avenue_dataset(root, gt_dir, split="test")
         >>> samples.head()
-           root     folder         image_path                      mask_path                   split
-        0  ./avenue testing_videos ./avenue/training_videos/01.avi ./avenue/masks/01_label.mat test
-        1  ./avenue testing_videos ./avenue/training_videos/02.avi ./avenue/masks/01_label.mat test
-        ...
+           root     folder    image_path    mask_path   split
+        0  ./avenue testing  01.avi        01_label.mat test
+        1  ./avenue testing  02.avi        02_label.mat test
 
     Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+        DataFrame: Dataframe containing samples for the requested split
     """
     root = validate_path(root)
 
@@ -166,17 +175,28 @@ def make_avenue_dataset(root: Path, gt_dir: Path, split: Split | str | None = No
 
 
 class AvenueClipsIndexer(ClipsIndexer):
-    """Clips class for Avenue dataset."""
+    """Clips indexer class for Avenue dataset.
+
+    This class handles retrieving video clips and corresponding masks from the
+    Avenue dataset.
+    """
 
     def get_mask(self, idx: int) -> np.ndarray | None:
-        """Retrieve the masks from the file system."""
+        """Retrieve masks from the file system.
+
+        Args:
+            idx (int): Index of the clip
+
+        Returns:
+            np.ndarray | None: Array of masks if available, else None
+        """
         video_idx, frames_idx = self.get_clip_location(idx)
         matfile = self.mask_paths[video_idx]
         if matfile == "":  # no gt masks available for this clip
             return None
         frames = self.clips[video_idx][frames_idx]
 
-        # read masks from .png files if available, othwerise from mat files.
+        # read masks from .png files if available, otherwise from mat files
         mask_folder = Path(matfile).with_suffix("")
         if mask_folder.exists():
             mask_frames = sorted(mask_folder.glob("*"))
diff --git a/src/anomalib/data/datasets/video/shanghaitech.py b/src/anomalib/data/datasets/video/shanghaitech.py
index 424a13e9e6..c1fad64c20 100644
--- a/src/anomalib/data/datasets/video/shanghaitech.py
+++ b/src/anomalib/data/datasets/video/shanghaitech.py
@@ -1,16 +1,62 @@
 """ShanghaiTech Campus Dataset.
 
-Description:
-    This script contains PyTorch Dataset for the ShanghaiTech Campus dataset.
-    If the dataset is not on the file system, the DataModule class downloads and
-    extracts the dataset and converts video files to a format that is readable by pyav.
+This module provides PyTorch Dataset implementation for the ShanghaiTech Campus
+dataset for abnormal event detection. The dataset contains surveillance videos
+with both normal and abnormal events.
+
+If the dataset is not already present on the file system, the DataModule class
+will download and extract the dataset, converting the video files to a format
+readable by pyav.
+
+The dataset expects the following directory structure::
+
+    root/
+    ├── training/
+    │   └── converted_videos/
+    │       ├── 01_001.avi
+    │       ├── 01_002.avi
+    │       └── ...
+    └── testing/
+        ├── frames/
+        │   ├── 01_0014/
+        │   │   ├── 000001.jpg
+        │   │   └── ...
+        │   └── ...
+        └── test_pixel_mask/
+            ├── 01_0014.npy
+            └── ...
+
+Example:
+    Create a dataset for training:
+
+    >>> from anomalib.data.datasets import ShanghaiTechDataset
+    >>> from anomalib.data.utils import Split
+    >>> dataset = ShanghaiTechDataset(
+    ...     root="./datasets/shanghaitech",
+    ...     scene=1,
+    ...     split=Split.TRAIN
+    ... )
+    >>> dataset[0].keys()
+    dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image'])
+
+    Create a test dataset:
+
+    >>> dataset = ShanghaiTechDataset(
+    ...     root="./datasets/shanghaitech",
+    ...     scene=1,
+    ...     split=Split.TEST
+    ... )
+    >>> dataset[0].keys()
+    dict_keys(['image', 'mask', 'video_path', 'frames', 'last_frame',
+    'original_image', 'label'])
 
 License:
     ShanghaiTech Campus Dataset is released under the BSD 2-Clause License.
 
 Reference:
-    - W. Liu and W. Luo, D. Lian and S. Gao. "Future Frame Prediction for Anomaly Detection -- A New Baseline."
-      IEEE Conference on Computer Vision and Pattern Recognition (CVPR). 2018.
+    Liu, W., Luo, W., Lian, D., & Gao, S. (2018). Future frame prediction for
+    anomaly detection--a new baseline. In Proceedings of the IEEE conference on
+    computer vision and pattern recognition (pp. 6536-6545).
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -34,14 +80,28 @@ class ShanghaiTechDataset(AnomalibVideoDataset):
     """ShanghaiTech Dataset class.
 
     Args:
-        split (Split): Split of the dataset, usually Split.TRAIN or Split.TEST
-        root (Path | str): Path to the root of the dataset
-        scene (int): Index of the dataset scene (category) in range [1, 13]
-        clip_length_in_frames (int, optional): Number of video frames in each clip.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
+        split (Split): Dataset split - either ``Split.TRAIN`` or ``Split.TEST``
+        root (Path | str): Path to the root directory containing the dataset.
+            Defaults to ``"./datasets/shanghaitech"``.
+        scene (int): Index of the dataset scene (category) in range [1, 13].
+            Defaults to ``1``.
+        clip_length_in_frames (int, optional): Number of frames in each video
+            clip. Defaults to ``2``.
+        frames_between_clips (int, optional): Number of frames between each
+            consecutive video clip. Defaults to ``1``.
+        target_frame (VideoTargetFrame): Specifies which frame in the clip to use
+            for ground truth retrieval. Defaults to ``VideoTargetFrame.LAST``.
+        transform (Transform | None, optional): Transforms to apply to the input
+            images. Defaults to ``None``.
+
+    Example:
+        >>> from anomalib.data.datasets import ShanghaiTechDataset
+        >>> from anomalib.data.utils import Split
+        >>> dataset = ShanghaiTechDataset(
+        ...     root="./datasets/shanghaitech",
+        ...     scene=1,
+        ...     split=Split.TRAIN
+        ... )
     """
 
     def __init__(
@@ -69,28 +129,42 @@ def __init__(
 
 
 class ShanghaiTechTrainClipsIndexer(ClipsIndexer):
-    """Clips indexer for ShanghaiTech dataset.
+    """Clips indexer for ShanghaiTech training dataset.
 
-    The train and test subsets of the ShanghaiTech dataset use different file formats, so separate
-    clips indexer implementations are needed.
+    The train and test subsets use different file formats, so separate clips
+    indexer implementations are needed.
     """
 
     @staticmethod
     def get_mask(idx: int) -> torch.Tensor | None:
-        """No masks available for training set."""
+        """No masks available for training set.
+
+        Args:
+            idx (int): Index of the clip.
+
+        Returns:
+            None: Training set has no masks.
+        """
         del idx  # Unused argument
         return None
 
 
 class ShanghaiTechTestClipsIndexer(ClipsIndexer):
-    """Clips indexer for the test set of the ShanghaiTech Campus dataset.
+    """Clips indexer for ShanghaiTech test dataset.
 
-    The train and test subsets of the ShanghaiTech dataset use different file formats, so separate
-    clips indexer implementations are needed.
+    The train and test subsets use different file formats, so separate clips
+    indexer implementations are needed.
     """
 
     def get_mask(self, idx: int) -> torch.Tensor | None:
-        """Retrieve the masks from the file system."""
+        """Retrieve the masks from the file system.
+
+        Args:
+            idx (int): Index of the clip.
+
+        Returns:
+            torch.Tensor | None: Ground truth mask if available, else None.
+        """
         video_idx, frames_idx = self.get_clip_location(idx)
         mask_file = self.mask_paths[video_idx]
         if mask_file == "":  # no gt masks available for this clip
@@ -107,19 +181,24 @@ def _compute_frame_pts(self) -> None:
             n_frames = len(list(Path(video_path).glob("*.jpg")))
             self.video_pts.append(torch.Tensor(range(n_frames)))
 
-        self.video_fps = [None] * len(self.video_paths)  # fps information cannot be inferred from folder structure
+        # fps information cannot be inferred from folder structure
+        self.video_fps = [None] * len(self.video_paths)
 
     def get_clip(self, idx: int) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any], int]:
         """Get a subclip from a list of videos.
 
         Args:
-            idx (int): index of the subclip. Must be between 0 and num_clips().
+            idx (int): Index of the subclip. Must be between 0 and num_clips().
 
         Returns:
-            video (torch.Tensor)
-            audio (torch.Tensor)
-            info (Dict)
-            video_idx (int): index of the video in `video_paths`
+            tuple containing:
+                - video (torch.Tensor): Video clip tensor
+                - audio (torch.Tensor): Empty audio tensor
+                - info (dict): Empty info dictionary
+                - video_idx (int): Index of the video in video_paths
+
+        Raises:
+            IndexError: If idx is out of range.
         """
         if idx >= self.num_clips():
             msg = f"Index {idx} out of range ({self.num_clips()} number of clips)"
@@ -139,29 +218,41 @@ def get_clip(self, idx: int) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]
 def make_shanghaitech_dataset(root: Path, scene: int, split: Split | str | None = None) -> DataFrame:
     """Create ShanghaiTech dataset by parsing the file structure.
 
-    The files are expected to follow the structure:
-        path/to/dataset/[training_videos|testing_videos]/video_filename.avi
-        path/to/ground_truth/mask_filename.mat
+    The files are expected to follow the structure::
+
+        root/
+        ├── training/
+        │   └── converted_videos/
+        │       ├── 01_001.avi
+        │       └── ...
+        └── testing/
+            ├── frames/
+            │   ├── 01_0014/
+            │   │   ├── 000001.jpg
+            │   │   └── ...
+            │   └── ...
+            └── test_pixel_mask/
+                ├── 01_0014.npy
+                └── ...
 
     Args:
-        root (Path): Path to dataset
-        scene (int): Index of the dataset scene (category) in range [1, 13]
-        split (Split | str | None, optional): Dataset split (ie., either train or test). Defaults to None.
+        root (Path): Path to dataset root directory.
+        scene (int): Index of the dataset scene (category) in range [1, 13].
+        split (Split | str | None, optional): Dataset split (train or test).
+            Defaults to ``None``.
 
-    Example:
-        The following example shows how to get testing samples from ShanghaiTech dataset:
+    Returns:
+        DataFrame: DataFrame containing samples for the requested split.
 
-        >>> root = Path('./shanghaiTech')
+    Example:
+        >>> from pathlib import Path
+        >>> root = Path('./shanghaitech')
         >>> scene = 1
-        >>> samples = make_avenue_dataset(path, scene, split='test')
+        >>> samples = make_shanghaitech_dataset(root, scene, split='test')
         >>> samples.head()
-            root            image_path                          split   mask_path
-        0	shanghaitech	shanghaitech/testing/frames/01_0014	test	shanghaitech/testing/test_pixel_mask/01_0014.npy
-        1	shanghaitech	shanghaitech/testing/frames/01_0015	test	shanghaitech/testing/test_pixel_mask/01_0015.npy
-        ...
-
-    Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+            root         image_path                       split    mask_path
+        0   shanghaitech shanghaitech/testing/frames/01_0014 test ...01_0014.npy
+        1   shanghaitech shanghaitech/testing/frames/01_0015 test ...01_0015.npy
     """
     scene_prefix = str(scene).zfill(2)
 
diff --git a/src/anomalib/data/datasets/video/ucsd_ped.py b/src/anomalib/data/datasets/video/ucsd_ped.py
index 5a619be3f1..ffc2ab8c18 100644
--- a/src/anomalib/data/datasets/video/ucsd_ped.py
+++ b/src/anomalib/data/datasets/video/ucsd_ped.py
@@ -1,4 +1,62 @@
-"""UCSD Pedestrian Dataset."""
+"""UCSD Pedestrian Dataset.
+
+This module provides PyTorch Dataset implementation for the UCSD Pedestrian
+dataset for abnormal event detection. The dataset contains surveillance videos
+with both normal and abnormal events.
+
+The dataset expects the following directory structure::
+
+    root/
+    ├── UCSDped1/
+    │   ├── Train/
+    │   │   ├── Train001/
+    │   │   │   ├── 001.tif
+    │   │   │   └── ...
+    │   │   └── ...
+    │   └── Test/
+    │       ├── Test001/
+    │       │   ├── 001.tif
+    │       │   └── ...
+    │       ├── Test001_gt/
+    │       │   ├── 001.bmp
+    │       │   └── ...
+    │       └── ...
+    └── UCSDped2/
+        ├── Train/
+        └── Test/
+
+Example:
+    Create a dataset for training:
+
+    >>> from anomalib.data.datasets import UCSDpedDataset
+    >>> from anomalib.data.utils import Split
+    >>> dataset = UCSDpedDataset(
+    ...     root="./datasets/ucsdped",
+    ...     category="UCSDped1",
+    ...     split=Split.TRAIN
+    ... )
+    >>> dataset[0].keys()
+    dict_keys(['image', 'video_path', 'frames', 'last_frame', 'original_image'])
+
+    Create a test dataset:
+
+    >>> dataset = UCSDpedDataset(
+    ...     root="./datasets/ucsdped",
+    ...     category="UCSDped1",
+    ...     split=Split.TEST
+    ... )
+    >>> dataset[0].keys()
+    dict_keys(['image', 'mask', 'video_path', 'frames', 'last_frame',
+    'original_image', 'label'])
+
+License:
+    UCSD Pedestrian Dataset is released under the BSD 2-Clause License.
+
+Reference:
+    Mahadevan, V., Li, W., Bhalodia, V., & Vasconcelos, N. (2010). Anomaly
+    detection in crowded scenes. In IEEE Conference on Computer Vision and
+    Pattern Recognition (CVPR), 2010.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -25,14 +83,31 @@ class UCSDpedDataset(AnomalibVideoDataset):
     """UCSDped Dataset class.
 
     Args:
-        root (Path | str): Path to the root of the dataset
-        category (str): Sub-category of the dataset, e.g. "UCSDped1" or "UCSDped2"
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
+        root (Path | str): Path to the root of the dataset.
+        category (str): Sub-category of the dataset, must be one of ``CATEGORIES``.
+        split (str | Split | None): Dataset split - usually ``Split.TRAIN`` or
+            ``Split.TEST``.
         clip_length_in_frames (int, optional): Number of video frames in each clip.
-        frames_between_clips (int, optional): Number of frames between each consecutive video clip.
-        target_frame (VideoTargetFrame): Specifies the target frame in the video clip, used for ground truth retrieval.
-        transform (Transform, optional): Transforms that should be applied to the input images.
+            Defaults to ``2``.
+        frames_between_clips (int, optional): Number of frames between each
+            consecutive video clip. Defaults to ``10``.
+        target_frame (VideoTargetFrame): Specifies the target frame in the video
+            clip, used for ground truth retrieval. Defaults to
+            ``VideoTargetFrame.LAST``.
+        transform (Transform | None, optional): Transforms to apply to the images.
             Defaults to ``None``.
+
+    Example:
+        >>> from pathlib import Path
+        >>> from anomalib.data.datasets import UCSDpedDataset
+        >>> dataset = UCSDpedDataset(
+        ...     root=Path("./datasets/ucsdped"),
+        ...     category="UCSDped1",
+        ...     split="train"
+        ... )
+        >>> dataset[0].keys()
+        dict_keys(['image', 'video_path', 'frames', 'last_frame',
+        'original_image'])
     """
 
     def __init__(
@@ -62,7 +137,14 @@ class UCSDpedClipsIndexer(ClipsIndexer):
     """Clips class for UCSDped dataset."""
 
     def get_mask(self, idx: int) -> np.ndarray | None:
-        """Retrieve the masks from the file system."""
+        """Retrieve the masks from the file system.
+
+        Args:
+            idx (int): Index of the clip.
+
+        Returns:
+            np.ndarray | None: Stack of mask frames if available, None otherwise.
+        """
         video_idx, frames_idx = self.get_clip_location(idx)
         mask_folder = self.mask_paths[video_idx]
         if mask_folder == "":  # no gt masks available for this clip
@@ -87,13 +169,18 @@ def get_clip(self, idx: int) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]
         """Get a subclip from a list of videos.
 
         Args:
-            idx (int): index of the subclip. Must be between 0 and num_clips().
+            idx (int): Index of the subclip. Must be between 0 and num_clips().
 
         Returns:
-            video (torch.Tensor)
-            audio (torch.Tensor)
-            info (dict)
-            video_idx (int): index of the video in `video_paths`
+            tuple[torch.Tensor, torch.Tensor, dict[str, Any], int]: Tuple
+            containing:
+                - video frames tensor
+                - empty audio tensor
+                - empty info dict
+                - video index
+
+        Raises:
+            IndexError: If ``idx`` is out of range.
         """
         if idx >= self.num_clips():
             msg = f"Index {idx} out of range ({self.num_clips()} number of clips)"
@@ -113,16 +200,19 @@ def get_clip(self, idx: int) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]
 def make_ucsd_dataset(path: Path, split: str | Split | None = None) -> DataFrame:
     """Create UCSD Pedestrian dataset by parsing the file structure.
 
-    The files are expected to follow the structure:
+    The files are expected to follow the structure::
+
         path/to/dataset/category/split/video_id/image_filename.tif
         path/to/dataset/category/split/video_id_gt/mask_filename.bmp
 
     Args:
-        path (Path): Path to dataset
-        split (str | Split | None, optional): Dataset split (ie., either train or test). Defaults to None.
+        path (Path): Path to dataset.
+        split (str | Split | None, optional): Dataset split (ie., either train or
+            test). Defaults to ``None``.
 
     Example:
-        The following example shows how to get testing samples from UCSDped2 category:
+        The following example shows how to get testing samples from UCSDped2
+        category:
 
         >>> root = Path('./UCSDped')
         >>> category = 'UCSDped2'
@@ -132,13 +222,11 @@ def make_ucsd_dataset(path: Path, split: str | Split | None = None) -> DataFrame
 
         >>> samples = make_ucsd_dataset(path, split='test')
         >>> samples.head()
-           root             folder image_path                    mask_path                         split
-        0  UCSDped/UCSDped2 Test   UCSDped/UCSDped2/Test/Test001 UCSDped/UCSDped2/Test/Test001_gt  test
-        1  UCSDped/UCSDped2 Test   UCSDped/UCSDped2/Test/Test002 UCSDped/UCSDped2/Test/Test002_gt  test
-        ...
+           root             folder image_path                    mask_path
+        0  UCSDped/UCSDped2 Test   UCSDped/UCSDped2/Test/Test001 UCSDped/...
 
     Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+        DataFrame: Output dataframe containing samples for the requested split.
     """
     path = validate_path(path)
     folders = [filename for filename in sorted(path.glob("*/*")) if filename.is_dir()]
diff --git a/src/anomalib/data/errors.py b/src/anomalib/data/errors.py
index 97c956663c..7909bc9659 100644
--- a/src/anomalib/data/errors.py
+++ b/src/anomalib/data/errors.py
@@ -1,14 +1,35 @@
-"""Custom Exception Class for Mismatch Detection (MisMatchError)."""
+"""Custom exceptions for anomalib data validation.
+
+This module provides custom exception classes for handling data validation errors
+in anomalib.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 
 class MisMatchError(Exception):
-    """Exception raised when a mismatch is detected.
+    """Exception raised when a data mismatch is detected.
+
+    This exception is raised when there is a mismatch between expected and actual
+    data formats or values during validation.
+
+    Args:
+        message (str): Custom error message. Defaults to "Mismatch detected."
 
     Attributes:
         message (str): Explanation of the error.
+
+    Examples:
+        >>> raise MisMatchError()  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+            ...
+        MisMatchError: Mismatch detected.
+        >>> raise MisMatchError("Image dimensions do not match")
+        ... # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+            ...
+        MisMatchError: Image dimensions do not match
     """
 
     def __init__(self, message: str = "") -> None:
diff --git a/src/anomalib/data/image/datumaro.py b/src/anomalib/data/image/datumaro.py
deleted file mode 100644
index b4836990ec..0000000000
--- a/src/anomalib/data/image/datumaro.py
+++ /dev/null
@@ -1,226 +0,0 @@
-"""Dataloader for Datumaro format.
-
-Note: This currently only works for annotations exported from Intel Geti™.
-"""
-
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import json
-from pathlib import Path
-
-import pandas as pd
-from torchvision.transforms.v2 import Transform
-
-from anomalib import TaskType
-from anomalib.data.base import AnomalibDataModule, AnomalibDataset
-from anomalib.data.utils import LabelName, Split, TestSplitMode, ValSplitMode
-
-
-def make_datumaro_dataset(root: str | Path, split: str | Split | None = None) -> pd.DataFrame:
-    """Make Datumaro Dataset.
-
-    Assumes the following directory structure:
-
-    dataset
-    ├── annotations
-    │    └── default.json
-    └── images
-        └── default
-                ├── image1.jpg
-                ├── image2.jpg
-                └── ...
-
-    Args:
-        root (str | Path): Path to the dataset root directory.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST.
-            Defaults to ``None``.
-
-    Examples:
-        >>> root = Path("path/to/dataset")
-        >>> samples = make_datumaro_dataset(root)
-        >>> samples.head()
-            image_path	label	label_index	split	mask_path
-        0	path/to/dataset...	Normal	0	Split.TRAIN
-        1	path/to/dataset...	Normal	0	Split.TRAIN
-        2	path/to/dataset...	Normal	0	Split.TRAIN
-        3	path/to/dataset...	Normal	0	Split.TRAIN
-        4	path/to/dataset...	Normal	0	Split.TRAIN
-
-
-    Returns:
-        DataFrame: an output dataframe containing samples for the requested split (ie., train or test).
-    """
-    annotation_file = Path(root) / "annotations" / "default.json"
-    with annotation_file.open() as f:
-        annotations = json.load(f)
-
-    categories = annotations["categories"]
-    categories = {idx: label["name"] for idx, label in enumerate(categories["label"]["labels"])}
-
-    samples = []
-    for item in annotations["items"]:
-        image_path = Path(root) / "images" / "default" / item["image"]["path"]
-        label_index = item["annotations"][0]["label_id"]
-        label = categories[label_index]
-        samples.append({
-            "image_path": str(image_path),
-            "label": label,
-            "label_index": label_index,
-            "split": None,
-            "mask_path": "",  # mask is provided in the annotation file and is not on disk.
-        })
-    samples_df = pd.DataFrame(
-        samples,
-        columns=["image_path", "label", "label_index", "split", "mask_path"],
-        index=range(len(samples)),
-    )
-    # Create test/train split
-    # By default assign all "Normal" samples to train and all "Anomalous" samples to test
-    samples_df.loc[samples_df["label_index"] == LabelName.NORMAL, "split"] = Split.TRAIN
-    samples_df.loc[samples_df["label_index"] == LabelName.ABNORMAL, "split"] = Split.TEST
-
-    # Get the data frame for the split.
-    if split:
-        samples_df = samples_df[samples_df.split == split].reset_index(drop=True)
-
-    return samples_df
-
-
-class DatumaroDataset(AnomalibDataset):
-    """Datumaro dataset class.
-
-    Args:
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
-        root (str | Path): Path to the dataset root directory.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST
-            Defaults to ``None``.
-
-
-    Examples:
-        .. code-block:: python
-
-            from anomalib.data.image.datumaro import DatumaroDataset
-            from torchvision.transforms.v2 import Resize
-
-            dataset = DatumaroDataset(root=root,
-                task="classification",
-                transform=Resize((256, 256)),
-            )
-            print(dataset[0].keys())
-            # Output: dict_keys(['dm_format_version', 'infos', 'categories', 'items'])
-
-    """
-
-    def __init__(
-        self,
-        task: TaskType,
-        root: str | Path,
-        transform: Transform | None = None,
-        split: str | Split | None = None,
-    ) -> None:
-        super().__init__(task, transform)
-        self.split = split
-        self.samples = make_datumaro_dataset(root, split)
-
-
-class Datumaro(AnomalibDataModule):
-    """Datumaro datamodule.
-
-    Args:
-        root (str | Path): Path to the dataset root directory.
-        train_batch_size (int): Batch size for training dataloader.
-            Defaults to ``32``.
-        eval_batch_size (int): Batch size for evaluation dataloader.
-            Defaults to ``32``.
-        num_workers (int): Number of workers for dataloaders.
-            Defaults to ``8``.
-        task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation``.
-            Defaults to ``TaskType.CLASSIFICATION``. Currently only supports classification.
-        image_size (tuple[int, int], optional): Size to which input images should be resized.
-            Defaults to ``None``.
-        transform (Transform, optional): Transforms that should be applied to the input images.
-            Defaults to ``None``.
-        train_transform (Transform, optional): Transforms that should be applied to the input images during training.
-            Defaults to ``None``.
-        eval_transform (Transform, optional): Transforms that should be applied to the input images during evaluation.
-            Defaults to ``None``.
-        test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained.
-            Defaults to ``TestSplitMode.FROM_DIR``.
-        test_split_ratio (float): Fraction of images from the train set that will be reserved for testing.
-            Defaults to ``0.2``.
-        val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained.
-            Defaults to ``ValSplitMode.SAME_AS_TEST``.
-        val_split_ratio (float): Fraction of train or test images that will be reserved for validation.
-            Defaults to ``0.5``.
-        seed (int | None, optional): Seed which may be set to a fixed value for reproducibility.
-            Defualts to ``None``.
-
-    Examples:
-        To create a Datumaro datamodule
-
-        >>> from pathlib import Path
-        >>> from torchvision.transforms.v2 import Resize
-        >>> root = Path("path/to/dataset")
-        >>> datamodule = Datumaro(root, transform=Resize((256, 256)))
-        >>> datamodule.setup()
-        >>> i, data = next(enumerate(datamodule.train_dataloader()))
-        >>> data.keys()
-        dict_keys(['image_path', 'label', 'image'])
-
-        >>> data["image"].shape
-        torch.Size([32, 3, 256, 256])
-    """
-
-    def __init__(
-        self,
-        root: str | Path,
-        train_batch_size: int = 32,
-        eval_batch_size: int = 32,
-        num_workers: int = 8,
-        task: TaskType = TaskType.CLASSIFICATION,
-        image_size: tuple[int, int] | None = None,
-        transform: Transform | None = None,
-        train_transform: Transform | None = None,
-        eval_transform: Transform | None = None,
-        test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
-        test_split_ratio: float = 0.5,
-        val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
-        val_split_ratio: float = 0.5,
-        seed: int | None = None,
-    ) -> None:
-        if task != TaskType.CLASSIFICATION:
-            msg = "Datumaro dataloader currently only supports classification task."
-            raise ValueError(msg)
-        super().__init__(
-            train_batch_size=train_batch_size,
-            eval_batch_size=eval_batch_size,
-            num_workers=num_workers,
-            val_split_mode=val_split_mode,
-            val_split_ratio=val_split_ratio,
-            test_split_mode=test_split_mode,
-            test_split_ratio=test_split_ratio,
-            image_size=image_size,
-            transform=transform,
-            train_transform=train_transform,
-            eval_transform=eval_transform,
-            seed=seed,
-        )
-        self.root = root
-        self.task = task
-
-    def _setup(self, _stage: str | None = None) -> None:
-        self.train_data = DatumaroDataset(
-            task=self.task,
-            root=self.root,
-            transform=self.train_transform,
-            split=Split.TRAIN,
-        )
-        self.test_data = DatumaroDataset(
-            task=self.task,
-            root=self.root,
-            transform=self.eval_transform,
-            split=Split.TEST,
-        )
diff --git a/src/anomalib/data/predict.py b/src/anomalib/data/predict.py
index 06c743b88f..e53ef2b52f 100644
--- a/src/anomalib/data/predict.py
+++ b/src/anomalib/data/predict.py
@@ -1,4 +1,16 @@
-"""Inference Dataset."""
+"""Dataset for performing inference on images.
+
+This module provides a dataset class for loading and preprocessing images for
+inference in anomaly detection tasks.
+
+Example:
+    >>> from pathlib import Path
+    >>> from anomalib.data import PredictDataset
+    >>> dataset = PredictDataset(path="path/to/images")
+    >>> item = dataset[0]
+    >>> item.image.shape  # doctest: +SKIP
+    torch.Size([3, 256, 256])
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -14,14 +26,27 @@
 
 
 class PredictDataset(Dataset):
-    """Inference Dataset to perform prediction.
+    """Dataset for performing inference on images.
 
     Args:
-        path (str | Path): Path to an image or image-folder.
-        transform (A.Compose | None, optional): Transform object describing the transforms that are
-            applied to the inputs.
-        image_size (int | tuple[int, int] | None, optional): Target image size
-            to resize the original image. Defaults to None.
+        path (str | Path): Path to an image or directory containing images.
+        transform (Transform | None, optional): Transform object describing the
+            transforms to be applied to the inputs. Defaults to ``None``.
+        image_size (int | tuple[int, int], optional): Target size to which input
+            images will be resized. If int, a square image of that size will be
+            created. Defaults to ``(256, 256)``.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> dataset = PredictDataset(
+        ...     path=Path("path/to/images"),
+        ...     image_size=(224, 224),
+        ... )
+        >>> len(dataset)  # doctest: +SKIP
+        10
+        >>> item = dataset[0]  # doctest: +SKIP
+        >>> item.image.shape  # doctest: +SKIP
+        torch.Size([3, 224, 224])
     """
 
     def __init__(
@@ -37,11 +62,22 @@ def __init__(
         self.image_size = image_size
 
     def __len__(self) -> int:
-        """Get the number of images in the given path."""
+        """Get number of images in dataset.
+
+        Returns:
+            int: Number of images in the dataset.
+        """
         return len(self.image_filenames)
 
     def __getitem__(self, index: int) -> ImageItem:
-        """Get the image based on the `index`."""
+        """Get image item at specified index.
+
+        Args:
+            index (int): Index of the image to retrieve.
+
+        Returns:
+            ImageItem: Object containing the loaded image and its metadata.
+        """
         image_filename = self.image_filenames[index]
         image = read_image(image_filename, as_tensor=True)
         if self.transform:
@@ -54,5 +90,10 @@ def __getitem__(self, index: int) -> ImageItem:
 
     @property
     def collate_fn(self) -> Callable:
-        """Get the collate function."""
+        """Get collate function for creating batches.
+
+        Returns:
+            Callable: Function that collates multiple ``ImageItem`` instances into
+                a batch.
+        """
         return ImageBatch.collate
diff --git a/src/anomalib/data/transforms/center_crop.py b/src/anomalib/data/transforms/center_crop.py
index 88b8655aae..880acd5484 100644
--- a/src/anomalib/data/transforms/center_crop.py
+++ b/src/anomalib/data/transforms/center_crop.py
@@ -1,4 +1,17 @@
-"""Custom Torchvision transforms for Anomalib."""
+"""Custom Torchvision transforms for Anomalib.
+
+This module provides custom center crop transforms that are compatible with ONNX
+export.
+
+Example:
+    >>> import torch
+    >>> from anomalib.data.transforms.center_crop import ExportableCenterCrop
+    >>> transform = ExportableCenterCrop(size=(224, 224))
+    >>> image = torch.randn(3, 256, 256)
+    >>> output = transform(image)
+    >>> output.shape
+    torch.Size([3, 224, 224])
+"""
 
 # Original Code
 # Copyright (c) Soumith Chintala 2016
@@ -29,14 +42,17 @@ def _center_crop_compute_crop_anchor(
 ) -> tuple[int, int]:
     """Compute the anchor point for center-cropping.
 
-    This function is a modified version of the torchvision.transforms.functional._center_crop_compute_crop_anchor
-    function. The original function uses `round` to compute the anchor point, which is not compatible with ONNX.
+    This function is a modified version of the torchvision center crop anchor
+    computation that is compatible with ONNX export.
 
     Args:
-        crop_height (int): Desired height of the crop.
-        crop_width (int): Desired width of the crop.
-        image_height (int): Height of the input image.
-        image_width (int): Width of the input image.
+        crop_height (int): Desired height of the crop
+        crop_width (int): Desired width of the crop
+        image_height (int): Height of the input image
+        image_width (int): Width of the input image
+
+    Returns:
+        tuple[int, int]: Tuple containing the top and left crop anchor points
     """
     crop_top = torch.tensor((image_height - crop_height) / 2.0).round().int().item()
     crop_left = torch.tensor((image_width - crop_width) / 2.0).round().int().item()
@@ -46,11 +62,21 @@ def _center_crop_compute_crop_anchor(
 def center_crop_image(image: torch.Tensor, output_size: list[int]) -> torch.Tensor:
     """Apply center-cropping to an input image.
 
-    Uses the modified anchor point computation function to compute the anchor point for center-cropping.
+    Uses the modified anchor point computation function to ensure ONNX
+    compatibility.
 
     Args:
-        image (torch.Tensor): Input image to be center-cropped.
-        output_size (list[int]): Desired output size of the crop.
+        image (torch.Tensor): Input image tensor to be center-cropped
+        output_size (list[int]): Desired output size ``[height, width]``
+
+    Returns:
+        torch.Tensor: Center-cropped image tensor
+
+    Example:
+        >>> image = torch.randn(3, 256, 256)
+        >>> output = center_crop_image(image, [224, 224])
+        >>> output.shape
+        torch.Size([3, 224, 224])
     """
     crop_height, crop_width = _center_crop_parse_output_size(output_size)
     shape = image.shape
@@ -59,22 +85,45 @@ def center_crop_image(image: torch.Tensor, output_size: list[int]) -> torch.Tens
     image_height, image_width = shape[-2:]
 
     if crop_height > image_height or crop_width > image_width:
-        padding_ltrb = _center_crop_compute_padding(crop_height, crop_width, image_height, image_width)
+        padding_ltrb = _center_crop_compute_padding(
+            crop_height,
+            crop_width,
+            image_height,
+            image_width,
+        )
         image = pad(image, _parse_pad_padding(padding_ltrb), value=0.0)
 
         image_height, image_width = image.shape[-2:]
         if crop_width == image_width and crop_height == image_height:
             return image
 
-    crop_top, crop_left = _center_crop_compute_crop_anchor(crop_height, crop_width, image_height, image_width)
-    return image[..., crop_top : (crop_top + crop_height), crop_left : (crop_left + crop_width)]
+    crop_top, crop_left = _center_crop_compute_crop_anchor(
+        crop_height,
+        crop_width,
+        image_height,
+        image_width,
+    )
+    return image[
+        ...,
+        crop_top : (crop_top + crop_height),
+        crop_left : (crop_left + crop_width),
+    ]
 
 
 class ExportableCenterCrop(Transform):
-    """Transform that applies center-cropping to an input image and allows to be exported to ONNX.
+    """Transform that applies center-cropping with ONNX export support.
 
     Args:
-        size (int | tuple[int, int]): Desired output size of the crop.
+        size (int | tuple[int, int]): Desired output size. If int, creates a
+            square crop of size ``(size, size)``. If tuple, creates a
+            rectangular crop of size ``(height, width)``.
+
+    Example:
+        >>> transform = ExportableCenterCrop(224)
+        >>> image = torch.randn(3, 256, 256)
+        >>> output = transform(image)
+        >>> output.shape
+        torch.Size([3, 224, 224])
     """
 
     def __init__(self, size: int | tuple[int, int]) -> None:
@@ -82,6 +131,14 @@ def __init__(self, size: int | tuple[int, int]) -> None:
         self.size = list(size) if isinstance(size, tuple) else [size, size]
 
     def _transform(self, inpt: torch.Tensor, params: dict[str, Any]) -> torch.Tensor:
-        """Apply the transform."""
+        """Apply the center crop transform.
+
+        Args:
+            inpt (torch.Tensor): Input tensor to transform
+            params (dict[str, Any]): Transform parameters (unused)
+
+        Returns:
+            torch.Tensor: Center-cropped output tensor
+        """
         del params
         return center_crop_image(inpt, output_size=self.size)
diff --git a/src/anomalib/data/transforms/multi_random_choice.py b/src/anomalib/data/transforms/multi_random_choice.py
index 1d507c17a2..f19c5fa483 100644
--- a/src/anomalib/data/transforms/multi_random_choice.py
+++ b/src/anomalib/data/transforms/multi_random_choice.py
@@ -1,4 +1,24 @@
-"""Multi random choice transform."""
+"""Multi random choice transform.
+
+This transform randomly applies multiple transforms from a list of transforms.
+
+Example:
+    >>> import torchvision.transforms.v2 as v2
+    >>> transforms = [
+    ...     v2.RandomHorizontalFlip(p=1.0),
+    ...     v2.ColorJitter(brightness=0.5),
+    ...     v2.RandomRotation(10),
+    ... ]
+    >>> # Apply 1-2 random transforms with equal probability
+    >>> transform = MultiRandomChoice(transforms, num_transforms=2)
+    >>> # Always apply exactly 2 transforms with custom probabilities
+    >>> transform = MultiRandomChoice(
+    ...     transforms,
+    ...     probabilities=[0.5, 0.3, 0.2],
+    ...     num_transforms=2,
+    ...     fixed_num_transforms=True
+    ... )
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -15,17 +35,22 @@ class MultiRandomChoice(v2.Transform):
     This transform does not support torchscript.
 
     Args:
-        transforms (sequence or torch.nn.Module): List of transformations to choose from.
-        probabilities (list[float] | None, optional): Probability of each transform being picked.
-            If None (default), all transforms have equal probability. If provided, probabilities
-            will be normalized to sum to 1.
-        num_transforms (int): Maximum number of transforms to apply at once.
+        transforms: List of transformations to choose from.
+        probabilities: Probability of each transform being picked. If ``None``
+            (default), all transforms have equal probability. If provided,
+            probabilities will be normalized to sum to 1.
+        num_transforms: Maximum number of transforms to apply at once.
             Defaults to ``1``.
-        fixed_num_transforms (bool): If ``True``, always applies exactly ``num_transforms`` transforms.
-            If ``False``, randomly picks between 1 and ``num_transforms``.
-            Defaults to ``False``.
+        fixed_num_transforms: If ``True``, always applies exactly
+            ``num_transforms`` transforms. If ``False``, randomly picks between
+            1 and ``num_transforms``. Defaults to ``False``.
+
+    Raises:
+        TypeError: If ``transforms`` is not a sequence of callables.
+        ValueError: If length of ``probabilities`` does not match length of
+            ``transforms``.
 
-    Examples:
+    Example:
         >>> import torchvision.transforms.v2 as v2
         >>> transforms = [
         ...     v2.RandomHorizontalFlip(p=1.0),
@@ -34,7 +59,6 @@ class MultiRandomChoice(v2.Transform):
         ... ]
         >>> # Apply 1-2 random transforms with equal probability
         >>> transform = MultiRandomChoice(transforms, num_transforms=2)
-
         >>> # Always apply exactly 2 transforms with custom probabilities
         >>> transform = MultiRandomChoice(
         ...     transforms,
@@ -71,7 +95,14 @@ def __init__(
         self.fixed_num_transforms = fixed_num_transforms
 
     def forward(self, *inputs: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, ...]:
-        """Apply randomly selected transforms to the input."""
+        """Apply randomly selected transforms to the input.
+
+        Args:
+            *inputs: Input tensors to transform.
+
+        Returns:
+            Transformed tensor(s).
+        """
         # First determine number of transforms to apply
         num_transforms = (
             self.num_transforms if self.fixed_num_transforms else int(torch.randint(self.num_transforms, (1,)) + 1)
diff --git a/src/anomalib/data/utils/__init__.py b/src/anomalib/data/utils/__init__.py
index 570c45af4a..d70b9721f7 100644
--- a/src/anomalib/data/utils/__init__.py
+++ b/src/anomalib/data/utils/__init__.py
@@ -1,4 +1,23 @@
-"""Helper utilities for data."""
+"""Helper utilities for data.
+
+This module provides various utility functions for data handling in Anomalib.
+
+The utilities are organized into several categories:
+
+- Image handling: Functions for reading, writing and processing images
+- Box handling: Functions for converting between masks and bounding boxes
+- Path handling: Functions for validating and resolving file paths
+- Dataset splitting: Functions for splitting datasets into train/val/test
+- Data generation: Functions for generating synthetic data like Perlin noise
+- Download utilities: Functions for downloading and extracting datasets
+
+Example:
+    >>> from anomalib.data.utils import read_image, generate_perlin_noise
+    >>> # Read an image
+    >>> image = read_image("path/to/image.jpg")
+    >>> # Generate Perlin noise
+    >>> noise = generate_perlin_noise(256, 256)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/utils/boxes.py b/src/anomalib/data/utils/boxes.py
index ade9563e55..a2bed89342 100644
--- a/src/anomalib/data/utils/boxes.py
+++ b/src/anomalib/data/utils/boxes.py
@@ -1,4 +1,8 @@
-"""Helper functions for processing bounding box detections and annotations."""
+"""Helper functions for processing bounding box detections and annotations.
+
+This module provides utility functions for converting between different bounding box
+formats and handling bounding box operations.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,21 +16,37 @@ def masks_to_boxes(
     masks: torch.Tensor,
     anomaly_maps: torch.Tensor | None = None,
 ) -> tuple[list[torch.Tensor], list[torch.Tensor]]:
-    """Convert a batch of segmentation masks to bounding box coordinates.
+    """Convert batch of segmentation masks to bounding box coordinates.
 
     Args:
-        masks (torch.Tensor): Input tensor of shape (B, 1, H, W), (B, H, W) or (H, W)
-        anomaly_maps (Tensor | None, optional): Anomaly maps of shape (B, 1, H, W), (B, H, W) or (H, W) which are
-            used to determine an anomaly score for the converted bounding boxes.
+        masks: Input tensor of masks. Can be one of:
+            - shape ``(B, 1, H, W)``
+            - shape ``(B, H, W)``
+            - shape ``(H, W)``
+        anomaly_maps: Optional anomaly maps. Can be one of:
+            - shape ``(B, 1, H, W)``
+            - shape ``(B, H, W)``
+            - shape ``(H, W)``
+            Used to determine anomaly scores for converted bounding boxes.
 
     Returns:
-        list[torch.Tensor]: A list of length B where each element is a tensor of shape (N, 4)
-            containing the bounding box coordinates of the objects in the masks in xyxy format.
-        list[torch.Tensor]: A list of length B where each element is a tensor of length (N)
-            containing an anomaly score for each of the converted boxes.
+        Tuple containing:
+            - List of length ``B`` where each element is tensor of shape ``(N, 4)``
+              containing bounding box coordinates in ``xyxy`` format
+            - List of length ``B`` where each element is tensor of length ``N``
+              containing anomaly scores for each converted box
+
+    Examples:
+        >>> import torch
+        >>> masks = torch.zeros((2, 1, 32, 32))
+        >>> masks[0, 0, 10:20, 15:25] = 1  # Add box in first image
+        >>> boxes, scores = masks_to_boxes(masks)
+        >>> boxes[0]  # Coordinates for first image
+        tensor([[15., 10., 24., 19.]])
     """
     height, width = masks.shape[-2:]
-    masks = masks.view((-1, 1, height, width)).float()  # reshape to (B, 1, H, W) and cast to float
+    # reshape to (B, 1, H, W) and cast to float
+    masks = masks.view((-1, 1, height, width)).float()
     if anomaly_maps is not None:
         anomaly_maps = anomaly_maps.view((-1,) + masks.shape[-2:])
 
@@ -57,16 +77,22 @@ def masks_to_boxes(
 
 
 def boxes_to_masks(boxes: list[torch.Tensor], image_size: tuple[int, int]) -> torch.Tensor:
-    """Convert bounding boxes to segmentations masks.
+    """Convert bounding boxes to segmentation masks.
 
     Args:
-        boxes (list[torch.Tensor]): A list of length B where each element is a tensor of shape (N, 4)
-            containing the bounding box coordinates of the regions of interest in xyxy format.
-        image_size (tuple[int, int]): Image size of the output masks in (H, W) format.
+        boxes: List of length ``B`` where each element is tensor of shape ``(N, 4)``
+            containing bounding box coordinates in ``xyxy`` format
+        image_size: Output mask size as ``(H, W)``
 
     Returns:
-        Tensor: torch.Tensor of shape (B, H, W) in which each slice is a binary mask showing the pixels contained by a
-            bounding box.
+        Binary masks of shape ``(B, H, W)`` where pixels contained within boxes
+        are set to 1
+
+    Examples:
+        >>> boxes = [torch.tensor([[10, 15, 20, 25]])]  # One box in first image
+        >>> masks = boxes_to_masks(boxes, (32, 32))
+        >>> masks.shape
+        torch.Size([1, 32, 32])
     """
     masks = torch.zeros((len(boxes), *image_size)).to(boxes[0].device)
     for im_idx, im_boxes in enumerate(boxes):
@@ -77,19 +103,25 @@ def boxes_to_masks(boxes: list[torch.Tensor], image_size: tuple[int, int]) -> to
 
 
 def boxes_to_anomaly_maps(boxes: torch.Tensor, scores: torch.Tensor, image_size: tuple[int, int]) -> torch.Tensor:
-    """Convert bounding box coordinates to anomaly heatmaps.
+    """Convert bounding boxes and scores to anomaly heatmaps.
 
     Args:
-        boxes (list[torch.Tensor]): A list of length B where each element is a tensor of shape (N, 4)
-            containing the bounding box coordinates of the regions of interest in xyxy format.
-        scores (list[torch.Tensor]): A list of length B where each element is a 1D tensor of length N
-            containing the anomaly scores for each region of interest.
-        image_size (tuple[int, int]): Image size of the output masks in (H, W) format.
+        boxes: List of length ``B`` where each element is tensor of shape ``(N, 4)``
+            containing bounding box coordinates in ``xyxy`` format
+        scores: List of length ``B`` where each element is 1D tensor of length ``N``
+            containing anomaly scores for each box
+        image_size: Output heatmap size as ``(H, W)``
 
     Returns:
-        Tensor: torch.Tensor of shape (B, H, W). The pixel locations within each bounding box are collectively
-            assigned the anomaly score of the bounding box. In the case of overlapping bounding boxes,
-            the highest score is used.
+        Anomaly heatmaps of shape ``(B, H, W)``. Pixels within each box are set to
+        that box's anomaly score. For overlapping boxes, the highest score is used.
+
+    Examples:
+        >>> boxes = [torch.tensor([[10, 15, 20, 25]])]  # One box
+        >>> scores = [torch.tensor([0.9])]  # Score for the box
+        >>> maps = boxes_to_anomaly_maps(boxes, scores, (32, 32))
+        >>> maps[0, 20, 15]  # Point inside box
+        tensor(0.9000)
     """
     anomaly_maps = torch.zeros((len(boxes), *image_size)).to(boxes[0].device)
     for im_idx, (im_boxes, im_scores) in enumerate(zip(boxes, scores, strict=False)):
@@ -102,15 +134,21 @@ def boxes_to_anomaly_maps(boxes: torch.Tensor, scores: torch.Tensor, image_size:
 
 
 def scale_boxes(boxes: torch.Tensor, image_size: torch.Size, new_size: torch.Size) -> torch.Tensor:
-    """Scale bbox coordinates to a new image size.
+    """Scale bounding box coordinates to a new image size.
 
     Args:
-        boxes (torch.Tensor): Boxes of shape (N, 4) - (x1, y1, x2, y2).
-        image_size (Size): Size of the original image in which the bbox coordinates were retrieved.
-        new_size (Size): New image size to which the bbox coordinates will be scaled.
+        boxes: Boxes of shape ``(N, 4)`` in ``(x1, y1, x2, y2)`` format
+        image_size: Original image size the boxes were computed for
+        new_size: Target image size to scale boxes to
 
     Returns:
-        Tensor: Updated boxes of shape (N, 4) - (x1, y1, x2, y2).
+        Scaled boxes of shape ``(N, 4)`` in ``(x1, y1, x2, y2)`` format
+
+    Examples:
+        >>> boxes = torch.tensor([[10, 15, 20, 25]])
+        >>> scaled = scale_boxes(boxes, (32, 32), (64, 64))
+        >>> scaled
+        tensor([[20., 30., 40., 50.]])
     """
     scale = torch.Tensor([*new_size]) / torch.Tensor([*image_size])
     return boxes * scale.repeat(2).to(boxes.device)
diff --git a/src/anomalib/data/utils/download.py b/src/anomalib/data/utils/download.py
index 7df5da1403..698b2d11bf 100644
--- a/src/anomalib/data/utils/download.py
+++ b/src/anomalib/data/utils/download.py
@@ -1,4 +1,10 @@
-"""Helper to show progress bars with `urlretrieve`, check hash of file."""
+"""Helper functions for downloading datasets with progress bars and hash verification.
+
+This module provides utilities for:
+- Showing progress bars during downloads with ``urlretrieve``
+- Verifying file hashes
+- Safely extracting compressed files
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -23,7 +29,14 @@
 
 @dataclass
 class DownloadInfo:
-    """Info needed to download a dataset from a url."""
+    """Information needed to download a dataset from a URL.
+
+    Args:
+        name: Name of the dataset
+        url: URL to download the dataset from
+        hashsum: Expected hash value of the downloaded file
+        filename: Optional filename to save as. If not provided, extracts from URL
+    """
 
     name: str
     url: str
@@ -32,98 +45,45 @@ class DownloadInfo:
 
 
 class DownloadProgressBar(tqdm):
-    """Create progress bar for urlretrieve. Subclasses `tqdm`.
-
-    For information about the parameters in constructor, refer to `tqdm`'s documentation.
-
-    Args:
-        iterable (Iterable | None): Iterable to decorate with a progressbar.
-                            Leave blank to manually manage the updates.
-        desc (str | None): Prefix for the progressbar.
-        total (int | float | None): The number of expected iterations. If unspecified,
-                                            len(iterable) is used if possible. If float("inf") or as a last
-                                            resort, only basic progress statistics are displayed
-                                            (no ETA, no progressbar).
-                                            If `gui` is True and this parameter needs subsequent updating,
-                                            specify an initial arbitrary large positive number,
-                                            e.g. 9e9.
-        leave (bool | None): upon termination of iteration. If `None`, will leave only if `position` is `0`.
-        file (io.TextIOWrapper |  io.StringIO | None): Specifies where to output the progress messages
-                                                            (default: sys.stderr). Uses `file.write(str)` and
-                                                            `file.flush()` methods.  For encoding, see
-                                                            `write_bytes`.
-        ncols (int | None): The width of the entire output message. If specified,
-                            dynamically resizes the progressbar to stay within this bound.
-                            If unspecified, attempts to use environment width. The
-                            fallback is a meter width of 10 and no limit for the counter and
-                            statistics. If 0, will not print any meter (only stats).
-        mininterval (float | None): Minimum progress display update interval [default: 0.1] seconds.
-        maxinterval (float | None): Maximum progress display update interval [default: 10] seconds.
-                                    Automatically adjusts `miniters` to correspond to `mininterval`
-                                    after long display update lag. Only works if `dynamic_miniters`
-                                    or monitor thread is enabled.
-        miniters (int | float | None): Minimum progress display update interval, in iterations.
-                                            If 0 and `dynamic_miniters`, will automatically adjust to equal
-                                            `mininterval` (more CPU efficient, good for tight loops).
-                                            If > 0, will skip display of specified number of iterations.
-                                            Tweak this and `mininterval` to get very efficient loops.
-                                            If your progress is erratic with both fast and slow iterations
-                                            (network, skipping items, etc) you should set miniters=1.
-        use_ascii (str | bool | None): If unspecified or False, use unicode (smooth blocks) to fill
-                                        the meter. The fallback is to use ASCII characters " 123456789#".
-        disable (bool | None): Whether to disable the entire progressbar wrapper
-                                    [default: False]. If set to None, disable on non-TTY.
-        unit (str | None): String that will be used to define the unit of each iteration
-                            [default: it].
-        unit_scale (int | float | bool): If 1 or True, the number of iterations will be reduced/scaled
-                            automatically and a metric prefix following the
-                            International System of Units standard will be added
-                            (kilo, mega, etc.) [default: False]. If any other non-zero
-                            number, will scale `total` and `n`.
-        dynamic_ncols (bool | None): If set, constantly alters `ncols` and `nrows` to the
-                                        environment (allowing for window resizes) [default: False].
-        smoothing (float | None): Exponential moving average smoothing factor for speed estimates
-                                    (ignored in GUI mode). Ranges from 0 (average speed) to 1
-                                    (current/instantaneous speed) [default: 0.3].
-        bar_format (str | None):  Specify a custom bar string formatting. May impact performance.
-                                    [default: '{l_bar}{bar}{r_bar}'], where
-                                    l_bar='{desc}: {percentage:3.0f}%|' and
-                                    r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, '
-                                    '{rate_fmt}{postfix}]'
-                                    Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt,
-                                    percentage, elapsed, elapsed_s, ncols, nrows, desc, unit,
-                                    rate, rate_fmt, rate_noinv, rate_noinv_fmt,
-                                    rate_inv, rate_inv_fmt, postfix, unit_divisor,
-                                    remaining, remaining_s, eta.
-                                    Note that a trailing ": " is automatically removed after {desc}
-                                    if the latter is empty.
-        initial (int | float | None): The initial counter value. Useful when restarting a progress
-                                            bar [default: 0]. If using float, consider specifying `{n:.3f}`
-                                            or similar in `bar_format`, or specifying `unit_scale`.
-        position (int | None): Specify the line offset to print this bar (starting from 0)
-                                    Automatic if unspecified.
-                                    Useful to manage multiple bars at once (eg, from threads).
-        postfix (dict | None): Specify additional stats to display at the end of the bar.
-                                    Calls `set_postfix(**postfix)` if possible (dict).
-        unit_divisor (float | None): [default: 1000], ignored unless `unit_scale` is True.
-        write_bytes (bool | None): If (default: None) and `file` is unspecified,
-                                    bytes will be written in Python 2. If `True` will also write
-                                    bytes. In all other cases will default to unicode.
-        lock_args (tuple | None): Passed to `refresh` for intermediate output
-                                    (initialisation, iterating, and updating).
-                                    nrows (int | None): The screen height. If specified, hides nested bars
-                                    outside this bound. If unspecified, attempts to use environment height.
-                                    The fallback is 20.
-        colour (str | None): Bar colour (e.g. 'green', '#00ff00').
-        delay (float | None): Don't display until [default: 0] seconds have elapsed.
-        gui (bool | None): WARNING: internal parameter - do not use.
-                                Use tqdm.gui.tqdm(...) instead. If set, will attempt to use
-                                matplotlib animations for a graphical output [default: False].
+    """Progress bar for ``urlretrieve`` downloads.
 
+    Subclasses ``tqdm`` to provide a progress bar during file downloads.
 
     Example:
-        >>> with DownloadProgressBar(unit='B', unit_scale=True, miniters=1, desc=url.split('/')[-1]) as p_bar:
-        >>>         urllib.request.urlretrieve(url, filename=output_path, reporthook=p_bar.update_to)
+        >>> url = "https://example.com/file.zip"
+        >>> output_path = "file.zip"
+        >>> with DownloadProgressBar(unit='B', unit_scale=True, miniters=1,
+        ...         desc=url.split('/')[-1]) as p_bar:
+        ...     urlretrieve(url, filename=output_path,
+        ...                reporthook=p_bar.update_to)
+
+    Args:
+        iterable: Iterable to decorate with a progressbar
+        desc: Prefix for the progressbar
+        total: Expected number of iterations
+        leave: Whether to leave the progress bar after completion
+        file: Output stream for progress messages
+        ncols: Width of the progress bar
+        mininterval: Minimum update interval in seconds
+        maxinterval: Maximum update interval in seconds
+        miniters: Minimum progress display update interval in iterations
+        use_ascii: Whether to use ASCII characters for the progress bar
+        disable: Whether to disable the progress bar
+        unit: Unit of measurement
+        unit_scale: Whether to scale units automatically
+        dynamic_ncols: Whether to adapt to terminal resizes
+        smoothing: Exponential moving average smoothing factor
+        bar_format: Custom progress bar format string
+        initial: Initial counter value
+        position: Line offset for printing
+        postfix: Additional stats to display
+        unit_divisor: Unit divisor for scaling
+        write_bytes: Whether to write bytes
+        lock_args: Arguments passed to refresh
+        nrows: Screen height
+        colour: Bar color
+        delay: Display delay in seconds
+        gui: Whether to use matplotlib animations
     """
 
     def __init__(
@@ -187,17 +147,21 @@ def __init__(
         )
         self.total: int | float | None
 
-    def update_to(self, chunk_number: int = 1, max_chunk_size: int = 1, total_size: int | None = None) -> None:
-        """Progress bar hook for tqdm.
+    def update_to(
+        self,
+        chunk_number: int = 1,
+        max_chunk_size: int = 1,
+        total_size: int | None = None,
+    ) -> None:
+        """Update progress bar based on download progress.
 
-        Based on https://stackoverflow.com/a/53877507
-        The implementor does not have to bother about passing parameters to this as it gets them from urlretrieve.
-        However the context needs a few parameters. Refer to the example.
+        This method is used as a callback for ``urlretrieve`` to update the
+        progress bar during downloads.
 
         Args:
-            chunk_number (int, optional): The current chunk being processed. Defaults to 1.
-            max_chunk_size (int, optional): Maximum size of each chunk. Defaults to 1.
-            total_size (int, optional): Total download size. Defaults to None.
+            chunk_number: Current chunk being processed
+            max_chunk_size: Maximum size of each chunk
+            total_size: Total download size
         """
         if total_size is not None:
             self.total = total_size
@@ -205,14 +169,13 @@ def update_to(self, chunk_number: int = 1, max_chunk_size: int = 1, total_size:
 
 
 def is_file_potentially_dangerous(file_name: str) -> bool:
-    """Check if a file is potentially dangerous.
+    """Check if a file path contains potentially dangerous patterns.
 
     Args:
-        file_name (str): Filename.
+        file_name: Path to check
 
     Returns:
-        bool: True if the member is potentially dangerous, False otherwise.
-
+        ``True`` if the path matches unsafe patterns, ``False`` otherwise
     """
     # Some example criteria. We could expand this.
     unsafe_patterns = ["/etc/", "/root/"]
@@ -220,13 +183,12 @@ def is_file_potentially_dangerous(file_name: str) -> bool:
 
 
 def safe_extract(tar_file: TarFile, root: Path, members: list[TarInfo]) -> None:
-    """Extract safe members from a tar archive.
+    """Safely extract members from a tar archive.
 
     Args:
-        tar_file (TarFile): TarFile object.
-        root (Path): Root directory where the dataset will be stored.
-        members (List[TarInfo]): List of safe members to be extracted.
-
+        tar_file: TarFile object to extract from
+        root: Root directory for extraction
+        members: List of safe members to extract
     """
     for member in members:
         # check if the file already exists
@@ -238,14 +200,14 @@ def generate_hash(file_path: str | Path, algorithm: str = "sha256") -> str:
     """Generate a hash of a file using the specified algorithm.
 
     Args:
-        file_path (str | Path): Path to the file to hash.
-        algorithm (str): The hashing algorithm to use (e.g., 'sha256', 'sha3_512').
+        file_path: Path to the file to hash
+        algorithm: Hashing algorithm to use (e.g. 'sha256', 'sha3_512')
 
     Returns:
-        str: The hexadecimal hash string of the file.
+        Hexadecimal hash string of the file
 
     Raises:
-        ValueError: If the specified hashing algorithm is not supported.
+        ValueError: If the specified hashing algorithm is not supported
     """
     # Get the hashing algorithm.
     try:
@@ -264,30 +226,37 @@ def generate_hash(file_path: str | Path, algorithm: str = "sha256") -> str:
 
 
 def check_hash(file_path: Path, expected_hash: str, algorithm: str = "sha256") -> None:
-    """Raise value error if hash does not match the calculated hash of the file.
+    """Verify that a file's hash matches the expected value.
 
     Args:
-        file_path (Path): Path to file.
-        expected_hash (str): Expected hash of the file.
-        algorithm (str): Hashing algorithm to use ('sha256', 'sha3_512', etc.).
+        file_path: Path to file to check
+        expected_hash: Expected hash value
+        algorithm: Hashing algorithm to use
+
+    Raises:
+        ValueError: If the calculated hash does not match the expected hash
     """
     # Compare the calculated hash with the expected hash
     calculated_hash = generate_hash(file_path, algorithm)
     if calculated_hash != expected_hash:
         msg = (
-            f"Calculated hash {calculated_hash} of downloaded file {file_path} does not match the required hash "
-            f"{expected_hash}."
+            f"Calculated hash {calculated_hash} of downloaded file {file_path} "
+            f"does not match the required hash {expected_hash}."
         )
         raise ValueError(msg)
 
 
 def extract(file_name: Path, root: Path) -> None:
-    """Extract a dataset.
+    """Extract a compressed dataset file.
+
+    Supports .zip, .tar, .gz, .xz and .tgz formats.
 
     Args:
-        file_name (Path): Path of the file to be extracted.
-        root (Path): Root directory where the dataset will be stored.
+        file_name: Path of the file to extract
+        root: Root directory for extraction
 
+    Raises:
+        ValueError: If the file format is not recognized
     """
     logger.info(f"Extracting dataset into {root} folder.")
 
@@ -317,12 +286,15 @@ def download_and_extract(root: Path, info: DownloadInfo) -> None:
     """Download and extract a dataset.
 
     Args:
-        root (Path): Root directory where the dataset will be stored.
-        info (DownloadInfo): Info needed to download the dataset.
+        root: Root directory where the dataset will be stored
+        info: Download information for the dataset
+
+    Raises:
+        RuntimeError: If the URL scheme is not http(s)
     """
     root.mkdir(parents=True, exist_ok=True)
 
-    # save the compressed file in the specified root directory, using the same file name as on the server
+    # save the compressed file in the specified root directory
     downloaded_file_path = root / info.filename if info.filename else root / info.url.split("/")[-1]
 
     if downloaded_file_path.exists():
@@ -350,16 +322,17 @@ def is_within_directory(directory: Path, target: Path) -> bool:
     """Check if a target path is located within a given directory.
 
     Args:
-        directory (Path): path of the parent directory
-        target (Path): path of the target
+        directory: Path of the parent directory
+        target: Path to check
 
     Returns:
-        (bool): True if the target is within the directory, False otherwise
+        ``True`` if target is within directory, ``False`` otherwise
     """
     abs_directory = directory.resolve()
     abs_target = target.resolve()
 
-    # TODO(djdameln): Replace with pathlib is_relative_to after switching to Python 3.10
+    # TODO(djdameln): Replace with pathlib is_relative_to after switching to
+    # Python 3.10
     # CVS-122655
     prefix = os.path.commonprefix([abs_directory, abs_target])
     return prefix == str(abs_directory)
diff --git a/src/anomalib/data/utils/generators/__init__.py b/src/anomalib/data/utils/generators/__init__.py
index c46f30d08e..c9c0410c03 100644
--- a/src/anomalib/data/utils/generators/__init__.py
+++ b/src/anomalib/data/utils/generators/__init__.py
@@ -1,6 +1,26 @@
-"""Utilities to generate synthetic data."""
+"""Utilities to generate synthetic data.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides utilities for generating synthetic data for anomaly detection.
+The utilities include:
+
+- Perlin noise generation: Functions for creating Perlin noise patterns
+- Anomaly generation: Classes for generating synthetic anomalies
+
+Example:
+    >>> from anomalib.data.utils.generators import generate_perlin_noise
+    >>> # Generate 256x256 Perlin noise
+    >>> noise = generate_perlin_noise(256, 256)
+    >>> print(noise.shape)
+    torch.Size([256, 256])
+
+    >>> from anomalib.data.utils.generators import PerlinAnomalyGenerator
+    >>> # Create anomaly generator
+    >>> generator = PerlinAnomalyGenerator()
+    >>> # Generate anomaly mask
+    >>> mask = generator.generate(256, 256)
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .perlin import PerlinAnomalyGenerator, generate_perlin_noise
diff --git a/src/anomalib/data/utils/generators/perlin.py b/src/anomalib/data/utils/generators/perlin.py
index 052d565121..acdbcb56ef 100644
--- a/src/anomalib/data/utils/generators/perlin.py
+++ b/src/anomalib/data/utils/generators/perlin.py
@@ -1,4 +1,26 @@
-"""Perlin noise-based synthetic anomaly generator."""
+"""Perlin noise-based synthetic anomaly generator.
+
+This module provides functionality to generate synthetic anomalies using Perlin noise
+patterns. The generator can create both noise-based and image-based anomalies with
+configurable parameters.
+
+Example:
+    >>> from anomalib.data.utils.generators.perlin import generate_perlin_noise
+    >>> import torch
+    >>> # Generate 256x256 noise with default random scale
+    >>> noise = generate_perlin_noise(256, 256)
+    >>> print(noise.shape)
+    torch.Size([256, 256])
+
+    >>> # Generate 512x512 noise with fixed scale
+    >>> noise = generate_perlin_noise(512, 512, scale=(8, 8))
+    >>> print(noise.shape)
+    torch.Size([512, 512])
+
+    >>> # Generate noise on GPU if available
+    >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    >>> noise = generate_perlin_noise(128, 128, device=device)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -21,21 +43,25 @@ def generate_perlin_noise(
 ) -> torch.Tensor:
     """Generate a Perlin noise pattern.
 
-    This function generates a Perlin noise pattern using a grid-based gradient noise approach.
-    The noise is generated by interpolating between randomly generated gradient vectors at grid vertices.
-    The interpolation uses a quintic curve for smooth transitions.
+    This function generates a Perlin noise pattern using a grid-based gradient noise
+    approach. The noise is generated by interpolating between randomly generated
+    gradient vectors at grid vertices. The interpolation uses a quintic curve for
+    smooth transitions.
 
     Args:
-        height: Desired height of the noise pattern
-        width: Desired width of the noise pattern
-        scale: Tuple of (scale_x, scale_y) for noise granularity. If None, random scales will be used.
-               Larger scales produce coarser noise patterns, while smaller scales produce finer patterns.
-        device: Device to generate the noise on. If None, uses current default device
+        height: Desired height of the noise pattern.
+        width: Desired width of the noise pattern.
+        scale: Tuple of ``(scale_x, scale_y)`` for noise granularity. If ``None``,
+            random scales will be used. Larger scales produce coarser noise patterns,
+            while smaller scales produce finer patterns.
+        device: Device to generate the noise on. If ``None``, uses current default
+            device.
 
     Returns:
-        Tensor of shape [height, width] containing the noise pattern, with values roughly in [-1, 1] range
+        torch.Tensor: Tensor of shape ``[height, width]`` containing the noise
+            pattern, with values roughly in ``[-1, 1]`` range.
 
-    Examples:
+    Example:
         >>> # Generate 256x256 noise with default random scale
         >>> noise = generate_perlin_noise(256, 256)
         >>> print(noise.shape)
@@ -128,7 +154,23 @@ def fade(t: torch.Tensor) -> torch.Tensor:
 class PerlinAnomalyGenerator(v2.Transform):
     """Perlin noise-based synthetic anomaly generator.
 
-    Examples:
+    This class provides functionality to generate synthetic anomalies using Perlin
+    noise patterns. It can also use real anomaly source images for more realistic
+    anomaly generation.
+
+    Args:
+        anomaly_source_path: Optional path to directory containing anomaly source
+            images. If provided, these images will be used instead of Perlin noise
+            patterns.
+        probability: Probability of applying the anomaly transformation to an image.
+            Default: ``0.5``.
+        blend_factor: Factor determining how much of the anomaly to blend with the
+            original image. Can be a float or a tuple of ``(min, max)``. Default:
+            ``(0.2, 1.0)``.
+        rotation_range: Range of rotation angles in degrees for the Perlin noise
+            pattern. Default: ``(-90, 90)``.
+
+    Example:
         >>> # Single image usage with default parameters
         >>> transform = PerlinAnomalyGenerator()
         >>> image = torch.randn(3, 256, 256)  # [C, H, W]
@@ -215,13 +257,15 @@ def generate_perturbation(
         """Generate perturbed image and mask.
 
         Args:
-            height: Height of the output image
-            width: Width of the output image
-            device: Device to generate the perturbation on
-            anomaly_source_path: Optional path to source image for anomaly
+            height: Height of the output image.
+            width: Width of the output image.
+            device: Device to generate the perturbation on.
+            anomaly_source_path: Optional path to source image for anomaly.
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor]: Perturbation and mask tensors
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing:
+                - Perturbation tensor of shape ``[H, W, C]``
+                - Mask tensor of shape ``[H, W, 1]``
         """
         # Generate perlin noise
         perlin_noise = generate_perlin_noise(height, width, device=device)
@@ -265,7 +309,19 @@ def _transform_image(
         w: int,
         device: torch.device,
     ) -> tuple[torch.Tensor, torch.Tensor]:
-        """Transform a single image."""
+        """Transform a single image.
+
+        Args:
+            img: Input image tensor of shape ``[C, H, W]``.
+            h: Height of the image.
+            w: Width of the image.
+            device: Device to perform the transformation on.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing:
+                - Augmented image tensor of shape ``[C, H, W]``
+                - Mask tensor of shape ``[1, H, W]``
+        """
         if torch.rand(1, device=device) > self.probability:
             return img, torch.zeros((1, h, w), device=device)
 
@@ -295,7 +351,17 @@ def _transform_image(
         return augmented_img, mask
 
     def forward(self, img: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        """Apply augmentation using the mask for single image or batch."""
+        """Apply augmentation using the mask for single image or batch.
+
+        Args:
+            img: Input image tensor of shape ``[C, H, W]`` or batch tensor of shape
+                ``[B, C, H, W]``.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing:
+                - Augmented image tensor of same shape as input
+                - Mask tensor of shape ``[1, H, W]`` or ``[B, 1, H, W]``
+        """
         device = img.device
         is_batch = len(img.shape) == 4
 
diff --git a/src/anomalib/data/utils/image.py b/src/anomalib/data/utils/image.py
index 64a27724cc..0f0ed0c255 100644
--- a/src/anomalib/data/utils/image.py
+++ b/src/anomalib/data/utils/image.py
@@ -1,4 +1,25 @@
-"""Image Utils."""
+"""Image utilities for reading, writing and processing images.
+
+This module provides various utility functions for handling images in Anomalib:
+
+- Reading images in various formats (RGB, grayscale, depth)
+- Writing images to disk
+- Converting between different image formats
+- Processing images (padding, resizing etc.)
+- Handling image filenames and paths
+
+Example:
+    >>> from anomalib.data.utils import read_image
+    >>> # Read image as numpy array
+    >>> image = read_image("image.jpg")
+    >>> print(type(image))
+    
+
+    >>> # Read image as tensor
+    >>> image = read_image("image.jpg", as_tensor=True)
+    >>> print(type(image))
+    
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -25,25 +46,22 @@
 
 
 def is_image_file(filename: str | Path) -> bool:
-    """Check if the filename is an image file.
+    """Check if the filename has a valid image extension.
 
     Args:
-        filename (str | Path): Filename to check.
+        filename (str | Path): Path to file to check
 
     Returns:
-        bool: True if the filename is an image file.
+        bool: ``True`` if filename has valid image extension
 
     Examples:
-        >>> is_image_file("000.png")
+        >>> is_image_file("image.jpg")
         True
 
-        >>> is_image_file("002.JPEG")
+        >>> is_image_file("image.png")
         True
 
-        >>> is_image_file("009.tiff")
-        True
-
-        >>> is_image_file("002.avi")
+        >>> is_image_file("image.txt")
         False
     """
     filename = Path(filename)
@@ -51,39 +69,31 @@ def is_image_file(filename: str | Path) -> bool:
 
 
 def get_image_filename(filename: str | Path) -> Path:
-    """Get image filename.
+    """Get validated image filename.
 
     Args:
-        filename (str | Path): Filename to check.
+        filename (str | Path): Path to image file
 
     Returns:
-        Path: Image filename.
-
-    Examples:
-        Assume that we have the following files in the directory:
-
-        .. code-block:: bash
+        Path: Validated path to image file
 
-            $ ls
-            000.png  001.jpg  002.JPEG  003.tiff  004.png  005.txt
-
-        >>> get_image_filename("000.png")
-        PosixPath('000.png')
+    Raises:
+        FileNotFoundError: If file does not exist
+        ValueError: If file is not an image
 
-        >>> get_image_filename("001.jpg")
-        PosixPath('001.jpg')
+    Examples:
+        >>> get_image_filename("image.jpg")
+        PosixPath('image.jpg')
 
-        >>> get_image_filename("009.tiff")
+        >>> get_image_filename("missing.jpg")
         Traceback (most recent call last):
-        File "", line 1, in 
-        File "", line 18, in get_image_filename
-        FileNotFoundError: File not found: 009.tiff
+            ...
+        FileNotFoundError: File not found: missing.jpg
 
-        >>> get_image_filename("005.txt")
+        >>> get_image_filename("text.txt")
         Traceback (most recent call last):
-        File "", line 1, in 
-        File "", line 18, in get_image_filename
-        ValueError: ``filename`` is not an image file. 005.txt
+            ...
+        ValueError: ``filename`` is not an image file: text.txt
     """
     filename = Path(filename)
 
@@ -98,31 +108,25 @@ def get_image_filename(filename: str | Path) -> Path:
 
 
 def get_image_filenames_from_dir(path: str | Path) -> list[Path]:
-    """Get image filenames from directory.
+    """Get list of image filenames from directory.
 
     Args:
-        path (str | Path): Path to image directory.
-
-    Raises:
-        ValueError: When ``path`` is not a directory.
+        path (str | Path): Path to directory containing images
 
     Returns:
-        list[Path]: Image filenames.
+        list[Path]: List of paths to image files
 
-    Examples:
-        Assume that we have the following files in the directory:
-        $ ls
-        000.png  001.jpg  002.JPEG  003.tiff  004.png  005.png
+    Raises:
+        ValueError: If path is not a directory or no images found
 
-        >>> get_image_filenames_from_dir(".")
-        [PosixPath('000.png'), PosixPath('001.jpg'), PosixPath('002.JPEG'),
-        PosixPath('003.tiff'), PosixPath('004.png'), PosixPath('005.png')]
+    Examples:
+        >>> get_image_filenames_from_dir("images/")
+        [PosixPath('images/001.jpg'), PosixPath('images/002.png')]
 
-        >>> get_image_filenames_from_dir("009.tiff")
+        >>> get_image_filenames_from_dir("empty/")
         Traceback (most recent call last):
-        File "", line 1, in 
-        File "", line 18, in get_image_filenames_from_dir
-        ValueError: ``path`` is not a directory: 009.tiff
+            ...
+        ValueError: Found 0 images in empty/
     """
     path = Path(path)
     if not path.is_dir():
@@ -139,50 +143,26 @@ def get_image_filenames_from_dir(path: str | Path) -> list[Path]:
 
 
 def get_image_filenames(path: str | Path, base_dir: str | Path | None = None) -> list[Path]:
-    """Get image filenames.
+    """Get list of image filenames from path.
 
     Args:
-        path (str | Path): Path to image or image-folder.
-        base_dir (Path): Base directory to restrict file access.
+        path (str | Path): Path to image file or directory
+        base_dir (str | Path | None): Base directory to restrict file access
 
     Returns:
-        list[Path]: List of image filenames.
+        list[Path]: List of paths to image files
 
     Examples:
-        Assume that we have the following files in the directory:
+        >>> get_image_filenames("image.jpg")
+        [PosixPath('image.jpg')]
 
-        .. code-block:: bash
+        >>> get_image_filenames("images/")
+        [PosixPath('images/001.jpg'), PosixPath('images/002.png')]
 
-            $ tree images
-            images
-            ├── bad
-            │   ├── 003.png
-            │   └── 004.jpg
-            └── good
-                ├── 000.png
-                └── 001.tiff
-
-        We can get the image filenames with various ways:
-
-        >>> get_image_filenames("images/bad/003.png")
-        PosixPath('/home/sakcay/Projects/anomalib/images/bad/003.png')]
-
-        It is possible to recursively get the image filenames from a directory:
-
-        >>> get_image_filenames("images")
-        [PosixPath('/home/sakcay/Projects/anomalib/images/bad/003.png'),
-        PosixPath('/home/sakcay/Projects/anomalib/images/bad/004.jpg'),
-        PosixPath('/home/sakcay/Projects/anomalib/images/good/001.tiff'),
-        PosixPath('/home/sakcay/Projects/anomalib/images/good/000.png')]
-
-        If we want to restrict the file access to a specific directory,
-        we can use ``base_dir`` argument.
-
-        >>> get_image_filenames("images", base_dir="images/bad")
+        >>> get_image_filenames("images/", base_dir="allowed/")
         Traceback (most recent call last):
-        File "", line 1, in 
-        File "", line 18, in get_image_filenames
-        ValueError: Access denied: Path is outside the allowed directory.
+            ...
+        ValueError: Access denied: Path is outside the allowed directory
     """
     path = validate_path(path, base_dir)
     image_filenames: list[Path] = []
@@ -199,24 +179,23 @@ def get_image_filenames(path: str | Path, base_dir: str | Path | None = None) ->
 
 
 def duplicate_filename(path: str | Path) -> Path:
-    """Check and duplicate filename.
-
-    This function checks the path and adds a suffix if it already exists on the file system.
+    """Add numeric suffix to filename if it already exists.
 
     Args:
-        path (str | Path): Input Path
+        path (str | Path): Path to file
+
+    Returns:
+        Path: Path with numeric suffix if original exists
 
     Examples:
-        >>> path = Path("datasets/MVTec/bottle/test/broken_large/000.png")
-        >>> path.exists()
-        True
+        >>> duplicate_filename("image.jpg")  # File doesn't exist
+        PosixPath('image.jpg')
 
-        If we pass this to ``duplicate_filename`` function we would get the following:
-        >>> duplicate_filename(path)
-        PosixPath('datasets/MVTec/bottle/test/broken_large/000_1.png')
+        >>> duplicate_filename("exists.jpg")  # File exists
+        PosixPath('exists_1.jpg')
 
-    Returns:
-        Path: Duplicated output path.
+        >>> duplicate_filename("exists.jpg")  # Both exist
+        PosixPath('exists_2.jpg')
     """
     path = Path(path)
 
@@ -234,54 +213,36 @@ def duplicate_filename(path: str | Path) -> Path:
 
 
 def generate_output_image_filename(input_path: str | Path, output_path: str | Path) -> Path:
-    """Generate an output filename to save the inference image.
-
-    This function generates an output filaname by checking the input and output filenames. Input path is
-    the input to infer, and output path is the path to save the output predictions specified by the user.
-
-    The function expects ``input_path`` to always be a file, not a directory. ``output_path`` could be a
-    filename or directory. If it is a filename, the function checks if the specified filename exists on
-    the file system. If yes, the function calls ``duplicate_filename`` to duplicate the filename to avoid
-    overwriting the existing file. If ``output_path`` is a directory, this function adds the parent and
-    filenames of ``input_path`` to ``output_path``.
+    """Generate output filename for inference image.
 
     Args:
-        input_path (str | Path): Path to the input image to infer.
-        output_path (str | Path): Path to output to save the predictions.
-            Could be a filename or a directory.
+        input_path (str | Path): Path to input image
+        output_path (str | Path): Path to save output (file or directory)
 
-    Examples:
-        >>> input_path = Path("datasets/MVTec/bottle/test/broken_large/000.png")
-        >>> output_path = Path("datasets/MVTec/bottle/test/broken_large/000.png")
-        >>> generate_output_image_filename(input_path, output_path)
-        PosixPath('datasets/MVTec/bottle/test/broken_large/000_1.png')
-
-        >>> input_path = Path("datasets/MVTec/bottle/test/broken_large/000.png")
-        >>> output_path = Path("results/images")
-        >>> generate_output_image_filename(input_path, output_path)
-        PosixPath('results/images/broken_large/000.png')
+    Returns:
+        Path: Generated output filename
 
     Raises:
-        ValueError: When the ``input_path`` is not a file.
+        ValueError: If input_path is not a file
 
-    Returns:
-        Path: The output filename to save the output predictions from the inferencer.
+    Examples:
+        >>> generate_output_image_filename("input.jpg", "output.jpg")
+        PosixPath('output.jpg')  # or output_1.jpg if exists
+
+        >>> generate_output_image_filename("dir/input.jpg", "outdir")
+        PosixPath('outdir/dir/input.jpg')
     """
     input_path = validate_path(input_path)
     output_path = validate_path(output_path, should_exist=False)
 
-    # Input validation: Check if input_path is a valid directory or file
-    if input_path.is_file() is False:
-        msg = "input_path is expected to be a file to generate a proper output filename."
+    if not input_path.is_file():
+        msg = "input_path is expected to be a file"
         raise ValueError(msg)
 
-    # If the output is a directory, then add parent directory name
-    # and filename to the path. This is to ensure we do not overwrite
-    # images and organize based on the categories.
     if output_path.is_dir():
         output_image_filename = output_path / input_path.parent.name / input_path.name
     elif output_path.is_file() and output_path.exists():
-        msg = f"{output_path} already exists. Renaming the file to avoid overwriting."
+        msg = f"{output_path} already exists. Renaming to avoid overwriting."
         logger.warning(msg)
         output_image_filename = duplicate_filename(output_path)
     else:
@@ -293,32 +254,28 @@ def generate_output_image_filename(input_path: str | Path, output_path: str | Pa
 
 
 def get_image_height_and_width(image_size: int | Sequence[int]) -> tuple[int, int]:
-    """Get image height and width from ``image_size`` variable.
+    """Get height and width from image size parameter.
 
     Args:
-        image_size (int | Sequence[int] | None, optional): Input image size.
+        image_size (int | Sequence[int]): Single int for square, or (H,W) sequence
+
+    Returns:
+        tuple[int, int]: Image height and width
 
     Raises:
-        ValueError: Image size not None, int or Sequence of values.
+        TypeError: If image_size is not int or sequence of ints
 
     Examples:
-        >>> get_image_height_and_width(image_size=256)
+        >>> get_image_height_and_width(256)
         (256, 256)
 
-        >>> get_image_height_and_width(image_size=(256, 256))
-        (256, 256)
+        >>> get_image_height_and_width((480, 640))
+        (480, 640)
 
-        >>> get_image_height_and_width(image_size=(256, 256, 3))
-        (256, 256)
-
-        >>> get_image_height_and_width(image_size=256.)
+        >>> get_image_height_and_width(256.0)
         Traceback (most recent call last):
-        File "", line 1, in 
-        File "", line 18, in get_image_height_and_width
-        ValueError: ``image_size`` could be either int or tuple[int, int]
-
-    Returns:
-        tuple[int | None, int | None]: A tuple containing image height and width values.
+            ...
+        TypeError: ``image_size`` could be either int or tuple[int, int]
     """
     if isinstance(image_size, int):
         height_and_width = (image_size, image_size)
@@ -332,41 +289,44 @@ def get_image_height_and_width(image_size: int | Sequence[int]) -> tuple[int, in
 
 
 def read_image(path: str | Path, as_tensor: bool = False) -> torch.Tensor | np.ndarray:
-    """Read image from disk in RGB format.
+    """Read RGB image from disk.
 
     Args:
-        path (str, Path): path to the image file
-        as_tensor (bool, optional): If True, returns the image as a tensor. Defaults to False.
+        path (str | Path): Path to image file
+        as_tensor (bool): If ``True``, return torch.Tensor. Defaults to ``False``
 
-    Example:
-        >>> image = read_image("test_image.jpg")
+    Returns:
+        torch.Tensor | np.ndarray: Image as tensor or array, normalized to [0,1]
+
+    Examples:
+        >>> image = read_image("image.jpg")
         >>> type(image)
         
-        >>>
-        >>> image = read_image("test_image.jpg", as_tensor=True)
+
+        >>> image = read_image("image.jpg", as_tensor=True)
         >>> type(image)
         
-
-    Returns:
-        image as numpy array
     """
     image = Image.open(path).convert("RGB")
     return to_dtype(to_image(image), torch.float32, scale=True) if as_tensor else np.array(image) / 255.0
 
 
 def read_mask(path: str | Path, as_tensor: bool = False) -> torch.Tensor | np.ndarray:
-    """Read mask from disk.
+    """Read grayscale mask from disk.
 
     Args:
-        path (str, Path): path to the mask file
-        as_tensor (bool, optional): If True, returns the mask as a tensor. Defaults to False.
+        path (str | Path): Path to mask file
+        as_tensor (bool): If ``True``, return torch.Tensor. Defaults to ``False``
+
+    Returns:
+        torch.Tensor | np.ndarray: Mask as tensor or array
 
-    Example:
-        >>> mask = read_mask("test_mask.png")
+    Examples:
+        >>> mask = read_mask("mask.png")
         >>> type(mask)
         
-        >>>
-        >>> mask = read_mask("test_mask.png", as_tensor=True)
+
+        >>> mask = read_mask("mask.png", as_tensor=True)
         >>> type(mask)
         
     """
@@ -375,34 +335,40 @@ def read_mask(path: str | Path, as_tensor: bool = False) -> torch.Tensor | np.nd
 
 
 def read_depth_image(path: str | Path) -> np.ndarray:
-    """Read tiff depth image from disk.
+    """Read depth image from TIFF file.
 
     Args:
-        path (str, Path): path to the image file
-
-    Example:
-        >>> image = read_depth_image("test_image.tiff")
+        path (str | Path): Path to TIFF depth image
 
     Returns:
-        image as numpy array
+        np.ndarray: Depth image array
+
+    Examples:
+        >>> depth = read_depth_image("depth.tiff")
+        >>> type(depth)
+        
     """
     path = path if isinstance(path, str) else str(path)
     return tiff.imread(path)
 
 
 def pad_nextpow2(batch: torch.Tensor) -> torch.Tensor:
-    """Compute required padding from input size and return padded images.
+    """Pad images to next power of 2 size.
 
-    Finds the largest dimension and computes a square image of dimensions that are of the power of 2.
-    In case the image dimension is odd, it returns the image with an extra padding on one side.
+    Finds largest dimension and pads to square power-of-2 size. Handles odd sizes.
 
     Args:
-        batch (torch.Tensor): Input images
+        batch (torch.Tensor): Batch of images to pad
 
     Returns:
-        batch: Padded batch
+        torch.Tensor: Padded image batch
+
+    Examples:
+        >>> x = torch.randn(1, 3, 127, 128)
+        >>> padded = pad_nextpow2(x)
+        >>> padded.shape
+        torch.Size([1, 3, 128, 128])
     """
-    # find the largest dimension
     l_dim = 2 ** math.ceil(math.log(max(*batch.shape[-2:]), 2))
     padding_w = [math.ceil((l_dim - batch.shape[-2]) / 2), math.floor((l_dim - batch.shape[-2]) / 2)]
     padding_h = [math.ceil((l_dim - batch.shape[-1]) / 2), math.floor((l_dim - batch.shape[-1]) / 2)]
@@ -410,11 +376,15 @@ def pad_nextpow2(batch: torch.Tensor) -> torch.Tensor:
 
 
 def show_image(image: np.ndarray | Figure, title: str = "Image") -> None:
-    """Show an image on the screen.
+    """Display image in window.
 
     Args:
-        image (np.ndarray | Figure): Image that will be shown in the window.
-        title (str, optional): Title that will be given to that window. Defaults to "Image".
+        image (np.ndarray | Figure): Image or matplotlib figure to display
+        title (str): Window title. Defaults to "Image"
+
+    Examples:
+        >>> img = read_image("image.jpg")
+        >>> show_image(img, title="My Image")
     """
     if isinstance(image, Figure):
         image = figure_to_array(image)
@@ -425,13 +395,18 @@ def show_image(image: np.ndarray | Figure, title: str = "Image") -> None:
 
 
 def save_image(filename: Path | str, image: np.ndarray | Figure, root: Path | None = None) -> None:
-    """Save an image to the file system.
+    """Save image to disk.
 
     Args:
-        filename (Path | str): Path or filename to which the image will be saved.
-        image (np.ndarray | Figure): Image that will be saved to the file system.
-        root (Path, optional): Root directory to save the image. If provided, the top level directory of an absolute
-            filename will be overwritten. Defaults to None.
+        filename (Path | str): Output filename
+        image (np.ndarray | Figure): Image or matplotlib figure to save
+        root (Path | None): Optional root dir to save under. Defaults to None
+
+    Examples:
+        >>> img = read_image("input.jpg")
+        >>> save_image("output.jpg", img)
+
+        >>> save_image("subdir/output.jpg", img, root=Path("results"))
     """
     if isinstance(image, Figure):
         image = figure_to_array(image)
@@ -453,13 +428,21 @@ def save_image(filename: Path | str, image: np.ndarray | Figure, root: Path | No
 
 
 def figure_to_array(fig: Figure) -> np.ndarray:
-    """Convert a matplotlib figure to a numpy array.
+    """Convert matplotlib figure to numpy array.
 
     Args:
-        fig (Figure): Matplotlib figure.
+        fig (Figure): Matplotlib figure to convert
 
     Returns:
-        np.ndarray: Numpy array containing the image.
+        np.ndarray: RGB image array
+
+    Examples:
+        >>> import matplotlib.pyplot as plt
+        >>> fig = plt.figure()
+        >>> plt.plot([1, 2, 3])
+        >>> img = figure_to_array(fig)
+        >>> type(img)
+        
     """
     fig.canvas.draw()
     # convert figure to np.ndarray for saving via visualizer
diff --git a/src/anomalib/data/utils/label.py b/src/anomalib/data/utils/label.py
index 28908c8169..ce12b8bfb2 100644
--- a/src/anomalib/data/utils/label.py
+++ b/src/anomalib/data/utils/label.py
@@ -1,4 +1,20 @@
-"""Label name enum class."""
+"""Label name enumeration class.
+
+This module defines an enumeration class for labeling data in anomaly detection tasks.
+The labels are represented as integers, where:
+
+- ``NORMAL`` (0): Represents normal/good samples
+- ``ABNORMAL`` (1): Represents anomalous/defective samples
+
+Example:
+    >>> from anomalib.data.utils.label import LabelName
+    >>> label = LabelName.NORMAL
+    >>> label.value
+    0
+    >>> label = LabelName.ABNORMAL
+    >>> label.value
+    1
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -7,7 +23,16 @@
 
 
 class LabelName(int, Enum):
-    """Name of label."""
+    """Enumeration class for labeling data in anomaly detection.
+
+    This class inherits from both ``int`` and ``Enum`` to create an integer-based
+    enumeration. This allows for easy comparison and conversion between label
+    names and their corresponding integer values.
+
+    Attributes:
+        NORMAL (int): Label value 0, representing normal/good samples
+        ABNORMAL (int): Label value 1, representing anomalous/defective samples
+    """
 
     NORMAL = 0
     ABNORMAL = 1
diff --git a/src/anomalib/data/utils/path.py b/src/anomalib/data/utils/path.py
index 7bc61b27fe..4889cab0ec 100644
--- a/src/anomalib/data/utils/path.py
+++ b/src/anomalib/data/utils/path.py
@@ -1,4 +1,23 @@
-"""Path Utils."""
+"""Path utilities for handling file paths in anomalib.
+
+This module provides utilities for:
+
+- Validating and resolving file paths
+- Checking path length and character restrictions
+- Converting between path types
+- Handling file extensions
+- Managing directory types for anomaly detection
+
+Example:
+    >>> from anomalib.data.utils.path import validate_path
+    >>> path = validate_path("./datasets/MVTec/bottle/train/good/000.png")
+    >>> print(path)
+    PosixPath('/abs/path/to/anomalib/datasets/MVTec/bottle/train/good/000.png')
+
+    >>> from anomalib.data.utils.path import DirType
+    >>> print(DirType.NORMAL)
+    normal
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,7 +31,17 @@
 
 
 class DirType(str, Enum):
-    """Dir type names."""
+    """Directory type names for organizing anomaly detection datasets.
+
+    Attributes:
+        NORMAL: Directory containing normal/good samples for training
+        ABNORMAL: Directory containing anomalous/defective samples
+        NORMAL_TEST: Directory containing normal test samples
+        NORMAL_DEPTH: Directory containing depth maps for normal samples
+        ABNORMAL_DEPTH: Directory containing depth maps for abnormal samples
+        NORMAL_TEST_DEPTH: Directory containing depth maps for normal test samples
+        MASK: Directory containing ground truth segmentation masks
+    """
 
     NORMAL = "normal"
     ABNORMAL = "abnormal"
@@ -24,13 +53,18 @@ class DirType(str, Enum):
 
 
 def _check_and_convert_path(path: str | Path) -> Path:
-    """Check an input path, and convert to Pathlib object.
+    """Check and convert input path to pathlib object.
 
     Args:
-        path (str | Path): Input path.
+        path: Input path as string or Path object
 
     Returns:
-        Path: Output path converted to pathlib object.
+        Path object of the input path
+
+    Example:
+        >>> path = _check_and_convert_path("./datasets/example.png")
+        >>> isinstance(path, Path)
+        True
     """
     if not isinstance(path, Path):
         path = Path(path)
@@ -42,16 +76,25 @@ def _prepare_files_labels(
     path_type: str,
     extensions: tuple[str, ...] | None = None,
 ) -> tuple[list, list]:
-    """Return a list of filenames and list corresponding labels.
+    """Get lists of filenames and corresponding labels from a directory.
 
     Args:
-        path (str | Path): Path to the directory containing images.
-        path_type (str): Type of images in the provided path ("normal", "abnormal", "normal_test")
-        extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the
-            directory.
+        path: Path to directory containing images
+        path_type: Type of images ("normal", "abnormal", "normal_test")
+        extensions: Allowed file extensions. Defaults to ``IMG_EXTENSIONS``
 
     Returns:
-        List, List: Filenames of the images provided in the paths, labels of the images provided in the paths
+        Tuple containing:
+            - List of image filenames
+            - List of corresponding labels
+
+    Raises:
+        RuntimeError: If no valid images found or extensions don't start with dot
+
+    Example:
+        >>> files, labels = _prepare_files_labels("./normal", "normal", (".png",))
+        >>> len(files) == len(labels)
+        True
     """
     path = _check_and_convert_path(path)
     if extensions is None:
@@ -79,14 +122,19 @@ def _prepare_files_labels(
 
 
 def resolve_path(folder: str | Path, root: str | Path | None = None) -> Path:
-    """Combine root and folder and returns the absolute path.
-
-    This allows users to pass either a root directory and relative paths, or absolute paths to each of the
-    image sources. This function makes sure that the samples dataframe always contains absolute paths.
+    """Combine root and folder paths into absolute path.
 
     Args:
-        folder (str | Path | None): Folder location containing image or mask data.
-        root (str | Path | None): Root directory for the dataset.
+        folder: Folder location containing image or mask data
+        root: Optional root directory for the dataset
+
+    Returns:
+        Absolute path combining root and folder
+
+    Example:
+        >>> path = resolve_path("subdir", "/root")
+        >>> path.is_absolute()
+        True
     """
     folder = Path(folder)
     if folder.is_absolute():
@@ -102,40 +150,37 @@ def resolve_path(folder: str | Path, root: str | Path | None = None) -> Path:
 
 
 def is_path_too_long(path: str | Path, max_length: int = 512) -> bool:
-    r"""Check if the path contains too long input.
+    """Check if path exceeds maximum allowed length.
 
     Args:
-        path (str | Path): Path to check.
-        max_length (int): Maximum length a path can be before it is considered too long.
-            Defaults to ``512``.
+        path: Path to check
+        max_length: Maximum allowed path length. Defaults to ``512``
 
     Returns:
-        bool: True if the path contains too long input, False otherwise.
+        ``True`` if path is too long, ``False`` otherwise
 
-    Examples:
-        >>> contains_too_long_input("./datasets/MVTec/bottle/train/good/000.png")
+    Example:
+        >>> is_path_too_long("short_path.txt")
         False
-
-        >>> contains_too_long_input("./datasets/MVTec/bottle/train/good/000.png" + "a" * 4096)
+        >>> is_path_too_long("a" * 1000)
         True
     """
     return len(str(path)) > max_length
 
 
 def contains_non_printable_characters(path: str | Path) -> bool:
-    r"""Check if the path contains non-printable characters.
+    r"""Check if path contains non-printable characters.
 
     Args:
-        path (str | Path): Path to check.
+        path: Path to check
 
     Returns:
-        bool: True if the path contains non-printable characters, False otherwise.
+        ``True`` if path contains non-printable chars, ``False`` otherwise
 
-    Examples:
-        >>> contains_non_printable_characters("./datasets/MVTec/bottle/train/good/000.png")
+    Example:
+        >>> contains_non_printable_characters("normal.txt")
         False
-
-        >>> contains_non_printable_characters("./datasets/MVTec/bottle/train/good/000.png\0")
+        >>> contains_non_printable_characters("test\x00.txt")
         True
     """
     printable_pattern = re.compile(r"^[\x20-\x7E]+$")
@@ -148,46 +193,27 @@ def validate_path(
     should_exist: bool = True,
     extensions: tuple[str, ...] | None = None,
 ) -> Path:
-    """Validate the path.
+    """Validate path for existence, permissions and extension.
 
     Args:
-        path (str | Path): Path to validate.
-        base_dir (str | Path): Base directory to restrict file access.
-        should_exist (bool): If True, do not raise an exception if the path does not exist.
-        extensions (tuple[str, ...] | None): Accepted extensions for the path. An exception is raised if the
-            path does not have one of the accepted extensions. If None, no check is performed. Defaults to None.
+        path: Path to validate
+        base_dir: Base directory to restrict file access
+        should_exist: If ``True``, verify path exists
+        extensions: Allowed file extensions
 
     Returns:
-        Path: Validated path.
-
-    Examples:
-        >>> validate_path("./datasets/MVTec/bottle/train/good/000.png")
-        PosixPath('/abs/path/to/anomalib/datasets/MVTec/bottle/train/good/000.png')
-
-        >>> validate_path("./datasets/MVTec/bottle/train/good/000.png", base_dir="./datasets/MVTec")
-        PosixPath('/abs/path/to/anomalib/datasets/MVTec/bottle/train/good/000.png')
-
-        >>> validate_path("/path/to/unexisting/file")
-        Traceback (most recent call last):
-        File "", line 1, in 
-        File "", line 18, in validate_path
-        FileNotFoundError: Path does not exist: /path/to/unexisting/file
-
-        Accessing a file without read permission should raise PermissionError:
-
-        .. note::
-
-            Note that, we are using ``/usr/local/bin`` directory as an example here.
-            If this directory does not exist on your system, this will raise
-            ``FileNotFoundError`` instead of ``PermissionError``. You could change
-            the directory to any directory that you do not have read permission.
-
-        >>> validate_path("/bin/bash", base_dir="/bin/")
-        Traceback (most recent call last):
-        File "", line 1, in 
-        File "", line 18, in validate_path
-        PermissionError: Read permission denied for the file: /usr/local/bin
-
+        Validated Path object
+
+    Raises:
+        TypeError: If path is invalid type
+        ValueError: If path is too long or has invalid characters/extension
+        FileNotFoundError: If path doesn't exist when required
+        PermissionError: If path lacks required permissions
+
+    Example:
+        >>> path = validate_path("./datasets/image.png", extensions=(".png",))
+        >>> path.suffix
+        '.png'
     """
     # Check if the path is of an appropriate type
     if not isinstance(path, str | Path):
@@ -222,7 +248,7 @@ def validate_path(
 
     # Check if the path has one of the accepted extensions
     if extensions is not None and path.suffix not in extensions:
-        msg = f"Path extension is not accepted. Accepted extensions: {extensions}. Path: {path}"
+        msg = f"Path extension is not accepted. Accepted: {extensions}. Path: {path}"
         raise ValueError(msg)
 
     return path
@@ -233,14 +259,19 @@ def validate_and_resolve_path(
     root: str | Path | None = None,
     base_dir: str | Path | None = None,
 ) -> Path:
-    """Validate and resolve the path.
+    """Validate and resolve path by combining validation and resolution.
 
     Args:
-        folder (str | Path): Folder location containing image or mask data.
-        root (str | Path | None): Root directory for the dataset.
-        base_dir (str | Path | None): Base directory to restrict file access.
+        folder: Folder location containing image or mask data
+        root: Root directory for the dataset
+        base_dir: Base directory to restrict file access
 
     Returns:
-        Path: Validated and resolved path.
+        Validated and resolved absolute Path
+
+    Example:
+        >>> path = validate_and_resolve_path("subdir", "/root")
+        >>> path.is_absolute()
+        True
     """
     return validate_path(resolve_path(folder, root), base_dir)
diff --git a/src/anomalib/data/utils/split.py b/src/anomalib/data/utils/split.py
index fe085ea1cf..db872a19b7 100644
--- a/src/anomalib/data/utils/split.py
+++ b/src/anomalib/data/utils/split.py
@@ -1,11 +1,29 @@
-"""Dataset Split Utils.
+"""Dataset splitting utilities.
 
-This module contains function in regards to splitting normal images in training set,
-and creating validation sets from test sets.
+This module provides functions for splitting datasets in anomaly detection tasks:
 
-These function are useful
-    - when the test set does not contain any normal images.
-    - when the dataset doesn't have a validation set.
+- Splitting normal images into training and validation sets
+- Creating validation sets from test sets
+- Label-aware splitting to maintain class distributions
+- Random splitting with optional seed for reproducibility
+
+These utilities are particularly useful when:
+
+- The test set lacks normal images
+- The dataset needs a validation set
+- Class balance needs to be maintained during splits
+
+Example:
+    >>> from anomalib.data.utils.split import random_split
+    >>> # Split dataset with 80/20 ratio
+    >>> train_set, val_set = random_split(dataset, split_ratio=0.2)
+    >>> len(train_set), len(val_set)
+    (800, 200)
+
+    >>> # Label-aware split preserving class distributions
+    >>> splits = random_split(dataset, [0.7, 0.2, 0.1], label_aware=True)
+    >>> len(splits)
+    3
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -26,7 +44,13 @@
 
 
 class Split(str, Enum):
-    """Split of a subset."""
+    """Dataset split type.
+
+    Attributes:
+        TRAIN: Training split
+        VAL: Validation split
+        TEST: Test split
+    """
 
     TRAIN = "train"
     VAL = "val"
@@ -34,7 +58,13 @@ class Split(str, Enum):
 
 
 class TestSplitMode(str, Enum):
-    """Splitting mode used to obtain subset."""
+    """Mode used to obtain test split.
+
+    Attributes:
+        NONE: No test split
+        FROM_DIR: Test split from directory
+        SYNTHETIC: Synthetic test split
+    """
 
     NONE = "none"
     FROM_DIR = "from_dir"
@@ -42,7 +72,15 @@ class TestSplitMode(str, Enum):
 
 
 class ValSplitMode(str, Enum):
-    """Splitting mode used to obtain validation subset."""
+    """Mode used to obtain validation split.
+
+    Attributes:
+        NONE: No validation split
+        SAME_AS_TEST: Use same split as test
+        FROM_TRAIN: Split from training set
+        FROM_TEST: Split from test set
+        SYNTHETIC: Synthetic validation split
+    """
 
     NONE = "none"
     SAME_AS_TEST = "same_as_test"
@@ -51,14 +89,21 @@ class ValSplitMode(str, Enum):
     SYNTHETIC = "synthetic"
 
 
-def concatenate_datasets(datasets: Sequence["data.AnomalibDataset"]) -> "data.AnomalibDataset":
-    """Concatenate multiple datasets into a single dataset object.
+def concatenate_datasets(
+    datasets: Sequence["data.AnomalibDataset"],
+) -> "data.AnomalibDataset":
+    """Concatenate multiple datasets into a single dataset.
 
     Args:
-        datasets (Sequence[AnomalibDataset]): Sequence of at least two datasets.
+        datasets: Sequence of at least two datasets to concatenate
 
     Returns:
-        AnomalibDataset: Dataset that contains the combined samples of all input datasets.
+        Combined dataset containing samples from all input datasets
+
+    Example:
+        >>> combined = concatenate_datasets([dataset1, dataset2])
+        >>> len(combined) == len(dataset1) + len(dataset2)
+        True
     """
     concat_dataset = datasets[0]
     for dataset in datasets[1:]:
@@ -72,16 +117,26 @@ def random_split(
     label_aware: bool = False,
     seed: int | None = None,
 ) -> list["data.AnomalibDataset"]:
-    """Perform a random split of a dataset.
+    """Randomly split a dataset into multiple subsets.
 
     Args:
-        dataset (AnomalibDataset): Source dataset
-        split_ratio (Union[float, Sequence[float]]): Fractions of the splits that will be produced. The values in the
-            sequence must sum to 1. If a single value is passed, the ratio will be converted to
-            [1-split_ratio, split_ratio].
-        label_aware (bool): When True, the relative occurrence of the different class labels of the source dataset will
-            be maintained in each of the subsets.
-        seed (int | None, optional): Seed that can be passed if results need to be reproducible
+        dataset: Source dataset to split
+        split_ratio: Split ratios that must sum to 1. If single float ``x`` is
+            provided, splits into ``[1-x, x]``
+        label_aware: If ``True``, maintains class label distributions in splits
+        seed: Random seed for reproducibility
+
+    Returns:
+        List of dataset splits based on provided ratios
+
+    Example:
+        >>> splits = random_split(dataset, [0.7, 0.3], seed=42)
+        >>> len(splits)
+        2
+        >>> # Label-aware splitting
+        >>> splits = random_split(dataset, 0.2, label_aware=True)
+        >>> len(splits)
+        2
     """
     if isinstance(split_ratio, float):
         split_ratio = [1 - split_ratio, split_ratio]
@@ -128,8 +183,24 @@ def random_split(
     return [concatenate_datasets(subset) for subset in subsets]
 
 
-def split_by_label(dataset: "data.AnomalibDataset") -> tuple["data.AnomalibDataset", "data.AnomalibDataset"]:
-    """Split the dataset into the normal and anomalous subsets."""
+def split_by_label(
+    dataset: "data.AnomalibDataset",
+) -> tuple["data.AnomalibDataset", "data.AnomalibDataset"]:
+    """Split dataset into normal and anomalous subsets.
+
+    Args:
+        dataset: Dataset to split by label
+
+    Returns:
+        Tuple containing:
+            - Dataset with only normal samples (label 0)
+            - Dataset with only anomalous samples (label 1)
+
+    Example:
+        >>> normal, anomalous = split_by_label(dataset)
+        >>> len(normal) + len(anomalous) == len(dataset)
+        True
+    """
     samples = dataset.samples
     normal_indices = samples[samples.label_index == 0].index
     anomalous_indices = samples[samples.label_index == 1].index
diff --git a/src/anomalib/data/utils/synthetic.py b/src/anomalib/data/utils/synthetic.py
index c4b52d5b35..fb347aa157 100644
--- a/src/anomalib/data/utils/synthetic.py
+++ b/src/anomalib/data/utils/synthetic.py
@@ -1,6 +1,22 @@
 """Dataset that generates synthetic anomalies.
 
-This dataset can be used when there is a lack of real anomalous data.
+This module provides functionality to generate synthetic anomalies when real
+anomalous data is scarce or unavailable. It includes:
+
+- A dataset class that generates synthetic anomalies from normal images
+- Functions to convert normal samples into synthetic anomalous samples
+- Perlin noise-based anomaly generation
+- Temporary file management for synthetic data
+
+Example:
+    >>> from anomalib.data.utils.synthetic import SyntheticAnomalyDataset
+    >>> # Create synthetic dataset from normal samples
+    >>> synthetic_dataset = SyntheticAnomalyDataset(
+    ...     transform=transforms,
+    ...     source_samples=normal_samples
+    ... )
+    >>> len(synthetic_dataset)  # 50/50 normal/anomalous split
+    200
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -34,16 +50,36 @@ def make_synthetic_dataset(
     mask_dir: Path,
     anomalous_ratio: float = 0.5,
 ) -> DataFrame:
-    """Convert a set of normal samples into a mixed set of normal and synthetic anomalous samples.
+    """Convert normal samples into a mixed set with synthetic anomalies.
 
-    The synthetic images will be saved to the file system in the specified root directory under /images.
-    For the synthetic anomalous images, the masks will be saved under /ground_truth.
+    The function generates synthetic anomalous images and their corresponding
+    masks by applying Perlin noise-based perturbations to normal images.
 
     Args:
-        source_samples (DataFrame): Normal images that will be used as source for the synthetic anomalous images.
-        image_dir (Path): Directory to which the synthetic anomalous image files will be written.
-        mask_dir (Path): Directory to which the ground truth anomaly masks will be written.
-        anomalous_ratio (float): Fraction of source samples that will be converted into anomalous samples.
+        source_samples: DataFrame containing normal images used as source for
+            synthetic anomalies. Must contain columns: ``image_path``,
+            ``label``, ``label_index``, ``mask_path``, and ``split``.
+        image_dir: Directory where synthetic anomalous images will be saved.
+        mask_dir: Directory where ground truth anomaly masks will be saved.
+        anomalous_ratio: Fraction of source samples to convert to anomalous
+            samples. Defaults to ``0.5``.
+
+    Returns:
+        DataFrame containing both normal and synthetic anomalous samples.
+
+    Raises:
+        ValueError: If source samples contain any anomalous images.
+        NotADirectoryError: If ``image_dir`` or ``mask_dir`` is not a directory.
+
+    Example:
+        >>> df = make_synthetic_dataset(
+        ...     source_samples=normal_df,
+        ...     image_dir=Path("./synthetic/images"),
+        ...     mask_dir=Path("./synthetic/masks"),
+        ...     anomalous_ratio=0.3
+        ... )
+        >>> len(df[df.label == "abnormal"])  # 30% are anomalous
+        30
     """
     if 1 in source_samples.label_index.to_numpy():
         msg = "All source images must be normal."
@@ -66,19 +102,20 @@ def make_synthetic_dataset(
     anomalous_samples = anomalous_samples.reset_index(drop=True)
 
     # initialize augmenter
-    augmenter = PerlinAnomalyGenerator(anomaly_source_path="./datasets/dtd", probability=1.0, blend_factor=(0.01, 0.2))
+    augmenter = PerlinAnomalyGenerator(
+        anomaly_source_path="./datasets/dtd",
+        probability=1.0,
+        blend_factor=(0.01, 0.2),
+    )
 
     def augment(sample: Series) -> Series:
-        """Apply synthetic anomalous augmentation to a sample from a dataframe.
-
-        Reads an image, applies the augmentations, writes the augmented image and corresponding mask to the file system,
-        and returns a new Series object with the updates labels and file locations.
+        """Apply synthetic anomalous augmentation to a sample.
 
         Args:
-            sample (Series): DataFrame row containing info about the image that will be augmented.
+            sample: DataFrame row containing image information.
 
         Returns:
-            Series: DataFrame row with updated information about the augmented image.
+            Series containing updated information about the augmented image.
         """
         # read and transform image
         image = read_image(sample.image_path, as_tensor=True)
@@ -110,11 +147,26 @@ def augment(sample: Series) -> Series:
 
 
 class SyntheticAnomalyDataset(AnomalibDataset):
-    """Dataset which reads synthetically generated anomalous images from a temporary folder.
+    """Dataset for generating and managing synthetic anomalies.
+
+    The dataset creates synthetic anomalous images by applying Perlin
+    noise-based perturbations to normal images. The synthetic images are
+    stored in a temporary directory that is cleaned up when the dataset
+    object is deleted.
 
     Args:
-        transform (A.Compose): Transform object describing the transforms that are applied to the inputs.
-        source_samples (DataFrame): Normal samples to which the anomalous augmentations will be applied.
+        transform: Transform object describing the transforms applied to inputs.
+        source_samples: DataFrame containing normal samples used as source for
+            synthetic anomalies.
+
+    Example:
+        >>> transform = Compose([...])
+        >>> dataset = SyntheticAnomalyDataset(
+        ...     transform=transform,
+        ...     source_samples=normal_df
+        ... )
+        >>> len(dataset)  # 50/50 normal/anomalous split
+        100
     """
 
     def __init__(self, transform: Compose, source_samples: DataFrame) -> None:
@@ -122,7 +174,7 @@ def __init__(self, transform: Compose, source_samples: DataFrame) -> None:
 
         self.source_samples = source_samples
 
-        # Files will be written to a temporary directory in the workdir, which is cleaned up after code execution
+        # Files will be written to a temporary directory in the workdir
         root = Path(ROOT)
         root.mkdir(parents=True, exist_ok=True)
 
@@ -134,21 +186,40 @@ def __init__(self, transform: Compose, source_samples: DataFrame) -> None:
         self.im_dir.mkdir()
         self.mask_dir.mkdir()
 
-        self._cleanup = True  # flag that determines if temp dir is cleaned up when instance is deleted
-        self.samples = make_synthetic_dataset(self.source_samples, self.im_dir, self.mask_dir, 0.5)
+        self._cleanup = True  # flag that determines if temp dir is cleaned up
+        self.samples = make_synthetic_dataset(
+            self.source_samples,
+            self.im_dir,
+            self.mask_dir,
+            0.5,
+        )
 
     @classmethod
-    def from_dataset(cls: type["SyntheticAnomalyDataset"], dataset: AnomalibDataset) -> "SyntheticAnomalyDataset":
-        """Create a synthetic anomaly dataset from an existing dataset of normal images.
+    def from_dataset(
+        cls: type["SyntheticAnomalyDataset"],
+        dataset: AnomalibDataset,
+    ) -> "SyntheticAnomalyDataset":
+        """Create synthetic dataset from existing dataset of normal images.
 
         Args:
-            dataset (AnomalibDataset): Dataset consisting of only normal images that will be converrted to a synthetic
-                anomalous dataset with a 50/50 normal anomalous split.
+            dataset: Dataset containing only normal images to convert into a
+                synthetic dataset with 50/50 normal/anomalous split.
+
+        Returns:
+            New synthetic anomaly dataset.
+
+        Example:
+            >>> normal_dataset = Dataset(...)
+            >>> synthetic = SyntheticAnomalyDataset.from_dataset(normal_dataset)
         """
         return cls(transform=dataset.transform, source_samples=dataset.samples)
 
     def __copy__(self) -> "SyntheticAnomalyDataset":
-        """Return a shallow copy of the dataset object and prevents cleanup when original object is deleted."""
+        """Return shallow copy and prevent cleanup of original.
+
+        Returns:
+            Shallow copy of the dataset object.
+        """
         cls = self.__class__
         new = cls.__new__(cls)
         new.__dict__.update(self.__dict__)
@@ -156,7 +227,14 @@ def __copy__(self) -> "SyntheticAnomalyDataset":
         return new
 
     def __deepcopy__(self, _memo: dict) -> "SyntheticAnomalyDataset":
-        """Return a deep copy of the dataset object and prevents cleanup when original object is deleted."""
+        """Return deep copy and prevent cleanup of original.
+
+        Args:
+            _memo: Memo dictionary used by deepcopy.
+
+        Returns:
+            Deep copy of the dataset object.
+        """
         cls = self.__class__
         new = cls.__new__(cls)
         for key, value in self.__dict__.items():
@@ -165,6 +243,6 @@ def __deepcopy__(self, _memo: dict) -> "SyntheticAnomalyDataset":
         return new
 
     def __del__(self) -> None:
-        """Make sure the temporary directory is cleaned up when the dataset object is deleted."""
+        """Clean up temporary directory when dataset object is deleted."""
         if self._cleanup:
             shutil.rmtree(self.root)
diff --git a/src/anomalib/data/utils/tiler.py b/src/anomalib/data/utils/tiler.py
index 2c1e949e45..430763da1f 100644
--- a/src/anomalib/data/utils/tiler.py
+++ b/src/anomalib/data/utils/tiler.py
@@ -1,4 +1,28 @@
-"""Image Tiler."""
+"""Image tiling utilities for processing large images.
+
+This module provides functionality to:
+
+- Tile large images into smaller patches for efficient processing
+- Support overlapping and non-overlapping tiling strategies
+- Reconstruct original images from tiles
+- Handle upscaling and downscaling with padding or interpolation
+
+Example:
+    >>> from anomalib.data.utils.tiler import Tiler
+    >>> import torch
+    >>> # Create tiler with 256x256 tiles and 128 stride
+    >>> tiler = Tiler(tile_size=256, stride=128)
+    >>> # Create sample 512x512 image
+    >>> image = torch.rand(1, 3, 512, 512)
+    >>> # Generate tiles
+    >>> tiles = tiler.tile(image)
+    >>> tiles.shape
+    torch.Size([9, 3, 256, 256])
+    >>> # Reconstruct image from tiles
+    >>> reconstructed = tiler.untile(tiles)
+    >>> reconstructed.shape
+    torch.Size([1, 3, 512, 512])
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -14,39 +38,50 @@
 
 
 class ImageUpscaleMode(str, Enum):
-    """Type of mode when upscaling image."""
+    """Mode for upscaling images.
+
+    Attributes:
+        PADDING: Upscale by padding with zeros
+        INTERPOLATION: Upscale using interpolation
+    """
 
     PADDING = "padding"
     INTERPOLATION = "interpolation"
 
 
 class StrideSizeError(Exception):
-    """StrideSizeError to raise exception when stride size is greater than the tile size."""
+    """Error raised when stride size exceeds tile size."""
 
 
 def compute_new_image_size(image_size: tuple, tile_size: tuple, stride: tuple) -> tuple:
-    """Check if image size is divisible by tile size and stride.
-
-    If not divisible, it resizes the image size to make it divisible.
+    """Compute new image size that is divisible by tile size and stride.
 
     Args:
-        image_size (tuple): Original image size
-        tile_size (tuple): Tile size
-        stride (tuple): Stride
+        image_size: Original image size as ``(height, width)``
+        tile_size: Tile size as ``(height, width)``
+        stride: Stride size as ``(height, width)``
+
+    Returns:
+        tuple: New image size divisible by tile size and stride
 
     Examples:
-        >>> compute_new_image_size(image_size=(512, 512), tile_size=(256, 256), stride=(128, 128))
+        >>> compute_new_image_size((512, 512), (256, 256), (128, 128))
         (512, 512)
-
-        >>> compute_new_image_size(image_size=(512, 512), tile_size=(222, 222), stride=(111, 111))
+        >>> compute_new_image_size((512, 512), (222, 222), (111, 111))
         (555, 555)
-
-    Returns:
-        tuple: Updated image size that is divisible by tile size and stride.
     """
 
     def __compute_new_edge_size(edge_size: int, tile_size: int, stride: int) -> int:
-        """Resize within the edge level."""
+        """Compute new edge size that is divisible by tile size and stride.
+
+        Args:
+            edge_size: Original edge size
+            tile_size: Tile size for this edge
+            stride: Stride size for this edge
+
+        Returns:
+            int: New edge size
+        """
         if (edge_size - tile_size) % stride != 0:
             edge_size = (ceil((edge_size - tile_size) / stride) * stride) + tile_size
 
@@ -58,27 +93,30 @@ def __compute_new_edge_size(edge_size: int, tile_size: int, stride: int) -> int:
     return resized_h, resized_w
 
 
-def upscale_image(image: torch.Tensor, size: tuple, mode: ImageUpscaleMode = ImageUpscaleMode.PADDING) -> torch.Tensor:
-    """Upscale image to the desired size via either padding or interpolation.
+def upscale_image(
+    image: torch.Tensor,
+    size: tuple,
+    mode: ImageUpscaleMode = ImageUpscaleMode.PADDING,
+) -> torch.Tensor:
+    """Upscale image to desired size using padding or interpolation.
 
     Args:
-        image (torch.Tensor): Image
-        size (tuple): tuple to which image is upscaled.
-        mode (str, optional): Upscaling mode. Defaults to "padding".
+        image: Input image tensor
+        size: Target size as ``(height, width)``
+        mode: Upscaling mode, either ``"padding"`` or ``"interpolation"``
+
+    Returns:
+        torch.Tensor: Upscaled image
 
     Examples:
         >>> image = torch.rand(1, 3, 512, 512)
-        >>> image = upscale_image(image, size=(555, 555), mode="padding")
-        >>> image.shape
+        >>> upscaled = upscale_image(image, (555, 555), "padding")
+        >>> upscaled.shape
         torch.Size([1, 3, 555, 555])
 
-        >>> image = torch.rand(1, 3, 512, 512)
-        >>> image = upscale_image(image, size=(555, 555), mode="interpolation")
-        >>> image.shape
+        >>> upscaled = upscale_image(image, (555, 555), "interpolation")
+        >>> upscaled.shape
         torch.Size([1, 3, 555, 555])
-
-    Returns:
-        Tensor: Upscaled image.
     """
     image_h, image_w = image.shape[2:]
     resize_h, resize_w = size
@@ -102,22 +140,22 @@ def downscale_image(
     size: tuple,
     mode: ImageUpscaleMode = ImageUpscaleMode.PADDING,
 ) -> torch.Tensor:
-    """Opposite of upscaling. This image downscales image to a desired size.
+    """Downscale image to desired size.
 
     Args:
-        image (torch.Tensor): Input image
-        size (tuple): Size to which image is down scaled.
-        mode (str, optional): Downscaling mode. Defaults to "padding".
+        image: Input image tensor
+        size: Target size as ``(height, width)``
+        mode: Downscaling mode, either ``"padding"`` or ``"interpolation"``
+
+    Returns:
+        torch.Tensor: Downscaled image
 
     Examples:
         >>> x = torch.rand(1, 3, 512, 512)
-        >>> y = upscale_image(image, upscale_size=(555, 555), mode="padding")
-        >>> y = downscale_image(y, size=(512, 512), mode='padding')
-        >>> torch.allclose(x, y)
+        >>> y = upscale_image(x, (555, 555), "padding")
+        >>> z = downscale_image(y, (512, 512), "padding")
+        >>> torch.allclose(x, z)
         True
-
-    Returns:
-        Tensor: Downscaled image
     """
     input_h, input_w = size
     if mode == ImageUpscaleMode.PADDING:
@@ -129,29 +167,40 @@ def downscale_image(
 
 
 class Tiler:
-    """Tile Image into (non)overlapping Patches. Images are tiled in order to efficiently process large images.
+    """Tile images into overlapping or non-overlapping patches.
+
+    This class provides functionality to:
+    - Split large images into smaller tiles for efficient processing
+    - Support overlapping tiles with configurable stride
+    - Remove border pixels from tiles before reconstruction
+    - Reconstruct original image from processed tiles
 
     Args:
-        tile_size: Tile dimension for each patch
-        stride: Stride length between patches
-        remove_border_count: Number of border pixels to be removed from tile before untiling
-        mode: Upscaling mode for image resize.Supported formats: padding, interpolation
+        tile_size: Size of tiles as int or ``(height, width)``
+        stride: Stride between tiles as int or ``(height, width)``.
+            If ``None``, uses tile_size (non-overlapping)
+        remove_border_count: Number of border pixels to remove from tiles
+        mode: Upscaling mode for resizing, either ``"padding"`` or
+            ``"interpolation"``
 
     Examples:
         >>> import torch
         >>> from torchvision import transforms
         >>> from skimage.data import camera
-        >>> tiler = Tiler(tile_size=256,stride=128)
+        >>> # Create tiler for 256x256 tiles with 128 stride
+        >>> tiler = Tiler(tile_size=256, stride=128)
+        >>> # Convert test image to tensor
         >>> image = transforms.ToTensor()(camera())
+        >>> # Generate tiles
         >>> tiles = tiler.tile(image)
         >>> image.shape, tiles.shape
         (torch.Size([3, 512, 512]), torch.Size([9, 3, 256, 256]))
 
-        >>> # Perform your operations on the tiles.
+        >>> # Process tiles here...
 
-        >>> # Untile the patches to reconstruct the image
-        >>> reconstructed_image = tiler.untile(tiles)
-        >>> reconstructed_image.shape
+        >>> # Reconstruct image from tiles
+        >>> reconstructed = tiler.untile(tiles)
+        >>> reconstructed.shape
         torch.Size([1, 3, 512, 512])
     """
 
@@ -173,16 +222,11 @@ def __init__(
         self.mode = mode
 
         if self.stride_h > self.tile_size_h or self.stride_w > self.tile_size_w:
-            msg = (
-                "Larger stride size than kernel size produces unreliable tiling results. "
-                "Please ensure stride size is less than or equal than tiling size."
-            )
-            raise StrideSizeError(
-                msg,
-            )
+            msg = "Stride size larger than tile size produces unreliable results. Ensure stride size <= tile size."
+            raise StrideSizeError(msg)
 
         if self.mode not in {ImageUpscaleMode.PADDING, ImageUpscaleMode.INTERPOLATION}:
-            msg = f"Unknown tiling mode {self.mode}. Available modes are padding and interpolation"
+            msg = f"Unknown mode {self.mode}. Available modes: padding and interpolation"
             raise ValueError(msg)
 
         self.batch_size: int
@@ -202,64 +246,70 @@ def __init__(
 
     @staticmethod
     def validate_size_type(parameter: int | Sequence) -> tuple[int, ...]:
-        """Validate size type and return tuple of form [tile_h, tile_w].
+        """Validate and convert size parameter to tuple.
 
         Args:
-            parameter (int | Sequence): input tile size parameter.
+            parameter: Size as int or sequence of ``(height, width)``
 
         Returns:
-            tuple[int, ...]: Validated tile size in tuple form.
+            tuple: Validated size as ``(height, width)``
+
+        Raises:
+            TypeError: If parameter type is invalid
+            ValueError: If parameter length is not 2
         """
         if isinstance(parameter, int):
             output = (parameter, parameter)
         elif isinstance(parameter, Sequence):
             output = (parameter[0], parameter[1])
         else:
-            msg = f"Unknown type {type(parameter)} for tile or stride size. Could be int or Sequence type."
+            msg = f"Invalid type {type(parameter)} for tile/stride size. Must be int or Sequence."
             raise TypeError(msg)
 
         if len(output) != 2:
-            msg = f"Length of the size type must be 2 for height and width. Got {len(output)} instead."
+            msg = f"Size must have length 2, got {len(output)}"
             raise ValueError(msg)
 
         return output
 
     def __random_tile(self, image: torch.Tensor) -> torch.Tensor:
-        """Randomly crop tiles from the given image.
+        """Randomly crop tiles from image.
 
         Args:
-            image: input image to be cropped
+            image: Input image tensor
 
-        Returns: Randomly cropped tiles from the image
+        Returns:
+            torch.Tensor: Stack of random tiles
         """
         return torch.vstack([T.RandomCrop(self.tile_size_h)(image) for i in range(self.random_tile_count)])
 
     def __unfold(self, tensor: torch.Tensor) -> torch.Tensor:
-        """Unfolds tensor into tiles.
-
-        This is the core function to perform tiling operation.
+        """Unfold tensor into tiles.
 
         Args:
-            tensor: Input tensor from which tiles are generated.
+            tensor: Input tensor to tile
 
-        Returns: Generated tiles
+        Returns:
+            torch.Tensor: Generated tiles
         """
-        # identify device type based on input tensor
         device = tensor.device
-
-        # extract and calculate parameters
         batch, channels, image_h, image_w = tensor.shape
 
         self.num_patches_h = int((image_h - self.tile_size_h) / self.stride_h) + 1
         self.num_patches_w = int((image_w - self.tile_size_w) / self.stride_w) + 1
 
-        # create an empty torch tensor for output
         tiles = torch.zeros(
-            (self.num_patches_h, self.num_patches_w, batch, channels, self.tile_size_h, self.tile_size_w),
+            (
+                self.num_patches_h,
+                self.num_patches_w,
+                batch,
+                channels,
+                self.tile_size_h,
+                self.tile_size_w,
+            ),
             device=device,
         )
 
-        # fill-in output tensor with spatial patches extracted from the image
         for (tile_i, tile_j), (loc_i, loc_j) in zip(
             product(range(self.num_patches_h), range(self.num_patches_w)),
             product(
@@ -275,33 +325,30 @@ def __unfold(self, tensor: torch.Tensor) -> torch.Tensor:
                 loc_j : (loc_j + self.tile_size_w),
             ]
 
-        # rearrange the tiles in order [tile_count * batch, channels, tile_height, tile_width]
         tiles = tiles.permute(2, 0, 1, 3, 4, 5)
         return tiles.contiguous().view(-1, channels, self.tile_size_h, self.tile_size_w)
 
     def __fold(self, tiles: torch.Tensor) -> torch.Tensor:
-        """Fold the tiles back into the original tensor.
-
-        This is the core method to reconstruct the original image from its tiled version.
+        """Fold tiles back into original tensor.
 
         Args:
-            tiles: Tiles from the input image, generated via __unfold method.
+            tiles: Tiles generated by ``__unfold()``
 
         Returns:
-            Output that is the reconstructed version of the input tensor.
+            torch.Tensor: Reconstructed tensor
         """
-        # number of channels differs between image and anomaly map, so infer from input tiles.
         _, num_channels, tile_size_h, tile_size_w = tiles.shape
         scale_h, scale_w = (tile_size_h / self.tile_size_h), (tile_size_w / self.tile_size_w)
-        # identify device type based on input tensor
         device = tiles.device
-        # calculate tile size after borders removed
         reduced_tile_h = tile_size_h - (2 * self.remove_border_count)
         reduced_tile_w = tile_size_w - (2 * self.remove_border_count)
-        # reconstructed image dimension
-        image_size = (self.batch_size, num_channels, int(self.resized_h * scale_h), int(self.resized_w * scale_w))
+        image_size = (
+            self.batch_size,
+            num_channels,
+            int(self.resized_h * scale_h),
+            int(self.resized_w * scale_w),
+        )
 
-        # rearrange input tiles in format [tile_count, batch, channel, tile_h, tile_w]
         tiles = tiles.contiguous().view(
             self.batch_size,
             self.num_patches_h,
@@ -314,7 +361,6 @@ def __fold(self, tiles: torch.Tensor) -> torch.Tensor:
         tiles = tiles.contiguous().view(self.batch_size, num_channels, -1, tile_size_h, tile_size_w)
         tiles = tiles.permute(2, 0, 1, 3, 4)
 
-        # remove tile borders by defined count
         tiles = tiles[
             :,
             :,
@@ -323,13 +369,10 @@ def __fold(self, tiles: torch.Tensor) -> torch.Tensor:
             self.remove_border_count : reduced_tile_w + self.remove_border_count,
         ]
 
-        # create tensors to store intermediate results and outputs
         img = torch.zeros(image_size, device=device)
         lookup = torch.zeros(image_size, device=device)
         ones = torch.ones(reduced_tile_h, reduced_tile_w, device=device)
 
-        # reconstruct image by adding patches to their respective location and
-        # create a lookup for patch count in every location
         for patch, (loc_i, loc_j) in zip(
             tiles,
             product(
@@ -346,36 +389,44 @@ def __fold(self, tiles: torch.Tensor) -> torch.Tensor:
             ),
             strict=True,
         ):
-            img[:, :, loc_i : (loc_i + reduced_tile_h), loc_j : (loc_j + reduced_tile_w)] += patch
-            lookup[:, :, loc_i : (loc_i + reduced_tile_h), loc_j : (loc_j + reduced_tile_w)] += ones
+            img[
+                :,
+                :,
+                loc_i : (loc_i + reduced_tile_h),
+                loc_j : (loc_j + reduced_tile_w),
+            ] += patch
+            lookup[
+                :,
+                :,
+                loc_i : (loc_i + reduced_tile_h),
+                loc_j : (loc_j + reduced_tile_w),
+            ] += ones
 
-        # divide the reconstucted image by the lookup to average out the values
         img = torch.divide(img, lookup)
-        # alternative way of removing nan values (isnan not supported by openvino)
         img[img != img] = 0  # noqa: PLR0124
 
         return img
 
     def tile(self, image: torch.Tensor, use_random_tiling: bool = False) -> torch.Tensor:
-        """Tiles an input image to either overlapping, non-overlapping or random patches.
+        """Tile input image into patches.
 
         Args:
-            image: Input image to tile.
-            use_random_tiling: If True, randomly crops tiles from the image.
-                If False, tiles the image in a regular grid.
+            image: Input image tensor
+            use_random_tiling: If ``True``, randomly crop tiles.
+                If ``False``, tile in regular grid.
+
+        Returns:
+            torch.Tensor: Generated tiles
 
         Examples:
-            >>> from anomalib.data.utils.tiler import Tiler
-            >>> tiler = Tiler(tile_size=512,stride=256)
-            >>> image = torch.rand(size=(2, 3, 1024, 1024))
-            >>> image.shape
-            torch.Size([2, 3, 1024, 1024])
+            >>> tiler = Tiler(tile_size=512, stride=256)
+            >>> image = torch.rand(2, 3, 1024, 1024)
             >>> tiles = tiler.tile(image)
             >>> tiles.shape
             torch.Size([18, 3, 512, 512])
 
-        Returns:
-            Tiles generated from the image.
+        Raises:
+            ValueError: If tile size exceeds image size
         """
         if image.dim() == 3:
             image = image.unsqueeze(0)
@@ -383,13 +434,8 @@ def tile(self, image: torch.Tensor, use_random_tiling: bool = False) -> torch.Te
         self.batch_size, self.num_channels, self.input_h, self.input_w = image.shape
 
         if self.input_h < self.tile_size_h or self.input_w < self.tile_size_w:
-            msg = (
-                f"One of the edges of the tile size {self.tile_size_h, self.tile_size_w} is larger than "
-                f"that of the image {self.input_h, self.input_w}."
-            )
-            raise ValueError(
-                msg,
-            )
+            msg = f"Tile size {self.tile_size_h, self.tile_size_w} exceeds image size {self.input_h, self.input_w}"
+            raise ValueError(msg)
 
         self.resized_h, self.resized_w = compute_new_image_size(
             image_size=(self.input_h, self.input_w),
@@ -402,31 +448,25 @@ def tile(self, image: torch.Tensor, use_random_tiling: bool = False) -> torch.Te
         return self.__random_tile(image) if use_random_tiling else self.__unfold(image)
 
     def untile(self, tiles: torch.Tensor) -> torch.Tensor:
-        """Untiles patches to reconstruct the original input image.
+        """Reconstruct image from tiles.
 
-        If patches, are overlapping patches, the function averages the overlapping pixels,
-        and return the reconstructed image.
+        For overlapping tiles, averages overlapping regions.
 
         Args:
-            tiles: Tiles from the input image, generated via tile()..
+            tiles: Tiles generated by ``tile()``
+
+        Returns:
+            torch.Tensor: Reconstructed image
 
         Examples:
-            >>> from anomalib.data.utils.tiler import Tiler
-            >>> tiler = Tiler(tile_size=512,stride=256)
-            >>> image = torch.rand(size=(2, 3, 1024, 1024))
-            >>> image.shape
-            torch.Size([2, 3, 1024, 1024])
+            >>> tiler = Tiler(tile_size=512, stride=256)
+            >>> image = torch.rand(2, 3, 1024, 1024)
             >>> tiles = tiler.tile(image)
-            >>> tiles.shape
-            torch.Size([18, 3, 512, 512])
-            >>> reconstructed_image = tiler.untile(tiles)
-            >>> reconstructed_image.shape
+            >>> reconstructed = tiler.untile(tiles)
+            >>> reconstructed.shape
             torch.Size([2, 3, 1024, 1024])
-            >>> torch.equal(image, reconstructed_image)
+            >>> torch.equal(image, reconstructed)
             True
-
-        Returns:
-            Output that is the reconstructed version of the input tensor.
         """
         image = self.__fold(tiles)
         return downscale_image(image=image, size=(self.input_h, self.input_w), mode=self.mode)
diff --git a/src/anomalib/data/utils/video.py b/src/anomalib/data/utils/video.py
index cc3d839dfa..4bd5c360ba 100644
--- a/src/anomalib/data/utils/video.py
+++ b/src/anomalib/data/utils/video.py
@@ -1,4 +1,24 @@
-"""Video utils."""
+"""Video utilities for processing video data in anomaly detection.
+
+This module provides utilities for:
+
+- Indexing video clips and their corresponding masks
+- Converting videos between different codecs
+- Handling video frames and clips in PyTorch format
+
+Example:
+    >>> from anomalib.data.utils.video import ClipsIndexer
+    >>> # Create indexer for video files and masks
+    >>> indexer = ClipsIndexer(
+    ...     video_paths=["video1.mp4", "video2.mp4"],
+    ...     mask_paths=["mask1.mp4", "mask2.mp4"],
+    ...     clip_length_in_frames=16
+    ... )
+    >>> # Get video clip with metadata
+    >>> video_item = indexer.get_item(0)
+    >>> video_item.image.shape  # (16, 3, H, W)
+    torch.Size([16, 3, 256, 256])
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -15,15 +35,25 @@
 
 
 class ClipsIndexer(VideoClips, ABC):
-    """Extension of torchvision's VideoClips class that also returns the masks for each clip.
+    """Extension of torchvision's VideoClips class for video and mask indexing.
 
-    Subclasses should implement the get_mask method. By default, the class inherits the functionality of VideoClips,
-    which assumes that video_paths is a list of video files. If custom behaviour is required (e.g. video_paths is a list
-    of folders with single-frame images), the subclass should implement at least get_clip and _compute_frame_pts.
+    This class extends ``VideoClips`` to handle both video frames and their
+    corresponding mask annotations. It provides functionality to:
+
+    - Index and retrieve video clips
+    - Access corresponding mask frames
+    - Track frame indices and video metadata
+
+    Subclasses must implement the ``get_mask`` method. The default implementation
+    assumes ``video_paths`` contains video files. For custom data formats
+    (e.g., image sequences), subclasses should override ``get_clip`` and
+    ``_compute_frame_pts``.
 
     Args:
-        video_paths (list[str]): List of video paths that make up the dataset.
-        mask_paths (list[str]): List of paths to the masks for each video in the dataset.
+        video_paths: List of paths to video files in the dataset
+        mask_paths: List of paths to mask files corresponding to each video
+        clip_length_in_frames: Number of frames in each clip. Defaults to ``2``
+        frames_between_clips: Stride between consecutive clips. Defaults to ``1``
     """
 
     def __init__(
@@ -42,18 +72,40 @@ def __init__(
         self.mask_paths = mask_paths
 
     def last_frame_idx(self, video_idx: int) -> int:
-        """Return the index of the last frame for a given video."""
+        """Get index of the last frame in a video.
+
+        Args:
+            video_idx: Index of the video in the dataset
+
+        Returns:
+            Index of the last frame
+        """
         return self.clips[video_idx][-1][-1].item()
 
     @abstractmethod
     def get_mask(self, idx: int) -> torch.Tensor | None:
-        """Return the masks for the given index."""
+        """Get masks for the clip at the given index.
+
+        Args:
+            idx: Index of the clip
+
+        Returns:
+            Tensor containing mask frames, or None if no masks exist
+        """
         raise NotImplementedError
 
     def get_item(self, idx: int) -> VideoItem:
-        """Return a dictionary containing the clip, mask, video path and frame indices."""
+        """Get video clip and metadata at the given index.
+
+        Args:
+            idx: Index of the clip to retrieve
+
+        Returns:
+            VideoItem containing the clip frames, masks, path and metadata
+        """
         with warnings.catch_warnings():
-            # silence warning caused by bug in torchvision, see https://github.com/pytorch/vision/issues/5787
+            # silence warning caused by bug in torchvision
+            # see https://github.com/pytorch/vision/issues/5787
             warnings.simplefilter("ignore")
             clip, _, _, _ = self.get_clip(idx)
 
@@ -71,12 +123,15 @@ def get_item(self, idx: int) -> VideoItem:
 
 
 def convert_video(input_path: Path, output_path: Path, codec: str = "MP4V") -> None:
-    """Convert video file to a different codec.
+    """Convert a video file to use a different codec.
+
+    Creates the output directory if it doesn't exist. Reads the input video
+    frame by frame and writes to a new file using the specified codec.
 
     Args:
-        input_path (Path): Path to the input video.
-        output_path (Path): Path to the target output video.
-        codec (str): fourcc code of the codec that will be used for compression of the output file.
+        input_path: Path to the input video file
+        output_path: Path where the converted video will be saved
+        codec: FourCC code for the desired output codec. Defaults to ``"MP4V"``
     """
     if not output_path.parent.exists():
         output_path.parent.mkdir(parents=True)
@@ -89,7 +144,12 @@ def convert_video(input_path: Path, output_path: Path, codec: str = "MP4V") -> N
     frame_width = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH))
     frame_height = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT))
     fps = int(video_reader.get(cv2.CAP_PROP_FPS))
-    video_writer = cv2.VideoWriter(str(output_path), fourcc, fps, (frame_width, frame_height))
+    video_writer = cv2.VideoWriter(
+        str(output_path),
+        fourcc,
+        fps,
+        (frame_width, frame_height),
+    )
 
     # read frames
     success, frame = video_reader.read()
diff --git a/src/anomalib/data/validators/numpy/__init__.py b/src/anomalib/data/validators/numpy/__init__.py
index 759f7322bd..2ac929c9c5 100644
--- a/src/anomalib/data/validators/numpy/__init__.py
+++ b/src/anomalib/data/validators/numpy/__init__.py
@@ -1,4 +1,30 @@
-"""Anomalib Numpy data validators."""
+"""Anomalib Numpy data validators.
+
+This module provides validators for numpy array data used in Anomalib. The validators
+ensure data consistency and correctness for various data types:
+
+- Image data: Single images and batches
+- Video data: Single videos and batches
+- Depth data: Single depth maps and batches
+
+The validators check:
+    - Array shapes and dimensions
+    - Data types
+    - Value ranges
+    - Label formats
+    - Mask properties
+
+Example:
+    Validate a numpy image batch::
+
+        >>> from anomalib.data.validators import NumpyImageBatchValidator
+        >>> validator = NumpyImageBatchValidator()
+        >>> validator(images=images, labels=labels, masks=masks)
+
+Note:
+    The validators are used internally by the data modules to ensure data
+    consistency before processing.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/validators/numpy/depth.py b/src/anomalib/data/validators/numpy/depth.py
index 89d7726182..f0c6eb7724 100644
--- a/src/anomalib/data/validators/numpy/depth.py
+++ b/src/anomalib/data/validators/numpy/depth.py
@@ -1,4 +1,32 @@
-"""Validate numpy depth data."""
+"""Validate numpy depth data.
+
+This module provides validators for depth data stored as numpy arrays. The validators
+ensure data consistency and correctness for depth maps and batches of depth maps.
+
+The validators check:
+    - Array shapes and dimensions
+    - Data types
+    - Value ranges
+    - Label formats
+    - Mask properties
+
+Example:
+    Validate a single depth map::
+
+        >>> from anomalib.data.validators import NumpyDepthValidator
+        >>> validator = NumpyDepthValidator()
+        >>> validator.validate_image(depth_map)
+
+    Validate a batch of depth maps::
+
+        >>> from anomalib.data.validators import NumpyDepthBatchValidator
+        >>> validator = NumpyDepthBatchValidator()
+        >>> validator(depth_maps=depth_maps, labels=labels, masks=masks)
+
+Note:
+    The validators are used internally by the data modules to ensure data
+    consistency before processing depth map data.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -11,31 +39,87 @@
 
 
 class NumpyDepthValidator:
-    """Validate numpy.ndarray data for depth images."""
+    """Validate numpy depth data.
+
+    This class provides validation methods for depth data stored as numpy arrays.
+    It ensures data consistency and correctness for depth maps and associated
+    metadata.
+
+    The validator checks:
+        - Array shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate a depth map and associated metadata::
+
+            >>> from anomalib.data.validators import NumpyDepthValidator
+            >>> validator = NumpyDepthValidator()
+            >>> depth_map = np.random.rand(256, 256).astype(np.float32)
+            >>> validated_map = validator.validate_depth_map(depth_map)
+    """
 
     @staticmethod
     def validate_image(image: np.ndarray) -> np.ndarray:
-        """Validate the image array."""
+        """Validate image array.
+
+        Args:
+            image (np.ndarray): Input image to validate.
+
+        Returns:
+            np.ndarray: Validated image array.
+        """
         return NumpyImageValidator.validate_image(image)
 
     @staticmethod
     def validate_gt_label(label: int | np.ndarray | None) -> np.ndarray | None:
-        """Validate the ground truth label."""
+        """Validate ground truth label.
+
+        Args:
+            label (int | np.ndarray | None): Input label to validate.
+
+        Returns:
+            np.ndarray | None: Validated label.
+        """
         return NumpyImageValidator.validate_gt_label(label)
 
     @staticmethod
     def validate_gt_mask(mask: np.ndarray | None) -> np.ndarray | None:
-        """Validate the ground truth mask."""
+        """Validate ground truth mask.
+
+        Args:
+            mask (np.ndarray | None): Input mask to validate.
+
+        Returns:
+            np.ndarray | None: Validated mask.
+        """
         return NumpyImageValidator.validate_gt_mask(mask)
 
     @staticmethod
     def validate_mask_path(mask_path: str | None) -> str | None:
-        """Validate the mask path."""
+        """Validate mask path.
+
+        Args:
+            mask_path (str | None): Path to mask file.
+
+        Returns:
+            str | None: Validated mask path.
+        """
         return NumpyImageValidator.validate_mask_path(mask_path)
 
     @staticmethod
     def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
-        """Validate the anomaly map."""
+        """Validate anomaly map.
+
+        Args:
+            anomaly_map (np.ndarray | None): Input anomaly map to validate.
+
+        Returns:
+            np.ndarray | None: Validated anomaly map.
+        """
         return NumpyImageValidator.validate_anomaly_map(anomaly_map)
 
     @staticmethod
@@ -43,27 +127,76 @@ def validate_pred_score(
         pred_score: np.ndarray | float | None,
         anomaly_map: np.ndarray | None = None,
     ) -> np.ndarray | None:
-        """Validate the prediction score."""
+        """Validate prediction score.
+
+        Args:
+            pred_score (np.ndarray | float | None): Input prediction score.
+            anomaly_map (np.ndarray | None, optional): Associated anomaly map.
+                Defaults to None.
+
+        Returns:
+            np.ndarray | None: Validated prediction score.
+        """
         return NumpyImageValidator.validate_pred_score(pred_score, anomaly_map)
 
     @staticmethod
     def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
-        """Validate the prediction mask."""
+        """Validate prediction mask.
+
+        Args:
+            pred_mask (np.ndarray | None): Input prediction mask to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction mask.
+        """
         return NumpyImageValidator.validate_pred_mask(pred_mask)
 
     @staticmethod
     def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
-        """Validate the prediction label."""
+        """Validate prediction label.
+
+        Args:
+            pred_label (np.ndarray | None): Input prediction label to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction label.
+        """
         return NumpyImageValidator.validate_pred_label(pred_label)
 
     @staticmethod
     def validate_image_path(image_path: str | None) -> str | None:
-        """Validate the image path."""
+        """Validate image path.
+
+        Args:
+            image_path (str | None): Path to image file.
+
+        Returns:
+            str | None: Validated image path.
+        """
         return NumpyImageValidator.validate_image_path(image_path)
 
     @staticmethod
     def validate_depth_map(depth_map: np.ndarray | None) -> np.ndarray | None:
-        """Validate the depth map."""
+        """Validate depth map array.
+
+        Ensures the depth map has correct dimensions and data type.
+
+        Args:
+            depth_map (np.ndarray | None): Input depth map to validate.
+
+        Returns:
+            np.ndarray | None: Validated depth map as float32.
+
+        Raises:
+            TypeError: If depth map is not a numpy array.
+            ValueError: If depth map dimensions are invalid.
+
+        Example:
+            >>> depth_map = np.random.rand(256, 256).astype(np.float32)
+            >>> validated = NumpyDepthValidator.validate_depth_map(depth_map)
+            >>> validated.shape
+            (256, 256)
+        """
         if depth_map is None:
             return None
         if not isinstance(depth_map, np.ndarray):
@@ -79,66 +212,185 @@ def validate_depth_map(depth_map: np.ndarray | None) -> np.ndarray | None:
 
     @staticmethod
     def validate_depth_path(depth_path: str | None) -> str | None:
-        """Validate the depth path."""
+        """Validate depth map file path.
+
+        Args:
+            depth_path (str | None): Path to depth map file.
+
+        Returns:
+            str | None: Validated depth map path.
+        """
         return validate_path(depth_path) if depth_path else None
 
     @staticmethod
     def validate_explanation(explanation: str | None) -> str | None:
-        """Validate the explanation."""
+        """Validate explanation string.
+
+        Args:
+            explanation (str | None): Input explanation to validate.
+
+        Returns:
+            str | None: Validated explanation string.
+        """
         return NumpyImageValidator.validate_explanation(explanation)
 
 
 class NumpyDepthBatchValidator:
-    """Validate numpy.ndarray data for batches of depth images."""
+    """Validate numpy depth data batches.
+
+    This class provides validation methods for batches of depth data stored as numpy arrays.
+    It ensures data consistency and correctness for batches of depth maps and associated
+    metadata.
+
+    The validator checks:
+        - Array shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate a batch of depth maps and associated metadata::
+
+            >>> from anomalib.data.validators import NumpyDepthBatchValidator
+            >>> validator = NumpyDepthBatchValidator()
+            >>> depth_maps = np.random.rand(32, 256, 256).astype(np.float32)
+            >>> labels = np.zeros(32)
+            >>> masks = np.zeros((32, 256, 256))
+            >>> validator.validate_depth_map(depth_maps)
+            >>> validator.validate_gt_label(labels)
+            >>> validator.validate_gt_mask(masks)
+    """
 
     @staticmethod
     def validate_image(image: np.ndarray) -> np.ndarray:
-        """Validate the image batch array."""
+        """Validate image batch array.
+
+        Args:
+            image (np.ndarray): Input image batch to validate.
+
+        Returns:
+            np.ndarray: Validated image batch array.
+        """
         return NumpyImageBatchValidator.validate_image(image)
 
     @staticmethod
     def validate_gt_label(gt_label: np.ndarray | Sequence[int] | None) -> np.ndarray | None:
-        """Validate the ground truth label batch."""
+        """Validate ground truth label batch.
+
+        Args:
+            gt_label (np.ndarray | Sequence[int] | None): Input label batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated label batch.
+        """
         return NumpyImageBatchValidator.validate_gt_label(gt_label)
 
     @staticmethod
     def validate_gt_mask(gt_mask: np.ndarray | None) -> np.ndarray | None:
-        """Validate the ground truth mask batch."""
+        """Validate ground truth mask batch.
+
+        Args:
+            gt_mask (np.ndarray | None): Input mask batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated mask batch.
+        """
         return NumpyImageBatchValidator.validate_gt_mask(gt_mask)
 
     @staticmethod
     def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
-        """Validate the mask paths for a batch."""
+        """Validate mask file paths for a batch.
+
+        Args:
+            mask_path (Sequence[str] | None): Sequence of mask file paths to validate.
+
+        Returns:
+            list[str] | None: Validated mask file paths.
+        """
         return NumpyImageBatchValidator.validate_mask_path(mask_path)
 
     @staticmethod
     def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
-        """Validate the anomaly map batch."""
+        """Validate anomaly map batch.
+
+        Args:
+            anomaly_map (np.ndarray | None): Input anomaly map batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated anomaly map batch.
+        """
         return NumpyImageBatchValidator.validate_anomaly_map(anomaly_map)
 
     @staticmethod
     def validate_pred_score(pred_score: np.ndarray | None) -> np.ndarray | None:
-        """Validate the prediction scores for a batch."""
+        """Validate prediction scores for a batch.
+
+        Args:
+            pred_score (np.ndarray | None): Input prediction scores to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction scores.
+        """
         return NumpyImageBatchValidator.validate_pred_score(pred_score)
 
     @staticmethod
     def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
-        """Validate the prediction mask batch."""
+        """Validate prediction mask batch.
+
+        Args:
+            pred_mask (np.ndarray | None): Input prediction mask batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction mask batch.
+        """
         return NumpyImageBatchValidator.validate_pred_mask(pred_mask)
 
     @staticmethod
     def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
-        """Validate the prediction label batch."""
+        """Validate prediction label batch.
+
+        Args:
+            pred_label (np.ndarray | None): Input prediction label batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated prediction label batch.
+        """
         return NumpyImageBatchValidator.validate_pred_label(pred_label)
 
     @staticmethod
     def validate_image_path(image_path: list[str] | None) -> list[str] | None:
-        """Validate the image paths for a batch."""
+        """Validate image file paths for a batch.
+
+        Args:
+            image_path (list[str] | None): List of image file paths to validate.
+
+        Returns:
+            list[str] | None: Validated image file paths.
+        """
         return NumpyImageBatchValidator.validate_image_path(image_path)
 
     @staticmethod
     def validate_depth_map(depth_map: np.ndarray | None) -> np.ndarray | None:
-        """Validate the depth map batch."""
+        """Validate depth map batch.
+
+        Args:
+            depth_map (np.ndarray | None): Input depth map batch to validate.
+
+        Returns:
+            np.ndarray | None: Validated depth map batch as float32.
+
+        Raises:
+            TypeError: If depth map batch is not a numpy array.
+            ValueError: If depth map batch dimensions are invalid.
+
+        Example:
+            >>> depth_maps = np.random.rand(32, 256, 256).astype(np.float32)
+            >>> validated = NumpyDepthBatchValidator.validate_depth_map(depth_maps)
+            >>> validated.shape
+            (32, 256, 256)
+        """
         if depth_map is None:
             return None
         if not isinstance(depth_map, np.ndarray):
@@ -154,7 +406,17 @@ def validate_depth_map(depth_map: np.ndarray | None) -> np.ndarray | None:
 
     @staticmethod
     def validate_depth_path(depth_path: list[str] | None) -> list[str] | None:
-        """Validate the depth paths for a batch."""
+        """Validate depth map file paths for a batch.
+
+        Args:
+            depth_path (list[str] | None): List of depth map file paths to validate.
+
+        Returns:
+            list[str] | None: Validated depth map file paths.
+
+        Raises:
+            TypeError: If depth_path is not a list of strings.
+        """
         if depth_path is None:
             return None
         if not isinstance(depth_path, list):
@@ -164,5 +426,12 @@ def validate_depth_path(depth_path: list[str] | None) -> list[str] | None:
 
     @staticmethod
     def validate_explanation(explanation: list[str] | None) -> list[str] | None:
-        """Validate the explanations for a batch."""
+        """Validate explanation strings for a batch.
+
+        Args:
+            explanation (list[str] | None): List of explanation strings to validate.
+
+        Returns:
+            list[str] | None: Validated explanation strings.
+        """
         return NumpyImageBatchValidator.validate_explanation(explanation)
diff --git a/src/anomalib/data/validators/numpy/image.py b/src/anomalib/data/validators/numpy/image.py
index 455ecde2b0..579ca2cf01 100644
--- a/src/anomalib/data/validators/numpy/image.py
+++ b/src/anomalib/data/validators/numpy/image.py
@@ -1,4 +1,32 @@
-"""Validate numpy image data."""
+"""Validate numpy image data.
+
+This module provides validators for image data stored as numpy arrays. The validators
+ensure data consistency and correctness for images and batches of images.
+
+The validators check:
+    - Array shapes and dimensions
+    - Data types
+    - Value ranges
+    - Label formats
+    - Mask properties
+
+Example:
+    Validate a single image::
+
+        >>> from anomalib.data.validators import NumpyImageValidator
+        >>> validator = NumpyImageValidator()
+        >>> validator.validate_image(image)
+
+    Validate a batch of images::
+
+        >>> from anomalib.data.validators import NumpyImageBatchValidator
+        >>> validator = NumpyImageBatchValidator()
+        >>> validator(images=images, labels=labels, masks=masks)
+
+Note:
+    The validators are used internally by the data modules to ensure data
+    consistency before processing image data.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,33 +38,71 @@
 
 
 class NumpyImageValidator:
-    """Validate numpy.ndarray data for images."""
+    """Validate numpy array data for images.
+
+    This class provides validation methods for image data stored as numpy arrays.
+    It ensures data consistency and correctness for images and associated metadata.
+
+    The validator checks:
+        - Array shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate an image and associated metadata::
+
+            >>> from anomalib.data.validators import NumpyImageValidator
+            >>> validator = NumpyImageValidator()
+            >>> image = np.random.rand(256, 256, 3)
+            >>> validated_image = validator.validate_image(image)
+            >>> label = 1
+            >>> validated_label = validator.validate_gt_label(label)
+            >>> mask = np.random.randint(0, 2, (256, 256))
+            >>> validated_mask = validator.validate_gt_mask(mask)
+
+    Note:
+        The validator is used internally by the data modules to ensure data
+        consistency before processing.
+    """
 
     @staticmethod
     def validate_image(image: np.ndarray) -> np.ndarray:
         """Validate the image array.
 
+        Validates and normalizes input image arrays. Handles both RGB and grayscale
+        images, and converts between channel-first and channel-last formats.
+
         Args:
-            image (np.ndarray): Input image array.
+            image (``np.ndarray``): Input image array to validate.
 
         Returns:
-            np.ndarray: Validated image array.
+            ``np.ndarray``: Validated image array in channel-last format (H,W,C).
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the image array does not have the correct shape.
-
-        Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
-            >>> rgb_image = np.random.rand(256, 256, 3)
-            >>> validated_rgb = NumpyImageValidator.validate_image(rgb_image)
-            >>> validated_rgb.shape
-            (256, 256, 3)
-            >>> gray_image = np.random.rand(256, 256)
-            >>> validated_gray = NumpyImageValidator.validate_image(gray_image)
-            >>> validated_gray.shape
-            (256, 256, 1)
+            TypeError: If ``image`` is not a numpy array.
+            ValueError: If ``image`` dimensions or channels are invalid.
+
+        Example:
+            Validate RGB and grayscale images::
+
+                >>> import numpy as np
+                >>> from anomalib.data.validators import NumpyImageValidator
+                >>> rgb_image = np.random.rand(256, 256, 3)
+                >>> validated_rgb = NumpyImageValidator.validate_image(rgb_image)
+                >>> validated_rgb.shape
+                (256, 256, 3)
+                >>> gray_image = np.random.rand(256, 256)
+                >>> validated_gray = NumpyImageValidator.validate_image(gray_image)
+                >>> validated_gray.shape
+                (256, 256, 1)
+
+        Note:
+            - 2D arrays are treated as grayscale and expanded to 3D
+            - Channel-first arrays (C,H,W) are converted to channel-last (H,W,C)
+            - Output is always float32 type
         """
         if not isinstance(image, np.ndarray):
             msg = f"Image must be a numpy.ndarray, got {type(image)}."
@@ -64,27 +130,36 @@ def validate_image(image: np.ndarray) -> np.ndarray:
     def validate_gt_label(label: int | np.ndarray | None) -> np.ndarray | None:
         """Validate the ground truth label.
 
+        Validates and normalizes input labels to boolean numpy arrays.
+
         Args:
-            label (int | np.ndarray | None): Input ground truth label.
+            label (``int`` | ``np.ndarray`` | ``None``): Input ground truth label.
 
         Returns:
-            np.ndarray | None: Validated ground truth label as a boolean array, or None.
+            ``np.ndarray`` | ``None``: Validated label as boolean array, or None.
 
         Raises:
-            TypeError: If the input is neither an integer nor a numpy.ndarray.
-            ValueError: If the label shape or dtype is invalid.
-
-        Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
-            >>> label_int = 1
-            >>> validated_label = NumpyImageValidator.validate_gt_label(label_int)
-            >>> validated_label
-            array(True)
-            >>> label_array = np.array(0)
-            >>> validated_label = NumpyImageValidator.validate_gt_label(label_array)
-            >>> validated_label
-            array(False)
+            TypeError: If ``label`` is not an integer or numpy array.
+            ValueError: If ``label`` shape is not scalar.
+
+        Example:
+            Validate integer and array labels::
+
+                >>> import numpy as np
+                >>> from anomalib.data.validators import NumpyImageValidator
+                >>> label_int = 1
+                >>> validated_label = NumpyImageValidator.validate_gt_label(label_int)
+                >>> validated_label
+                array(True)
+                >>> label_array = np.array(0)
+                >>> validated_label = NumpyImageValidator.validate_gt_label(label_array)
+                >>> validated_label
+                array(False)
+
+        Note:
+            - Integer inputs are converted to numpy arrays
+            - Output is always boolean type
+            - None inputs return None
         """
         if label is None:
             return None
@@ -105,23 +180,32 @@ def validate_gt_label(label: int | np.ndarray | None) -> np.ndarray | None:
     def validate_gt_mask(mask: np.ndarray | None) -> np.ndarray | None:
         """Validate the ground truth mask.
 
+        Validates and normalizes input mask arrays.
+
         Args:
-            mask (np.ndarray | None): Input ground truth mask.
+            mask (``np.ndarray`` | ``None``): Input ground truth mask.
 
         Returns:
-            np.ndarray | None: Validated ground truth mask, or None.
+            ``np.ndarray`` | ``None``: Validated mask as boolean array, or None.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the mask shape is invalid.
-
-        Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
-            >>> mask = np.random.randint(0, 2, (224, 224))
-            >>> validated_mask = NumpyImageValidator.validate_gt_mask(mask)
-            >>> validated_mask.shape
-            (224, 224)
+            TypeError: If ``mask`` is not a numpy array.
+            ValueError: If ``mask`` dimensions are invalid.
+
+        Example:
+            Validate a binary mask::
+
+                >>> import numpy as np
+                >>> from anomalib.data.validators import NumpyImageValidator
+                >>> mask = np.random.randint(0, 2, (224, 224))
+                >>> validated_mask = NumpyImageValidator.validate_gt_mask(mask)
+                >>> validated_mask.shape
+                (224, 224)
+
+        Note:
+            - 3D masks with shape (H,W,1) are squeezed to (H,W)
+            - Output is always boolean type
+            - None inputs return None
         """
         if mask is None:
             return None
@@ -142,23 +226,32 @@ def validate_gt_mask(mask: np.ndarray | None) -> np.ndarray | None:
     def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
         """Validate the anomaly map.
 
+        Validates and normalizes input anomaly map arrays.
+
         Args:
-            anomaly_map (np.ndarray | None): Input anomaly map.
+            anomaly_map (``np.ndarray`` | ``None``): Input anomaly map.
 
         Returns:
-            np.ndarray | None: Validated anomaly map, or None.
+            ``np.ndarray`` | ``None``: Validated anomaly map as float32 array, or None.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the anomaly map shape is invalid.
-
-        Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
-            >>> anomaly_map = np.random.rand(224, 224)
-            >>> validated_map = NumpyImageValidator.validate_anomaly_map(anomaly_map)
-            >>> validated_map.shape
-            (224, 224)
+            TypeError: If ``anomaly_map`` is not a numpy array.
+            ValueError: If ``anomaly_map`` dimensions are invalid.
+
+        Example:
+            Validate an anomaly map::
+
+                >>> import numpy as np
+                >>> from anomalib.data.validators import NumpyImageValidator
+                >>> anomaly_map = np.random.rand(224, 224)
+                >>> validated_map = NumpyImageValidator.validate_anomaly_map(anomaly_map)
+                >>> validated_map.shape
+                (224, 224)
+
+        Note:
+            - 3D maps with shape (1,H,W) are squeezed to (H,W)
+            - Output is always float32 type
+            - None inputs return None
         """
         if anomaly_map is None:
             return None
@@ -180,17 +273,22 @@ def validate_image_path(image_path: str | None) -> str | None:
         """Validate the image path.
 
         Args:
-            image_path (str | None): Input image path.
+            image_path (``str`` | ``None``): Input image path.
 
         Returns:
-            str | None: Validated image path, or None.
+            ``str`` | ``None``: Validated image path, or None.
 
-        Examples:
-            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
-            >>> path = "/path/to/image.jpg"
-            >>> validated_path = NumpyImageValidator.validate_image_path(path)
-            >>> validated_path == path
-            True
+        Example:
+            Validate an image path::
+
+                >>> from anomalib.data.validators import NumpyImageValidator
+                >>> path = "/path/to/image.jpg"
+                >>> validated_path = NumpyImageValidator.validate_image_path(path)
+                >>> validated_path == path
+                True
+
+        Note:
+            Returns None if input is None.
         """
         return validate_path(image_path) if image_path else None
 
@@ -199,17 +297,22 @@ def validate_mask_path(mask_path: str | None) -> str | None:
         """Validate the mask path.
 
         Args:
-            mask_path (str | None): Input mask path.
+            mask_path (``str`` | ``None``): Input mask path.
 
         Returns:
-            str | None: Validated mask path, or None.
+            ``str`` | ``None``: Validated mask path, or None.
 
-        Examples:
-            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
-            >>> path = "/path/to/mask.png"
-            >>> validated_path = NumpyImageValidator.validate_mask_path(path)
-            >>> validated_path == path
-            True
+        Example:
+            Validate a mask path::
+
+                >>> from anomalib.data.validators import NumpyImageValidator
+                >>> path = "/path/to/mask.png"
+                >>> validated_path = NumpyImageValidator.validate_mask_path(path)
+                >>> validated_path == path
+                True
+
+        Note:
+            Returns None if input is None.
         """
         return validate_path(mask_path) if mask_path else None
 
@@ -220,28 +323,37 @@ def validate_pred_score(
     ) -> np.ndarray | None:
         """Validate the prediction score.
 
+        Validates and normalizes prediction scores to float32 numpy arrays.
+
         Args:
-            pred_score (np.ndarray | float | None): Input prediction score.
-            anomaly_map (np.ndarray | None): Input anomaly map.
+            pred_score (``np.ndarray`` | ``float`` | ``None``): Input prediction score.
+            anomaly_map (``np.ndarray`` | ``None``): Input anomaly map.
 
         Returns:
-            np.ndarray | None: Validated prediction score as a float32 array, or None.
+            ``np.ndarray`` | ``None``: Validated score as float32 array, or None.
 
         Raises:
-            TypeError: If the input is neither a float, numpy.ndarray, nor None.
-            ValueError: If the prediction score is not a scalar.
-
-        Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
-            >>> score = 0.8
-            >>> validated_score = NumpyImageValidator.validate_pred_score(score)
-            >>> validated_score
-            array(0.8, dtype=float32)
-            >>> score_array = np.array(0.7)
-            >>> validated_score = NumpyImageValidator.validate_pred_score(score_array)
-            >>> validated_score
-            array(0.7, dtype=float32)
+            TypeError: If ``pred_score`` cannot be converted to numpy array.
+            ValueError: If ``pred_score`` is not scalar.
+
+        Example:
+            Validate prediction scores::
+
+                >>> import numpy as np
+                >>> from anomalib.data.validators import NumpyImageValidator
+                >>> score = 0.8
+                >>> validated_score = NumpyImageValidator.validate_pred_score(score)
+                >>> validated_score
+                array(0.8, dtype=float32)
+                >>> score_array = np.array(0.7)
+                >>> validated_score = NumpyImageValidator.validate_pred_score(score_array)
+                >>> validated_score
+                array(0.7, dtype=float32)
+
+        Note:
+            - If input is None and anomaly_map provided, returns max of anomaly_map
+            - Output is always float32 type
+            - None inputs with no anomaly_map return None
         """
         if pred_score is None:
             return np.amax(anomaly_map) if anomaly_map is not None else None
@@ -263,19 +375,26 @@ def validate_pred_score(
     def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction mask.
 
+        Validates and normalizes prediction mask arrays.
+
         Args:
-            pred_mask (np.ndarray | None): Input prediction mask.
+            pred_mask (``np.ndarray`` | ``None``): Input prediction mask.
 
         Returns:
-            np.ndarray | None: Validated prediction mask, or None.
+            ``np.ndarray`` | ``None``: Validated mask as boolean array, or None.
 
-        Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
-            >>> mask = np.random.randint(0, 2, (224, 224))
-            >>> validated_mask = NumpyImageValidator.validate_pred_mask(mask)
-            >>> validated_mask.shape
-            (224, 224)
+        Example:
+            Validate a prediction mask::
+
+                >>> import numpy as np
+                >>> from anomalib.data.validators import NumpyImageValidator
+                >>> mask = np.random.randint(0, 2, (224, 224))
+                >>> validated_mask = NumpyImageValidator.validate_pred_mask(mask)
+                >>> validated_mask.shape
+                (224, 224)
+
+        Note:
+            Uses same validation as ground truth masks.
         """
         return NumpyImageValidator.validate_gt_mask(pred_mask)  # We can reuse the gt_mask validation
 
@@ -283,23 +402,31 @@ def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
     def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction label.
 
+        Validates and normalizes prediction labels to boolean numpy arrays.
+
         Args:
-            pred_label (np.ndarray | None): Input prediction label.
+            pred_label (``np.ndarray`` | ``None``): Input prediction label.
 
         Returns:
-            np.ndarray | None: Validated prediction label as a boolean array, or None.
+            ``np.ndarray`` | ``None``: Validated label as boolean array, or None.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the prediction label is not a scalar.
-
-        Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageValidator
-            >>> label = np.array(1)
-            >>> validated_label = NumpyImageValidator.validate_pred_label(label)
-            >>> validated_label
-            array(True)
+            TypeError: If ``pred_label`` cannot be converted to numpy array.
+            ValueError: If ``pred_label`` is not scalar.
+
+        Example:
+            Validate a prediction label::
+
+                >>> import numpy as np
+                >>> from anomalib.data.validators import NumpyImageValidator
+                >>> label = np.array(1)
+                >>> validated_label = NumpyImageValidator.validate_pred_label(label)
+                >>> validated_label
+                array(True)
+
+        Note:
+            - Output is always boolean type
+            - None inputs return None
         """
         if pred_label is None:
             return None
@@ -317,20 +444,28 @@ def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
 
     @staticmethod
     def validate_explanation(explanation: str | None) -> str | None:
-        """Validate the explanation.
+        """Validate the explanation string.
 
         Args:
-            explanation (str | None): Input explanation.
+            explanation (``str`` | ``None``): Input explanation string.
 
         Returns:
-            str | None: Validated explanation, or None.
+            ``str`` | ``None``: Validated explanation string, or None.
 
-        Examples:
-            >>> from anomalib.dataclasses.validators import ImageValidator
-            >>> explanation = "The image has a crack on the wall."
-            >>> validated_explanation = ImageValidator.validate_explanation(explanation)
-            >>> validated_explanation == explanation
-            True
+        Raises:
+            TypeError: If ``explanation`` is not a string.
+
+        Example:
+            Validate an explanation string::
+
+                >>> from anomalib.dataclasses.validators import ImageValidator
+                >>> explanation = "The image has a crack on the wall."
+                >>> validated = ImageValidator.validate_explanation(explanation)
+                >>> validated == explanation
+                True
+
+        Note:
+            Returns None if input is None.
         """
         if explanation is None:
             return None
@@ -341,41 +476,80 @@ def validate_explanation(explanation: str | None) -> str | None:
 
 
 class NumpyImageBatchValidator:
-    """Validate numpy.ndarray data for batches of images."""
+    """Validate batches of image data stored as numpy arrays.
+
+    This class provides validation methods for batches of image data stored as numpy arrays.
+    It ensures data consistency and correctness for images and associated metadata.
+
+    The validator checks:
+        - Array shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate a batch of images and associated metadata::
+
+            >>> from anomalib.data.validators import NumpyImageBatchValidator
+            >>> validator = NumpyImageBatchValidator()
+            >>> images = np.random.rand(32, 256, 256, 3)
+            >>> labels = np.zeros(32)
+            >>> masks = np.zeros((32, 256, 256))
+            >>> validator.validate_image(images)
+            >>> validator.validate_gt_label(labels)
+            >>> validator.validate_gt_mask(masks)
+    """
 
     @staticmethod
     def validate_image(image: np.ndarray) -> np.ndarray:
         """Validate the image batch array.
 
+        This method validates batches of images stored as numpy arrays. It handles:
+            - Single images and batches
+            - Grayscale and RGB images
+            - Channel-first and channel-last formats
+            - Type conversion to float32
+
         Args:
-            image (np.ndarray): Input image batch array.
+            image (``np.ndarray``): Input image batch array.
 
         Returns:
-            np.ndarray: Validated image batch array.
+            ``np.ndarray``: Validated image batch array in [N,H,W,C] format.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the image batch array does not have the correct shape.
+            TypeError: If ``image`` is not a numpy array.
+            ValueError: If ``image`` shape is invalid.
 
         Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
-            >>> batch = np.random.rand(32, 224, 224, 3)
-            >>> validated_batch = NumpyImageBatchValidator.validate_image(batch)
-            >>> validated_batch.shape
-            (32, 224, 224, 3)
-            >>> grayscale_batch = np.random.rand(32, 224, 224)
-            >>> validated_grayscale = NumpyImageBatchValidator.validate_image(grayscale_batch)
-            >>> validated_grayscale.shape
-            (32, 224, 224, 1)
-            >>> torch_style_batch = np.random.rand(32, 3, 224, 224)
-            >>> validated_torch_style = NumpyImageBatchValidator.validate_image(torch_style_batch)
-            >>> validated_torch_style.shape
-            (32, 224, 224, 3)
-            >>> single_image = np.zeros((224, 224, 3))
-            >>> validated_single = NumpyImageBatchValidator.validate_image(single_image)
-            >>> validated_single.shape
-            (1, 224, 224, 3)
+            Validate RGB batch::
+
+                >>> batch = np.random.rand(32, 224, 224, 3)
+                >>> validated = NumpyImageBatchValidator.validate_image(batch)
+                >>> validated.shape
+                (32, 224, 224, 3)
+
+            Validate grayscale batch::
+
+                >>> gray = np.random.rand(32, 224, 224)
+                >>> validated = NumpyImageBatchValidator.validate_image(gray)
+                >>> validated.shape
+                (32, 224, 224, 1)
+
+            Validate channel-first batch::
+
+                >>> chf = np.random.rand(32, 3, 224, 224)
+                >>> validated = NumpyImageBatchValidator.validate_image(chf)
+                >>> validated.shape
+                (32, 224, 224, 3)
+
+            Validate single image::
+
+                >>> img = np.zeros((224, 224, 3))
+                >>> validated = NumpyImageBatchValidator.validate_image(img)
+                >>> validated.shape
+                (1, 224, 224, 3)
         """
         # Check if the image is a numpy array
         if not isinstance(image, np.ndarray):
@@ -410,27 +584,37 @@ def validate_image(image: np.ndarray) -> np.ndarray:
     def validate_gt_label(gt_label: np.ndarray | Sequence[int] | None) -> np.ndarray | None:
         """Validate the ground truth label batch.
 
+        This method validates batches of ground truth labels. It handles:
+            - Numpy arrays and sequences of integers
+            - Type conversion to boolean
+            - Shape validation
+
         Args:
-            gt_label (np.ndarray | Sequence[int] | None): Input ground truth label batch.
+            gt_label (``np.ndarray`` | ``Sequence[int]`` | ``None``): Input ground truth label
+                batch.
 
         Returns:
-            np.ndarray | None: Validated ground truth label batch as a boolean array, or None.
+            ``np.ndarray`` | ``None``: Validated ground truth label batch as boolean array,
+                or ``None``.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray or Sequence[int].
-            ValueError: If the label batch shape is invalid.
+            TypeError: If ``gt_label`` is not a numpy array or sequence of integers.
+            ValueError: If ``gt_label`` shape is invalid.
 
         Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
-            >>> labels = np.array([0, 1, 1, 0])
-            >>> validated_labels = NumpyImageBatchValidator.validate_gt_label(labels)
-            >>> validated_labels
-            array([False,  True,  True, False])
-            >>> list_labels = [1, 0, 1, 1]
-            >>> validated_list = NumpyImageBatchValidator.validate_gt_label(list_labels)
-            >>> validated_list
-            array([ True, False,  True,  True])
+            Validate numpy array labels::
+
+                >>> labels = np.array([0, 1, 1, 0])
+                >>> validated = NumpyImageBatchValidator.validate_gt_label(labels)
+                >>> validated
+                array([False,  True,  True, False])
+
+            Validate list labels::
+
+                >>> labels = [1, 0, 1, 1]
+                >>> validated = NumpyImageBatchValidator.validate_gt_label(labels)
+                >>> validated
+                array([ True, False,  True,  True])
         """
         if gt_label is None:
             return None
@@ -448,29 +632,38 @@ def validate_gt_label(gt_label: np.ndarray | Sequence[int] | None) -> np.ndarray
     def validate_gt_mask(gt_mask: np.ndarray | None) -> np.ndarray | None:
         """Validate the ground truth mask batch.
 
+        This method validates batches of ground truth masks. It handles:
+            - Channel-first and channel-last formats
+            - Type conversion to boolean
+            - Shape validation
+
         Args:
-            gt_mask (np.ndarray | None): Input ground truth mask batch.
+            gt_mask (``np.ndarray`` | ``None``): Input ground truth mask batch.
 
         Returns:
-            np.ndarray | None: Validated ground truth mask batch as a boolean array, or None.
+            ``np.ndarray`` | ``None``: Validated ground truth mask batch as boolean array,
+                or ``None``.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the mask batch shape is invalid.
+            TypeError: If ``gt_mask`` is not a numpy array.
+            ValueError: If ``gt_mask`` shape is invalid.
 
         Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
-            >>> masks = np.random.randint(0, 2, (4, 224, 224))
-            >>> validated_masks = NumpyImageBatchValidator.validate_gt_mask(masks)
-            >>> validated_masks.shape
-            (4, 224, 224)
-            >>> validated_masks.dtype
-            dtype('bool')
-            >>> torch_style_masks = np.random.randint(0, 2, (4, 1, 224, 224))
-            >>> validated_torch_style = NumpyImageBatchValidator.validate_gt_mask(torch_style_masks)
-            >>> validated_torch_style.shape
-            (4, 224, 224, 1)
+            Validate channel-last masks::
+
+                >>> masks = np.random.randint(0, 2, (4, 224, 224))
+                >>> validated = NumpyImageBatchValidator.validate_gt_mask(masks)
+                >>> validated.shape
+                (4, 224, 224)
+                >>> validated.dtype
+                dtype('bool')
+
+            Validate channel-first masks::
+
+                >>> masks = np.random.randint(0, 2, (4, 1, 224, 224))
+                >>> validated = NumpyImageBatchValidator.validate_gt_mask(masks)
+                >>> validated.shape
+                (4, 224, 224, 1)
         """
         if gt_mask is None:
             return None
@@ -495,26 +688,26 @@ def validate_gt_mask(gt_mask: np.ndarray | None) -> np.ndarray | None:
     def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
         """Validate the mask paths for a batch.
 
+        This method validates sequences of mask file paths. It handles:
+            - Type conversion to strings
+            - Path sequence validation
+
         Args:
-            mask_path (Sequence[str] | None): Input sequence of mask paths.
+            mask_path (``Sequence[str]`` | ``None``): Input sequence of mask paths.
 
         Returns:
-            list[str] | None: Validated list of mask paths, or None.
+            ``list[str]`` | ``None``: Validated list of mask paths, or ``None``.
 
         Raises:
-            TypeError: If the input is not a sequence of strings.
-            ValueError: If the number of paths doesn't match the batch size.
+            TypeError: If ``mask_path`` is not a sequence of strings.
 
         Examples:
-            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
-            >>> paths = ['mask1.png', 'mask2.png', 'mask3.png', 'mask4.png']
-            >>> validated_paths = NumpyImageBatchValidator.validate_mask_path(paths)
-            >>> validated_paths
-            ['mask1.png', 'mask2.png', 'mask3.png', 'mask4.png']
-            >>> NumpyImageBatchValidator.validate_mask_path(['mask1.png', 'mask2.png'], 4)
-            Traceback (most recent call last):
-                ...
-            ValueError: Invalid length for mask_path. Got length 2 for batch size 4.
+            Validate list of paths::
+
+                >>> paths = ['mask1.png', 'mask2.png', 'mask3.png']
+                >>> validated = NumpyImageBatchValidator.validate_mask_path(paths)
+                >>> validated
+                ['mask1.png', 'mask2.png', 'mask3.png']
         """
         if mask_path is None:
             return None
@@ -527,29 +720,37 @@ def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
     def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
         """Validate the anomaly map batch.
 
+        This method validates batches of anomaly maps. It handles:
+            - Channel-first and channel-last formats
+            - Type conversion to float32
+            - Shape validation
+
         Args:
-            anomaly_map (np.ndarray | None): Input anomaly map batch.
+            anomaly_map (``np.ndarray`` | ``None``): Input anomaly map batch.
 
         Returns:
-            np.ndarray | None: Validated anomaly map batch, or None.
+            ``np.ndarray`` | ``None``: Validated anomaly map batch, or ``None``.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the anomaly map batch shape is invalid.
+            TypeError: If ``anomaly_map`` is not a numpy array.
+            ValueError: If ``anomaly_map`` shape is invalid.
 
         Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
-            >>> anomaly_maps = np.random.rand(4, 224, 224)
-            >>> validated_maps = NumpyImageBatchValidator.validate_anomaly_map(anomaly_maps)
-            >>> validated_maps.shape
-            (4, 224, 224)
-            >>> validated_maps.dtype
-            dtype('float32')
-            >>> torch_style_maps = np.random.rand(4, 1, 224, 224)
-            >>> validated_torch_style = NumpyImageBatchValidator.validate_anomaly_map(torch_style_maps)
-            >>> validated_torch_style.shape
-            (4, 224, 224, 1)
+            Validate channel-last maps::
+
+                >>> maps = np.random.rand(4, 224, 224)
+                >>> validated = NumpyImageBatchValidator.validate_anomaly_map(maps)
+                >>> validated.shape
+                (4, 224, 224)
+                >>> validated.dtype
+                dtype('float32')
+
+            Validate channel-first maps::
+
+                >>> maps = np.random.rand(4, 1, 224, 224)
+                >>> validated = NumpyImageBatchValidator.validate_anomaly_map(maps)
+                >>> validated.shape
+                (4, 224, 224, 1)
         """
         if anomaly_map is None:
             return None
@@ -568,30 +769,38 @@ def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
     def validate_pred_score(pred_score: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction scores for a batch.
 
+        This method validates batches of prediction scores. It handles:
+            - 1D and 2D arrays
+            - Type conversion to float32
+            - Shape validation
+
         Args:
-            pred_score (np.ndarray | None): Input prediction score batch.
+            pred_score (``np.ndarray`` | ``None``): Input prediction score batch.
 
         Returns:
-            np.ndarray | None: Validated prediction score batch, or None.
+            ``np.ndarray`` | ``None``: Validated prediction score batch, or ``None``.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the prediction score batch is not 1-dimensional or 2-dimensional.
+            TypeError: If ``pred_score`` is not a numpy array.
+            ValueError: If ``pred_score`` shape is invalid.
 
         Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
-            >>> scores = np.array([0.1, 0.8, 0.3, 0.6])
-            >>> validated_scores = NumpyImageBatchValidator.validate_pred_score(scores)
-            >>> validated_scores
-            array([0.1, 0.8, 0.3, 0.6], dtype=float32)
-            >>> scores_2d = np.array([[0.1], [0.8], [0.3], [0.6]])
-            >>> validated_scores_2d = NumpyImageBatchValidator.validate_pred_score(scores_2d)
-            >>> validated_scores_2d
-            array([[0.1],
-                   [0.8],
-                   [0.3],
-                   [0.6]], dtype=float32)
+            Validate 1D scores::
+
+                >>> scores = np.array([0.1, 0.8, 0.3, 0.6])
+                >>> validated = NumpyImageBatchValidator.validate_pred_score(scores)
+                >>> validated
+                array([0.1, 0.8, 0.3, 0.6], dtype=float32)
+
+            Validate 2D scores::
+
+                >>> scores = np.array([[0.1], [0.8], [0.3], [0.6]])
+                >>> validated = NumpyImageBatchValidator.validate_pred_score(scores)
+                >>> validated
+                array([[0.1],
+                       [0.8],
+                       [0.3],
+                       [0.6]], dtype=float32)
         """
         if pred_score is None:
             return None
@@ -608,29 +817,37 @@ def validate_pred_score(pred_score: np.ndarray | None) -> np.ndarray | None:
     def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction mask batch.
 
+        This method validates batches of prediction masks. It handles:
+            - Channel-first and channel-last formats
+            - Type conversion to boolean
+            - Shape validation
+
         Args:
-            pred_mask (np.ndarray | None): Input prediction mask batch.
+            pred_mask (``np.ndarray`` | ``None``): Input prediction mask batch.
 
         Returns:
-            np.ndarray | None: Validated prediction mask batch, or None.
+            ``np.ndarray`` | ``None``: Validated prediction mask batch, or ``None``.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the prediction mask batch shape is invalid.
+            TypeError: If ``pred_mask`` is not a numpy array.
+            ValueError: If ``pred_mask`` shape is invalid.
 
         Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
-            >>> masks = np.random.randint(0, 2, (4, 224, 224))
-            >>> validated_masks = NumpyImageBatchValidator.validate_pred_mask(masks)
-            >>> validated_masks.shape
-            (4, 224, 224)
-            >>> validated_masks.dtype
-            dtype('bool')
-            >>> torch_style_masks = np.random.randint(0, 2, (4, 1, 224, 224))
-            >>> validated_torch_style = NumpyImageBatchValidator.validate_pred_mask(torch_style_masks)
-            >>> validated_torch_style.shape
-            (4, 224, 224, 1)
+            Validate channel-last masks::
+
+                >>> masks = np.random.randint(0, 2, (4, 224, 224))
+                >>> validated = NumpyImageBatchValidator.validate_pred_mask(masks)
+                >>> validated.shape
+                (4, 224, 224)
+                >>> validated.dtype
+                dtype('bool')
+
+            Validate channel-first masks::
+
+                >>> masks = np.random.randint(0, 2, (4, 1, 224, 224))
+                >>> validated = NumpyImageBatchValidator.validate_pred_mask(masks)
+                >>> validated.shape
+                (4, 224, 224, 1)
         """
         return NumpyImageBatchValidator.validate_gt_mask(pred_mask)
 
@@ -638,30 +855,39 @@ def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
     def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction label batch.
 
+        This method validates batches of prediction labels. It handles:
+            - 1D and 2D arrays
+            - Type conversion to boolean
+            - Shape validation
+
         Args:
-            pred_label (np.ndarray | None): Input prediction label batch.
+            pred_label (``np.ndarray`` | ``None``): Input prediction label batch.
 
         Returns:
-            np.ndarray | None: Validated prediction label batch as a boolean array, or None.
+            ``np.ndarray`` | ``None``: Validated prediction label batch as boolean array,
+                or ``None``.
 
         Raises:
-            TypeError: If the input is not a numpy.ndarray.
-            ValueError: If the prediction label batch is not 1-dimensional or 2-dimensional.
+            TypeError: If ``pred_label`` is not a numpy array.
+            ValueError: If ``pred_label`` shape is invalid.
 
         Examples:
-            >>> import numpy as np
-            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
-            >>> labels = np.array([0, 1, 1, 0])
-            >>> validated_labels = NumpyImageBatchValidator.validate_pred_label(labels)
-            >>> validated_labels
-            array([False,  True,  True, False])
-            >>> labels_2d = np.array([[0], [1], [1], [0]])
-            >>> validated_labels_2d = NumpyImageBatchValidator.validate_pred_label(labels_2d)
-            >>> validated_labels_2d
-            array([[False],
-                   [ True],
-                   [ True],
-                   [False]])
+            Validate 1D labels::
+
+                >>> labels = np.array([0, 1, 1, 0])
+                >>> validated = NumpyImageBatchValidator.validate_pred_label(labels)
+                >>> validated
+                array([False,  True,  True, False])
+
+            Validate 2D labels::
+
+                >>> labels = np.array([[0], [1], [1], [0]])
+                >>> validated = NumpyImageBatchValidator.validate_pred_label(labels)
+                >>> validated
+                array([[False],
+                       [ True],
+                       [ True],
+                       [False]])
         """
         if pred_label is None:
             return None
@@ -677,23 +903,33 @@ def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
     def validate_image_path(image_path: list[str] | None) -> list[str] | None:
         """Validate the image paths for a batch.
 
+        This method validates lists of image file paths. It handles:
+            - Type conversion to strings
+            - Path list validation
+
         Args:
-            image_path (list[str] | None): Input list of image paths.
+            image_path (``list[str]`` | ``None``): Input list of image paths.
 
         Returns:
-            list[str] | None: Validated list of image paths, or None.
+            ``list[str]`` | ``None``: Validated list of image paths, or ``None``.
 
         Raises:
-            TypeError: If the input is not a list of strings.
+            TypeError: If ``image_path`` is not a list.
 
         Examples:
-            >>> from anomalib.data.validators.numpy.image import NumpyImageBatchValidator
-            >>> paths = ['image1.jpg', 'image2.jpg', 'image3.jpg']
-            >>> validated_paths = NumpyImageBatchValidator.validate_image_path(paths)
-            >>> validated_paths
-            ['image1.jpg', 'image2.jpg', 'image3.jpg']
-            >>> NumpyImageBatchValidator.validate_image_path(['image1.jpg', 2, 'image3.jpg'])
-            ['image1.jpg', '2', 'image3.jpg']
+            Validate list of paths::
+
+                >>> paths = ['image1.jpg', 'image2.jpg', 'image3.jpg']
+                >>> validated = NumpyImageBatchValidator.validate_image_path(paths)
+                >>> validated
+                ['image1.jpg', 'image2.jpg', 'image3.jpg']
+
+            Validate mixed type paths::
+
+                >>> paths = ['image1.jpg', 2, 'image3.jpg']
+                >>> validated = NumpyImageBatchValidator.validate_image_path(paths)
+                >>> validated
+                ['image1.jpg', '2', 'image3.jpg']
         """
         if image_path is None:
             return None
@@ -706,21 +942,26 @@ def validate_image_path(image_path: list[str] | None) -> list[str] | None:
     def validate_explanation(explanation: list[str] | None) -> list[str] | None:
         """Validate the explanations for a batch.
 
+        This method validates lists of explanation strings. It handles:
+            - Type conversion to strings
+            - List validation
+
         Args:
-            explanation (list[str] | None): Input list of explanations.
+            explanation (``list[str]`` | ``None``): Input list of explanations.
 
         Returns:
-            list[str] | None: Validated list of explanations, or None.
+            ``list[str]`` | ``None``: Validated list of explanations, or ``None``.
 
         Raises:
-            TypeError: If the input is not a list of strings.
+            TypeError: If ``explanation`` is not a list.
 
         Examples:
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> explanations = ["The image has a crack on the wall.", "The image has a dent on the car."]
-            >>> validated_explanations = ImageBatchValidator.validate_explanation(explanations)
-            >>> print(validated_explanations)
-            ['The image has a crack on the wall.', 'The image has a dent on the car.']
+            Validate list of explanations::
+
+                >>> explanations = ["The image has a crack.", "The image has a dent."]
+                >>> validated = NumpyImageBatchValidator.validate_explanation(explanations)
+                >>> validated
+                ['The image has a crack.', 'The image has a dent.']
         """
         if explanation is None:
             return None
diff --git a/src/anomalib/data/validators/numpy/video.py b/src/anomalib/data/validators/numpy/video.py
index e12682881b..05eb42e910 100644
--- a/src/anomalib/data/validators/numpy/video.py
+++ b/src/anomalib/data/validators/numpy/video.py
@@ -1,4 +1,32 @@
-"""Validate numpy video data."""
+"""Validate numpy video data.
+
+This module provides validators for video data stored as numpy arrays. The validators
+ensure data consistency and correctness for videos and batches of videos.
+
+The validators check:
+    - Array shapes and dimensions
+    - Data types
+    - Value ranges
+    - Label formats
+    - Mask properties
+
+Example:
+    Validate a single video::
+
+        >>> from anomalib.data.validators import NumpyVideoValidator
+        >>> validator = NumpyVideoValidator()
+        >>> validator.validate_image(video)
+
+    Validate a batch of videos::
+
+        >>> from anomalib.data.validators import NumpyVideoBatchValidator
+        >>> validator = NumpyVideoBatchValidator()
+        >>> validator(videos=videos, labels=labels, masks=masks)
+
+Note:
+    The validators are used internally by the data modules to ensure data
+    consistency before processing video data.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -11,29 +39,62 @@
 
 
 class NumpyVideoValidator:
-    """Validate numpy.ndarray data for videos."""
+    """Validate numpy array data for videos.
+
+    This class provides validation methods for video data stored as numpy arrays.
+    It ensures data consistency and correctness for videos and associated metadata.
+
+    The validator checks:
+        - Array shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate a video and associated metadata::
+
+            >>> from anomalib.data.validators import NumpyVideoValidator
+            >>> validator = NumpyVideoValidator()
+            >>> video = np.random.rand(10, 224, 224, 3)  # [T, H, W, C]
+            >>> validated_video = validator.validate_image(video)
+            >>> label = 1
+            >>> validated_label = validator.validate_gt_label(label)
+            >>> mask = np.random.randint(0, 2, (10, 224, 224))  # [T, H, W]
+            >>> validated_mask = validator.validate_gt_mask(mask)
+
+    Note:
+        The validator is used internally by the data modules to ensure data
+        consistency before processing.
+    """
 
     @staticmethod
     def validate_image(image: np.ndarray) -> np.ndarray:
         """Validate the video array.
 
+        Validates and normalizes input video arrays. Handles both RGB and grayscale
+        videos, and ensures proper time dimension.
+
         Args:
-            image (np.ndarray): Input video array to validate.
+            image (``np.ndarray``): Input video array to validate.
 
         Returns:
-            np.ndarray: Validated video array as float32 with an added time dimension if not present.
+            ``np.ndarray``: Validated video array in format [T, H, W, C] as float32.
 
         Raises:
-            TypeError: If the input is not a numpy array.
-            ValueError: If the array dimensions or channel count are invalid.
+            TypeError: If ``image`` is not a numpy array.
+            ValueError: If ``image`` dimensions or channels are invalid.
 
         Example:
-            >>> import numpy as np
-            >>> validator = NumpyVideoValidator()
-            >>> video = np.random.rand(10, 224, 224, 3)  # [T, H, W, C]
-            >>> validated_video = validator.validate_image(video)
-            >>> print(validated_video.shape, validated_video.dtype)
-            (10, 224, 224, 3) float32
+            Validate RGB video::
+
+                >>> import numpy as np
+                >>> validator = NumpyVideoValidator()
+                >>> video = np.random.rand(10, 224, 224, 3)  # [T, H, W, C]
+                >>> validated_video = validator.validate_image(video)
+                >>> print(validated_video.shape, validated_video.dtype)
+                (10, 224, 224, 3) float32
         """
         if not isinstance(image, np.ndarray):
             msg = f"Video must be a numpy.ndarray, got {type(image)}."
@@ -58,14 +119,15 @@ def validate_gt_label(label: int | np.ndarray | None) -> np.ndarray | None:
         """Validate the ground truth label.
 
         Args:
-            label (int | np.ndarray | None): Input label to validate.
+            label (``int`` | ``np.ndarray`` | ``None``): Input label to validate.
 
         Returns:
-            np.ndarray | None: Validated label as boolean numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated label as boolean numpy array, or None if
+                input is None.
 
         Raises:
-            TypeError: If the input is not an integer or numpy array.
-            ValueError: If the label is not a scalar.
+            TypeError: If ``label`` is not an integer or numpy array.
+            ValueError: If ``label`` is not a scalar.
 
         Example:
             >>> validator = NumpyVideoValidator()
@@ -94,14 +156,15 @@ def validate_gt_mask(mask: np.ndarray | None) -> np.ndarray | None:
         """Validate the ground truth mask.
 
         Args:
-            mask (np.ndarray | None): Input mask to validate.
+            mask (``np.ndarray`` | ``None``): Input mask to validate.
 
         Returns:
-            np.ndarray | None: Validated mask as boolean numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated mask as boolean numpy array, or None if
+                input is None.
 
         Raises:
-            TypeError: If the input is not a numpy array.
-            ValueError: If the mask dimensions or channel count are invalid.
+            TypeError: If ``mask`` is not a numpy array.
+            ValueError: If ``mask`` dimensions or channel count are invalid.
 
         Example:
             >>> import numpy as np
@@ -129,10 +192,10 @@ def validate_mask_path(mask_path: str | None) -> str | None:
         """Validate the mask path.
 
         Args:
-            mask_path (str | None): Input mask path to validate.
+            mask_path (``str`` | ``None``): Input mask path to validate.
 
         Returns:
-            str | None: Validated mask path, or None if input is None.
+            ``str`` | ``None``: Validated mask path, or None if input is None.
 
         Example:
             >>> validator = NumpyVideoValidator()
@@ -148,14 +211,15 @@ def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
         """Validate the anomaly map.
 
         Args:
-            anomaly_map (np.ndarray | None): Input anomaly map to validate.
+            anomaly_map (``np.ndarray`` | ``None``): Input anomaly map to validate.
 
         Returns:
-            np.ndarray | None: Validated anomaly map as float32 numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated anomaly map as float32 numpy array, or
+                None if input is None.
 
         Raises:
-            TypeError: If the input is not a numpy array.
-            ValueError: If the anomaly map dimensions or channel count are invalid.
+            TypeError: If ``anomaly_map`` is not a numpy array.
+            ValueError: If ``anomaly_map`` dimensions or channel count are invalid.
 
         Example:
             >>> import numpy as np
@@ -183,14 +247,16 @@ def validate_pred_score(pred_score: np.ndarray | float | None) -> np.ndarray | N
         """Validate the prediction score.
 
         Args:
-            pred_score (np.ndarray | float | None): Input prediction score to validate.
+            pred_score (``np.ndarray`` | ``float`` | ``None``): Input prediction score to
+                validate.
 
         Returns:
-            np.ndarray | None: Validated prediction score as float32 numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated prediction score as float32 numpy array,
+                or None if input is None.
 
         Raises:
-            TypeError: If the input is not a float or numpy array.
-            ValueError: If the prediction score is not a scalar.
+            TypeError: If ``pred_score`` is not a float or numpy array.
+            ValueError: If ``pred_score`` is not a scalar.
 
         Example:
             >>> validator = NumpyVideoValidator()
@@ -216,10 +282,11 @@ def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction mask.
 
         Args:
-            pred_mask (np.ndarray | None): Input prediction mask to validate.
+            pred_mask (``np.ndarray`` | ``None``): Input prediction mask to validate.
 
         Returns:
-            np.ndarray | None: Validated prediction mask as boolean numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated prediction mask as boolean numpy array,
+                or None if input is None.
 
         Example:
             >>> import numpy as np
@@ -236,13 +303,15 @@ def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction label.
 
         Args:
-            pred_label (np.ndarray | None): Input prediction label to validate.
+            pred_label (``np.ndarray`` | ``None``): Input prediction label to validate.
 
         Returns:
-            np.ndarray | None: Validated prediction label as boolean numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated prediction label as boolean numpy array,
+                or None if input is None.
 
         Raises:
-            ValueError: If the input cannot be converted to a numpy array or is not a scalar.
+            ValueError: If ``pred_label`` cannot be converted to a numpy array or is not
+                a scalar.
 
         Example:
             >>> import numpy as np
@@ -271,10 +340,10 @@ def validate_video_path(video_path: str | None) -> str | None:
         """Validate the video path.
 
         Args:
-            video_path (str | None): Input video path to validate.
+            video_path (``str`` | ``None``): Input video path to validate.
 
         Returns:
-            str | None: Validated video path, or None if input is None.
+            ``str`` | ``None``: Validated video path, or None if input is None.
 
         Example:
             >>> validator = NumpyVideoValidator()
@@ -290,14 +359,14 @@ def validate_original_image(original_image: np.ndarray | None) -> np.ndarray | N
         """Validate the original video.
 
         Args:
-            original_image (np.ndarray | None): Input original video to validate.
+            original_image (``np.ndarray`` | ``None``): Input original video to validate.
 
         Returns:
-            np.ndarray | None: Validated original video, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated original video, or None if input is None.
 
         Raises:
-            TypeError: If the input is not a numpy array.
-            ValueError: If the original video dimensions or channel count are invalid.
+            TypeError: If ``original_image`` is not a numpy array.
+            ValueError: If ``original_image`` dimensions or channel count are invalid.
 
         Example:
             >>> import numpy as np
@@ -325,14 +394,14 @@ def validate_target_frame(target_frame: int | None) -> int | None:
         """Validate the target frame index.
 
         Args:
-            target_frame (int | None): Input target frame index to validate.
+            target_frame (``int`` | ``None``): Input target frame index to validate.
 
         Returns:
-            int | None: Validated target frame index, or None if input is None.
+            ``int`` | ``None``: Validated target frame index, or None if input is None.
 
         Raises:
-            TypeError: If the input is not an integer.
-            ValueError: If the target frame index is negative.
+            TypeError: If ``target_frame`` is not an integer.
+            ValueError: If ``target_frame`` is negative.
 
         Example:
             >>> validator = NumpyVideoValidator()
@@ -358,17 +427,45 @@ def validate_explanation(explanation: str | None) -> str | None:
 
 
 class NumpyVideoBatchValidator:
-    """Validate numpy.ndarray data for batches of videos."""
+    """Validate numpy array data for batches of videos.
+
+    This class provides validation methods for batches of video data stored as numpy arrays.
+    It ensures data consistency and correctness for video batches and associated metadata.
+
+    The validator checks:
+        - Array shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate a batch of videos and associated metadata::
+
+            >>> from anomalib.data.validators import NumpyVideoBatchValidator
+            >>> validator = NumpyVideoBatchValidator()
+            >>> videos = np.random.rand(32, 10, 224, 224, 3)  # [N, T, H, W, C]
+            >>> labels = np.zeros(32)
+            >>> masks = np.zeros((32, 10, 224, 224))
+            >>> validated_videos = validator.validate_image(videos)
+            >>> validated_labels = validator.validate_gt_label(labels)
+            >>> validated_masks = validator.validate_gt_mask(masks)
+
+    Note:
+        The validator is used internally by the data modules to ensure data
+        consistency before processing.
+    """
 
     @staticmethod
     def validate_image(image: np.ndarray) -> np.ndarray:
         """Validate the video batch array.
 
         Args:
-            image (np.ndarray): Input video batch array to validate.
+            image (``np.ndarray``): Input video batch array to validate.
 
         Returns:
-            np.ndarray: Validated video batch array as float32.
+            ``np.ndarray``: Validated video batch array as float32.
 
         Raises:
             TypeError: If the input is not a numpy array.
@@ -402,10 +499,12 @@ def validate_gt_label(gt_label: np.ndarray | Sequence[int] | None) -> np.ndarray
         """Validate the ground truth label batch.
 
         Args:
-            gt_label (np.ndarray | Sequence[int] | None): Input ground truth label batch to validate.
+            gt_label (``np.ndarray`` | ``Sequence[int]`` | ``None``): Input ground truth
+                label batch to validate.
 
         Returns:
-            np.ndarray | None: Validated ground truth label batch as boolean numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated ground truth label batch as boolean numpy
+                array, or None if input is None.
 
         Raises:
             TypeError: If the input is not a numpy array or sequence of integers.
@@ -436,10 +535,11 @@ def validate_gt_mask(gt_mask: np.ndarray | None) -> np.ndarray | None:
         """Validate the ground truth mask batch.
 
         Args:
-            gt_mask (np.ndarray | None): Input ground truth mask batch to validate.
+            gt_mask (``np.ndarray`` | ``None``): Input ground truth mask batch to validate.
 
         Returns:
-            np.ndarray | None: Validated ground truth mask batch as boolean numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated ground truth mask batch as boolean numpy
+                array, or None if input is None.
 
         Raises:
             TypeError: If the input is not a numpy array.
@@ -471,10 +571,10 @@ def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
         """Validate the mask paths for a batch.
 
         Args:
-            mask_path (Sequence[str] | None): Input mask paths to validate.
+            mask_path (``Sequence[str]`` | ``None``): Input mask paths to validate.
 
         Returns:
-            list[str] | None: Validated mask paths, or None if input is None.
+            ``list[str]`` | ``None``: Validated mask paths, or None if input is None.
 
         Example:
             >>> validator = NumpyVideoBatchValidator()
@@ -490,10 +590,11 @@ def validate_anomaly_map(anomaly_map: np.ndarray | None) -> np.ndarray | None:
         """Validate the anomaly map batch.
 
         Args:
-            anomaly_map (np.ndarray | None): Input anomaly map batch to validate.
+            anomaly_map (``np.ndarray`` | ``None``): Input anomaly map batch to validate.
 
         Returns:
-            np.ndarray | None: Validated anomaly map batch as float32 numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated anomaly map batch as float32 numpy array,
+                or None if input is None.
 
         Raises:
             TypeError: If the input is not a numpy array.
@@ -525,10 +626,11 @@ def validate_pred_score(pred_score: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction scores for a batch.
 
         Args:
-            pred_score (np.ndarray | None): Input prediction scores to validate.
+            pred_score (``np.ndarray`` | ``None``): Input prediction scores to validate.
 
         Returns:
-            np.ndarray | None: Validated prediction scores as float32 numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated prediction scores as float32 numpy array,
+                or None if input is None.
 
         Raises:
             TypeError: If the input is not a numpy array.
@@ -557,10 +659,11 @@ def validate_pred_mask(pred_mask: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction mask batch.
 
         Args:
-            pred_mask (np.ndarray | None): Input prediction mask batch to validate.
+            pred_mask (``np.ndarray`` | ``None``): Input prediction mask batch to validate.
 
         Returns:
-            np.ndarray | None: Validated prediction mask batch as boolean numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated prediction mask batch as boolean numpy
+                array, or None if input is None.
 
         Example:
             >>> import numpy as np
@@ -577,10 +680,12 @@ def validate_pred_label(pred_label: np.ndarray | None) -> np.ndarray | None:
         """Validate the prediction label batch.
 
         Args:
-            pred_label (np.ndarray | None): Input prediction label batch to validate.
+            pred_label (``np.ndarray`` | ``None``): Input prediction label batch to
+                validate.
 
         Returns:
-            np.ndarray | None: Validated prediction label batch as boolean numpy array, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated prediction label batch as boolean numpy
+                array, or None if input is None.
 
         Raises:
             TypeError: If the input is not a numpy array.
@@ -609,10 +714,10 @@ def validate_video_path(video_path: list[str] | None) -> list[str] | None:
         """Validate the video paths for a batch.
 
         Args:
-            video_path (list[str] | None): Input video paths to validate.
+            video_path (``list[str]`` | ``None``): Input video paths to validate.
 
         Returns:
-            list[str] | None: Validated video paths, or None if input is None.
+            ``list[str]`` | ``None``: Validated video paths, or None if input is None.
 
         Example:
             >>> validator = NumpyVideoBatchValidator()
@@ -628,10 +733,12 @@ def validate_original_image(original_image: np.ndarray | None) -> np.ndarray | N
         """Validate the original video batch.
 
         Args:
-            original_image (np.ndarray | None): Input original video batch to validate.
+            original_image (``np.ndarray`` | ``None``): Input original video batch to
+                validate.
 
         Returns:
-            np.ndarray | None: Validated original video batch, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated original video batch, or None if input is
+                None.
 
         Raises:
             TypeError: If the input is not a numpy array.
@@ -666,10 +773,12 @@ def validate_target_frame(target_frame: np.ndarray | None) -> np.ndarray | None:
         """Validate the target frame indices for a batch.
 
         Args:
-            target_frame (np.ndarray | None): Input target frame indices to validate.
+            target_frame (``np.ndarray`` | ``None``): Input target frame indices to
+                validate.
 
         Returns:
-            np.ndarray | None: Validated target frame indices, or None if input is None.
+            ``np.ndarray`` | ``None``: Validated target frame indices, or None if input is
+                None.
 
         Raises:
             TypeError: If the input is not a numpy array of integers.
diff --git a/src/anomalib/data/validators/path.py b/src/anomalib/data/validators/path.py
index 0ee5080710..36fcac6221 100644
--- a/src/anomalib/data/validators/path.py
+++ b/src/anomalib/data/validators/path.py
@@ -1,4 +1,35 @@
-"""Validate IO path data."""
+"""Validate IO path data.
+
+This module provides validators for file system paths. The validators ensure path
+consistency and correctness.
+
+The validators check:
+    - Path types (str vs Path objects)
+    - Path string formatting
+    - Batch size consistency
+    - None handling
+
+Example:
+    Validate a single path::
+
+        >>> from anomalib.data.validators import validate_path
+        >>> path = "/path/to/file.jpg"
+        >>> validated = validate_path(path)
+        >>> validated == path
+        True
+
+    Validate a batch of paths::
+
+        >>> from anomalib.data.validators import validate_batch_path
+        >>> paths = ["/path/1.jpg", "/path/2.jpg"]
+        >>> validated = validate_batch_path(paths, batch_size=2)
+        >>> len(validated)
+        2
+
+Note:
+    The validators are used internally by the data modules to ensure path
+    consistency before processing.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,24 +41,37 @@
 def validate_path(path: str | Path) -> str:
     """Validate a single input path.
 
+    This function validates and normalizes file system paths. It accepts string paths or
+    ``pathlib.Path`` objects and converts them to string format.
+
     Args:
-        path: The input path to validate. Can be None, a string, or a Path object.
+        path (``str`` | ``Path``): Input path to validate. Can be a string path or
+            ``pathlib.Path`` object.
 
     Returns:
-        - None if the input is None
-        - A string representing the validated path
+        ``str``: The validated path as a string.
 
     Raises:
-        TypeError: If the input is not None, a string, or a Path object.
+        TypeError: If ``path`` is not a string or ``Path`` object.
 
     Examples:
-        >>> validate_path(None)
-        None
-        >>> validate_path("/path/to/file.png")
-        '/path/to/file.png'
-        >>> from pathlib import Path
-        >>> validate_path(Path("/path/to/file.png"))
-        '/path/to/file.png'
+        Validate a string path::
+
+            >>> validate_path("/path/to/file.png")
+            '/path/to/file.png'
+
+        Validate a Path object::
+
+            >>> from pathlib import Path
+            >>> validate_path(Path("/path/to/file.png"))
+            '/path/to/file.png'
+
+        Invalid input raises TypeError::
+
+            >>> validate_path(123)
+            Traceback (most recent call last):
+                ...
+            TypeError: Path must be None, a string, or Path object, got .
     """
     if isinstance(path, str | Path):
         return str(path)
@@ -41,28 +85,51 @@ def validate_batch_path(
 ) -> list[str] | None:
     """Validate a batch of input paths.
 
+    This function validates and normalizes a sequence of file system paths. It accepts a
+    sequence of string paths or ``pathlib.Path`` objects and converts them to a list of
+    string paths. Optionally checks if the number of paths matches an expected batch size.
+
     Args:
-        paths: A sequence of paths to validate, or None.
-        batch_size: The expected number of paths. Defaults to None, in which case no batch size check is performed.
+        paths (``Sequence[str | Path] | None``): A sequence of paths to validate, or
+            ``None``. Each path can be a string or ``pathlib.Path`` object.
+        batch_size (``int | None``, optional): The expected number of paths. If specified,
+            validates that the number of paths matches this value. Defaults to ``None``,
+            in which case no batch size check is performed.
 
     Returns:
-        - None if the input is None
-        - A list of strings representing validated paths
+        ``list[str] | None``: A list of validated paths as strings, or ``None`` if the
+        input is ``None``.
 
     Raises:
-        TypeError: If the input is not None or a sequence of strings or Path objects.
-        ValueError: If a batch_size is specified and the number of paths doesn't match it.
+        TypeError: If ``paths`` is not ``None`` or a sequence of strings/``Path`` objects.
+        ValueError: If ``batch_size`` is specified and the number of paths doesn't match.
 
     Examples:
-        >>> paths = ["/path/to/file1.png", Path("/path/to/file2.png")]
-        >>> validate_batch_path(paths, batch_size=2)
-        ['/path/to/file1.png', '/path/to/file2.png']
-        >>> validate_batch_path(paths)  # Without specifying batch_size
-        ['/path/to/file1.png', '/path/to/file2.png']
-        >>> validate_batch_path(paths, batch_size=3)
-        Traceback (most recent call last):
-            ...
-        ValueError: Number of paths (2) does not match the specified batch size (3).
+        Validate a list of paths with batch size check::
+
+            >>> from pathlib import Path
+            >>> paths = ["/path/to/file1.png", Path("/path/to/file2.png")]
+            >>> validate_batch_path(paths, batch_size=2)
+            ['/path/to/file1.png', '/path/to/file2.png']
+
+        Validate without batch size check::
+
+            >>> validate_batch_path(paths)  # Without specifying batch_size
+            ['/path/to/file1.png', '/path/to/file2.png']
+
+        Batch size mismatch raises ValueError::
+
+            >>> validate_batch_path(paths, batch_size=3)
+            Traceback (most recent call last):
+                ...
+            ValueError: Number of paths (2) does not match the specified batch size (3).
+
+        Invalid input type raises TypeError::
+
+            >>> validate_batch_path("not_a_sequence")
+            Traceback (most recent call last):
+                ...
+            TypeError: Paths must be None or a sequence of strings or Path objects...
     """
     if paths is None:
         return None
diff --git a/src/anomalib/data/validators/torch/__init__.py b/src/anomalib/data/validators/torch/__init__.py
index 14253a93c7..8a654e282b 100644
--- a/src/anomalib/data/validators/torch/__init__.py
+++ b/src/anomalib/data/validators/torch/__init__.py
@@ -1,4 +1,33 @@
-"""Anomalib Torch data validators."""
+"""Validate PyTorch tensor data.
+
+This module provides validators for data stored as PyTorch tensors. The validators
+ensure data consistency and correctness for images, videos, depth maps and their
+batches.
+
+The validators check:
+    - Tensor shapes and dimensions
+    - Data types
+    - Value ranges
+    - Label formats
+    - Mask properties
+
+Example:
+    Validate a single image::
+
+        >>> from anomalib.data.validators import ImageValidator
+        >>> validator = ImageValidator()
+        >>> validator.validate_image(image)
+
+    Validate a batch of images::
+
+        >>> from anomalib.data.validators import ImageBatchValidator
+        >>> validator = ImageBatchValidator()
+        >>> validator(images=images, labels=labels, masks=masks)
+
+Note:
+    The validators are used internally by the data modules to ensure data
+    consistency before processing.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/data/validators/torch/depth.py b/src/anomalib/data/validators/torch/depth.py
index 6869769ad6..d20f6ffaa4 100644
--- a/src/anomalib/data/validators/torch/depth.py
+++ b/src/anomalib/data/validators/torch/depth.py
@@ -1,4 +1,33 @@
-"""Validate torch depth data."""
+"""Validate PyTorch tensor data for depth maps.
+
+This module provides validators for depth data stored as PyTorch tensors. The validators
+ensure data consistency and correctness for depth maps and their batches.
+
+The validators check:
+    - Tensor shapes and dimensions
+    - Data types
+    - Value ranges
+    - Label formats
+    - Mask properties
+    - Path validity
+
+Example:
+    Validate a single depth map::
+
+        >>> from anomalib.data.validators import DepthValidator
+        >>> validator = DepthValidator()
+        >>> validator.validate_depth_map(depth_map)
+
+    Validate a batch of depth maps::
+
+        >>> from anomalib.data.validators import DepthBatchValidator
+        >>> validator = DepthBatchValidator()
+        >>> validator(depth_maps=depth_maps, labels=labels, masks=masks)
+
+Note:
+    The validators are used internally by the data modules to ensure data
+    consistency before processing depth data.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -15,29 +44,65 @@
 
 
 class DepthValidator:
-    """Validate torch.Tensor data for depth images."""
+    """Validate torch.Tensor data for depth images.
+
+    This class provides validation methods for depth data stored as PyTorch tensors.
+    It ensures data consistency and correctness for depth maps and associated metadata.
+
+    The validator checks:
+        - Tensor shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate a depth map and associated metadata::
+
+            >>> from anomalib.data.validators import DepthValidator
+            >>> validator = DepthValidator()
+            >>> depth_map = torch.rand(224, 224)  # [H, W]
+            >>> validated_map = validator.validate_depth_map(depth_map)
+            >>> label = 1
+            >>> validated_label = validator.validate_gt_label(label)
+            >>> mask = torch.randint(0, 2, (1, 224, 224))  # [1, H, W]
+            >>> validated_mask = validator.validate_gt_mask(mask)
+
+    Note:
+        The validator is used internally by the data modules to ensure data
+        consistency before processing.
+    """
 
     @staticmethod
     def validate_image(image: torch.Tensor) -> Image:
         """Validate the image tensor.
 
+        This method validates and normalizes input image tensors. It handles:
+            - RGB images only
+            - Channel-first format [C, H, W]
+            - Type conversion to float32
+            - Value range normalization
+
         Args:
-            image (torch.Tensor): Input image tensor.
+            image (``torch.Tensor``): Input image tensor to validate.
 
         Returns:
-            Image: Validated image as a torchvision Image object.
+            ``Image``: Validated image as a torchvision Image object.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the image tensor does not have the correct shape.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators import DepthValidator
-            >>> image = torch.rand(3, 256, 256)
-            >>> validated_image = DepthValidator.validate_image(image)
-            >>> validated_image.shape
-            torch.Size([3, 256, 256])
+            TypeError: If ``image`` is not a torch.Tensor.
+            ValueError: If ``image`` dimensions or channels are invalid.
+
+        Example:
+            Validate RGB image::
+
+                >>> import torch
+                >>> from anomalib.data.validators import DepthValidator
+                >>> image = torch.rand(3, 256, 256)  # [C, H, W]
+                >>> validated = DepthValidator.validate_image(image)
+                >>> validated.shape
+                torch.Size([3, 256, 256])
         """
         if not isinstance(image, torch.Tensor):
             msg = f"Image must be a torch.Tensor, got {type(image)}."
@@ -54,27 +119,33 @@ def validate_image(image: torch.Tensor) -> Image:
     def validate_gt_label(label: int | torch.Tensor | None) -> torch.Tensor | None:
         """Validate the ground truth label.
 
+        This method validates and normalizes input labels. It handles:
+            - Integer and tensor inputs
+            - Type conversion to boolean
+            - Scalar values only
+
         Args:
-            label (int | torch.Tensor | None): Input ground truth label.
+            label (``int`` | ``torch.Tensor`` | ``None``): Input ground truth label.
 
         Returns:
-            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+            ``torch.Tensor`` | ``None``: Validated ground truth label as boolean tensor.
 
         Raises:
-            TypeError: If the input is neither an integer nor a torch.Tensor.
-            ValueError: If the label shape or dtype is invalid.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators import DepthValidator
-            >>> label_int = 1
-            >>> validated_label = DepthValidator.validate_gt_label(label_int)
-            >>> validated_label
-            tensor(True)
-            >>> label_tensor = torch.tensor(0)
-            >>> validated_label = DepthValidator.validate_gt_label(label_tensor)
-            >>> validated_label
-            tensor(False)
+            TypeError: If ``label`` is neither an integer nor a torch.Tensor.
+            ValueError: If ``label`` shape is invalid.
+
+        Example:
+            Validate integer and tensor labels::
+
+                >>> from anomalib.data.validators import DepthValidator
+                >>> label_int = 1
+                >>> validated = DepthValidator.validate_gt_label(label_int)
+                >>> validated
+                tensor(True)
+                >>> label_tensor = torch.tensor(0)
+                >>> validated = DepthValidator.validate_gt_label(label_tensor)
+                >>> validated
+                tensor(False)
         """
         if label is None:
             return None
@@ -95,25 +166,33 @@ def validate_gt_label(label: int | torch.Tensor | None) -> torch.Tensor | None:
     def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
         """Validate the ground truth mask.
 
+        This method validates and normalizes input masks. It handles:
+            - 2D and 3D inputs
+            - Single-channel masks
+            - Type conversion to boolean
+            - Channel dimension squeezing
+
         Args:
-            mask (torch.Tensor | None): Input ground truth mask.
+            mask (``torch.Tensor`` | ``None``): Input ground truth mask.
 
         Returns:
-            Mask | None: Validated ground truth mask, or None.
+            ``Mask`` | ``None``: Validated ground truth mask as torchvision Mask.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the mask shape is invalid.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators import DepthValidator
-            >>> mask = torch.randint(0, 2, (1, 224, 224))
-            >>> validated_mask = DepthValidator.validate_gt_mask(mask)
-            >>> isinstance(validated_mask, Mask)
-            True
-            >>> validated_mask.shape
-            torch.Size([224, 224])
+            TypeError: If ``mask`` is not a torch.Tensor.
+            ValueError: If ``mask`` dimensions or channels are invalid.
+
+        Example:
+            Validate binary segmentation mask::
+
+                >>> import torch
+                >>> from anomalib.data.validators import DepthValidator
+                >>> mask = torch.randint(0, 2, (1, 224, 224))  # [1, H, W]
+                >>> validated = DepthValidator.validate_gt_mask(mask)
+                >>> isinstance(validated, Mask)
+                True
+                >>> validated.shape
+                torch.Size([224, 224])
         """
         if mask is None:
             return None
@@ -134,18 +213,22 @@ def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
     def validate_image_path(image_path: str | None) -> str | None:
         """Validate the image path.
 
+        This method validates input image file paths.
+
         Args:
-            image_path (str | None): Input image path.
+            image_path (``str`` | ``None``): Input image path to validate.
 
         Returns:
-            str | None: Validated image path, or None.
+            ``str`` | ``None``: Validated image path, or None.
 
-        Examples:
-            >>> from anomalib.data.validators import DepthValidator
-            >>> path = "/path/to/image.jpg"
-            >>> validated_path = DepthValidator.validate_image_path(path)
-            >>> validated_path == path
-            True
+        Example:
+            Validate image file path::
+
+                >>> from anomalib.data.validators import DepthValidator
+                >>> path = "/path/to/image.jpg"
+                >>> validated = DepthValidator.validate_image_path(path)
+                >>> validated == path
+                True
         """
         return validate_path(image_path) if image_path else None
 
@@ -153,23 +236,30 @@ def validate_image_path(image_path: str | None) -> str | None:
     def validate_depth_map(depth_map: torch.Tensor | None) -> torch.Tensor | None:
         """Validate the depth map.
 
+        This method validates and normalizes input depth maps. It handles:
+            - 2D and 3D inputs
+            - Single and multi-channel depth maps
+            - Type conversion to float32
+
         Args:
-            depth_map (torch.Tensor | None): Input depth map.
+            depth_map (``torch.Tensor`` | ``None``): Input depth map to validate.
 
         Returns:
-            torch.Tensor | None: Validated depth map, or None.
+            ``torch.Tensor`` | ``None``: Validated depth map as float32 tensor.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the depth map shape is invalid.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators import DepthValidator
-            >>> depth_map = torch.rand(224, 224)
-            >>> validated_map = DepthValidator.validate_depth_map(depth_map)
-            >>> validated_map.shape
-            torch.Size([224, 224])
+            TypeError: If ``depth_map`` is not a torch.Tensor.
+            ValueError: If ``depth_map`` dimensions or channels are invalid.
+
+        Example:
+            Validate single-channel depth map::
+
+                >>> import torch
+                >>> from anomalib.data.validators import DepthValidator
+                >>> depth_map = torch.rand(224, 224)  # [H, W]
+                >>> validated = DepthValidator.validate_depth_map(depth_map)
+                >>> validated.shape
+                torch.Size([224, 224])
         """
         if depth_map is None:
             return None
@@ -188,18 +278,22 @@ def validate_depth_map(depth_map: torch.Tensor | None) -> torch.Tensor | None:
     def validate_depth_path(depth_path: str | None) -> str | None:
         """Validate the depth path.
 
+        This method validates input depth map file paths.
+
         Args:
-            depth_path (str | None): Input depth path.
+            depth_path (``str`` | ``None``): Input depth path to validate.
 
         Returns:
-            str | None: Validated depth path, or None.
+            ``str`` | ``None``: Validated depth path, or None.
 
-        Examples:
-            >>> from anomalib.data.validators import DepthValidator
-            >>> path = "/path/to/depth.png"
-            >>> validated_path = DepthValidator.validate_depth_path(path)
-            >>> validated_path == path
-            True
+        Example:
+            Validate depth map file path::
+
+                >>> from anomalib.data.validators import DepthValidator
+                >>> path = "/path/to/depth.png"
+                >>> validated = DepthValidator.validate_depth_path(path)
+                >>> validated == path
+                True
         """
         return validate_path(depth_path) if depth_path else None
 
@@ -235,28 +329,62 @@ def validate_explanation(explanation: str | None) -> str | None:
 
 
 class DepthBatchValidator:
-    """Validate torch.Tensor data for batches of depth images."""
+    """Validate torch.Tensor data for batches of depth images.
+
+    This class provides validation methods for batches of depth data stored as PyTorch tensors.
+    It ensures data consistency and correctness for depth maps and associated metadata.
+
+    The validator checks:
+        - Tensor shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate a batch of depth maps and associated metadata::
+
+            >>> from anomalib.data.validators import DepthBatchValidator
+            >>> validator = DepthBatchValidator()
+            >>> depth_maps = torch.rand(32, 224, 224)  # [N, H, W]
+            >>> labels = torch.zeros(32)
+            >>> masks = torch.zeros((32, 224, 224))
+            >>> validated_maps = validator.validate_depth_map(depth_maps)
+            >>> validated_labels = validator.validate_gt_label(labels)
+            >>> validated_masks = validator.validate_gt_mask(masks)
+
+    Note:
+        The validator is used internally by the data modules to ensure data
+        consistency before processing.
+    """
 
     @staticmethod
     def validate_image(image: torch.Tensor) -> Image:
         """Validate the image tensor for a batch.
 
+        This method validates batches of images stored as PyTorch tensors. It handles:
+            - Channel-first format [N, C, H, W]
+            - RGB images only
+            - Type conversion to float32
+            - Value range normalization
+
         Args:
-            image (torch.Tensor): Input image tensor.
+            image (``torch.Tensor``): Input image tensor to validate.
 
         Returns:
-            Image: Validated image as a torchvision Image object.
+            ``Image``: Validated image as a torchvision Image object.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the image tensor does not have the correct shape.
+            TypeError: If ``image`` is not a torch.Tensor.
+            ValueError: If ``image`` dimensions or channels are invalid.
 
-        Examples:
+        Example:
             >>> import torch
             >>> from anomalib.data.validators import DepthBatchValidator
-            >>> image = torch.rand(32, 3, 256, 256)
-            >>> validated_image = DepthBatchValidator.validate_image(image)
-            >>> validated_image.shape
+            >>> image = torch.rand(32, 3, 256, 256)  # [N, C, H, W]
+            >>> validated = DepthBatchValidator.validate_image(image)
+            >>> validated.shape
             torch.Size([32, 3, 256, 256])
         """
         if not isinstance(image, torch.Tensor):
@@ -274,22 +402,29 @@ def validate_image(image: torch.Tensor) -> Image:
     def validate_gt_label(gt_label: torch.Tensor | Sequence[int] | None) -> torch.Tensor | None:
         """Validate the ground truth label for a batch.
 
+        This method validates ground truth labels for batches. It handles:
+            - Conversion to boolean tensor
+            - Batch dimension validation
+            - None inputs
+
         Args:
-            gt_label (torch.Tensor | Sequence[int] | None): Input ground truth label.
+            gt_label (``torch.Tensor`` | ``Sequence[int]`` | ``None``): Input ground truth
+                label to validate.
 
         Returns:
-            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+            ``torch.Tensor`` | ``None``: Validated ground truth label as a boolean tensor,
+                or None.
 
         Raises:
-            TypeError: If the input is not a sequence of integers or a torch.Tensor.
-            ValueError: If the ground truth label does not match the expected batch size or data type.
+            TypeError: If ``gt_label`` is not a sequence of integers or torch.Tensor.
+            ValueError: If ``gt_label`` does not match expected batch size or data type.
 
-        Examples:
+        Example:
             >>> import torch
             >>> from anomalib.data.validators import DepthBatchValidator
             >>> gt_label = torch.tensor([0, 1, 1, 0])
-            >>> validated_label = DepthBatchValidator.validate_gt_label(gt_label)
-            >>> print(validated_label)
+            >>> validated = DepthBatchValidator.validate_gt_label(gt_label)
+            >>> print(validated)
             tensor([False,  True,  True, False])
         """
         return ImageBatchValidator.validate_gt_label(gt_label)
@@ -298,22 +433,28 @@ def validate_gt_label(gt_label: torch.Tensor | Sequence[int] | None) -> torch.Te
     def validate_gt_mask(gt_mask: torch.Tensor | None) -> Mask | None:
         """Validate the ground truth mask for a batch.
 
+        This method validates ground truth masks for batches. It handles:
+            - Batch dimension validation
+            - Binary mask values
+            - None inputs
+
         Args:
-            gt_mask (torch.Tensor | None): Input ground truth mask.
+            gt_mask (``torch.Tensor`` | ``None``): Input ground truth mask to validate.
 
         Returns:
-            Mask | None: Validated ground truth mask as a torchvision Mask object, or None.
+            ``Mask`` | ``None``: Validated ground truth mask as a torchvision Mask object,
+                or None.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the ground truth mask does not have the correct shape or batch size.
+            TypeError: If ``gt_mask`` is not a torch.Tensor.
+            ValueError: If ``gt_mask`` shape or batch size is invalid.
 
-        Examples:
+        Example:
             >>> import torch
             >>> from anomalib.data.validators import DepthBatchValidator
-            >>> gt_mask = torch.randint(0, 2, (4, 224, 224))
-            >>> validated_mask = DepthBatchValidator.validate_gt_mask(gt_mask)
-            >>> print(validated_mask.shape)
+            >>> gt_mask = torch.randint(0, 2, (4, 224, 224))  # [N, H, W]
+            >>> validated = DepthBatchValidator.validate_gt_mask(gt_mask)
+            >>> print(validated.shape)
             torch.Size([4, 224, 224])
         """
         return ImageBatchValidator.validate_gt_mask(gt_mask)
@@ -322,21 +463,26 @@ def validate_gt_mask(gt_mask: torch.Tensor | None) -> Mask | None:
     def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
         """Validate the mask paths for a batch.
 
+        This method validates file paths for batches of mask images. It handles:
+            - Path existence validation
+            - Batch size consistency
+            - None inputs
+
         Args:
-            mask_path (Sequence[str] | None): Input sequence of mask paths.
+            mask_path (``Sequence[str]`` | ``None``): Input sequence of mask paths.
 
         Returns:
-            list[str] | None: Validated list of mask paths, or None.
+            ``list[str]`` | ``None``: Validated list of mask paths, or None.
 
         Raises:
-            TypeError: If the input is not a sequence of strings.
-            ValueError: If the number of mask paths does not match the expected batch size.
+            TypeError: If ``mask_path`` is not a sequence of strings.
+            ValueError: If number of paths does not match expected batch size.
 
-        Examples:
+        Example:
             >>> from anomalib.data.validators import DepthBatchValidator
-            >>> mask_paths = ["path/to/mask_1.png", "path/to/mask_2.png"]
-            >>> validated_paths = DepthBatchValidator.validate_mask_path(mask_paths)
-            >>> print(validated_paths)
+            >>> paths = ["path/to/mask_1.png", "path/to/mask_2.png"]
+            >>> validated = DepthBatchValidator.validate_mask_path(paths)
+            >>> print(validated)
             ['path/to/mask_1.png', 'path/to/mask_2.png']
         """
         return ImageBatchValidator.validate_mask_path(mask_path)
@@ -345,20 +491,25 @@ def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
     def validate_image_path(image_path: list[str] | None) -> list[str] | None:
         """Validate the image paths for a batch.
 
+        This method validates file paths for batches of images. It handles:
+            - Path existence validation
+            - Batch size consistency
+            - None inputs
+
         Args:
-            image_path (list[str] | None): Input list of image paths.
+            image_path (``list[str]`` | ``None``): Input list of image paths.
 
         Returns:
-            list[str] | None: Validated list of image paths, or None.
+            ``list[str]`` | ``None``: Validated list of image paths, or None.
 
         Raises:
-            TypeError: If the input is not a list of strings.
+            TypeError: If ``image_path`` is not a list of strings.
 
-        Examples:
+        Example:
             >>> from anomalib.data.validators import DepthBatchValidator
-            >>> image_paths = ["path/to/image_1.jpg", "path/to/image_2.jpg"]
-            >>> validated_paths = DepthBatchValidator.validate_image_path(image_paths)
-            >>> print(validated_paths)
+            >>> paths = ["path/to/image_1.jpg", "path/to/image_2.jpg"]
+            >>> validated = DepthBatchValidator.validate_image_path(paths)
+            >>> print(validated)
             ['path/to/image_1.jpg', 'path/to/image_2.jpg']
         """
         return ImageBatchValidator.validate_image_path(image_path)
@@ -367,22 +518,28 @@ def validate_image_path(image_path: list[str] | None) -> list[str] | None:
     def validate_depth_map(depth_map: torch.Tensor | None) -> torch.Tensor | None:
         """Validate the depth map for a batch.
 
+        This method validates batches of depth maps. It handles:
+            - Single-channel and RGB depth maps
+            - Batch dimension validation
+            - Type conversion to float32
+            - None inputs
+
         Args:
-            depth_map (torch.Tensor | None): Input depth map.
+            depth_map (``torch.Tensor`` | ``None``): Input depth map to validate.
 
         Returns:
-            torch.Tensor | None: Validated depth map, or None.
+            ``torch.Tensor`` | ``None``: Validated depth map as float32, or None.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the depth map shape is invalid or doesn't match the batch size.
+            TypeError: If ``depth_map`` is not a torch.Tensor.
+            ValueError: If ``depth_map`` shape is invalid or batch size mismatch.
 
-        Examples:
+        Example:
             >>> import torch
             >>> from anomalib.data.validators import DepthBatchValidator
-            >>> depth_map = torch.rand(4, 224, 224)
-            >>> validated_map = DepthBatchValidator.validate_depth_map(depth_map)
-            >>> print(validated_map.shape)
+            >>> depth_map = torch.rand(4, 224, 224)  # [N, H, W]
+            >>> validated = DepthBatchValidator.validate_depth_map(depth_map)
+            >>> print(validated.shape)
             torch.Size([4, 224, 224])
         """
         if depth_map is None:
@@ -402,20 +559,25 @@ def validate_depth_map(depth_map: torch.Tensor | None) -> torch.Tensor | None:
     def validate_depth_path(depth_path: list[str] | None) -> list[str] | None:
         """Validate the depth paths for a batch.
 
+        This method validates file paths for batches of depth maps. It handles:
+            - Path existence validation
+            - Batch size consistency
+            - None inputs
+
         Args:
-            depth_path (list[str] | None): Input list of depth paths.
+            depth_path (``list[str]`` | ``None``): Input list of depth paths.
 
         Returns:
-            list[str] | None: Validated list of depth paths, or None.
+            ``list[str]`` | ``None``: Validated list of depth paths, or None.
 
         Raises:
-            TypeError: If the input is not a list of strings.
+            TypeError: If ``depth_path`` is not a list of strings.
 
-        Examples:
+        Example:
             >>> from anomalib.data.validators import DepthBatchValidator
-            >>> depth_paths = ["path/to/depth_1.png", "path/to/depth_2.png"]
-            >>> validated_paths = DepthBatchValidator.validate_depth_path(depth_paths)
-            >>> print(validated_paths)
+            >>> paths = ["path/to/depth_1.png", "path/to/depth_2.png"]
+            >>> validated = DepthBatchValidator.validate_depth_path(paths)
+            >>> print(validated)
             ['path/to/depth_1.png', 'path/to/depth_2.png']
         """
         if depth_path is None:
diff --git a/src/anomalib/data/validators/torch/image.py b/src/anomalib/data/validators/torch/image.py
index c9a8ac07cb..06a729ff92 100644
--- a/src/anomalib/data/validators/torch/image.py
+++ b/src/anomalib/data/validators/torch/image.py
@@ -1,4 +1,33 @@
-"""Validate torch image data."""
+"""Validate PyTorch tensor data for images.
+
+This module provides validators for image data stored as PyTorch tensors. The validators
+ensure data consistency and correctness for images and their batches.
+
+The validators check:
+    - Tensor shapes and dimensions
+    - Data types
+    - Value ranges
+    - Label formats
+    - Mask properties
+    - Path validity
+
+Example:
+    Validate a single image::
+
+        >>> from anomalib.data.validators import ImageValidator
+        >>> validator = ImageValidator()
+        >>> validator.validate_image(image)
+
+    Validate a batch of images::
+
+        >>> from anomalib.data.validators import ImageBatchValidator
+        >>> validator = ImageBatchValidator()
+        >>> validator(images=images, labels=labels, masks=masks)
+
+Note:
+    The validators are used internally by the data modules to ensure data
+    consistency before processing.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -14,26 +43,60 @@
 
 
 class ImageValidator:
-    """Validate torch.Tensor data for images."""
+    """Validate torch.Tensor data for images.
+
+    This class provides validation methods for image data stored as PyTorch tensors.
+    It ensures data consistency and correctness for images and associated metadata.
+
+    The validator checks:
+        - Tensor shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate an image and associated metadata::
+
+            >>> from anomalib.data.validators import ImageValidator
+            >>> validator = ImageValidator()
+            >>> image = torch.rand(3, 224, 224)  # [C, H, W]
+            >>> validated_image = validator.validate_image(image)
+            >>> label = 1
+            >>> validated_label = validator.validate_gt_label(label)
+            >>> mask = torch.randint(0, 2, (1, 224, 224))  # [1, H, W]
+            >>> validated_mask = validator.validate_gt_mask(mask)
+
+    Note:
+        The validator is used internally by the data modules to ensure data
+        consistency before processing.
+    """
 
     @staticmethod
     def validate_image(image: torch.Tensor) -> torch.Tensor:
         """Validate the image tensor.
 
+        This method validates and normalizes input image tensors. It handles:
+            - RGB images only
+            - Channel-first format [C, H, W]
+            - Type conversion to float32
+            - Value range normalization
+
         Args:
-            image (torch.Tensor): Input image tensor.
+            image (``torch.Tensor``): Input image tensor to validate.
 
         Returns:
-            torch.Tensor: Validated image tensor.
+            ``torch.Tensor``: Validated image tensor in [C, H, W] format.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the image tensor does not have the correct shape.
+            TypeError: If ``image`` is not a torch.Tensor.
+            ValueError: If ``image`` dimensions or channels are invalid.
 
-        Examples:
+        Example:
             >>> import torch
             >>> from anomalib.data.validators import ImageValidator
-            >>> image = torch.rand(3, 256, 256)
+            >>> image = torch.rand(3, 256, 256)  # [C, H, W]
             >>> validated_image = ImageValidator.validate_image(image)
             >>> validated_image.shape
             torch.Size([3, 256, 256])
@@ -53,19 +116,26 @@ def validate_image(image: torch.Tensor) -> torch.Tensor:
     def validate_gt_label(label: int | torch.Tensor | None) -> torch.Tensor | None:
         """Validate the ground truth label.
 
+        This method validates and normalizes input labels. It handles:
+            - Integer and tensor inputs
+            - Type conversion to boolean
+            - Output is always boolean type
+            - None inputs return None
+
         Args:
-            label (int | torch.Tensor | None): Input ground truth label.
+            label (``int`` | ``torch.Tensor`` | ``None``): Input ground truth label.
 
         Returns:
-            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+            ``torch.Tensor`` | ``None``: Validated ground truth label as a boolean
+                tensor, or None.
 
         Raises:
-            TypeError: If the input is neither an integer nor a torch.Tensor.
-            ValueError: If the label shape or dtype is invalid.
+            TypeError: If ``label`` is neither an integer nor a torch.Tensor.
+            ValueError: If ``label`` shape or dtype is invalid.
 
-        Examples:
+        Example:
             >>> import torch
-            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> from anomalib.data.validators import ImageValidator
             >>> label_int = 1
             >>> validated_label = ImageValidator.validate_gt_label(label_int)
             >>> validated_label
@@ -94,20 +164,27 @@ def validate_gt_label(label: int | torch.Tensor | None) -> torch.Tensor | None:
     def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
         """Validate the ground truth mask.
 
+        This method validates and normalizes input masks. It handles:
+            - Single channel masks only
+            - [H, W] and [1, H, W] formats
+            - Type conversion to boolean
+            - None inputs return None
+
         Args:
-            mask (torch.Tensor | None): Input ground truth mask.
+            mask (``torch.Tensor`` | ``None``): Input ground truth mask.
 
         Returns:
-            Mask | None: Validated ground truth mask, or None.
+            ``Mask`` | ``None``: Validated ground truth mask as a torchvision Mask
+                object, or None.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the mask shape is invalid.
+            TypeError: If ``mask`` is not a torch.Tensor.
+            ValueError: If ``mask`` dimensions or channels are invalid.
 
-        Examples:
+        Example:
             >>> import torch
-            >>> from anomalib.dataclasses.validators import ImageValidator
-            >>> mask = torch.randint(0, 2, (1, 224, 224))
+            >>> from anomalib.data.validators import ImageValidator
+            >>> mask = torch.randint(0, 2, (1, 224, 224))  # [1, H, W]
             >>> validated_mask = ImageValidator.validate_gt_mask(mask)
             >>> isinstance(validated_mask, Mask)
             True
@@ -133,20 +210,27 @@ def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
     def validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
         """Validate the anomaly map.
 
+        This method validates and normalizes input anomaly maps. It handles:
+            - Single channel maps only
+            - [H, W] and [1, H, W] formats
+            - Type conversion to float32
+            - None inputs return None
+
         Args:
-            anomaly_map (torch.Tensor | None): Input anomaly map.
+            anomaly_map (``torch.Tensor`` | ``None``): Input anomaly map.
 
         Returns:
-            Mask | None: Validated anomaly map as a Mask, or None.
+            ``Mask`` | ``None``: Validated anomaly map as a torchvision Mask object,
+                or None.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the anomaly map shape is invalid.
+            TypeError: If ``anomaly_map`` is not a torch.Tensor.
+            ValueError: If ``anomaly_map`` dimensions or channels are invalid.
 
-        Examples:
+        Example:
             >>> import torch
-            >>> from anomalib.dataclasses.validators import ImageValidator
-            >>> anomaly_map = torch.rand(1, 224, 224)
+            >>> from anomalib.data.validators import ImageValidator
+            >>> anomaly_map = torch.rand(1, 224, 224)  # [1, H, W]
             >>> validated_map = ImageValidator.validate_anomaly_map(anomaly_map)
             >>> isinstance(validated_map, Mask)
             True
@@ -173,14 +257,16 @@ def validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
     def validate_image_path(image_path: str | None) -> str | None:
         """Validate the image path.
 
+        This method validates input image file paths.
+
         Args:
-            image_path (str | None): Input image path.
+            image_path (``str`` | ``None``): Input image path to validate.
 
         Returns:
-            str | None: Validated image path, or None.
+            ``str`` | ``None``: Validated image path, or None.
 
-        Examples:
-            >>> from anomalib.dataclasses.validators import ImageValidator
+        Example:
+            >>> from anomalib.data.validators import ImageValidator
             >>> path = "/path/to/image.jpg"
             >>> validated_path = ImageValidator.validate_image_path(path)
             >>> validated_path == path
@@ -192,14 +278,16 @@ def validate_image_path(image_path: str | None) -> str | None:
     def validate_mask_path(mask_path: str | None) -> str | None:
         """Validate the mask path.
 
+        This method validates input mask file paths.
+
         Args:
-            mask_path (str | None): Input mask path.
+            mask_path (``str`` | ``None``): Input mask path to validate.
 
         Returns:
-            str | None: Validated mask path, or None.
+            ``str`` | ``None``: Validated mask path, or None.
 
-        Examples:
-            >>> from anomalib.dataclasses.validators import ImageValidator
+        Example:
+            >>> from anomalib.data.validators import ImageValidator
             >>> path = "/path/to/mask.png"
             >>> validated_path = ImageValidator.validate_mask_path(path)
             >>> validated_path == path
@@ -213,17 +301,24 @@ def validate_pred_score(
     ) -> torch.Tensor | None:
         """Validate the prediction score.
 
+        This method validates and normalizes prediction scores. It handles:
+            - Float, numpy array and tensor inputs
+            - Type conversion to float32
+            - None inputs return None
+
         Args:
-            pred_score (torch.Tensor | float | None): Input prediction score.
+            pred_score (``torch.Tensor`` | ``np.ndarray`` | ``float`` | ``None``):
+                Input prediction score.
 
         Returns:
-            torch.Tensor | None: Validated prediction score as a float32 tensor, or None.
+            ``torch.Tensor`` | ``None``: Validated prediction score as a float32
+                tensor, or None.
 
         Raises:
-            TypeError: If the input is neither a float, torch.Tensor, nor None.
-            ValueError: If the prediction score is not a scalar.
+            TypeError: If ``pred_score`` cannot be converted to a tensor.
+            ValueError: If ``pred_score`` is not a scalar.
 
-        Examples:
+        Example:
             >>> import torch
             >>> from anomalib.data.validators import ImageValidator
             >>> score = 0.8
@@ -234,9 +329,6 @@ def validate_pred_score(
             >>> validated_score = ImageValidator.validate_pred_score(score_tensor)
             >>> validated_score
             tensor(0.7000)
-            >>> validated_score = ImageValidator.validate_pred_score(None)
-            >>> validated_score is None
-            True
         """
         if pred_score is None:
             return None
@@ -254,17 +346,23 @@ def validate_pred_score(
     def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
         """Validate the prediction mask.
 
+        This method validates and normalizes prediction masks. It handles:
+            - Single channel masks only
+            - [H, W] and [1, H, W] formats
+            - Type conversion to boolean
+            - None inputs return None
+
         Args:
-            pred_mask (torch.Tensor | None): Input prediction mask.
+            pred_mask (``torch.Tensor`` | ``None``): Input prediction mask.
 
         Returns:
-            Mask | None: Validated prediction mask, or None.
+            ``Mask`` | ``None``: Validated prediction mask as a torchvision Mask
+                object, or None.
 
-
-        Examples:
+        Example:
             >>> import torch
-            >>> from anomalib.dataclasses.validators import ImageValidator
-            >>> mask = torch.randint(0, 2, (1, 224, 224))
+            >>> from anomalib.data.validators import ImageValidator
+            >>> mask = torch.randint(0, 2, (1, 224, 224))  # [1, H, W]
             >>> validated_mask = ImageValidator.validate_pred_mask(mask)
             >>> isinstance(validated_mask, Mask)
             True
@@ -277,19 +375,26 @@ def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
     def validate_pred_label(pred_label: torch.Tensor | np.ndarray | float | None) -> torch.Tensor | None:
         """Validate the prediction label.
 
+        This method validates and normalizes prediction labels. It handles:
+            - Float, numpy array and tensor inputs
+            - Type conversion to boolean
+            - None inputs return None
+
         Args:
-            pred_label (torch.Tensor | None): Input prediction label.
+            pred_label (``torch.Tensor`` | ``np.ndarray`` | ``float`` | ``None``):
+                Input prediction label.
 
         Returns:
-            torch.Tensor | None: Validated prediction label as a boolean tensor, or None.
+            ``torch.Tensor`` | ``None``: Validated prediction label as a boolean
+                tensor, or None.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the prediction label is not a scalar.
+            TypeError: If ``pred_label`` cannot be converted to a tensor.
+            ValueError: If ``pred_label`` is not a scalar.
 
-        Examples:
+        Example:
             >>> import torch
-            >>> from anomalib.dataclasses.validators import ImageValidator
+            >>> from anomalib.data.validators import ImageValidator
             >>> label = torch.tensor(1)
             >>> validated_label = ImageValidator.validate_pred_label(label)
             >>> validated_label
@@ -311,19 +416,24 @@ def validate_pred_label(pred_label: torch.Tensor | np.ndarray | float | None) ->
 
     @staticmethod
     def validate_explanation(explanation: str | None) -> str | None:
-        """Validate the explanation.
+        """Validate the explanation string.
+
+        This method validates explanation strings.
 
         Args:
-            explanation (str | None): Input explanation.
+            explanation (``str`` | ``None``): Input explanation string.
 
         Returns:
-            str | None: Validated explanation, or None.
+            ``str`` | ``None``: Validated explanation string, or None.
+
+        Raises:
+            TypeError: If ``explanation`` is not a string.
 
-        Examples:
-            >>> from anomalib.dataclasses.validators import ImageValidator
+        Example:
+            >>> from anomalib.data.validators import ImageValidator
             >>> explanation = "The image has a crack on the wall."
-            >>> validated_explanation = ImageValidator.validate_explanation(explanation)
-            >>> validated_explanation == explanation
+            >>> validated = ImageValidator.validate_explanation(explanation)
+            >>> validated == explanation
             True
         """
         if explanation is None:
@@ -335,29 +445,65 @@ def validate_explanation(explanation: str | None) -> str | None:
 
 
 class ImageBatchValidator:
-    """Validate torch.Tensor data for batches of images."""
+    """Validate torch.Tensor data for batches of images.
+
+    This class provides validation methods for batches of image data stored as PyTorch tensors.
+    It ensures data consistency and correctness for images and associated metadata.
+
+    The validator checks:
+        - Tensor shapes and dimensions
+        - Data types
+        - Value ranges
+        - Label formats
+        - Mask properties
+        - Path validity
+
+    Example:
+        Validate a batch of images and associated metadata::
+
+            >>> from anomalib.data.validators import ImageBatchValidator
+            >>> validator = ImageBatchValidator()
+            >>> images = torch.rand(32, 3, 256, 256)  # [N, C, H, W]
+            >>> labels = torch.zeros(32)
+            >>> masks = torch.zeros((32, 256, 256))
+            >>> validator.validate_image(images)
+            >>> validator.validate_gt_label(labels)
+            >>> validator.validate_gt_mask(masks)
+
+    Note:
+        The validator is used internally by the data modules to ensure data
+        consistency before processing.
+    """
 
     @staticmethod
     def validate_image(image: torch.Tensor) -> Image:
         """Validate the image for a batch.
 
+        This method validates batches of images stored as PyTorch tensors. It handles:
+            - Single images and batches
+            - RGB images only
+            - Channel-first format [N, C, H, W]
+            - Type conversion to float32
+
         Args:
-            image (torch.Tensor): Input image tensor.
+            image (``torch.Tensor``): Input image tensor to validate.
 
         Returns:
-            Image: Validated image as a torchvision Image object.
+            ``Image``: Validated image as a torchvision Image object.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the image tensor does not have the correct shape or number of channels.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> image = torch.rand(32, 3, 224, 224)
-            >>> validated_image = ImageBatchValidator.validate_image(image)
-            >>> print(validated_image.shape)
-            torch.Size([32, 3, 224, 224])
+            TypeError: If ``image`` is not a torch.Tensor.
+            ValueError: If ``image`` dimensions or channels are invalid.
+
+        Example:
+            Validate RGB batch::
+
+                >>> import torch
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> image = torch.rand(32, 3, 224, 224)  # [N, C, H, W]
+                >>> validated = ImageBatchValidator.validate_image(image)
+                >>> validated.shape
+                torch.Size([32, 3, 224, 224])
         """
         if not isinstance(image, torch.Tensor):
             msg = f"Image must be a torch.Tensor, got {type(image)}."
@@ -376,23 +522,32 @@ def validate_image(image: torch.Tensor) -> Image:
     def validate_gt_label(gt_label: torch.Tensor | Sequence[int] | None) -> torch.Tensor | None:
         """Validate the ground truth label for a batch.
 
+        This method validates batches of ground truth labels. It handles:
+            - Conversion to torch.Tensor if needed
+            - Type conversion to boolean
+            - Shape validation
+
         Args:
-            gt_label (torch.Tensor | Sequence[int] | None): Input ground truth label.
+            gt_label (``torch.Tensor`` | ``Sequence[int]`` | ``None``): Input ground truth
+                label.
 
         Returns:
-            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+            ``torch.Tensor`` | ``None``: Validated ground truth label as a boolean tensor,
+                or None.
 
         Raises:
-            TypeError: If the input is not a sequence of integers or a torch.Tensor.
-            ValueError: If the ground truth label does not match the expected batch size or data type.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> gt_label = torch.tensor([0, 1, 1, 0])
-            >>> validated_label = ImageBatchValidator.validate_gt_label(gt_label)
-            >>> print(validated_label)
-            tensor([False,  True,  True, False])
+            TypeError: If ``gt_label`` is not a sequence of integers or torch.Tensor.
+            ValueError: If ``gt_label`` shape or data type is invalid.
+
+        Example:
+            Validate ground truth labels::
+
+                >>> import torch
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> gt_label = torch.tensor([0, 1, 1, 0])
+                >>> validated = ImageBatchValidator.validate_gt_label(gt_label)
+                >>> validated
+                tensor([False,  True,  True, False])
         """
         if gt_label is None:
             return None
@@ -413,23 +568,31 @@ def validate_gt_label(gt_label: torch.Tensor | Sequence[int] | None) -> torch.Te
     def validate_gt_mask(gt_mask: torch.Tensor | None) -> Mask | None:
         """Validate the ground truth mask for a batch.
 
+        This method validates batches of ground truth masks. It handles:
+            - Single masks and batches
+            - Shape normalization
+            - Type conversion to boolean
+
         Args:
-            gt_mask (torch.Tensor | None): Input ground truth mask.
+            gt_mask (``torch.Tensor`` | ``None``): Input ground truth mask.
 
         Returns:
-            Mask | None: Validated ground truth mask as a torchvision Mask object, or None.
+            ``Mask`` | ``None``: Validated ground truth mask as a torchvision Mask object,
+                or None.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the ground truth mask does not have the correct shape or batch size.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> gt_mask = torch.randint(0, 2, (4, 224, 224))
-            >>> validated_mask = ImageBatchValidator.validate_gt_mask(gt_mask)
-            >>> print(validated_mask.shape)
-            torch.Size([4, 224, 224])
+            TypeError: If ``gt_mask`` is not a torch.Tensor.
+            ValueError: If ``gt_mask`` shape is invalid.
+
+        Example:
+            Validate ground truth masks::
+
+                >>> import torch
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> gt_mask = torch.randint(0, 2, (4, 224, 224))
+                >>> validated = ImageBatchValidator.validate_gt_mask(gt_mask)
+                >>> validated.shape
+                torch.Size([4, 224, 224])
         """
         if gt_mask is None:
             return None
@@ -452,22 +615,25 @@ def validate_gt_mask(gt_mask: torch.Tensor | None) -> Mask | None:
     def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
         """Validate the mask paths for a batch.
 
+        This method validates batches of mask file paths.
+
         Args:
-            mask_path (Sequence[str] | None): Input sequence of mask paths.
+            mask_path (``Sequence[str]`` | ``None``): Input sequence of mask paths.
 
         Returns:
-            list[str] | None: Validated list of mask paths, or None.
+            ``list[str]`` | ``None``: Validated list of mask paths, or None.
 
         Raises:
-            TypeError: If the input is not a sequence of strings.
-            ValueError: If the number of mask paths does not match the expected batch size.
-
-        Examples:
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> mask_paths = ["path/to/mask_1.png", "path/to/mask_2.png"]
-            >>> validated_paths = ImageBatchValidator.validate_mask_path(mask_paths)
-            >>> print(validated_paths)
-            ['path/to/mask_1.png', 'path/to/mask_2.png']
+            TypeError: If ``mask_path`` is not a sequence of strings.
+
+        Example:
+            Validate mask paths::
+
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> mask_paths = ["path/to/mask_1.png", "path/to/mask_2.png"]
+                >>> validated = ImageBatchValidator.validate_mask_path(mask_paths)
+                >>> validated
+                ['path/to/mask_1.png', 'path/to/mask_2.png']
         """
         if mask_path is None:
             return None
@@ -480,22 +646,29 @@ def validate_mask_path(mask_path: Sequence[str] | None) -> list[str] | None:
     def validate_anomaly_map(anomaly_map: torch.Tensor | np.ndarray | None) -> Mask | None:
         """Validate the anomaly map for a batch.
 
+        This method validates batches of anomaly maps. It handles:
+            - Conversion from numpy arrays
+            - Shape normalization
+            - Type conversion to float32
+
         Args:
-            anomaly_map (torch.Tensor | np.ndarray | None): Input anomaly map.
+            anomaly_map (``torch.Tensor`` | ``np.ndarray`` | ``None``): Input anomaly map.
 
         Returns:
-            Mask | None: Validated anomaly map as a torchvision Mask object, or None.
+            ``Mask`` | ``None``: Validated anomaly map as a torchvision Mask object, or None.
 
         Raises:
-            ValueError: If the anomaly map cannot be converted to a torch.Tensor or has an invalid shape.
+            ValueError: If ``anomaly_map`` cannot be converted to tensor or has invalid shape.
 
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> anomaly_map = torch.rand(4, 224, 224)
-            >>> validated_map = ImageBatchValidator.validate_anomaly_map(anomaly_map)
-            >>> print(validated_map.shape)
-            torch.Size([4, 224, 224])
+        Example:
+            Validate anomaly maps::
+
+                >>> import torch
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> anomaly_map = torch.rand(4, 224, 224)
+                >>> validated = ImageBatchValidator.validate_anomaly_map(anomaly_map)
+                >>> validated.shape
+                torch.Size([4, 224, 224])
         """
         if anomaly_map is None:
             return None
@@ -523,27 +696,31 @@ def validate_pred_score(
     ) -> torch.Tensor | None:
         """Validate the prediction scores for a batch.
 
+        This method validates batches of prediction scores. It handles:
+            - Conversion from numpy arrays and sequences
+            - Type conversion to float32
+
         Args:
-            pred_score (torch.Tensor | Sequence[float] | None): Input prediction scores.
+            pred_score (``torch.Tensor`` | ``Sequence[float]`` | ``None``): Input prediction
+                scores.
 
         Returns:
-            torch.Tensor | None: Validated prediction scores as a float32 tensor, or None.
+            ``torch.Tensor`` | ``None``: Validated prediction scores as float32 tensor,
+                or None.
 
         Raises:
-            TypeError: If the input is neither a sequence of floats, torch.Tensor, nor None.
-            ValueError: If the prediction scores are not a 1-dimensional tensor or sequence.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> scores = [0.8, 0.7, 0.9]
-            >>> validated_scores = ImageBatchValidator.validate_pred_score(scores)
-            >>> validated_scores
-            tensor([0.8000, 0.7000, 0.9000])
-            >>> score_tensor = torch.tensor([0.8, 0.7, 0.9])
-            >>> validated_scores = ImageBatchValidator.validate_pred_score(score_tensor)
-            >>> validated_scores
-            tensor([0.8000, 0.7000, 0.9000])
+            TypeError: If ``pred_score`` is not a valid input type.
+            ValueError: If ``pred_score`` cannot be converted to tensor.
+
+        Example:
+            Validate prediction scores::
+
+                >>> import torch
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> scores = [0.8, 0.7, 0.9]
+                >>> validated = ImageBatchValidator.validate_pred_score(scores)
+                >>> validated
+                tensor([0.8000, 0.7000, 0.9000])
         """
         if pred_score is None:
             return None
@@ -563,19 +740,25 @@ def validate_pred_score(
     def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
         """Validate the prediction mask for a batch.
 
+        This method validates batches of prediction masks using the same logic as ground
+        truth masks.
+
         Args:
-            pred_mask (torch.Tensor | None): Input prediction mask.
+            pred_mask (``torch.Tensor`` | ``None``): Input prediction mask.
 
         Returns:
-            Mask | None: Validated prediction mask as a torchvision Mask object, or None.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> pred_mask = torch.randint(0, 2, (4, 224, 224))
-            >>> validated_mask = ImageBatchValidator.validate_pred_mask(pred_mask)
-            >>> print(validated_mask.shape)
-            torch.Size([4, 224, 224])
+            ``Mask`` | ``None``: Validated prediction mask as a torchvision Mask object,
+                or None.
+
+        Example:
+            Validate prediction masks::
+
+                >>> import torch
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> pred_mask = torch.randint(0, 2, (4, 224, 224))
+                >>> validated = ImageBatchValidator.validate_pred_mask(pred_mask)
+                >>> validated.shape
+                torch.Size([4, 224, 224])
         """
         return ImageBatchValidator.validate_gt_mask(pred_mask)  # We can reuse the gt_mask validation
 
@@ -583,23 +766,30 @@ def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
     def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
         """Validate the prediction label for a batch.
 
+        This method validates batches of prediction labels. It handles:
+            - Shape normalization
+            - Type conversion to boolean
+
         Args:
-            pred_label (torch.Tensor | None): Input prediction label.
+            pred_label (``torch.Tensor`` | ``None``): Input prediction label.
 
         Returns:
-            torch.Tensor | None: Validated prediction label as a boolean tensor, or None.
+            ``torch.Tensor`` | ``None``: Validated prediction label as boolean tensor,
+                or None.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the prediction label has an invalid shape.
-
-        Examples:
-            >>> import torch
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> pred_label = torch.tensor([[1], [0], [1], [1]])
-            >>> validated_label = ImageBatchValidator.validate_pred_label(pred_label)
-            >>> print(validated_label)
-            tensor([ True, False,  True,  True])
+            TypeError: If ``pred_label`` is not a torch.Tensor.
+            ValueError: If ``pred_label`` has invalid shape.
+
+        Example:
+            Validate prediction labels::
+
+                >>> import torch
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> pred_label = torch.tensor([[1], [0], [1], [1]])
+                >>> validated = ImageBatchValidator.validate_pred_label(pred_label)
+                >>> validated
+                tensor([ True, False,  True,  True])
         """
         if pred_label is None:
             return None
@@ -625,21 +815,25 @@ def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
     def validate_image_path(image_path: list[str] | None) -> list[str] | None:
         """Validate the image paths for a batch.
 
+        This method validates batches of image file paths.
+
         Args:
-            image_path (list[str] | None): Input list of image paths.
+            image_path (``list[str]`` | ``None``): Input list of image paths.
 
         Returns:
-            list[str] | None: Validated list of image paths, or None.
+            ``list[str]`` | ``None``: Validated list of image paths, or None.
 
         Raises:
-            TypeError: If the input is not a list of strings.
-
-        Examples:
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> image_paths = ["path/to/image_1.jpg", "path/to/image_2.jpg"]
-            >>> validated_paths = ImageBatchValidator.validate_image_path(image_paths)
-            >>> print(validated_paths)
-            ['path/to/image_1.jpg', 'path/to/image_2.jpg']
+            TypeError: If ``image_path`` is not a list of strings.
+
+        Example:
+            Validate image paths::
+
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> image_paths = ["path/to/image_1.jpg", "path/to/image_2.jpg"]
+                >>> validated = ImageBatchValidator.validate_image_path(image_paths)
+                >>> validated
+                ['path/to/image_1.jpg', 'path/to/image_2.jpg']
         """
         if image_path is None:
             return None
@@ -652,21 +846,25 @@ def validate_image_path(image_path: list[str] | None) -> list[str] | None:
     def validate_explanation(explanation: list[str] | None) -> list[str] | None:
         """Validate the explanations for a batch.
 
+        This method validates batches of explanation strings.
+
         Args:
-            explanation (list[str] | None): Input list of explanations.
+            explanation (``list[str]`` | ``None``): Input list of explanations.
 
         Returns:
-            list[str] | None: Validated list of explanations, or None.
+            ``list[str]`` | ``None``: Validated list of explanations, or None.
 
         Raises:
-            TypeError: If the input is not a list of strings.
-
-        Examples:
-            >>> from anomalib.data.validators.torch.image import ImageBatchValidator
-            >>> explanations = ["The image has a crack on the wall.", "The image has a dent on the car."]
-            >>> validated_explanations = ImageBatchValidator.validate_explanation(explanations)
-            >>> print(validated_explanations)
-            ['The image has a crack on the wall.', 'The image has a dent on the car.']
+            TypeError: If ``explanation`` is not a list of strings.
+
+        Example:
+            Validate explanations::
+
+                >>> from anomalib.data.validators import ImageBatchValidator
+                >>> explanations = ["Crack on wall", "Dent on car"]
+                >>> validated = ImageBatchValidator.validate_explanation(explanations)
+                >>> validated
+                ['Crack on wall', 'Dent on car']
         """
         if explanation is None:
             return None
diff --git a/src/anomalib/data/validators/torch/video.py b/src/anomalib/data/validators/torch/video.py
index bcfca62451..0f93325f7a 100644
--- a/src/anomalib/data/validators/torch/video.py
+++ b/src/anomalib/data/validators/torch/video.py
@@ -1,4 +1,33 @@
-"""Validate torch video data."""
+"""Validate PyTorch tensor data for videos.
+
+This module provides validators for video data stored as PyTorch tensors. The validators
+ensure data consistency and correctness for videos and their batches.
+
+The validators check:
+    - Tensor shapes and dimensions
+    - Data types
+    - Value ranges
+    - Label formats
+    - Mask properties
+    - Path validity
+
+Example:
+    Validate a single video::
+
+        >>> from anomalib.data.validators import VideoValidator
+        >>> validator = VideoValidator()
+        >>> validator.validate_image(video)
+
+    Validate a batch of videos::
+
+        >>> from anomalib.data.validators import VideoBatchValidator
+        >>> validator = VideoBatchValidator()
+        >>> validator(videos=videos, labels=labels, masks=masks)
+
+Note:
+    The validators are used internally by the data modules to ensure data
+    consistency before processing video data.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,36 +41,72 @@
 
 
 class VideoValidator:
-    """Validate torch.Tensor data for videos."""
+    """Validate torch.Tensor data for videos.
+
+    This class provides static methods to validate video data and related metadata stored as
+    PyTorch tensors. The validators ensure data consistency and correctness by checking
+    tensor shapes, dimensions, data types, and value ranges.
+
+    The validator methods handle:
+        - Video tensors
+        - Ground truth labels and masks
+        - Prediction scores, labels and masks
+        - Video paths and metadata
+        - Frame indices and timing information
+
+    Each validation method performs thorough checks and returns properly formatted data
+    ready for use in video processing pipelines.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.data.validators import VideoValidator
+        >>> video = torch.rand(10, 3, 256, 256)  # 10 frames, RGB
+        >>> validator = VideoValidator()
+        >>> validated_video = validator.validate_image(video)
+        >>> validated_video.shape
+        torch.Size([10, 3, 256, 256])
+    """
 
     @staticmethod
     def validate_image(image: torch.Tensor) -> torch.Tensor:
-        """Validate the video tensor.
+        """Validate a video tensor.
+
+        Validates and normalizes video tensors, handling both single and multi-frame cases.
+        Checks tensor type, dimensions, and channel count.
 
         Args:
-            image (Image): Input tensor.
+            image (torch.Tensor): Input video tensor with shape either:
+                - ``[C, H, W]`` for single frame
+                - ``[T, C, H, W]`` for multiple frames
+                where ``C`` is channels (1 or 3), ``H`` height, ``W`` width,
+                and ``T`` number of frames.
 
         Returns:
-            Image: Validated tensor.
+            torch.Tensor: Validated and normalized video tensor.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the video tensor does not have the correct shape.
+            TypeError: If ``image`` is not a ``torch.Tensor``.
+            ValueError: If tensor dimensions or channel count are invalid.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoValidator
-            >>> video = torch.rand(10, 3, 256, 256)  # 10 frames, RGB
-            >>> validated_video = VideoValidator.validate_image(video)
-            >>> validated_video.shape
+            >>> # Multi-frame RGB video
+            >>> video = torch.rand(10, 3, 256, 256)
+            >>> validated = VideoValidator.validate_image(video)
+            >>> validated.shape
             torch.Size([10, 3, 256, 256])
-            >>> single_frame_rgb = torch.rand(3, 256, 256)  # Single RGB frame
-            >>> validated_single_frame_rgb = VideoValidator.validate_image(single_frame_rgb)
-            >>> validated_single_frame_rgb.shape
+
+            >>> # Single RGB frame
+            >>> frame = torch.rand(3, 256, 256)
+            >>> validated = VideoValidator.validate_image(frame)
+            >>> validated.shape
             torch.Size([1, 3, 256, 256])
-            >>> single_frame_gray = torch.rand(1, 256, 256)  # Single grayscale frame
-            >>> validated_single_frame_gray = VideoValidator.validate_image(single_frame_gray)
-            >>> validated_single_frame_gray.shape
+
+            >>> # Single grayscale frame
+            >>> gray = torch.rand(1, 256, 256)
+            >>> validated = VideoValidator.validate_image(gray)
+            >>> validated.shape
             torch.Size([1, 1, 256, 256])
         """
         if not isinstance(image, torch.Tensor):
@@ -64,28 +129,36 @@ def validate_image(image: torch.Tensor) -> torch.Tensor:
 
     @staticmethod
     def validate_gt_label(label: int | torch.Tensor | None) -> torch.Tensor | None:
-        """Validate the ground truth label.
+        """Validate ground truth label.
+
+        Validates and converts ground truth labels to boolean tensors.
 
         Args:
-            label (int | torch.Tensor | None): Input ground truth label.
+            label (int | torch.Tensor | None): Input label as either:
+                - Integer (0 or 1)
+                - Boolean tensor
+                - Integer tensor
+                - ``None``
 
         Returns:
-            torch.Tensor | None: Validated ground truth label as a boolean tensor, or None.
+            torch.Tensor | None: Validated boolean tensor label or ``None``.
 
         Raises:
-            TypeError: If the input is neither an integer nor a torch.Tensor.
-            ValueError: If the label shape or dtype is invalid.
+            TypeError: If ``label`` is not an integer, tensor or ``None``.
+            ValueError: If label shape or dtype is invalid.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoValidator
-            >>> label_int = 1
-            >>> validated_label = VideoValidator.validate_gt_label(label_int)
-            >>> validated_label
+            >>> # Integer label
+            >>> validated = VideoValidator.validate_gt_label(1)
+            >>> validated
             tensor(True)
-            >>> label_tensor = torch.tensor([0, 0], dtype=torch.int32)
-            >>> validated_label = VideoValidator.validate_gt_label(label_tensor)
-            >>> validated_label
+
+            >>> # Tensor label
+            >>> label = torch.tensor([0, 0], dtype=torch.int32)
+            >>> validated = VideoValidator.validate_gt_label(label)
+            >>> validated
             tensor([False, False])
         """
         if label is None:
@@ -102,26 +175,33 @@ def validate_gt_label(label: int | torch.Tensor | None) -> torch.Tensor | None:
 
     @staticmethod
     def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
-        """Validate the ground truth mask.
+        """Validate ground truth mask.
+
+        Validates and converts ground truth masks to boolean Mask objects.
 
         Args:
-            mask (torch.Tensor | None): Input ground truth mask.
+            mask (torch.Tensor | None): Input mask tensor with shape either:
+                - ``[H, W]`` for single frame
+                - ``[T, H, W]`` for multiple frames
+                - ``[T, 1, H, W]`` for multiple frames with channel dimension
+                where ``H`` is height, ``W`` width, and ``T`` number of frames.
 
         Returns:
-            Mask | None: Validated ground truth mask, or None.
+            Mask | None: Validated boolean mask or ``None``.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the mask shape is invalid.
+            TypeError: If ``mask`` is not a ``torch.Tensor`` or ``None``.
+            ValueError: If mask shape is invalid.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoValidator
-            >>> mask = torch.randint(0, 2, (10, 1, 224, 224))  # 10 frames
-            >>> validated_mask = VideoValidator.validate_gt_mask(mask)
-            >>> isinstance(validated_mask, Mask)
+            >>> # Multi-frame mask
+            >>> mask = torch.randint(0, 2, (10, 1, 224, 224))
+            >>> validated = VideoValidator.validate_gt_mask(mask)
+            >>> isinstance(validated, Mask)
             True
-            >>> validated_mask.shape
+            >>> validated.shape
             torch.Size([10, 224, 224])
         """
         if mask is None:
@@ -141,26 +221,32 @@ def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
 
     @staticmethod
     def validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
-        """Validate the anomaly map.
+        """Validate anomaly map.
+
+        Validates and converts anomaly maps to float32 Mask objects.
 
         Args:
-            anomaly_map (torch.Tensor | None): Input anomaly map.
+            anomaly_map (torch.Tensor | None): Input anomaly map tensor with shape either:
+                - ``[T, H, W]`` for multiple frames
+                - ``[T, 1, H, W]`` for multiple frames with channel dimension
+                where ``H`` is height, ``W`` width, and ``T`` number of frames.
 
         Returns:
-            Mask | None: Validated anomaly map as a Mask, or None.
+            Mask | None: Validated float32 mask or ``None``.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the anomaly map shape is invalid.
+            TypeError: If ``anomaly_map`` is not a ``torch.Tensor`` or ``None``.
+            ValueError: If anomaly map shape is invalid.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoValidator
-            >>> anomaly_map = torch.rand(10, 1, 224, 224)  # 10 frames
-            >>> validated_map = VideoValidator.validate_anomaly_map(anomaly_map)
-            >>> isinstance(validated_map, Mask)
+            >>> # Multi-frame anomaly map
+            >>> amap = torch.rand(10, 1, 224, 224)
+            >>> validated = VideoValidator.validate_anomaly_map(amap)
+            >>> isinstance(validated, Mask)
             True
-            >>> validated_map.shape
+            >>> validated.shape
             torch.Size([10, 224, 224])
         """
         if anomaly_map is None:
@@ -181,38 +267,38 @@ def validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
 
     @staticmethod
     def validate_video_path(video_path: str | None) -> str | None:
-        """Validate the video path.
+        """Validate video file path.
 
         Args:
-            video_path (str | None): Input video path.
+            video_path (str | None): Input video file path or ``None``.
 
         Returns:
-            str | None: Validated video path, or None.
+            str | None: Validated video path or ``None``.
 
         Examples:
             >>> from anomalib.data.validators import VideoValidator
             >>> path = "/path/to/video.mp4"
-            >>> validated_path = VideoValidator.validate_video_path(path)
-            >>> validated_path == path
+            >>> validated = VideoValidator.validate_video_path(path)
+            >>> validated == path
             True
         """
         return validate_path(video_path) if video_path else None
 
     @staticmethod
     def validate_mask_path(mask_path: str | None) -> str | None:
-        """Validate the mask path.
+        """Validate mask file path.
 
         Args:
-            mask_path (str | None): Input mask path.
+            mask_path (str | None): Input mask file path or ``None``.
 
         Returns:
-            str | None: Validated mask path, or None.
+            str | None: Validated mask path or ``None``.
 
         Examples:
             >>> from anomalib.data.validators import VideoValidator
             >>> path = "/path/to/mask.mp4"
-            >>> validated_path = VideoValidator.validate_mask_path(path)
-            >>> validated_path == path
+            >>> validated = VideoValidator.validate_mask_path(path)
+            >>> validated == path
             True
         """
         return validate_path(mask_path) if mask_path else None
@@ -222,25 +308,27 @@ def validate_pred_score(
         pred_score: torch.Tensor | float | None,
         anomaly_map: torch.Tensor | None = None,
     ) -> torch.Tensor | None:
-        """Validate the prediction score.
+        """Validate prediction score.
+
+        Validates prediction scores and optionally computes them from anomaly maps.
 
         Args:
-            pred_score (torch.Tensor | float | None): Input prediction score.
-            anomaly_map (torch.Tensor | None): Input anomaly map.
+            pred_score (torch.Tensor | float | None): Input prediction score or ``None``.
+            anomaly_map (torch.Tensor | None): Optional anomaly map to compute score from.
 
         Returns:
-            torch.Tensor | None: Validated prediction score as a float32 tensor, or None.
+            torch.Tensor | None: Validated float32 prediction score or ``None``.
 
         Raises:
-            TypeError: If the input is neither a float, torch.Tensor, nor None.
-            ValueError: If the prediction score is not a scalar.
+            TypeError: If ``pred_score`` is not a float, tensor or ``None``.
+            ValueError: If prediction score is not a scalar.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoValidator
             >>> score = 0.8
-            >>> validated_score = VideoValidator.validate_pred_score(score)
-            >>> validated_score
+            >>> validated = VideoValidator.validate_pred_score(score)
+            >>> validated
             tensor(0.8000)
         """
         if pred_score is None:
@@ -261,46 +349,46 @@ def validate_pred_score(
 
     @staticmethod
     def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
-        """Validate the prediction mask.
+        """Validate prediction mask.
 
         Args:
-            pred_mask (torch.Tensor | None): Input prediction mask.
+            pred_mask (torch.Tensor | None): Input prediction mask tensor or ``None``.
 
         Returns:
-            Mask | None: Validated prediction mask, or None.
+            Mask | None: Validated prediction mask or ``None``.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoValidator
-            >>> mask = torch.randint(0, 2, (10, 1, 224, 224))  # 10 frames
-            >>> validated_mask = VideoValidator.validate_pred_mask(mask)
-            >>> isinstance(validated_mask, Mask)
+            >>> mask = torch.randint(0, 2, (10, 1, 224, 224))
+            >>> validated = VideoValidator.validate_pred_mask(mask)
+            >>> isinstance(validated, Mask)
             True
-            >>> validated_mask.shape
+            >>> validated.shape
             torch.Size([10, 224, 224])
         """
         return VideoValidator.validate_gt_mask(pred_mask)  # We can reuse the gt_mask validation
 
     @staticmethod
     def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
-        """Validate the prediction label.
+        """Validate prediction label.
 
         Args:
-            pred_label (torch.Tensor | None): Input prediction label.
+            pred_label (torch.Tensor | None): Input prediction label or ``None``.
 
         Returns:
-            torch.Tensor | None: Validated prediction label as a boolean tensor, or None.
+            torch.Tensor | None: Validated boolean prediction label or ``None``.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the prediction label is not a scalar.
+            TypeError: If ``pred_label`` is not a ``torch.Tensor``.
+            ValueError: If prediction label is not a scalar.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoValidator
             >>> label = torch.tensor(1)
-            >>> validated_label = VideoValidator.validate_pred_label(label)
-            >>> validated_label
+            >>> validated = VideoValidator.validate_pred_label(label)
+            >>> validated
             tensor(True)
         """
         if pred_label is None:
@@ -319,29 +407,33 @@ def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
 
     @staticmethod
     def validate_original_image(original_image: torch.Tensor | Video | None) -> torch.Tensor | Video | None:
-        """Validate the original video or image.
+        """Validate original video or image.
 
         Args:
-            original_image (torch.Tensor | Video | None): Input original video or image.
+            original_image (torch.Tensor | Video | None): Input original video/image or
+                ``None``.
 
         Returns:
-            torch.Tensor | Video | None: Validated original video or image.
+            torch.Tensor | Video | None: Validated original video/image or ``None``.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor or torchvision Video object.
-            ValueError: If the tensor does not have the correct shape.
+            TypeError: If input is not a ``torch.Tensor`` or ``Video``.
+            ValueError: If tensor shape is invalid.
 
         Examples:
             >>> import torch
             >>> from torchvision.tv_tensors import Video
             >>> from anomalib.data.validators import VideoValidator
-            >>> video = Video(torch.rand(10, 3, 224, 224))  # 10 frames
-            >>> validated_video = VideoValidator.validate_original_image(video)
-            >>> validated_video.shape
+            >>> # Video tensor
+            >>> video = Video(torch.rand(10, 3, 224, 224))
+            >>> validated = VideoValidator.validate_original_image(video)
+            >>> validated.shape
             torch.Size([10, 3, 224, 224])
-            >>> image = torch.rand(3, 256, 256)  # Single image
-            >>> validated_image = VideoValidator.validate_original_image(image)
-            >>> validated_image.shape
+
+            >>> # Single image
+            >>> image = torch.rand(3, 256, 256)
+            >>> validated = VideoValidator.validate_original_image(image)
+            >>> validated.shape
             torch.Size([3, 256, 256])
         """
         if original_image is None:
@@ -369,22 +461,22 @@ def validate_original_image(original_image: torch.Tensor | Video | None) -> torc
 
     @staticmethod
     def validate_target_frame(target_frame: int | None) -> int | None:
-        """Validate the target frame index.
+        """Validate target frame index.
 
         Args:
-            target_frame (int | None): Input target frame index.
+            target_frame (int | None): Input target frame index or ``None``.
 
         Returns:
-            int | None: Validated target frame index, or None.
+            int | None: Validated target frame index or ``None``.
 
         Raises:
-            TypeError: If the input is not an integer.
-            ValueError: If the target frame index is negative.
+            TypeError: If ``target_frame`` is not an integer.
+            ValueError: If target frame index is negative.
 
         Examples:
             >>> from anomalib.data.validators import VideoValidator
-            >>> validated_frame = VideoValidator.validate_target_frame(31)
-            >>> print(validated_frame)
+            >>> validated = VideoValidator.validate_target_frame(31)
+            >>> print(validated)
             31
         """
         if target_frame is None:
@@ -399,24 +491,24 @@ def validate_target_frame(target_frame: int | None) -> int | None:
 
     @staticmethod
     def validate_frames(frames: torch.Tensor | None) -> torch.Tensor | None:
-        """Validate the frames tensor.
+        """Validate frames tensor.
 
         Args:
-            frames (torch.Tensor | None): Input frames tensor or frame indices.
+            frames (torch.Tensor | None): Input frames tensor or frame indices or ``None``.
 
         Returns:
-            torch.Tensor | None: Validated frames tensor, or None.
+            torch.Tensor | None: Validated frames tensor or ``None``.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the frames tensor is not a 1D tensor of indices.
+            TypeError: If ``frames`` is not a ``torch.Tensor``.
+            ValueError: If frames tensor is not a 1D tensor of indices.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoValidator
-            >>> frame_indices = torch.tensor([0, 5, 10])
-            >>> validated_indices = VideoValidator.validate_frames(frame_indices)
-            >>> validated_indices
+            >>> indices = torch.tensor([0, 5, 10])
+            >>> validated = VideoValidator.validate_frames(indices)
+            >>> validated
             tensor([0, 5, 10])
         """
         if frames is None:
@@ -442,30 +534,36 @@ def validate_frames(frames: torch.Tensor | None) -> torch.Tensor | None:
 
     @staticmethod
     def validate_last_frame(last_frame: torch.Tensor | int | float | None) -> torch.Tensor | int | None:
-        """Validate the last frame index.
+        """Validate last frame index.
 
         Args:
-            last_frame (torch.Tensor | int | float | None): Input last frame index.
+            last_frame (torch.Tensor | int | float | None): Input last frame index or
+                ``None``.
 
         Returns:
-            torch.Tensor | int | None: Validated last frame index, or None.
+            torch.Tensor | int | None: Validated last frame index or ``None``.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor, int, or float.
-            ValueError: If the last frame index is negative.
+            TypeError: If ``last_frame`` is not a tensor, int, or float.
+            ValueError: If last frame index is negative.
 
         Examples:
             >>> from anomalib.data.validators import VideoValidator
-            >>> validated_frame = VideoValidator.validate_last_frame(5)
-            >>> print(validated_frame)
+            >>> # Integer input
+            >>> validated = VideoValidator.validate_last_frame(5)
+            >>> print(validated)
             5
-            >>> validated_float = VideoValidator.validate_last_frame(5.7)
-            >>> print(validated_float)
+
+            >>> # Float input
+            >>> validated = VideoValidator.validate_last_frame(5.7)
+            >>> print(validated)
             5
+
+            >>> # Tensor input
             >>> import torch
             >>> tensor_frame = torch.tensor(10.3)
-            >>> validated_tensor = VideoValidator.validate_last_frame(tensor_frame)
-            >>> print(validated_tensor)
+            >>> validated = VideoValidator.validate_last_frame(tensor_frame)
+            >>> print(validated)
             tensor(10)
         """
         if last_frame is None:
@@ -495,27 +593,45 @@ def validate_explanation(explanation: str | None) -> str | None:
 
 
 class VideoBatchValidator:
-    """Validate torch.Tensor data for video batches."""
+    """Validate ``torch.Tensor`` data for video batches.
+
+    This class provides static methods to validate various video batch data types including
+    tensors, masks, labels, paths and more. Each method performs thorough validation of
+    its input and returns the validated data in the correct format.
+    """
 
     @staticmethod
     def validate_image(image: Video) -> Video:
         """Validate the video batch tensor.
 
+        Validates that the input video batch tensor has the correct dimensions, number of
+        channels and data type. Converts the tensor to float32 and scales values to [0,1]
+        range.
+
         Args:
-            image (Video): Input video batch tensor.
+            image (Video): Input video batch tensor. Should be either:
+                - Shape ``(B,C,H,W)`` for single frame images
+                - Shape ``(B,T,C,H,W)`` for multi-frame videos
+                Where:
+                    - ``B`` is batch size
+                    - ``T`` is number of frames
+                    - ``C`` is number of channels (1 or 3)
+                    - ``H`` is height
+                    - ``W`` is width
 
         Returns:
-            Video: Validated video batch tensor.
+            Video: Validated and normalized video batch tensor.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the tensor does not have the correct dimensions or number of channels.
+            TypeError: If ``image`` is not a ``torch.Tensor``.
+            ValueError: If tensor dimensions or channel count are invalid.
 
         Examples:
             >>> import torch
             >>> from torchvision.tv_tensors import Video
             >>> from anomalib.data.validators import VideoBatchValidator
-            >>> video_batch = Video(torch.rand(2, 10, 3, 224, 224))  # 2 videos, 10 frames each
+            >>> # Create sample video batch with 2 videos, 10 frames each
+            >>> video_batch = Video(torch.rand(2, 10, 3, 224, 224))
             >>> validated_batch = VideoBatchValidator.validate_image(video_batch)
             >>> print(validated_batch.shape)
             torch.Size([2, 10, 3, 224, 224])
@@ -544,14 +660,18 @@ def validate_image(image: Video) -> Video:
     def validate_gt_label(label: torch.Tensor | None) -> torch.Tensor | None:
         """Validate the ground truth labels for a batch.
 
+        Validates that the input ground truth labels have the correct data type and
+        format. Converts labels to boolean type.
+
         Args:
-            label (torch.Tensor | None): Input ground truth labels.
+            label (torch.Tensor | None): Input ground truth labels. Should be a 1D tensor
+                of boolean or integer values.
 
         Returns:
-            torch.Tensor | None: Validated ground truth labels.
+            torch.Tensor | None: Validated ground truth labels as boolean tensor.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor or has an invalid dtype.
+            TypeError: If ``label`` is not a ``torch.Tensor`` or has invalid dtype.
 
         Examples:
             >>> import torch
@@ -575,25 +695,35 @@ def validate_gt_label(label: torch.Tensor | None) -> torch.Tensor | None:
     def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
         """Validate the ground truth masks for a batch.
 
+        Validates that the input ground truth masks have the correct shape and format.
+        Converts masks to boolean type.
+
         Args:
-            mask (torch.Tensor | None): Input ground truth masks.
+            mask (torch.Tensor | None): Input ground truth masks. Should be one of:
+                - Shape ``(H,W)`` for single mask
+                - Shape ``(N,H,W)`` for batch of masks
+                - Shape ``(N,1,H,W)`` for batch with channel dimension
 
         Returns:
-            Mask | None: Validated ground truth masks.
+            Mask | None: Validated ground truth masks as boolean tensor.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the mask has an invalid shape.
+            TypeError: If ``mask`` is not a ``torch.Tensor``.
+            ValueError: If mask shape is invalid.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoBatchValidator
-            >>> gt_masks = torch.rand(10, 224, 224) > 0.5  # 10 frames each
+            >>> # Create 10 frame masks
+            >>> gt_masks = torch.rand(10, 224, 224) > 0.5
             >>> validated_masks = VideoBatchValidator.validate_gt_mask(gt_masks)
             >>> print(validated_masks.shape)
             torch.Size([10, 224, 224])
-            >>> single_frame_masks = torch.rand(4, 456, 256) > 0.5  # 4 single-frame images
-            >>> validated_single_frame = VideoBatchValidator.validate_gt_mask(single_frame_masks)
+            >>> # Create 4 single-frame masks
+            >>> single_frame_masks = torch.rand(4, 456, 256) > 0.5
+            >>> validated_single_frame = VideoBatchValidator.validate_gt_mask(
+            ...     single_frame_masks
+            ... )
             >>> print(validated_single_frame.shape)
             torch.Size([4, 456, 256])
         """
@@ -618,14 +748,17 @@ def validate_gt_mask(mask: torch.Tensor | None) -> Mask | None:
     def validate_mask_path(mask_path: list[str] | None) -> list[str] | None:
         """Validate the mask paths for a batch.
 
+        Validates that the input mask paths are in the correct format.
+
         Args:
-            mask_path (list[str] | None): Input mask paths.
+            mask_path (list[str] | None): Input mask paths. Should be a list of strings
+                containing valid file paths.
 
         Returns:
             list[str] | None: Validated mask paths.
 
         Raises:
-            TypeError: If the input is not a list of strings.
+            TypeError: If ``mask_path`` is not a list of strings.
 
         Examples:
             >>> from anomalib.data.validators import VideoBatchValidator
@@ -640,20 +773,31 @@ def validate_mask_path(mask_path: list[str] | None) -> list[str] | None:
     def validate_anomaly_map(anomaly_map: torch.Tensor | None) -> Mask | None:
         """Validate the anomaly maps for a batch.
 
+        Validates that the input anomaly maps have the correct shape and format.
+        Converts maps to float32 type.
+
         Args:
-            anomaly_map (torch.Tensor | None): Input anomaly maps.
+            anomaly_map (torch.Tensor | None): Input anomaly maps. Should be either:
+                - Shape ``(B,T,H,W)`` for single channel maps
+                - Shape ``(B,T,1,H,W)`` for explicit single channel
+                Where:
+                    - ``B`` is batch size
+                    - ``T`` is number of frames
+                    - ``H`` is height
+                    - ``W`` is width
 
         Returns:
-            Mask | None: Validated anomaly maps.
+            Mask | None: Validated anomaly maps as float32 tensor.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the anomaly map has an invalid shape.
+            TypeError: If ``anomaly_map`` is not a ``torch.Tensor``.
+            ValueError: If anomaly map shape is invalid.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoBatchValidator
-            >>> anomaly_maps = torch.rand(2, 10, 224, 224)  # 2 videos, 10 frames each
+            >>> # Create maps for 2 videos with 10 frames each
+            >>> anomaly_maps = torch.rand(2, 10, 224, 224)
             >>> validated_maps = VideoBatchValidator.validate_anomaly_map(anomaly_maps)
             >>> print(validated_maps.shape)
             torch.Size([2, 10, 224, 224])
@@ -680,15 +824,21 @@ def validate_pred_score(
     ) -> torch.Tensor | None:
         """Validate the prediction scores for a batch.
 
+        Validates that the input prediction scores have the correct format. If no scores
+        are provided but an anomaly map is given, computes scores from the map.
+
         Args:
-            pred_score (torch.Tensor | None): Input prediction scores.
-            anomaly_map (torch.Tensor | None): Input anomaly map (optional).
+            pred_score (torch.Tensor | None): Input prediction scores. Should be a 1D
+                tensor of float values.
+            anomaly_map (torch.Tensor | None, optional): Input anomaly map used to compute
+                scores if ``pred_score`` is None.
 
         Returns:
-            torch.Tensor | None: Validated prediction scores.
+            torch.Tensor | None: Validated prediction scores as float32 tensor.
 
         Raises:
-            ValueError: If the prediction scores have an invalid shape or cannot be converted to a tensor.
+            ValueError: If prediction scores have invalid shape or cannot be converted to
+                tensor.
 
         Examples:
             >>> import torch
@@ -717,8 +867,11 @@ def validate_pred_score(
     def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
         """Validate the prediction masks for a batch.
 
+        Validates prediction masks using the same logic as ground truth masks.
+
         Args:
-            pred_mask (torch.Tensor | None): Input prediction masks.
+            pred_mask (torch.Tensor | None): Input prediction masks. Should follow same
+                format as ground truth masks.
 
         Returns:
             Mask | None: Validated prediction masks.
@@ -726,7 +879,8 @@ def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoBatchValidator
-            >>> pred_masks = torch.rand(2, 10, 224, 224) > 0.5  # 2 videos, 10 frames each
+            >>> # Create masks for 2 videos with 10 frames each
+            >>> pred_masks = torch.rand(2, 10, 224, 224) > 0.5
             >>> validated_masks = VideoBatchValidator.validate_pred_mask(pred_masks)
             >>> print(validated_masks.shape)
             torch.Size([2, 10, 224, 224])
@@ -737,14 +891,19 @@ def validate_pred_mask(pred_mask: torch.Tensor | None) -> Mask | None:
     def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
         """Validate the prediction labels for a batch.
 
+        Validates that the input prediction labels have the correct format and converts
+        them to boolean type.
+
         Args:
-            pred_label (torch.Tensor | None): Input prediction labels.
+            pred_label (torch.Tensor | None): Input prediction labels. Should be a 1D
+                tensor of boolean or numeric values.
 
         Returns:
-            torch.Tensor | None: Validated prediction labels.
+            torch.Tensor | None: Validated prediction labels as boolean tensor.
 
         Raises:
-            ValueError: If the prediction labels have an invalid shape or cannot be converted to a tensor.
+            ValueError: If prediction labels have invalid shape or cannot be converted to
+                tensor.
 
         Examples:
             >>> import torch
@@ -771,22 +930,37 @@ def validate_pred_label(pred_label: torch.Tensor | None) -> torch.Tensor | None:
     def validate_original_image(original_image: torch.Tensor | Video | None) -> torch.Tensor | Video | None:
         """Validate the original videos for a batch.
 
+        Validates that the input videos have the correct dimensions and channel count.
+        Adds temporal dimension to single frame inputs.
+
         Args:
-            original_image (torch.Tensor | Video | None): Input original videos.
+            original_image (torch.Tensor | Video | None): Input original videos. Should be
+                either:
+                - Shape ``(B,C,H,W)`` for single frame images
+                - Shape ``(B,T,C,H,W)`` for multi-frame videos
+                Where:
+                    - ``B`` is batch size
+                    - ``T`` is number of frames
+                    - ``C`` is number of channels (must be 3)
+                    - ``H`` is height
+                    - ``W`` is width
 
         Returns:
             torch.Tensor | Video | None: Validated original videos.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor or torchvision Video object.
-            ValueError: If the video has an invalid shape or number of channels.
+            TypeError: If input is not a ``torch.Tensor`` or ``torchvision.Video``.
+            ValueError: If video has invalid shape or channel count.
 
         Examples:
             >>> import torch
             >>> from torchvision.tv_tensors import Video
             >>> from anomalib.data.validators import VideoBatchValidator
-            >>> original_videos = Video(torch.rand(2, 10, 3, 224, 224))  # 2 videos, 10 frames each
-            >>> validated_videos = VideoBatchValidator.validate_original_image(original_videos)
+            >>> # Create 2 videos with 10 frames each
+            >>> original_videos = Video(torch.rand(2, 10, 3, 224, 224))
+            >>> validated_videos = VideoBatchValidator.validate_original_image(
+            ...     original_videos
+            ... )
             >>> print(validated_videos.shape)
             torch.Size([2, 10, 3, 224, 224])
         """
@@ -817,14 +991,17 @@ def validate_original_image(original_image: torch.Tensor | Video | None) -> torc
     def validate_video_path(video_path: list[str] | None) -> list[str] | None:
         """Validate the video paths for a batch.
 
+        Validates that the input video paths are in the correct format.
+
         Args:
-            video_path (list[str] | None): Input video paths.
+            video_path (list[str] | None): Input video paths. Should be a list of strings
+                containing valid file paths.
 
         Returns:
             list[str] | None: Validated video paths.
 
         Raises:
-            TypeError: If the input is not a list of strings.
+            TypeError: If ``video_path`` is not a list of strings.
 
         Examples:
             >>> from anomalib.data.validators import VideoBatchValidator
@@ -839,15 +1016,18 @@ def validate_video_path(video_path: list[str] | None) -> list[str] | None:
     def validate_target_frame(target_frame: torch.Tensor | None) -> torch.Tensor | None:
         """Validate the target frame indices for a batch.
 
+        Validates that the input target frame indices are non-negative integers.
+
         Args:
-            target_frame (torch.Tensor | None): Input target frame indices.
+            target_frame (torch.Tensor | None): Input target frame indices. Should be a
+                1D tensor of non-negative integers.
 
         Returns:
-            torch.Tensor | None: Validated target frame indices.
+            torch.Tensor | None: Validated target frame indices as int64 tensor.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the target frame indices are invalid.
+            TypeError: If ``target_frame`` is not a ``torch.Tensor``.
+            ValueError: If target frame indices are invalid.
 
         Examples:
             >>> import torch
@@ -874,15 +1054,20 @@ def validate_target_frame(target_frame: torch.Tensor | None) -> torch.Tensor | N
     def validate_frames(frames: torch.Tensor | None) -> torch.Tensor | None:
         """Validate the frame indices for a batch.
 
+        Validates that the input frame indices are non-negative integers and converts
+        them to the correct shape.
+
         Args:
-            frames (torch.Tensor | None): Input frame indices.
+            frames (torch.Tensor | None): Input frame indices. Should be either:
+                - Shape ``(N,)`` for 1D tensor
+                - Shape ``(N,1)`` for 2D tensor
 
         Returns:
-            torch.Tensor | None: Validated frame indices.
+            torch.Tensor | None: Validated frame indices as 1D int64 tensor.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the frame indices are invalid.
+            TypeError: If ``frames`` is not a ``torch.Tensor``.
+            ValueError: If frame indices are invalid.
 
         Examples:
             >>> import torch
@@ -911,21 +1096,26 @@ def validate_frames(frames: torch.Tensor | None) -> torch.Tensor | None:
     def validate_last_frame(last_frame: torch.Tensor | None) -> torch.Tensor | None:
         """Validate the last frame indices for a batch.
 
+        Validates that the input last frame indices are non-negative integers.
+
         Args:
-            last_frame (torch.Tensor | None): Input last frame indices.
+            last_frame (torch.Tensor | None): Input last frame indices. Should be a 1D
+                tensor of non-negative numeric values.
 
         Returns:
-            torch.Tensor | None: Validated last frame indices.
+            torch.Tensor | None: Validated last frame indices as int64 tensor.
 
         Raises:
-            TypeError: If the input is not a torch.Tensor.
-            ValueError: If the last frame indices are invalid.
+            TypeError: If ``last_frame`` is not a ``torch.Tensor``.
+            ValueError: If last frame indices are invalid.
 
         Examples:
             >>> import torch
             >>> from anomalib.data.validators import VideoBatchValidator
             >>> last_frames = torch.tensor([9.5, 12.2, 15.8, 10.0])
-            >>> validated_last_frames = VideoBatchValidator.validate_last_frame(last_frames)
+            >>> validated_last_frames = VideoBatchValidator.validate_last_frame(
+            ...     last_frames
+            ... )
             >>> print(validated_last_frames)
             tensor([ 9, 12, 15, 10])
         """
diff --git a/src/anomalib/deploy/__init__.py b/src/anomalib/deploy/__init__.py
index e2bec10b1f..358f130b3e 100644
--- a/src/anomalib/deploy/__init__.py
+++ b/src/anomalib/deploy/__init__.py
@@ -1,4 +1,26 @@
-"""Functions for Inference and model deployment."""
+"""Functions for model inference and deployment.
+
+This module provides functionality for deploying trained anomaly detection models
+and performing inference. It includes:
+
+- Model export utilities for converting models to different formats
+- Inference classes for making predictions:
+    - :class:`Inferencer`: Base inferencer interface
+    - :class:`TorchInferencer`: For PyTorch models
+    - :class:`OpenVINOInferencer`: For OpenVINO IR models
+
+Example:
+    >>> from anomalib.deploy import TorchInferencer
+    >>> model = TorchInferencer(path="path/to/model.pt")
+    >>> predictions = model.predict(image="path/to/image.jpg")
+
+    The prediction contains anomaly maps and scores:
+
+    >>> predictions.anomaly_map  # doctest: +SKIP
+    tensor([[0.1, 0.2, ...]])
+    >>> predictions.pred_score  # doctest: +SKIP
+    tensor(0.86)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/deploy/export.py b/src/anomalib/deploy/export.py
index 69e508396f..a65f093869 100644
--- a/src/anomalib/deploy/export.py
+++ b/src/anomalib/deploy/export.py
@@ -1,4 +1,23 @@
-"""Utilities for optimization and OpenVINO conversion."""
+"""Utilities for optimization and OpenVINO conversion.
+
+This module provides functionality for exporting and optimizing anomaly detection
+models to different formats like ONNX, OpenVINO IR and PyTorch.
+
+Example:
+    Export a model to ONNX format:
+
+    >>> from anomalib.deploy import ExportType
+    >>> export_type = ExportType.ONNX
+    >>> export_type
+    'onnx'
+
+    Export with OpenVINO compression:
+
+    >>> from anomalib.deploy import CompressionType
+    >>> compression = CompressionType.INT8_PTQ
+    >>> compression
+    'int8_ptq'
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,14 +31,18 @@
 class ExportType(str, Enum):
     """Model export type.
 
-    Examples:
+    Supported export formats for anomaly detection models.
+
+    Attributes:
+        ONNX: Export model to ONNX format
+        OPENVINO: Export model to OpenVINO IR format
+        TORCH: Export model to PyTorch format
+
+    Example:
         >>> from anomalib.deploy import ExportType
-        >>> ExportType.ONNX
+        >>> export_type = ExportType.ONNX
+        >>> export_type
         'onnx'
-        >>> ExportType.OPENVINO
-        'openvino'
-        >>> ExportType.TORCH
-        'torch'
     """
 
     ONNX = "onnx"
@@ -31,20 +54,22 @@ class CompressionType(str, Enum):
     """Model compression type when exporting to OpenVINO.
 
     Attributes:
-        FP16 (str): Weight compression (FP16). All weights are converted to FP16.
-        INT8 (str): Weight compression (INT8). All weights are quantized to INT8,
-            but are dequantized to floating point before inference.
-        INT8_PTQ (str): Full integer post-training quantization (INT8).
-            All weights and operations are quantized to INT8. Inference is done
-            in INT8 precision.
-        INT8_ACQ (str): Accuracy-control quantization (INT8). Weights and
+        FP16: Weight compression to FP16 precision. All weights are converted
+            to FP16.
+        INT8: Weight compression to INT8 precision. All weights are quantized
+            to INT8, but are dequantized to floating point before inference.
+        INT8_PTQ: Full integer post-training quantization to INT8 precision.
+            All weights and operations are quantized to INT8. Inference is
+            performed in INT8 precision.
+        INT8_ACQ: Accuracy-control quantization to INT8 precision. Weights and
             operations are quantized to INT8, except those that would degrade
-            quality of the model more than is acceptable. Inference is done in
-            a mixed precision.
+            model quality beyond an acceptable threshold. Inference uses mixed
+            precision.
 
-    Examples:
+    Example:
         >>> from anomalib.deploy import CompressionType
-        >>> CompressionType.INT8_PTQ
+        >>> compression = CompressionType.INT8_PTQ
+        >>> compression
         'int8_ptq'
     """
 
diff --git a/src/anomalib/deploy/inferencers/__init__.py b/src/anomalib/deploy/inferencers/__init__.py
index f47ece3425..00e73e0003 100644
--- a/src/anomalib/deploy/inferencers/__init__.py
+++ b/src/anomalib/deploy/inferencers/__init__.py
@@ -1,6 +1,19 @@
-"""Inferencers for Torch and OpenVINO."""
+"""Inferencers for performing inference with anomaly detection models.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides inferencer classes for running inference with trained models
+using different backends:
+
+- :class:`Inferencer`: Base class defining the inferencer interface
+- :class:`TorchInferencer`: For inference with PyTorch models
+- :class:`OpenVINOInferencer`: For optimized inference with OpenVINO
+
+Example:
+    >>> from anomalib.deploy import TorchInferencer
+    >>> model = TorchInferencer(path="path/to/model.pt")
+    >>> predictions = model.predict(image="path/to/image.jpg")
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .base_inferencer import Inferencer
diff --git a/src/anomalib/deploy/inferencers/base_inferencer.py b/src/anomalib/deploy/inferencers/base_inferencer.py
index b549b32a19..e53d8a487f 100644
--- a/src/anomalib/deploy/inferencers/base_inferencer.py
+++ b/src/anomalib/deploy/inferencers/base_inferencer.py
@@ -1,4 +1,11 @@
-"""Base Inferencer for Torch and OpenVINO."""
+"""Base Inferencer for Torch and OpenVINO.
+
+This module provides the base inferencer class that defines the interface for
+performing inference with anomaly detection models.
+
+The base class is used by both the PyTorch and OpenVINO inferencers to ensure
+a consistent API across different backends.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -20,49 +27,118 @@
 
 
 class Inferencer(ABC):
-    """Abstract class for the inference.
+    """Abstract base class for performing inference with anomaly detection models.
+
+    This class defines the interface that must be implemented by concrete
+    inferencer classes for different backends (PyTorch, OpenVINO).
 
-    This is used by both Torch and OpenVINO inference.
+    Example:
+        >>> from anomalib.deploy import TorchInferencer
+        >>> model = TorchInferencer(path="path/to/model.pt")
+        >>> predictions = model.predict(image="path/to/image.jpg")
     """
 
     @abstractmethod
     def load_model(self, path: str | Path) -> Any:  # noqa: ANN401
-        """Load Model."""
+        """Load a model from the specified path.
+
+        Args:
+            path (str | Path): Path to the model file.
+
+        Returns:
+            Any: Loaded model instance.
+
+        Raises:
+            NotImplementedError: This is an abstract method.
+        """
         raise NotImplementedError
 
     @abstractmethod
     def pre_process(self, image: np.ndarray) -> np.ndarray | torch.Tensor:
-        """Pre-process."""
+        """Pre-process an input image.
+
+        Args:
+            image (np.ndarray): Input image to pre-process.
+
+        Returns:
+            np.ndarray | torch.Tensor: Pre-processed image.
+
+        Raises:
+            NotImplementedError: This is an abstract method.
+        """
         raise NotImplementedError
 
     @abstractmethod
     def forward(self, image: np.ndarray | torch.Tensor) -> np.ndarray | torch.Tensor:
-        """Forward-Pass input to model."""
+        """Perform a forward pass on the model.
+
+        Args:
+            image (np.ndarray | torch.Tensor): Pre-processed input image.
+
+        Returns:
+            np.ndarray | torch.Tensor: Model predictions.
+
+        Raises:
+            NotImplementedError: This is an abstract method.
+        """
         raise NotImplementedError
 
     @abstractmethod
     def post_process(self, predictions: np.ndarray | torch.Tensor, metadata: dict[str, Any] | None) -> dict[str, Any]:
-        """Post-Process."""
+        """Post-process model predictions.
+
+        Args:
+            predictions (np.ndarray | torch.Tensor): Raw model predictions.
+            metadata (dict[str, Any] | None): Metadata used for post-processing.
+
+        Returns:
+            dict[str, Any]: Post-processed predictions.
+
+        Raises:
+            NotImplementedError: This is an abstract method.
+        """
         raise NotImplementedError
 
     @abstractmethod
     def predict(self, image: str | Path | np.ndarray | torch.Tensor) -> ImageResult:
-        """Predict."""
+        """Run inference on an image.
+
+        Args:
+            image (str | Path | np.ndarray | torch.Tensor): Input image.
+
+        Returns:
+            ImageResult: Prediction results.
+
+        Raises:
+            NotImplementedError: This is an abstract method.
+        """
         raise NotImplementedError
 
     @staticmethod
     def _superimpose_segmentation_mask(metadata: dict, anomaly_map: np.ndarray, image: np.ndarray) -> np.ndarray:
-        """Superimpose segmentation mask on top of image.
+        """Superimpose segmentation mask on an image.
 
         Args:
-            metadata (dict): Metadata of the image which contains the image size.
-            anomaly_map (np.ndarray): Anomaly map which is used to extract segmentation mask.
-            image (np.ndarray): Image on which segmentation mask is to be superimposed.
+            metadata (dict): Image metadata containing the image dimensions.
+            anomaly_map (np.ndarray): Anomaly map used to extract segmentation.
+            image (np.ndarray): Image on which to superimpose the mask.
 
         Returns:
-            np.ndarray: Image with segmentation mask superimposed.
+            np.ndarray: Image with superimposed segmentation mask.
+
+        Example:
+            >>> image = np.zeros((100, 100, 3))
+            >>> anomaly_map = np.zeros((100, 100))
+            >>> metadata = {"image_shape": (100, 100)}
+            >>> result = Inferencer._superimpose_segmentation_mask(
+            ...     metadata,
+            ...     anomaly_map,
+            ...     image,
+            ... )
+            >>> result.shape
+            (100, 100, 3)
         """
-        pred_mask = compute_mask(anomaly_map, 0.5)  # assumes predictions are normalized.
+        pred_mask = compute_mask(anomaly_map, 0.5)  # assumes normalized preds
         image_height = metadata["image_shape"][0]
         image_width = metadata["image_shape"][1]
         pred_mask = cv2.resize(pred_mask, (image_width, image_height))
@@ -72,13 +148,18 @@ def _superimpose_segmentation_mask(metadata: dict, anomaly_map: np.ndarray, imag
         return image
 
     def __call__(self, image: np.ndarray) -> ImageResult:
-        """Call predict on the Image.
+        """Call predict on an image.
 
         Args:
-            image (np.ndarray): Input Image
+            image (np.ndarray): Input image.
 
         Returns:
             ImageResult: Prediction results to be visualized.
+
+        Example:
+            >>> model = Inferencer()  # doctest: +SKIP
+            >>> image = np.zeros((100, 100, 3))
+            >>> predictions = model(image)  # doctest: +SKIP
         """
         return self.predict(image)
 
@@ -88,17 +169,29 @@ def _normalize(
         metadata: dict | DictConfig,
         anomaly_maps: torch.Tensor | np.ndarray | None = None,
     ) -> tuple[np.ndarray | torch.Tensor | None, float]:
-        """Apply normalization and resizes the image.
+        """Normalize predictions using min-max normalization.
 
         Args:
-            pred_scores (Tensor | np.float32): Predicted anomaly score
-            metadata (dict | DictConfig): Meta data. Post-processing step sometimes requires
-                additional meta data such as image shape. This variable comprises such info.
-            anomaly_maps (Tensor | np.ndarray | None): Predicted raw anomaly map.
+            pred_scores (torch.Tensor | np.float32): Predicted anomaly scores.
+            metadata (dict | DictConfig): Metadata containing normalization
+                parameters.
+            anomaly_maps (torch.Tensor | np.ndarray | None): Raw anomaly maps.
+                Defaults to None.
 
         Returns:
-            tuple[np.ndarray | torch.Tensor | None, float]: Post processed predictions that are ready to be
-                visualized and predicted scores.
+            tuple[np.ndarray | torch.Tensor | None, float]: Normalized predictions
+                and scores.
+
+        Example:
+            >>> scores = torch.tensor(0.5)
+            >>> metadata = {
+            ...     "image_threshold": 0.5,
+            ...     "pred_scores.min": 0.0,
+            ...     "pred_scores.max": 1.0
+            ... }
+            >>> maps, norm_scores = Inferencer._normalize(scores, metadata)
+            >>> norm_scores
+            0.5
         """
         # min max normalization
         if "pred_scores.min" in metadata and "pred_scores.max" in metadata:
@@ -118,15 +211,21 @@ def _normalize(
 
         return anomaly_maps, float(pred_scores)
 
-    def _load_metadata(self, path: str | Path | dict | None = None) -> dict | DictConfig:  # noqa: PLR6301
-        """Load the meta data from the given path.
+    @staticmethod
+    def _load_metadata(path: str | Path | dict | None = None) -> dict | DictConfig:
+        """Load metadata from a file.
 
         Args:
-            path (str | Path | dict | None, optional): Path to JSON file containing the metadata.
-                If no path is provided, it returns an empty dict. Defaults to None.
+            path (str | Path | dict | None): Path to metadata file. If None,
+                returns empty dict. Defaults to None.
 
         Returns:
-            dict | DictConfig: Dictionary containing the metadata.
+            dict | DictConfig: Loaded metadata.
+
+        Example:
+            >>> model = Inferencer()  # doctest: +SKIP
+            >>> metadata = model._load_metadata("path/to/metadata.json")
+            ... # doctest: +SKIP
         """
         metadata: dict[str, float | np.ndarray | torch.Tensor] | DictConfig = {}
         if path is not None:
diff --git a/src/anomalib/deploy/inferencers/openvino_inferencer.py b/src/anomalib/deploy/inferencers/openvino_inferencer.py
index 61b4a3d0ee..07afc52535 100644
--- a/src/anomalib/deploy/inferencers/openvino_inferencer.py
+++ b/src/anomalib/deploy/inferencers/openvino_inferencer.py
@@ -1,4 +1,50 @@
-"""OpenVINO Inferencer implementation."""
+"""OpenVINO Inferencer for optimized model inference.
+
+This module provides the OpenVINO inferencer implementation for running optimized
+inference with OpenVINO IR models.
+
+Example:
+    Assume we have OpenVINO IR model files in the following structure:
+
+    .. code-block:: bash
+
+        $ tree weights
+        ./weights
+        ├── model.bin
+        ├── model.xml
+        └── metadata.json
+
+    Create an OpenVINO inferencer:
+
+    >>> from anomalib.deploy import OpenVINOInferencer
+    >>> inferencer = OpenVINOInferencer(
+    ...     path="weights/model.xml",
+    ...     device="CPU"
+    ... )
+
+    Make predictions:
+
+    >>> # From image path
+    >>> prediction = inferencer.predict("path/to/image.jpg")
+
+    >>> # From PIL Image
+    >>> from PIL import Image
+    >>> image = Image.open("path/to/image.jpg")
+    >>> prediction = inferencer.predict(image)
+
+    >>> # From numpy array
+    >>> import numpy as np
+    >>> image = np.random.rand(224, 224, 3)
+    >>> prediction = inferencer.predict(image)
+
+    The prediction result contains anomaly maps and scores:
+
+    >>> prediction.anomaly_map  # doctest: +SKIP
+    array([[0.1, 0.2, ...]], dtype=float32)
+
+    >>> prediction.pred_score  # doctest: +SKIP
+    0.86
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -18,67 +64,25 @@
 
 
 class OpenVINOInferencer:
-    """OpenVINO implementation for the inference.
+    """OpenVINO inferencer for optimized model inference.
 
     Args:
-        path (str | Path): Path to the openvino onnx, xml or bin file.
-        metadata (str | Path | dict, optional): Path to metadata file or a dict object defining the
-            metadata.
-            Defaults to ``None``.
-        device (str | None, optional): Device to run the inference on (AUTO, CPU, GPU, NPU).
-            Defaults to ``AUTO``.
-        task (TaskType | None, optional): Task type.
-            Defaults to ``None``.
-        config (dict | None, optional): Configuration parameters for the inference
+        path (str | Path | tuple[bytes, bytes]): Path to OpenVINO IR files
+            (``.xml`` and ``.bin``) or ONNX model, or tuple of xml/bin data as
+            bytes.
+        device (str | None, optional): Inference device.
+            Options: ``"AUTO"``, ``"CPU"``, ``"GPU"``, ``"NPU"``.
+            Defaults to ``"AUTO"``.
+        config (dict | None, optional): OpenVINO configuration parameters.
             Defaults to ``None``.
 
-    Examples:
-        Assume that we have an OpenVINO IR model and metadata files in the following structure:
-
-        .. code-block:: bash
-
-            $ tree weights
-            ./weights
-            ├── model.bin
-            ├── model.xml
-            └── metadata.json
-
-        We could then create ``OpenVINOInferencer`` as follows:
-
-        >>> from anomalib.deploy.inferencers import OpenVINOInferencer
-        >>> inferencer = OpenVINOInferencer(
-        ...     path="weights/model.xml",
-        ...     metadata="weights/metadata.json",
-        ...     device="CPU",
+    Example:
+        >>> from anomalib.deploy import OpenVINOInferencer
+        >>> model = OpenVINOInferencer(
+        ...     path="model.xml",
+        ...     device="CPU"
         ... )
-
-        This will ensure that the model is loaded on the ``CPU`` device and the
-        metadata is loaded from the ``metadata.json`` file. To make a prediction,
-        we can simply call the ``predict`` method:
-
-        >>> prediction = inferencer.predict(image="path/to/image.jpg")
-
-        Alternatively we can also pass the image as a PIL image or numpy array:
-
-        >>> from PIL import Image
-        >>> image = Image.open("path/to/image.jpg")
-        >>> prediction = inferencer.predict(image=image)
-
-        >>> import numpy as np
-        >>> image = np.random.rand(224, 224, 3)
-        >>> prediction = inferencer.predict(image=image)
-
-        ``prediction`` will be an ``ImageResult`` object containing the prediction
-        results. For example, to visualize the heatmap, we can do the following:
-
-        >>> from matplotlib import pyplot as plt
-        >>> plt.imshow(result.heatmap)
-
-        It is also possible to visualize the true and predicted masks if the
-        task is ``TaskType.SEGMENTATION``:
-
-        >>> plt.imshow(result.gt_mask)
-        >>> plt.imshow(result.pred_mask)
+        >>> prediction = model.predict("test.jpg")
     """
 
     def __init__(
@@ -92,20 +96,24 @@ def __init__(
             raise ImportError(msg)
 
         self.device = device
-
         self.config = config
         self.input_blob, self.output_blob, self.model = self.load_model(path)
 
     def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any, Any]:
-        """Load the OpenVINO model.
+        """Load OpenVINO model from file or bytes.
 
         Args:
-            path (str | Path | tuple[bytes, bytes]): Path to the onnx or xml and bin files
-                                                        or tuple of .xml and .bin data as bytes.
+            path (str | Path | tuple[bytes, bytes]): Path to model files or model
+                data as bytes tuple.
 
         Returns:
-            [tuple[str, str, ExecutableNetwork]]: Input and Output blob names
-                together with the Executable network.
+            tuple[Any, Any, Any]: Tuple containing:
+                - Input blob
+                - Output blob
+                - Compiled model
+
+        Raises:
+            ValueError: If model path has invalid extension.
         """
         import openvino as ov
 
@@ -131,7 +139,11 @@ def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any,
         cache_folder.mkdir(exist_ok=True)
         core.set_property({"CACHE_DIR": cache_folder})
 
-        compile_model = core.compile_model(model=model, device_name=self.device, config=self.config)
+        compile_model = core.compile_model(
+            model=model,
+            device_name=self.device,
+            config=self.config,
+        )
 
         input_blob = compile_model.input(0)
         output_blob = compile_model.output(0)
@@ -140,13 +152,13 @@ def load_model(self, path: str | Path | tuple[bytes, bytes]) -> tuple[Any, Any,
 
     @staticmethod
     def pre_process(image: np.ndarray) -> np.ndarray:
-        """Pre-process the input image by applying transformations.
+        """Pre-process input image.
 
         Args:
             image (np.ndarray): Input image.
 
         Returns:
-            np.ndarray: pre-processed image.
+            np.ndarray: Pre-processed image with shape (N,C,H,W).
         """
         # Normalize numpy array to range [0, 1]
         if image.dtype != np.float32:
@@ -164,27 +176,29 @@ def pre_process(image: np.ndarray) -> np.ndarray:
 
     @staticmethod
     def post_process(predictions: OVDict) -> dict:
-        """Convert OpenVINO output dictionary to NumpyBatch."""
+        """Convert OpenVINO predictions to dictionary.
+
+        Args:
+            predictions (OVDict): Raw predictions from OpenVINO model.
+
+        Returns:
+            dict: Dictionary of prediction tensors.
+        """
         names = [next(iter(name)) for name in predictions.names()]
         values = predictions.to_tuple()
         return dict(zip(names, values, strict=False))
 
-    def predict(
-        self,
-        image: str | Path | np.ndarray,
-    ) -> NumpyImageBatch:
-        """Perform a prediction for a given input image.
-
-        The main workflow is (i) pre-processing, (ii) forward-pass, (iii) post-process.
+    def predict(self, image: str | Path | np.ndarray) -> NumpyImageBatch:
+        """Run inference on an input image.
 
         Args:
-            image (Union[str, np.ndarray]): Input image whose output is to be predicted.
-                It could be either a path to image or numpy array itself.
-
-            metadata: Metadata information such as shape, threshold.
+            image (str | Path | np.ndarray): Input image as file path or array.
 
         Returns:
-            ImageResult: Prediction results to be visualized.
+            NumpyImageBatch: Batch containing the predictions.
+
+        Raises:
+            TypeError: If image input is invalid type.
         """
         # Convert file path or string to image if necessary
         if isinstance(image, str | Path):
diff --git a/src/anomalib/deploy/inferencers/torch_inferencer.py b/src/anomalib/deploy/inferencers/torch_inferencer.py
index ed4283ad82..a8ef5c0c8f 100644
--- a/src/anomalib/deploy/inferencers/torch_inferencer.py
+++ b/src/anomalib/deploy/inferencers/torch_inferencer.py
@@ -1,4 +1,37 @@
-"""Torch inference implementations."""
+"""PyTorch inferencer for running inference with trained anomaly detection models.
+
+This module provides the PyTorch inferencer implementation for running inference
+with trained PyTorch models.
+
+Example:
+    Assume we have a PyTorch model saved as a ``.pt`` file:
+
+    >>> from anomalib.deploy import TorchInferencer
+    >>> model = TorchInferencer(path="path/to/model.pt", device="cpu")
+
+    Make predictions:
+
+    >>> # From image path
+    >>> prediction = model.predict("path/to/image.jpg")
+
+    >>> # From PIL Image
+    >>> from PIL import Image
+    >>> image = Image.open("path/to/image.jpg")
+    >>> prediction = model.predict(image)
+
+    >>> # From torch tensor
+    >>> import torch
+    >>> image = torch.rand(3, 224, 224)
+    >>> prediction = model.predict(image)
+
+    The prediction result contains anomaly maps and scores:
+
+    >>> prediction.anomaly_map  # doctest: +SKIP
+    tensor([[0.1, 0.2, ...]])
+
+    >>> prediction.pred_score  # doctest: +SKIP
+    tensor(0.86)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,39 +46,23 @@
 
 
 class TorchInferencer:
-    """PyTorch implementation for the inference.
+    """PyTorch inferencer for anomaly detection models.
 
     Args:
-        path (str | Path): Path to Torch model weights.
-        device (str): Device to use for inference. Options are ``auto``,
-            ``cpu``, ``cuda``.
-            Defaults to ``auto``.
-
-    Examples:
-        Assume that we have a Torch ``pt`` model and metadata files in the
-        following structure:
-
-        >>> from anomalib.deploy.inferencers import TorchInferencer
-        >>> inferencer = TorchInferencer(path="path/to/torch/model.pt", device="cpu")
-
-        This will ensure that the model is loaded on the ``CPU`` device. To make
-        a prediction, we can simply call the ``predict`` method:
-
-        >>> from anomalib.data.utils import read_image
-        >>> image = read_image("path/to/image.jpg")
-        >>> result = inferencer.predict(image)
-
-        ``result`` will be an ``PredictBatch`` object containing the prediction
-        results. For example, to visualize the heatmap, we can do the following:
-
-        >>> from matplotlib import pyplot as plt
-        >>> plt.imshow(result.heatmap)
-
-        It is also possible to visualize the true and predicted masks if the
-        task is ``TaskType.SEGMENTATION``:
-
-        >>> plt.imshow(result.gt_mask)
-        >>> plt.imshow(result.pred_mask)
+        path (str | Path): Path to the PyTorch model weights file.
+        device (str, optional): Device to use for inference.
+            Options are ``"auto"``, ``"cpu"``, ``"cuda"``, ``"gpu"``.
+            Defaults to ``"auto"``.
+
+    Example:
+        >>> from anomalib.deploy import TorchInferencer
+        >>> model = TorchInferencer(path="path/to/model.pt")
+        >>> predictions = model.predict(image="path/to/image.jpg")
+
+    Raises:
+        ValueError: If an invalid device is specified.
+        ValueError: If the model file has an unknown extension.
+        KeyError: If the checkpoint file does not contain a model.
     """
 
     def __init__(
@@ -63,10 +80,19 @@ def _get_device(device: str) -> torch.device:
         """Get the device to use for inference.
 
         Args:
-            device (str): Device to use for inference. Options are auto, cpu, cuda.
+            device (str): Device to use for inference.
+                Options are ``"auto"``, ``"cpu"``, ``"cuda"``, ``"gpu"``.
 
         Returns:
-            torch.device: Device to use for inference.
+            torch.device: PyTorch device object.
+
+        Raises:
+            ValueError: If an invalid device is specified.
+
+        Example:
+            >>> model = TorchInferencer(path="path/to/model.pt", device="cpu")
+            >>> model.device
+            device(type='cpu')
         """
         if device not in {"auto", "cpu", "cuda", "gpu"}:
             msg = f"Unknown device {device}"
@@ -79,19 +105,28 @@ def _get_device(device: str) -> torch.device:
         return torch.device(device)
 
     def _load_checkpoint(self, path: str | Path) -> dict:
-        """Load the checkpoint.
+        """Load the model checkpoint.
 
         Args:
-            path (str | Path): Path to the torch ckpt file.
+            path (str | Path): Path to the PyTorch checkpoint file.
 
         Returns:
             dict: Dictionary containing the model and metadata.
+
+        Raises:
+            ValueError: If the model file has an unknown extension.
+
+        Example:
+            >>> model = TorchInferencer(path="path/to/model.pt")
+            >>> checkpoint = model._load_checkpoint("path/to/model.pt")
+            >>> isinstance(checkpoint, dict)
+            True
         """
         if isinstance(path, str):
             path = Path(path)
 
         if path.suffix not in {".pt", ".pth"}:
-            msg = f"Unknown torch checkpoint file format {path.suffix}. Make sure you save the Torch model."
+            msg = f"Unknown PyTorch checkpoint format {path.suffix}. Make sure you save the PyTorch model."
             raise ValueError(msg)
 
         return torch.load(path, map_location=self.device)
@@ -100,32 +135,43 @@ def load_model(self, path: str | Path) -> nn.Module:
         """Load the PyTorch model.
 
         Args:
-            path (str | Path): Path to the Torch model.
+            path (str | Path): Path to the PyTorch model file.
 
         Returns:
-            (nn.Module): Torch model.
+            nn.Module: Loaded PyTorch model in evaluation mode.
+
+        Raises:
+            KeyError: If the checkpoint file does not contain a model.
+
+        Example:
+            >>> model = TorchInferencer(path="path/to/model.pt")
+            >>> isinstance(model.model, nn.Module)
+            True
         """
         checkpoint = self._load_checkpoint(path)
         if "model" not in checkpoint:
-            msg = "``model`` is not found in the checkpoint. Please check the checkpoint file."
+            msg = "``model`` not found in checkpoint. Please check the checkpoint file."
             raise KeyError(msg)
 
         model = checkpoint["model"]
         model.eval()
         return model.to(self.device)
 
-    def predict(
-        self,
-        image: str | Path | torch.Tensor,
-    ) -> ImageBatch:
-        """Perform a prediction for a given input image.
+    def predict(self, image: str | Path | torch.Tensor) -> ImageBatch:
+        """Predict anomalies for an input image.
 
         Args:
-            image (Union[str, np.ndarray]): Input image whose output is to be predicted.
-                It could be either a path to image or the tensor itself.
+            image (str | Path | torch.Tensor): Input image to predict.
+                Can be a file path or PyTorch tensor.
 
         Returns:
-            ImageResult: Prediction results to be visualized.
+            ImageBatch: Prediction results containing anomaly maps and scores.
+
+        Example:
+            >>> model = TorchInferencer(path="path/to/model.pt")
+            >>> predictions = model.predict("path/to/image.jpg")
+            >>> predictions.anomaly_map.shape  # doctest: +SKIP
+            torch.Size([1, 256, 256])
         """
         if isinstance(image, str | Path):
             image = read_image(image, as_tensor=True)
@@ -139,13 +185,20 @@ def predict(
         )
 
     def pre_process(self, image: torch.Tensor) -> torch.Tensor:
-        """Pre process the input image.
+        """Pre-process the input image.
 
         Args:
-            image (torch.Tensor): Input image
+            image (torch.Tensor): Input image tensor.
 
         Returns:
-            Tensor: pre-processed image.
+            torch.Tensor: Pre-processed image tensor.
+
+        Example:
+            >>> model = TorchInferencer(path="path/to/model.pt")
+            >>> image = torch.rand(3, 224, 224)
+            >>> processed = model.pre_process(image)
+            >>> processed.shape
+            torch.Size([1, 3, 224, 224])
         """
         if image.dim() == 3:
             image = image.unsqueeze(0)  # model expects [B, C, H, W]
diff --git a/src/anomalib/engine/__init__.py b/src/anomalib/engine/__init__.py
index 3bb239f5a5..e887d4f7bb 100644
--- a/src/anomalib/engine/__init__.py
+++ b/src/anomalib/engine/__init__.py
@@ -1,4 +1,27 @@
-"""Anomalib engine."""
+"""Engine module for training and evaluating anomaly detection models.
+
+This module provides functionality for training and evaluating anomaly detection
+models. The main component is the :class:`Engine` class which handles:
+
+- Model training and validation
+- Metrics computation and logging
+- Checkpointing and model export
+- Distributed training support
+
+Example:
+    Create and use an engine:
+
+    >>> from anomalib.engine import Engine
+    >>> engine = Engine()
+    >>> engine.train()  # doctest: +SKIP
+    >>> engine.test()  # doctest: +SKIP
+
+    The engine can also be used with a custom configuration:
+
+    >>> from anomalib.config import Config
+    >>> config = Config(path="config.yaml")
+    >>> engine = Engine(config=config)  # doctest: +SKIP
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/engine/engine.py b/src/anomalib/engine/engine.py
index a548dd23e4..ac577ad37a 100644
--- a/src/anomalib/engine/engine.py
+++ b/src/anomalib/engine/engine.py
@@ -1,4 +1,29 @@
-"""Implements custom trainer for Anomalib."""
+"""Implements custom trainer for Anomalib.
+
+This module provides the core training engine for Anomalib models. The Engine class
+wraps PyTorch Lightning's Trainer with additional functionality specific to anomaly
+detection tasks.
+
+The engine handles:
+- Model training and validation
+- Metrics computation and logging
+- Checkpointing and model export
+- Distributed training support
+
+Example:
+    Create and use an engine:
+
+    >>> from anomalib.engine import Engine
+    >>> engine = Engine()
+    >>> engine.train()  # doctest: +SKIP
+    >>> engine.test()  # doctest: +SKIP
+
+    The engine can also be used with a custom configuration:
+
+    >>> from anomalib.config import Config
+    >>> config = Config(path="config.yaml")
+    >>> engine = Engine(config=config)  # doctest: +SKIP
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -27,28 +52,33 @@
 
 
 class UnassignedError(Exception):
-    """Unassigned error."""
+    """Raised when a required component is not assigned."""
 
 
 class _TrainerArgumentsCache:
-    """Cache arguments.
+    """Cache arguments for PyTorch Lightning Trainer.
 
-    Since the Engine class accepts PyTorch Lightning Trainer arguments, we store these arguments using this class
-    before the trainer is instantiated.
+    Since the Engine class accepts PyTorch Lightning Trainer arguments, we store
+    these arguments using this class before the trainer is instantiated.
 
     Args:
-        (**kwargs): Trainer arguments that are cached
+        **kwargs: Trainer arguments that are cached.
 
     Example:
+        >>> from omegaconf import OmegaConf
         >>> conf = OmegaConf.load("config.yaml")
-        >>> cache =  _TrainerArgumentsCache(**conf.trainer)
+        >>> cache = _TrainerArgumentsCache(**conf.trainer)
         >>> cache.args
         {
             ...
             'max_epochs': 100,
             'val_check_interval': 0
         }
-        >>> model = Padim(layers=["layer1", "layer2", "layer3"], input_size=(256, 256), backbone="resnet18")
+        >>> model = Padim(
+        ...     layers=["layer1", "layer2", "layer3"],
+        ...     input_size=(256, 256),
+        ...     backbone="resnet18",
+        ... )
         >>> cache.update(model)
         Overriding max_epochs from 100 with 1 for Padim
         Overriding val_check_interval from 0 with 1.0 for Padim
@@ -64,10 +94,10 @@ def __init__(self, **kwargs) -> None:
         self._cached_args = {**kwargs}
 
     def update(self, model: AnomalibModule) -> None:
-        """Replace cached arguments with arguments retrieved from the model.
+        """Replace cached arguments with arguments from the model.
 
         Args:
-            model (AnomalibModule): The model used for training
+            model (AnomalibModule): The model used for training.
         """
         for key, value in model.trainer_arguments.items():
             if key in self._cached_args and self._cached_args[key] != value:
@@ -77,35 +107,52 @@ def update(self, model: AnomalibModule) -> None:
             self._cached_args[key] = value
 
     def requires_update(self, model: AnomalibModule) -> bool:
+        """Check if the cache needs to be updated.
+
+        Args:
+            model (AnomalibModule): Model to check against.
+
+        Returns:
+            bool: True if cache needs update, False otherwise.
+        """
         return any(self._cached_args.get(key, None) != value for key, value in model.trainer_arguments.items())
 
     @property
     def args(self) -> dict[str, Any]:
+        """Get the cached arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary of cached trainer arguments.
+        """
         return self._cached_args
 
 
 class Engine:
-    """Anomalib Engine.
-
-    .. note::
+    """Anomalib Engine for training and evaluating anomaly detection models.
 
-        Refer to PyTorch Lightning's Trainer for a list of parameters for
-        details on other Trainer parameters.
+    The Engine class wraps PyTorch Lightning's Trainer with additional
+    functionality specific to anomaly detection tasks.
 
     Args:
-        callbacks (list[Callback]): Add a callback or list of callbacks.
-        normalization (NORMALIZATION, optional): Normalization method.
-            Defaults to NormalizationMethod.MIN_MAX.
-        threshold (THRESHOLD):
-            Thresholding method. Defaults to "F1AdaptiveThreshold".
-        image_metrics (list[str] | str | dict[str, dict[str, Any]] | None, optional): Image metrics to be used for
-            evaluation. Defaults to None.
-        pixel_metrics (list[str] | str | dict[str, dict[str, Any]] | None, optional): Pixel metrics to be used for
-            evaluation. Defaults to None.
-        default_root_dir (str, optional): Default root directory for the trainer.
-            The results will be saved in this directory.
-            Defaults to ``results``.
-        **kwargs: PyTorch Lightning Trainer arguments.
+        callbacks (list[Callback] | None, optional): Add a callback or list of
+            callbacks. Defaults to None.
+        logger (Logger | Iterable[Logger] | bool | None, optional): Logger (or
+            iterable collection of loggers) to use. Defaults to None.
+        default_root_dir (str | Path, optional): Default path for saving trainer
+            outputs. Defaults to "results".
+        **kwargs: Additional arguments passed to PyTorch Lightning Trainer.
+
+    Example:
+        >>> from anomalib.engine import Engine
+        >>> engine = Engine()
+        >>> engine.train()  # doctest: +SKIP
+        >>> engine.test()  # doctest: +SKIP
+
+        With custom configuration:
+
+        >>> from anomalib.config import Config
+        >>> config = Config(path="config.yaml")
+        >>> engine = Engine(config=config)  # doctest: +SKIP
     """
 
     def __init__(
diff --git a/src/anomalib/loggers/__init__.py b/src/anomalib/loggers/__init__.py
index 8c47306ddc..953a5974ca 100644
--- a/src/anomalib/loggers/__init__.py
+++ b/src/anomalib/loggers/__init__.py
@@ -1,4 +1,26 @@
-"""Load PyTorch Lightning Loggers."""
+"""Logging configuration and PyTorch Lightning logger integrations.
+
+This module provides logging utilities and integrations with various logging frameworks
+for use with anomaly detection models. The main components are:
+
+- Console logging configuration via ``configure_logger()``
+- Integration with logging frameworks:
+    - Comet ML via :class:`AnomalibCometLogger`
+    - MLflow via :class:`AnomalibMLFlowLogger`
+    - TensorBoard via :class:`AnomalibTensorBoardLogger`
+    - Weights & Biases via :class:`AnomalibWandbLogger`
+
+Example:
+    Configure console logging:
+
+    >>> from anomalib.loggers import configure_logger
+    >>> configure_logger(level="INFO")
+
+    Use a specific logger:
+
+    >>> from anomalib.loggers import AnomalibTensorBoardLogger
+    >>> logger = AnomalibTensorBoardLogger(log_dir="logs")
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -7,10 +29,7 @@
 
 from rich.logging import RichHandler
 
-__all__ = [
-    "configure_logger",
-    "get_experiment_logger",
-]
+__all__ = ["configure_logger"]
 
 try:
     from .comet import AnomalibCometLogger  # noqa: F401
@@ -31,13 +50,23 @@
 
 
 def configure_logger(level: int | str = logging.INFO) -> None:
-    """Get console logger by name.
+    """Configure console logging with consistent formatting.
+
+    This function sets up console logging with a standardized format and rich
+    tracebacks. It configures both the root logger and PyTorch Lightning logger
+    to use the same formatting.
 
     Args:
-        level (int | str, optional): Logger Level. Defaults to logging.INFO.
+        level (int | str): Logging level to use. Can be either a string name like
+            ``"INFO"`` or an integer constant like ``logging.INFO``. Defaults to
+            ``logging.INFO``.
 
-    Returns:
-        Logger: The expected logger.
+    Example:
+        >>> from anomalib.loggers import configure_logger
+        >>> configure_logger(level="DEBUG")  # doctest: +SKIP
+        >>> logger = logging.getLogger("my_logger")
+        >>> logger.info("Test message")  # doctest: +SKIP
+        2024-01-01 12:00:00 - my_logger - INFO - Test message
     """
     if isinstance(level, str):
         level = logging.getLevelName(level)
diff --git a/src/anomalib/loggers/base.py b/src/anomalib/loggers/base.py
index 485ae07f49..7ced9afced 100644
--- a/src/anomalib/loggers/base.py
+++ b/src/anomalib/loggers/base.py
@@ -1,4 +1,21 @@
-"""Base logger for image logging consistency across all loggers used in anomalib."""
+"""Base logger for image logging consistency across all loggers used in anomalib.
+
+This module provides a base class that defines a common interface for logging images
+across different logging backends used in anomalib.
+
+Example:
+    Create a custom image logger:
+
+    >>> class CustomImageLogger(ImageLoggerBase):
+    ...     def add_image(self, image, name=None):
+    ...         # Custom implementation
+    ...         pass
+
+    Use the logger:
+
+    >>> logger = CustomImageLogger()
+    >>> logger.add_image(image_array, name="test_image")  # doctest: +SKIP
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,9 +27,28 @@
 
 
 class ImageLoggerBase:
-    """Adds a common interface for logging the images."""
+    """Base class that provides a common interface for logging images.
+
+    This abstract base class ensures consistent image logging functionality across
+    different logger implementations in anomalib.
+
+    All custom image loggers should inherit from this class and implement the
+    ``add_image`` method.
+    """
 
     @abstractmethod
     def add_image(self, image: np.ndarray | Figure, name: str | None = None, **kwargs) -> None:
-        """Interface to log images in the respective loggers."""
+        """Log an image using the respective logger implementation.
+
+        Args:
+            image: Image to be logged, can be either a numpy array or matplotlib
+                Figure
+            name: Name/title of the image. Defaults to ``None``
+            **kwargs: Additional keyword arguments passed to the specific logger
+                implementation
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be
+                implemented by subclasses
+        """
         raise NotImplementedError
diff --git a/src/anomalib/loggers/comet.py b/src/anomalib/loggers/comet.py
index d946d9036f..4ca51ea101 100644
--- a/src/anomalib/loggers/comet.py
+++ b/src/anomalib/loggers/comet.py
@@ -1,4 +1,24 @@
-"""comet logger with add image interface."""
+"""Comet logger with image logging capabilities.
+
+This module provides a Comet logger implementation that adds an interface for
+logging images. It extends both the base image logger and PyTorch Lightning's
+Comet logger.
+
+Example:
+    >>> from anomalib.loggers import AnomalibCometLogger
+    >>> from anomalib.engine import Engine
+    >>> comet_logger = AnomalibCometLogger()  # doctest: +SKIP
+    >>> engine = Engine(logger=comet_logger)  # doctest: +SKIP
+
+    Log an image:
+    >>> import numpy as np
+    >>> image = np.random.rand(32, 32, 3)  # doctest: +SKIP
+    >>> comet_logger.add_image(
+    ...     image=image,
+    ...     name="test_image",
+    ...     global_step=0
+    ... )  # doctest: +SKIP
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,75 +36,52 @@
 
 
 class AnomalibCometLogger(ImageLoggerBase, CometLogger):
-    """Logger for comet.
+    """Logger for Comet ML with image logging capabilities.
 
-    Adds interface for ``add_image`` in the logger rather than calling the
-    experiment object.
-
-    .. note::
-        Same as the CometLogger provided by PyTorch Lightning and the doc string
-        is reproduced below.
-
-    Track your parameters, metrics, source code and more using
-    `Comet `_.
-
-    Install it with pip:
-
-    .. code-block:: bash
-
-        pip install comet-ml
-
-    Comet requires either an API Key (online mode) or a local directory path
-    (offline mode).
+    This logger extends PyTorch Lightning's CometLogger with an interface for
+    logging images. It inherits from both :class:`ImageLoggerBase` and
+    :class:`CometLogger`.
 
     Args:
-        api_key: Required in online mode. API key, found on Comet.ml. If not
-            given, this will be loaded from the environment variable
-            COMET_API_KEY or ~/.comet.config if either exists.
-            Defaults to ``None``.
-        save_dir: Required in offline mode. The path for the directory to save
-            local comet logs. If given, this also sets the directory for saving
-            checkpoints.
+        api_key: API key found on Comet.ml. If not provided, will be loaded from
+            ``COMET_API_KEY`` environment variable or ``~/.comet.config``.
+            Required for online mode.
             Defaults to ``None``.
-        project_name: Optional. Send your experiment to a specific project.
-            Otherwise will be sent to Uncategorized Experiments.
-            If the project name does not already exist, Comet.ml will create a
-            new project.
+        save_dir: Directory path to save local comet logs. Required for offline
+            mode. Also sets checkpoint directory if provided.
             Defaults to ``None``.
-        rest_api_key: Optional. Rest API key found in Comet.ml settings.
-            This is used to determine version number
+        project_name: Project name for the experiment. Creates new project if
+            doesn't exist.
             Defaults to ``None``.
-        experiment_name: Optional. String representing the name for this
-            particular experiment on Comet.ml.
+        rest_api_key: Rest API key from Comet.ml settings. Used for version
+            tracking.
             Defaults to ``None``.
-        experiment_key: Optional. If set, restores from existing experiment.
+        experiment_name: Name for this experiment on Comet.ml.
             Defaults to ``None``.
-        offline: If api_key and save_dir are both given, this determines whether
-            the experiment will be in online or offline mode. This is useful if
-            you use save_dir to control the checkpoints directory and have a
-            ~/.comet.config file but still want to run offline experiments.
+        experiment_key: Key to restore existing experiment.
             Defaults to ``None``.
-        prefix: A string to put at the beginning of metric keys.
+        offline: Force offline mode even with API key. Useful when using
+            ``save_dir`` for checkpoints with ``~/.comet.config``.
+            Defaults to ``False``.
+        prefix: String to prepend to metric keys.
             Defaults to ``""``.
-        kwargs: Additional arguments like `workspace`, `log_code`, etc. used by
-            :class:`CometExperiment` can be passed as keyword arguments in this
-            logger.
+        **kwargs: Additional arguments passed to :class:`CometExperiment`
+            (e.g. ``workspace``, ``log_code``).
 
     Raises:
-        ModuleNotFoundError:
-            If required Comet package is not installed on the device.
-        MisconfigurationException:
-            If neither ``api_key`` nor ``save_dir`` are passed as arguments.
+        ModuleNotFoundError: If ``comet-ml`` package is not installed.
+        MisconfigurationException: If neither ``api_key`` nor ``save_dir``
+            provided.
 
     Example:
         >>> from anomalib.loggers import AnomalibCometLogger
-        >>> from anomalib.engine import Engine
-        ...
-        >>> comet_logger = AnomalibCometLogger()
-        >>> engine =  Engine(logger=comet_logger)
+        >>> comet_logger = AnomalibCometLogger(
+        ...     project_name="anomaly_detection"
+        ... )  # doctest: +SKIP
 
-    See Also:
-        - `Comet Documentation `__
+    Note:
+        For more details, see the `Comet Documentation
+        `_
     """
 
     def __init__(
@@ -114,13 +111,36 @@ def __init__(
 
     @rank_zero_only
     def add_image(self, image: np.ndarray | Figure, name: str | None = None, **kwargs) -> None:
-        """Interface to add image to comet logger.
+        """Log an image to Comet.
 
         Args:
-            image (np.ndarray | Figure): Image to log.
-            name (str | None): The tag of the image
+            image: Image to log, either numpy array or matplotlib figure.
+            name: Name/tag for the image.
                 Defaults to ``None``.
-            kwargs: Accepts only `global_step` (int). The step at which to log the image.
+            **kwargs: Must contain ``global_step`` (int) indicating the step at
+                which to log the image.
+
+        Raises:
+            ValueError: If ``global_step`` not provided in kwargs.
+
+        Example:
+            >>> import numpy as np
+            >>> from matplotlib.figure import Figure
+            >>> logger = AnomalibCometLogger()  # doctest: +SKIP
+            >>> # Log numpy array
+            >>> image_array = np.random.rand(32, 32, 3)  # doctest: +SKIP
+            >>> logger.add_image(
+            ...     image=image_array,
+            ...     name="test_image",
+            ...     global_step=0
+            ... )  # doctest: +SKIP
+            >>> # Log matplotlib figure
+            >>> fig = Figure()  # doctest: +SKIP
+            >>> logger.add_image(
+            ...     image=fig,
+            ...     name="test_figure",
+            ...     global_step=1
+            ... )  # doctest: +SKIP
         """
         if "global_step" not in kwargs:
             msg = "`global_step` is required for comet logger"
diff --git a/src/anomalib/loggers/mlflow.py b/src/anomalib/loggers/mlflow.py
index f6ec089586..7b647b3108 100644
--- a/src/anomalib/loggers/mlflow.py
+++ b/src/anomalib/loggers/mlflow.py
@@ -1,4 +1,23 @@
-"""MLFlow logger with add image interface."""
+"""MLFlow logger with image logging capabilities.
+
+This module provides an MLFlow logger implementation that adds an interface for
+logging images. It extends both the base image logger and PyTorch Lightning's
+MLFlow logger.
+
+Example:
+    >>> from anomalib.loggers import AnomalibMLFlowLogger
+    >>> from anomalib.engine import Engine
+    >>> mlflow_logger = AnomalibMLFlowLogger()
+    >>> engine = Engine(logger=mlflow_logger)  # doctest: +SKIP
+
+    Log an image:
+    >>> import numpy as np
+    >>> image = np.random.rand(32, 32, 3)  # doctest: +SKIP
+    >>> mlflow_logger.add_image(
+    ...     image=image,
+    ...     name="test_image"
+    ... )  # doctest: +SKIP
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -15,54 +34,47 @@
 
 
 class AnomalibMLFlowLogger(ImageLoggerBase, MLFlowLogger):
-    """Logger for MLFlow.
+    """Logger for MLFlow with image logging capabilities.
 
-    Adds interface for ``add_image`` in the logger rather than calling the
-    experiment object.
-
-    .. note::
-        Same as the MLFlowLogger provided by PyTorch Lightning and the doc string is reproduced below.
-
-    Track your parameters, metrics, source code and more using
-    `MLFlow `_.
-
-    Install it with pip:
-
-    .. code-block:: bash
-
-        pip install mlflow
+    This logger extends PyTorch Lightning's MLFlowLogger with an interface for
+    logging images. It inherits from both :class:`ImageLoggerBase` and
+    :class:`MLFlowLogger`.
 
     Args:
-        experiment_name: The name of the experiment.
-        run_name: Name of the new run.
-            The `run_name` is internally stored as a ``mlflow.runName`` tag.
-            If the ``mlflow.runName`` tag has already been set in `tags`, the value is overridden by the `run_name`.
-        tracking_uri: Address of local or remote tracking server.
-            If not provided, defaults to `MLFLOW_TRACKING_URI` environment variable if set, otherwise it falls
-            back to `file:`.
-        save_dir: A path to a local directory where the MLflow runs get saved.
-            Defaults to `./mlruns` if `tracking_uri` is not provided.
-            Has no effect if `tracking_uri` is provided.
-        log_model: Log checkpoints created by `ModelCheckpoint` as MLFlow artifacts.
-
-            - if ``log_model == 'all'``, checkpoints are logged during training.
-            - if ``log_model == True``, checkpoints are logged at the end of training, \
-                except when `save_top_k == -1` which also logs every checkpoint during training.
-            - if ``log_model == False`` (default), no checkpoint is logged.
-
-        prefix: A string to put at the beginning of metric keys. Defaults to ``''``.
-        kwargs: Additional arguments like `tags`, `artifact_location` etc. used by
-            `MLFlowExperiment` can be passed as keyword arguments in this logger.
+        experiment_name: Name of the experiment. If not provided, defaults to
+            ``"anomalib_logs"``.
+        run_name: Name of the new run. The ``run_name`` is internally stored as
+            a ``mlflow.runName`` tag. If the ``mlflow.runName`` tag has already
+            been set in ``tags``, the value is overridden by the ``run_name``.
+        tracking_uri: Address of local or remote tracking server. If not provided,
+            defaults to ``MLFLOW_TRACKING_URI`` environment variable if set,
+            otherwise falls back to ``file:``.
+        save_dir: Path to local directory where MLflow runs are saved. Defaults
+            to ``"./mlruns"`` if ``tracking_uri`` is not provided. Has no effect
+            if ``tracking_uri`` is provided.
+        log_model: Log checkpoints created by ``ModelCheckpoint`` as MLFlow
+            artifacts:
+
+            - if ``"all"``: checkpoints are logged during training
+            - if ``True``: checkpoints are logged at end of training (except when
+              ``save_top_k == -1`` which logs every checkpoint during training)
+            - if ``False`` (default): no checkpoints are logged
+
+        prefix: String to prepend to metric keys. Defaults to ``""``.
+        **kwargs: Additional arguments like ``tags``, ``artifact_location`` etc.
+            used by ``MLFlowExperiment``.
 
     Example:
         >>> from anomalib.loggers import AnomalibMLFlowLogger
         >>> from anomalib.engine import Engine
-        ...
-        >>> mlflow_logger = AnomalibMLFlowLogger()
-        >>> engine = Engine(logger=mlflow_logger)
+        >>> mlflow_logger = AnomalibMLFlowLogger(
+        ...     experiment_name="my_experiment",
+        ...     run_name="my_run"
+        ... )  # doctest: +SKIP
+        >>> engine = Engine(logger=mlflow_logger)  # doctest: +SKIP
 
     See Also:
-        - `MLFlow Documentation `_.
+        - `MLFlow Documentation `_
     """
 
     def __init__(
@@ -87,14 +99,14 @@ def __init__(
 
     @rank_zero_only
     def add_image(self, image: np.ndarray | Figure, name: str | None = None, **kwargs) -> None:
-        """Interface to log images in the mlflow loggers.
+        """Log images to MLflow.
 
         Args:
-            image (np.ndarray | Figure): Image to log.
-            name (str | None): The tag of the image defaults to ``None``.
-            kwargs: Additional keyword arguments that are only used if `image` is of type Figure.
-                These arguments are passed directly to the method that saves the figure.
-                If `image` is a NumPy array, `kwargs` has no effect.
+            image: Image to log, can be either a numpy array or matplotlib Figure.
+            name: Name/title of the image. Defaults to ``None``.
+            **kwargs: Additional keyword arguments passed to the MLflow logging
+                method when ``image`` is a Figure. Has no effect when ``image``
+                is a numpy array.
         """
         # Need to call different functions of `Experiment` for  Figure vs np.ndarray
         if isinstance(image, Figure):
diff --git a/src/anomalib/loggers/tensorboard.py b/src/anomalib/loggers/tensorboard.py
index 3d02e457ac..60bd965f15 100644
--- a/src/anomalib/loggers/tensorboard.py
+++ b/src/anomalib/loggers/tensorboard.py
@@ -1,4 +1,24 @@
-"""Tensorboard logger with add image interface."""
+"""TensorBoard logger with image logging capabilities.
+
+This module provides a TensorBoard logger implementation that adds an interface for
+logging images. It extends both the base image logger and PyTorch Lightning's
+TensorBoard logger.
+
+Example:
+    >>> from anomalib.loggers import AnomalibTensorBoardLogger
+    >>> from anomalib.engine import Engine
+    >>> tensorboard_logger = AnomalibTensorBoardLogger("logs")
+    >>> engine = Engine(logger=tensorboard_logger)  # doctest: +SKIP
+
+    Log an image:
+    >>> import numpy as np
+    >>> image = np.random.rand(32, 32, 3)  # doctest: +SKIP
+    >>> tensorboard_logger.add_image(
+    ...     image=image,
+    ...     name="test_image",
+    ...     global_step=0
+    ... )  # doctest: +SKIP
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -18,48 +38,43 @@
 
 
 class AnomalibTensorBoardLogger(ImageLoggerBase, TensorBoardLogger):
-    """Logger for tensorboard.
+    """Logger for TensorBoard with image logging capabilities.
 
-    Adds interface for `add_image` in the logger rather than calling the experiment object.
+    This logger extends PyTorch Lightning's TensorBoardLogger with an interface
+    for logging images. It inherits from both :class:`ImageLoggerBase` and
+    :class:`TensorBoardLogger`.
 
-    .. note::
-        Same as the Tensorboard Logger provided by PyTorch Lightning and the doc string is reproduced below.
-
-    Logs are saved to
-    ``os.path.join(save_dir, name, version)``. This is the default logger in Lightning, it comes
-    preinstalled.
+    Args:
+        save_dir: Directory path where logs will be saved. The final path will be
+            ``os.path.join(save_dir, name, version)``.
+        name: Name of the experiment. If it is an empty string, no
+            per-experiment subdirectory is used. Defaults to ``"default"``.
+        version: Version of the experiment. If not specified, the logger checks
+            the save directory for existing versions and assigns the next
+            available one. If a string is provided, it is used as the
+            run-specific subdirectory name. Otherwise ``"version_${version}"`` is
+            used. Defaults to ``None``.
+        log_graph: If ``True``, adds the computational graph to TensorBoard. This
+            requires that the model has defined the ``example_input_array``
+            attribute. Defaults to ``False``.
+        default_hp_metric: If ``True``, enables a placeholder metric with key
+            ``hp_metric`` when ``log_hyperparams`` is called without a metric.
+            Defaults to ``True``.
+        prefix: String to prepend to metric keys. Defaults to ``""``.
+        **kwargs: Additional arguments like ``comment``, ``filename_suffix``,
+            etc. used by :class:`SummaryWriter`.
 
     Example:
-        >>> from anomalib.engine import Engine
         >>> from anomalib.loggers import AnomalibTensorBoardLogger
-        ...
-        >>> logger = AnomalibTensorBoardLogger("tb_logs", name="my_model")
-        >>> engine =  Engine(logger=logger)
-
-    Args:
-        save_dir (str): Save directory
-        name (str | None): Experiment name. Defaults to ``'default'``.
-            If it is the empty string then no per-experiment subdirectory is used.
-            Default: ``'default'``.
-        version (int | str | None): Experiment version. If version is not
-            specified the logger inspects the save directory for existing
-            versions, then automatically assigns the next available version.
-            If it is a string then it is used as the run-specific subdirectory
-            name, otherwise ``'version_${version}'`` is used.
-            Defaults to ``None``
-        log_graph (bool): Adds the computational graph to tensorboard. This
-            requires that the user has defined the `self.example_input_array`
-            attribute in their model.
-            Defaults to ``False``.
-        default_hp_metric (bool): Enables a placeholder metric with key
-            ``hp_metric`` when ``log_hyperparams`` is called without a metric
-            (otherwise calls to log_hyperparams without a metric are ignored).
-            Defaults to ``True``.
-        prefix (str): A string to put at the beginning of metric keys.
-            Defaults to ``''``.
-        **kwargs: Additional arguments like `comment`, `filename_suffix`, etc.
-            used by :class:`SummaryWriter` can be passed as keyword arguments in
-            this logger.
+        >>> from anomalib.engine import Engine
+        >>> logger = AnomalibTensorBoardLogger(
+        ...     save_dir="logs",
+        ...     name="my_experiment"
+        ... )  # doctest: +SKIP
+        >>> engine = Engine(logger=logger)  # doctest: +SKIP
+
+    See Also:
+        - `TensorBoard Documentation `_
     """
 
     def __init__(
@@ -85,13 +100,18 @@ def __init__(
 
     @rank_zero_only
     def add_image(self, image: np.ndarray | Figure, name: str | None = None, **kwargs) -> None:
-        """Interface to add image to tensorboard logger.
+        """Log images to TensorBoard.
 
         Args:
-            image (np.ndarray | Figure): Image to log
-            name (str | None): The tag of the image
-                Defaults to ``None``.
-            kwargs: Accepts only `global_step` (int). The step at which to log the image.
+            image: Image to log, can be either a numpy array or matplotlib
+                Figure.
+            name: Name/title of the image. Defaults to ``None``.
+            **kwargs: Must contain ``global_step`` (int) indicating the step at
+                which to log the image. Additional keyword arguments are passed
+                to the TensorBoard logging method.
+
+        Raises:
+            ValueError: If ``global_step`` is not provided in ``kwargs``.
         """
         if "global_step" not in kwargs:
             msg = "`global_step` is required for tensorboard logger"
diff --git a/src/anomalib/loggers/wandb.py b/src/anomalib/loggers/wandb.py
index ff41a0949e..a53ad2e82d 100644
--- a/src/anomalib/loggers/wandb.py
+++ b/src/anomalib/loggers/wandb.py
@@ -1,4 +1,23 @@
-"""wandb logger with add image interface."""
+"""Weights & Biases logger with image logging capabilities.
+
+This module provides a Weights & Biases logger implementation that adds an
+interface for logging images. It extends both the base image logger and PyTorch
+Lightning's WandbLogger.
+
+Example:
+    >>> from anomalib.loggers import AnomalibWandbLogger
+    >>> from anomalib.engine import Engine
+    >>> wandb_logger = AnomalibWandbLogger()  # doctest: +SKIP
+    >>> engine = Engine(logger=wandb_logger)  # doctest: +SKIP
+
+    Log an image:
+    >>> import numpy as np
+    >>> image = np.random.rand(32, 32, 3)  # doctest: +SKIP
+    >>> wandb_logger.add_image(
+    ...     image=image,
+    ...     name="test_image"
+    ... )  # doctest: +SKIP
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -23,68 +42,59 @@
 
 
 class AnomalibWandbLogger(ImageLoggerBase, WandbLogger):
-    """Logger for wandb.
+    """Logger for Weights & Biases with image logging capabilities.
 
-    Adds interface for `add_image` in the logger rather than calling the experiment object.
-
-    .. note::
-        Same as the wandb Logger provided by PyTorch Lightning and the doc string is reproduced below.
-
-    Log using `Weights and Biases `_.
-
-    Install it with pip:
-
-    .. code-block:: bash
-
-        $ pip install wandb
+    This logger extends PyTorch Lightning's WandbLogger with an interface for
+    logging images. It inherits from both :class:`ImageLoggerBase` and
+    :class:`WandbLogger`.
 
     Args:
-        name: Display name for the run.
-            Defaults to ``None``.
+        name: Display name for the run. Defaults to ``None``.
         save_dir: Path where data is saved (wandb dir by default).
-            Defaults to ``None``.
+            Defaults to ``"."``.
         version: Sets the version, mainly used to resume a previous run.
+            Defaults to ``None``.
         offline: Run offline (data can be streamed later to wandb servers).
             Defaults to ``False``.
-        dir: Alias for save_dir.
+        dir: Alias for ``save_dir``. Defaults to ``None``.
         id: Sets the version, mainly used to resume a previous run.
             Defaults to ``None``.
         anonymous: Enables or explicitly disables anonymous logging.
             Defaults to ``None``.
-        version: Same as id.
-            Defaults to ``None``.
         project: The name of the project to which this run will belong.
             Defaults to ``None``.
         log_model: Save checkpoints in wandb dir to upload on W&B servers.
             Defaults to ``False``.
-        experiment: WandB experiment object. Automatically set when creating a run.
-            Defaults to ``None``.
+        experiment: WandB experiment object. Automatically set when creating a
+            run. Defaults to ``None``.
         prefix: A string to put at the beginning of metric keys.
-            Defaults to ``''``.
-        **kwargs: Arguments passed to :func:`wandb.init` like `entity`, `group`, `tags`, etc.
+            Defaults to ``""``.
+        checkpoint_name: Name of the checkpoint to save.
+            Defaults to ``None``.
+        **kwargs: Additional arguments passed to :func:`wandb.init` like
+            ``entity``, ``group``, ``tags``, etc.
 
     Raises:
-        ImportError:
-            If required WandB package is not installed on the device.
-        MisconfigurationException:
-            If both ``log_model`` and ``offline``is set to ``True``.
+        ImportError: If required WandB package is not installed.
+        MisconfigurationException: If both ``log_model`` and ``offline`` are
+            set to ``True``.
 
     Example:
         >>> from anomalib.loggers import AnomalibWandbLogger
         >>> from anomalib.engine import Engine
-        ...
-        >>> wandb_logger = AnomalibWandbLogger()
-        >>> engine =  Engine(logger=wandb_logger)
+        >>> wandb_logger = AnomalibWandbLogger(
+        ...     project="my_project",
+        ...     name="my_run"
+        ... )  # doctest: +SKIP
+        >>> engine = Engine(logger=wandb_logger)  # doctest: +SKIP
 
-    .. note::
-        When logging manually through `wandb.log` or `trainer.logger.experiment.log`,
-        make sure to use `commit=False` so the logging step does not increase.
+    Note:
+        When logging manually through ``wandb.log`` or
+        ``trainer.logger.experiment.log``, make sure to use ``commit=False``
+        so the logging step does not increase.
 
     See Also:
-        - `Tutorial `__
-          on how to use W&B with PyTorch Lightning
-        - `W&B Documentation `__
-
+        - `W&B Documentation `_
     """
 
     def __init__(
@@ -122,13 +132,14 @@ def __init__(
 
     @rank_zero_only
     def add_image(self, image: np.ndarray | Figure, name: str | None = None, **kwargs) -> None:
-        """Interface to add image to wandb logger.
+        """Log an image to Weights & Biases.
 
         Args:
-            image (np.ndarray | Figure): Image to log
-            name (str | None): The tag of the image
-                Defaults to ``None``.
-            kwargs: Additional arguments to `wandb.Image`
+            image: Image to log, can be either a numpy array or matplotlib
+                Figure.
+            name: Name/title of the image. Defaults to ``None``.
+            **kwargs: Additional keyword arguments passed to
+                :class:`wandb.Image`. Currently unused.
         """
         del kwargs  # Unused argument.
 
@@ -137,10 +148,11 @@ def add_image(self, image: np.ndarray | Figure, name: str | None = None, **kwarg
 
     @rank_zero_only
     def save(self) -> None:
-        """Upload images to wandb server.
+        """Upload images to Weights & Biases server.
 
-        .. note::
-            There is a limit on the number of images that can be logged together to the `wandb` server.
+        Note:
+            There is a limit on the number of images that can be logged together
+            to the W&B server.
         """
         super().save()
         if len(self.image_list) > 1:
diff --git a/src/anomalib/metrics/__init__.py b/src/anomalib/metrics/__init__.py
index 6f606bc826..d04cdcba68 100644
--- a/src/anomalib/metrics/__init__.py
+++ b/src/anomalib/metrics/__init__.py
@@ -1,4 +1,41 @@
-"""Custom anomaly evaluation metrics."""
+"""Custom metrics for evaluating anomaly detection models.
+
+This module provides various metrics for evaluating anomaly detection performance:
+
+- Area Under Curve (AUC) metrics:
+    - ``AUROC``: Area Under Receiver Operating Characteristic curve
+    - ``AUPR``: Area Under Precision-Recall curve
+    - ``AUPRO``: Area Under Per-Region Overlap curve
+    - ``AUPIMO``: Area Under Per-Image Missed Overlap curve
+
+- F1-score metrics:
+    - ``F1Score``: Standard F1 score
+    - ``F1Max``: Maximum F1 score across thresholds
+
+- Threshold metrics:
+    - ``F1AdaptiveThreshold``: Finds optimal threshold by maximizing F1 score
+    - ``ManualThreshold``: Uses manually specified threshold
+
+- Other metrics:
+    - ``AnomalibMetric``: Base class for custom metrics
+    - ``AnomalyScoreDistribution``: Analyzes score distributions
+    - ``BinaryPrecisionRecallCurve``: Computes precision-recall curves
+    - ``Evaluator``: Combines multiple metrics for evaluation
+    - ``MinMax``: Normalizes scores to [0,1] range
+    - ``PRO``: Per-Region Overlap score
+    - ``PIMO``: Per-Image Missed Overlap score
+
+Example:
+    >>> from anomalib.metrics import AUROC, F1Score
+    >>> auroc = AUROC()
+    >>> f1 = F1Score()
+    >>> labels = torch.tensor([0, 1, 0, 1])
+    >>> scores = torch.tensor([0.1, 0.9, 0.2, 0.8])
+    >>> auroc(scores, labels)
+    tensor(1.)
+    >>> f1(scores, labels, threshold=0.5)
+    tensor(1.)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/metrics/anomaly_score_distribution.py b/src/anomalib/metrics/anomaly_score_distribution.py
index d95e863bbf..bbce60e069 100644
--- a/src/anomalib/metrics/anomaly_score_distribution.py
+++ b/src/anomalib/metrics/anomaly_score_distribution.py
@@ -1,4 +1,28 @@
-"""Module that computes the parameters of the normal data distribution of the training set."""
+"""Compute statistics of anomaly score distributions.
+
+This module provides the ``AnomalyScoreDistribution`` class which computes mean
+and standard deviation statistics of anomaly scores from normal training data.
+Statistics are computed for both image-level and pixel-level scores.
+
+The class tracks:
+    - Image-level statistics: Mean and std of image anomaly scores
+    - Pixel-level statistics: Mean and std of pixel anomaly maps
+
+Example:
+    >>> from anomalib.metrics import AnomalyScoreDistribution
+    >>> import torch
+    >>> # Create sample data
+    >>> scores = torch.tensor([0.1, 0.2, 0.15])  # Image anomaly scores
+    >>> maps = torch.tensor([[0.1, 0.2], [0.15, 0.25]])  # Pixel anomaly maps
+    >>> # Initialize and compute stats
+    >>> dist = AnomalyScoreDistribution()
+    >>> dist.update(anomaly_scores=scores, anomaly_maps=maps)
+    >>> image_mean, image_std, pixel_mean, pixel_std = dist.compute()
+
+Note:
+    The input scores and maps are log-transformed before computing statistics.
+    Both image-level scores and pixel-level maps are optional inputs.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -8,9 +32,30 @@
 
 
 class AnomalyScoreDistribution(Metric):
-    """Mean and standard deviation of the anomaly scores of normal training data."""
+    """Compute distribution statistics of anomaly scores.
+
+    This class tracks and computes the mean and standard deviation of anomaly
+    scores from the normal samples in the training set. Statistics are computed
+    for both image-level scores and pixel-level anomaly maps.
+
+    The metric maintains internal state to accumulate scores and maps across
+    batches before computing final statistics.
+
+    Example:
+        >>> dist = AnomalyScoreDistribution()
+        >>> # Update with batch of scores
+        >>> scores = torch.tensor([0.1, 0.2, 0.3])
+        >>> dist.update(anomaly_scores=scores)
+        >>> # Compute statistics
+        >>> img_mean, img_std, pix_mean, pix_std = dist.compute()
+    """
 
     def __init__(self, **kwargs) -> None:
+        """Initialize the metric states.
+
+        Args:
+            **kwargs: Additional arguments passed to parent class.
+        """
         super().__init__(**kwargs)
         self.anomaly_maps: list[torch.Tensor] = []
         self.anomaly_scores: list[torch.Tensor] = []
@@ -32,7 +77,14 @@ def update(
         anomaly_maps: torch.Tensor | None = None,
         **kwargs,
     ) -> None:
-        """Update the precision-recall curve metric."""
+        """Update the internal state with new scores and maps.
+
+        Args:
+            *args: Unused positional arguments.
+            anomaly_scores: Batch of image-level anomaly scores.
+            anomaly_maps: Batch of pixel-level anomaly maps.
+            **kwargs: Unused keyword arguments.
+        """
         del args, kwargs  # These variables are not used.
 
         if anomaly_maps is not None:
@@ -41,7 +93,15 @@ def update(
             self.anomaly_scores.append(anomaly_scores)
 
     def compute(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Compute stats."""
+        """Compute distribution statistics from accumulated scores and maps.
+
+        Returns:
+            tuple containing:
+                - image_mean: Mean of log-transformed image anomaly scores
+                - image_std: Standard deviation of log-transformed image scores
+                - pixel_mean: Mean of log-transformed pixel anomaly maps
+                - pixel_std: Standard deviation of log-transformed pixel maps
+        """
         anomaly_scores = torch.hstack(self.anomaly_scores)
         anomaly_scores = torch.log(anomaly_scores)
 
diff --git a/src/anomalib/metrics/aupr.py b/src/anomalib/metrics/aupr.py
index 5856a1ae5f..06cf2d9852 100644
--- a/src/anomalib/metrics/aupr.py
+++ b/src/anomalib/metrics/aupr.py
@@ -1,4 +1,34 @@
-"""Implementation of AUROC metric based on TorchMetrics."""
+"""Area Under the Precision-Recall Curve (AUPR) metric.
+
+This module provides the ``AUPR`` class which computes the area under the
+precision-recall curve for evaluating anomaly detection performance.
+
+The AUPR score summarizes the trade-off between precision and recall across
+different thresholds. It is particularly useful for imbalanced datasets where
+anomalies are rare.
+
+Example:
+    >>> from anomalib.metrics import AUPR
+    >>> import torch
+    >>> # Create sample data
+    >>> labels = torch.tensor([0, 0, 1, 1])  # Binary labels
+    >>> scores = torch.tensor([0.1, 0.2, 0.8, 0.9])  # Anomaly scores
+    >>> # Initialize and compute AUPR
+    >>> metric = AUPR()
+    >>> aupr_score = metric(scores, labels)
+    >>> aupr_score
+    tensor(1.0)
+
+The metric can also be updated incrementally with batches:
+
+    >>> for batch_scores, batch_labels in dataloader:
+    ...     metric.update(batch_scores, batch_labels)
+    >>> final_score = metric.compute()
+
+Note:
+    The AUPR score ranges from 0 to 1, with 1 indicating perfect ranking of
+    anomalies above normal samples.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/metrics/aupro.py b/src/anomalib/metrics/aupro.py
index 0b5ac69d58..9f80c01686 100644
--- a/src/anomalib/metrics/aupro.py
+++ b/src/anomalib/metrics/aupro.py
@@ -1,4 +1,52 @@
-"""Implementation of AUPRO score based on TorchMetrics."""
+"""Area Under Per-Region Overlap (AUPRO) metric.
+
+This module provides the ``AUPRO`` class which computes the area under the
+per-region overlap curve for evaluating anomaly segmentation performance.
+
+The AUPRO score measures how well predicted anomaly maps overlap with ground truth
+anomaly regions. It is computed by:
+
+1. Performing connected component analysis on ground truth masks
+2. Computing per-region ROC curves for each component
+3. Averaging the curves and computing area under the curve up to a FPR limit
+
+Example:
+    >>> from anomalib.metrics import AUPRO
+    >>> import torch
+    >>> # Create sample data
+    >>> labels = torch.randint(0, 2, (1, 10, 5))  # Binary segmentation masks
+    >>> scores = torch.rand_like(labels)  # Anomaly segmentation maps
+    >>> # Initialize and compute AUPRO
+    >>> metric = AUPRO(fpr_limit=0.3)
+    >>> aupro_score = metric(scores, labels)
+    >>> aupro_score
+    tensor(0.4321)
+
+The metric can also be updated incrementally with batches:
+
+    >>> for batch_scores, batch_labels in dataloader:
+    ...     metric.update(batch_scores, batch_labels)
+    >>> final_score = metric.compute()
+
+Args:
+    dist_sync_on_step (bool): Synchronize metric state across processes at each
+        ``forward()`` before returning the value at the step.
+        Defaults to ``False``.
+    process_group (Any | None): Specify the process group on which
+        synchronization is called. Defaults to ``None`` (entire world).
+    dist_sync_fn (Callable | None): Callback that performs the allgather
+        operation on the metric state. When ``None``, DDP will be used.
+        Defaults to ``None``.
+    fpr_limit (float): Limit for the false positive rate.
+        Defaults to ``0.3``.
+    num_thresholds (int | None): Number of thresholds to use for computing the
+        ROC curve. When ``None``, uses thresholds from torchmetrics.
+        Defaults to ``None``.
+
+Note:
+    The AUPRO score ranges from 0 to 1, with 1 indicating perfect overlap between
+    predictions and ground truth regions.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -24,30 +72,32 @@ class _AUPRO(Metric):
     """Area under per region overlap (AUPRO) Metric.
 
     Args:
-        dist_sync_on_step (bool): Synchronize metric state across processes at each ``forward()``
-            before returning the value at the step. Default: ``False``
-        process_group (Optional[Any]): Specify the process group on which synchronization is called.
-            Default: ``None`` (which selects the entire world)
-        dist_sync_fn (Optional[Callable]): Callback that performs the allgather operation on the metric state.
-            When ``None``, DDP will be used to perform the allgather.
-            Default: ``None``
-        fpr_limit (float): Limit for the false positive rate. Defaults to ``0.3``.
-        num_thresholds (int): Number of thresholds to use for computing the roc curve. Defaults to ``None``.
-            If ``None``, the roc curve is computed with the thresholds returned by
-            ``torchmetrics.functional.classification.thresholds``.
+        dist_sync_on_step (bool): Synchronize metric state across processes at
+            each ``forward()`` before returning the value at the step.
+            Defaults to ``False``.
+        process_group (Any | None): Specify the process group on which
+            synchronization is called. Defaults to ``None`` (entire world).
+        dist_sync_fn (Callable | None): Callback that performs the allgather
+            operation on the metric state. When ``None``, DDP will be used.
+            Defaults to ``None``.
+        fpr_limit (float): Limit for the false positive rate.
+            Defaults to ``0.3``.
+        num_thresholds (int | None): Number of thresholds to use for computing
+            the ROC curve. When ``None``, uses thresholds from torchmetrics.
+            Defaults to ``None``.
 
     Examples:
         >>> import torch
         >>> from anomalib.metrics import AUPRO
-        ...
-        >>> labels = torch.randint(low=0, high=2, size=(1, 10, 5), dtype=torch.float32)
+        >>> # Create sample data
+        >>> labels = torch.randint(0, 2, (1, 10, 5), dtype=torch.float32)
         >>> preds = torch.rand_like(labels)
-        ...
+        >>> # Initialize and compute
         >>> aupro = AUPRO(fpr_limit=0.3)
         >>> aupro(preds, labels)
         tensor(0.4321)
 
-        Increasing the fpr_limit will increase the AUPRO value:
+        Increasing the ``fpr_limit`` will increase the AUPRO value:
 
         >>> aupro = AUPRO(fpr_limit=0.7)
         >>> aupro(preds, labels)
@@ -59,11 +109,13 @@ class _AUPRO(Metric):
     full_state_update: bool = False
     preds: list[torch.Tensor]
     target: list[torch.Tensor]
-    # When not None, the computation is performed in constant-memory by computing the roc curve
-    # for fixed thresholds buckets/thresholds.
-    # Warning: The thresholds are evenly distributed between the min and max predictions
-    # if all predictions are inside [0, 1]. Otherwise, the thresholds are evenly distributed between 0 and 1.
-    # This warning can be removed when https://github.com/Lightning-AI/torchmetrics/issues/1526 is fixed
+    # When not None, the computation is performed in constant-memory by computing
+    # the roc curve for fixed thresholds buckets/thresholds.
+    # Warning: The thresholds are evenly distributed between the min and max
+    # predictions if all predictions are inside [0, 1]. Otherwise, the thresholds
+    # are evenly distributed between 0 and 1.
+    # This warning can be removed when
+    # https://github.com/Lightning-AI/torchmetrics/issues/1526 is fixed
     # and the roc curve is computed with deactivated formatting
     num_thresholds: int | None
 
@@ -100,8 +152,8 @@ def perform_cca(self) -> torch.Tensor:
         """Perform the Connected Component Analysis on the self.target tensor.
 
         Raises:
-            ValueError: ValueError is raised if self.target doesn't conform with requirements imposed by kornia for
-                        connected component analysis.
+            ValueError: ValueError is raised if self.target doesn't conform with
+                requirements imposed by kornia for connected component analysis.
 
         Returns:
             Tensor: Components labeled from 0 to N.
@@ -111,8 +163,8 @@ def perform_cca(self) -> torch.Tensor:
         # check and prepare target for labeling via kornia
         if target.min() < 0 or target.max() > 1:
             msg = (
-                "kornia.contrib.connected_components expects input to lie in the interval [0, 1], "
-                f"but found interval was [{target.min()}, {target.max()}]."
+                "kornia.contrib.connected_components expects input to lie in the "
+                f"interval [0, 1], but found [{target.min()}, {target.max()}]."
             )
             raise ValueError(
                 msg,
@@ -127,20 +179,28 @@ def compute_pro(
         target: torch.Tensor,
         preds: torch.Tensor,
     ) -> tuple[torch.Tensor, torch.Tensor]:
-        """Compute the pro/fpr value-pairs until the fpr specified by self.fpr_limit.
+        """Compute the pro/fpr value-pairs until the fpr specified by fpr_limit.
 
-        It leverages the fact that the overlap corresponds to the tpr, and thus computes the overall
-        PRO curve by aggregating per-region tpr/fpr values produced by ROC-construction.
+        It leverages the fact that the overlap corresponds to the tpr, and thus
+        computes the overall PRO curve by aggregating per-region tpr/fpr values
+        produced by ROC-construction.
+
+        Args:
+            cca (torch.Tensor): Connected components tensor
+            target (torch.Tensor): Ground truth tensor
+            preds (torch.Tensor): Model predictions tensor
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor]: tuple containing final fpr and tpr values.
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing final fpr and tpr
+                values.
         """
         if self.num_thresholds is not None:
-            # binary_roc is applying a sigmoid on the predictions before computing the roc curve
-            # when some predictions are out of [0, 1], the binning between min and max predictions
-            # cannot be applied in that case. This can be removed when
-            #  https://github.com/Lightning-AI/torchmetrics/issues/1526 is fixed and
-            #  the roc curve is computed with deactivated formatting.
+            # binary_roc is applying a sigmoid on the predictions before computing
+            # the roc curve when some predictions are out of [0, 1], the binning
+            # between min and max predictions cannot be applied in that case.
+            # This can be removed when
+            # https://github.com/Lightning-AI/torchmetrics/issues/1526 is fixed
+            # and the roc curve is computed with deactivated formatting.
 
             if torch.all((preds >= 0) * (preds <= 1)):
                 thresholds = thresholds_between_min_and_max(preds, self.num_thresholds, self.device)
@@ -163,10 +223,12 @@ def compute_pro(
         fpr = torch.zeros(output_size, device=preds.device, dtype=torch.float)
         new_idx = torch.arange(0, output_size, device=preds.device, dtype=torch.float)
 
-        # Loop over the labels, computing per-region tpr/fpr curves, and aggregating them.
-        # Note that, since the groundtruth is different for every all to `roc`, we also get
-        # different/unique tpr/fpr curves (i.e. len(_fpr_idx) is different for every call).
-        # We therefore need to resample per-region curves to a fixed sampling ratio (defined above).
+        # Loop over the labels, computing per-region tpr/fpr curves, and
+        # aggregating them. Note that, since the groundtruth is different for
+        # every all to `roc`, we also get different/unique tpr/fpr curves
+        # (i.e. len(_fpr_idx) is different for every call).
+        # We therefore need to resample per-region curves to a fixed sampling
+        # ratio (defined above).
         labels = cca.unique()[1:]  # 0 is background
         background = cca == 0
         _fpr: torch.Tensor
@@ -175,8 +237,9 @@ def compute_pro(
             interp: bool = False
             new_idx[-1] = output_size - 1
             mask = cca == label
-            # Need to calculate label-wise roc on union of background & mask, as otherwise we wrongly consider other
-            # label in labels as FPs. We also don't need to return the thresholds
+            # Need to calculate label-wise roc on union of background & mask, as
+            # otherwise we wrongly consider other label in labels as FPs.
+            # We also don't need to return the thresholds
             _fpr, _tpr = binary_roc(
                 preds=preds[background | mask],
                 target=mask[background | mask],
@@ -190,8 +253,9 @@ def compute_pro(
                 _fpr_limit = self.fpr_limit
 
             _fpr_idx = torch.where(_fpr <= _fpr_limit)[0]
-            # if computed roc curve is not specified sufficiently close to self.fpr_limit,
-            # we include the closest higher tpr/fpr pair and linearly interpolate the tpr/fpr point at self.fpr_limit
+            # if computed roc curve is not specified sufficiently close to
+            # self.fpr_limit, we include the closest higher tpr/fpr pair and
+            # linearly interpolate the tpr/fpr point at self.fpr_limit
             if not torch.allclose(_fpr[_fpr_idx].max(), self.fpr_limit):
                 _tmp_idx = torch.searchsorted(_fpr, self.fpr_limit)
                 _fpr_idx = torch.cat([_fpr_idx, _tmp_idx.unsqueeze_(0)])
@@ -225,7 +289,8 @@ def _compute(self) -> tuple[torch.Tensor, torch.Tensor]:
         Perform the Connected Component Analysis first then compute the PRO curve.
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor]: tuple containing final fpr and tpr values.
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing final fpr and tpr
+                values.
         """
         cca = self.perform_cca().flatten()
         target = dim_zero_cat(self.target).flatten()
@@ -234,7 +299,7 @@ def _compute(self) -> tuple[torch.Tensor, torch.Tensor]:
         return self.compute_pro(cca=cca, target=target, preds=preds)
 
     def compute(self) -> torch.Tensor:
-        """Fist compute PRO curve, then compute and scale area under the curve.
+        """First compute PRO curve, then compute and scale area under the curve.
 
         Returns:
             Tensor: Value of the AUPRO metric
@@ -248,7 +313,8 @@ def generate_figure(self) -> tuple[Figure, str]:
         """Generate a figure containing the PRO curve and the AUPRO.
 
         Returns:
-            tuple[Figure, str]: Tuple containing both the figure and the figure title to be used for logging
+            tuple[Figure, str]: Tuple containing both the figure and the figure
+                title to be used for logging
         """
         fpr, tpr = self._compute()
         aupro = self.compute()
@@ -287,7 +353,7 @@ def interp1d(old_x: torch.Tensor, old_y: torch.Tensor, new_x: torch.Tensor) -> t
         # to preserve order, but we actually want the preceeding index.
         idx -= 1
         # we clamp the index, because the number of intervals = old_x.size(0) -1,
-        # and the left neighbour should hence be at most number of intervals -1, i.e. old_x.size(0) - 2
+        # and the left neighbour should hence be at most number of intervals -1,
         idx = torch.clamp(idx, 0, old_x.size(0) - 2)
 
         # perform actual linear interpolation
diff --git a/src/anomalib/metrics/auroc.py b/src/anomalib/metrics/auroc.py
index 183da7a4f0..05fd87889c 100644
--- a/src/anomalib/metrics/auroc.py
+++ b/src/anomalib/metrics/auroc.py
@@ -1,4 +1,38 @@
-"""Implementation of AUROC metric based on TorchMetrics."""
+"""Area Under the Receiver Operating Characteristic (AUROC) metric.
+
+This module provides the ``AUROC`` class which computes the area under the ROC
+curve for evaluating anomaly detection performance.
+
+The AUROC score summarizes the trade-off between true positive rate (TPR) and
+false positive rate (FPR) across different thresholds. It measures how well the
+model can distinguish between normal and anomalous samples.
+
+Example:
+    >>> from anomalib.metrics import AUROC
+    >>> import torch
+    >>> # Create sample data
+    >>> labels = torch.tensor([0, 0, 1, 1])  # Binary labels
+    >>> scores = torch.tensor([0.1, 0.2, 0.8, 0.9])  # Anomaly scores
+    >>> # Initialize and compute AUROC
+    >>> metric = AUROC()
+    >>> auroc_score = metric(scores, labels)
+    >>> auroc_score
+    tensor(1.0)
+
+The metric can also be updated incrementally with batches:
+
+    >>> for batch_scores, batch_labels in dataloader:
+    ...     metric.update(batch_scores, batch_labels)
+    >>> final_score = metric.compute()
+
+Once computed, the ROC curve can be visualized:
+
+    >>> figure, title = metric.generate_figure()
+
+Note:
+    The AUROC score ranges from 0 to 1, with 1 indicating perfect ranking of
+    anomalies above normal samples.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,13 +50,17 @@
 class _AUROC(BinaryROC):
     """Area under the ROC curve.
 
+    This class computes the area under the receiver operating characteristic
+    curve, which plots the true positive rate against the false positive rate
+    at various thresholds.
+
     Examples:
+        To compute the metric for a set of predictions and ground truth targets:
+
         >>> import torch
         >>> from anomalib.metrics import AUROC
-        ...
         >>> preds = torch.tensor([0.13, 0.26, 0.08, 0.92, 0.03])
         >>> target = torch.tensor([0, 0, 1, 1, 0])
-        ...
         >>> auroc = AUROC()
         >>> auroc(preds, target)
         tensor(0.6667)
@@ -34,16 +72,16 @@ class _AUROC(BinaryROC):
         >>> auroc.compute()
         tensor(0.6667)
 
-        To plot the ROC curve, use the ``generate_figure`` method:
+        To plot the ROC curve:
 
-        >>> fig, title = auroc.generate_figure()
+        >>> figure, title = auroc.generate_figure()
     """
 
     def compute(self) -> torch.Tensor:
         """First compute ROC curve, then compute area under the curve.
 
         Returns:
-            Tensor: Value of the AUROC metric
+            torch.Tensor: Value of the AUROC metric
         """
         tpr: torch.Tensor
         fpr: torch.Tensor
@@ -52,21 +90,23 @@ def compute(self) -> torch.Tensor:
         return auc(fpr, tpr, reorder=True)
 
     def update(self, preds: torch.Tensor, target: torch.Tensor) -> None:
-        """Update state with new values.
+        """Update state with new predictions and targets.
 
-        Need to flatten new values as ROC expects them in this format for binary classification.
+        Need to flatten new values as ROC expects them in this format for binary
+        classification.
 
         Args:
-            preds (torch.Tensor): predictions of the model
-            target (torch.Tensor): ground truth targets
+            preds (torch.Tensor): Predictions from the model
+            target (torch.Tensor): Ground truth target labels
         """
         super().update(preds.flatten(), target.flatten())
 
     def _compute(self) -> tuple[torch.Tensor, torch.Tensor]:
-        """Compute fpr/tpr value pairs.
+        """Compute false positive rate and true positive rate value pairs.
 
         Returns:
-            Tuple containing Tensors for fpr and tpr
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing tensors for FPR
+                and TPR values
         """
         tpr: torch.Tensor
         fpr: torch.Tensor
@@ -74,10 +114,14 @@ def _compute(self) -> tuple[torch.Tensor, torch.Tensor]:
         return (fpr, tpr)
 
     def generate_figure(self) -> tuple[Figure, str]:
-        """Generate a figure containing the ROC curve, the baseline and the AUROC.
+        """Generate a figure showing the ROC curve.
+
+        The figure includes the ROC curve, a baseline representing random
+        performance, and the AUROC score.
 
         Returns:
-            tuple[Figure, str]: Tuple containing both the figure and the figure title to be used for logging
+            tuple[Figure, str]: Tuple containing both the figure and the figure
+                title to be used for logging
         """
         fpr, tpr = self._compute()
         auroc = self.compute()
diff --git a/src/anomalib/metrics/base.py b/src/anomalib/metrics/base.py
index 041e45a334..040fd00ece 100644
--- a/src/anomalib/metrics/base.py
+++ b/src/anomalib/metrics/base.py
@@ -1,37 +1,17 @@
-"""Base classes for metrics in Anomalib."""
+"""Base classes for metrics in Anomalib.
 
-# Copyright (C) 2024 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-from collections.abc import Sequence
+This module provides base classes for implementing metrics in Anomalib:
 
-from torchmetrics import Metric, MetricCollection
-
-from anomalib.data import Batch
+- ``AnomalibMetric``: Base class that makes torchmetrics compatible with Anomalib
+- ``create_anomalib_metric``: Factory function to create Anomalib metrics
 
+The ``AnomalibMetric`` class adds batch processing capabilities to any torchmetrics
+metric. It allows metrics to be updated directly with ``Batch`` objects instead of
+requiring individual tensors.
 
-class AnomalibMetric:
-    """Base class for metrics in Anomalib.
-
-    This class is designed to make any torchmetrics metric compatible with the
-    Anomalib framework. An Anomalib version of any torchmetrics metric can be created
-    by inheriting from this class and the desired torchmetrics metric. For example, to
-    create an Anomalib version of the BinaryF1Score metric, the user can create a new
-    class that inherits from AnomalibMetric and BinaryF1Score.
-
-    The AnomalibMetric class adds the ability to update the metric with a Batch
-    object instead of individual prediction and target tensors. To use this feature,
-    the user must provide a list of fields as constructor arguments when instantiating
-    the metric. When the metric is updated with a Batch object, it will extract the
-    values of these fields from the Batch object and pass them to the `update` method
-    of the metric.
-
-    Args:
-        fields (Sequence[str]): List of field names to extract from the Batch object.
-        prefix (str): Prefix to add to the metric name. Defaults to an empty string.
-        **kwargs: Variable keyword arguments that can be passed to the parent class.
+Example:
+    Create a custom F1 score metric::
 
-    Examples:
         >>> from torchmetrics.classification import BinaryF1Score
         >>> from anomalib.metrics import AnomalibMetric
         >>> from anomalib.data import ImageBatch
@@ -40,29 +20,85 @@ class that inherits from AnomalibMetric and BinaryF1Score.
         >>> class F1Score(AnomalibMetric, BinaryF1Score):
         ...     pass
         ...
+        >>> # Create metric specifying batch fields to use
         >>> f1_score = F1Score(fields=["pred_label", "gt_label"])
         >>>
+        >>> # Create sample batch
         >>> batch = ImageBatch(
         ...     image=torch.rand(4, 3, 256, 256),
         ...     pred_label=torch.tensor([0, 0, 0, 1]),
-        ...     gt_label=torch.tensor([0, 0, 1, 1])),
+        ...     gt_label=torch.tensor([0, 0, 1, 1])
         ... )
         >>>
-        >>> # The AnomalibMetric class allows us to update the metric by passing a Batch
-        >>> # object directly.
+        >>> # Update metric with batch directly
         >>> f1_score.update(batch)
         >>> f1_score.compute()
         tensor(0.6667)
-        >>>
-        >>> # specifying the field names allows us to distinguish between image and
-        >>> # pixel metrics.
-        >>> image_f1_score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
-        >>> pixel_f1_score = F1Score(fields=[pred_mask", "gt_mask"], prefix="pixel_")
+
+    Use factory function to create metric::
+
+        >>> from anomalib.metrics import create_anomalib_metric
+        >>> F1Score = create_anomalib_metric(BinaryF1Score)
+        >>> f1_score = F1Score(fields=["pred_label", "gt_label"])
+"""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Sequence
+
+from torchmetrics import Metric, MetricCollection
+
+from anomalib.data import Batch
+
+
+class AnomalibMetric:
+    """Base class for metrics in Anomalib.
+
+    Makes any torchmetrics metric compatible with the Anomalib framework by adding
+    batch processing capabilities. Subclasses must inherit from both this class
+    and a torchmetrics metric.
+
+    The class enables updating metrics with ``Batch`` objects instead of
+    individual tensors. It extracts the specified fields from the batch and
+    passes them to the underlying metric's update method.
+
+    Args:
+        fields (Sequence[str] | None): Names of fields to extract from batch.
+            If None, uses class's ``default_fields``. Required if no defaults.
+        prefix (str): Prefix added to metric name. Defaults to "".
+        **kwargs: Additional arguments passed to parent metric class.
+
+    Raises:
+        ValueError: If no fields are specified and class has no defaults.
+
+    Example:
+        Create image and pixel-level F1 metrics::
+
+            >>> from torchmetrics.classification import BinaryF1Score
+            >>> class F1Score(AnomalibMetric, BinaryF1Score):
+            ...     pass
+            ...
+            >>> # Image-level metric using pred_label and gt_label
+            >>> image_f1 = F1Score(
+            ...     fields=["pred_label", "gt_label"],
+            ...     prefix="image_"
+            ... )
+            >>> # Pixel-level metric using pred_mask and gt_mask
+            >>> pixel_f1 = F1Score(
+            ...     fields=["pred_mask", "gt_mask"],
+            ...     prefix="pixel_"
+            ... )
     """
 
     default_fields: Sequence[str]
 
-    def __init__(self, fields: Sequence[str] | None = None, prefix: str = "", **kwargs) -> None:
+    def __init__(
+        self,
+        fields: Sequence[str] | None = None,
+        prefix: str = "",
+        **kwargs,
+    ) -> None:
         fields = fields or getattr(self, "default_fields", None)
         if fields is None:
             msg = (
@@ -76,7 +112,7 @@ def __init__(self, fields: Sequence[str] | None = None, prefix: str = "", **kwar
         super().__init__(**kwargs)
 
     def __init_subclass__(cls, **kwargs) -> None:
-        """Check that the subclass implements the torchmetrics.Metric interface."""
+        """Check that subclass implements torchmetrics.Metric interface."""
         del kwargs
         assert issubclass(
             cls,
@@ -84,7 +120,16 @@ def __init_subclass__(cls, **kwargs) -> None:
         ), "AnomalibMetric must be a subclass of torchmetrics.Metric or torchmetrics.MetricCollection"
 
     def update(self, batch: Batch, *args, **kwargs) -> None:
-        """Update the metric with the specified fields from the Batch object."""
+        """Update metric with values from batch fields.
+
+        Args:
+            batch (Batch): Batch object containing required fields.
+            *args: Additional positional arguments passed to parent update.
+            **kwargs: Additional keyword arguments passed to parent update.
+
+        Raises:
+            ValueError: If batch is missing any required fields.
+        """
         for key in self.fields:
             if getattr(batch, key, None) is None:
                 msg = f"Batch object is missing required field: {key}"
@@ -96,32 +141,29 @@ def update(self, batch: Batch, *args, **kwargs) -> None:
 def create_anomalib_metric(metric_cls: type) -> type:
     """Create an Anomalib version of a torchmetrics metric.
 
-    This function creates an Anomalib version of a torchmetrics metric by inheriting
-    from the AnomalibMetric class and the specified torchmetrics metric class. The
-    resulting class will have the same name as the input metric class and will inherit
-    from both AnomalibMetric and the input metric class.
+    Factory function that creates a new class inheriting from both
+    ``AnomalibMetric`` and the input metric class. The resulting class has
+    batch processing capabilities while maintaining the original metric's
+    functionality.
 
     Args:
-        metric_cls (Callable): The torchmetrics metric class to wrap.
+        metric_cls (type): torchmetrics metric class to wrap.
 
     Returns:
-        AnomalibMetric: An Anomalib version of the input metric class.
+        type: New class inheriting from ``AnomalibMetric`` and input class.
 
-    Examples:
-        >>> from torchmetrics.classification import BinaryF1Score
-        >>> from anomalib.metrics import create_anomalib_metric
-        >>>
-        >>> F1Score = create_anomalib_metric(BinaryF1Score)
-        >>> # This is equivalent to the following class definition:
-        >>> # class F1Score(AnomalibMetric, BinaryF1Score): ...
-        >>>
-        >>> f1_score = F1Score(fields=["pred_label", "gt_label"])
-        >>>
-        >>> # The AnomalibMetric class allows us to update the metric by passing a Batch
-        >>> # object directly.
-        >>> f1_score.update(batch)
-        >>> f1_score.compute()
-        tensor(0.6667)
+    Raises:
+        AssertionError: If input class is not a torchmetrics.Metric subclass.
+
+    Example:
+        Create F1 score metric::
+
+            >>> from torchmetrics.classification import BinaryF1Score
+            >>> F1Score = create_anomalib_metric(BinaryF1Score)
+            >>> f1_score = F1Score(fields=["pred_label", "gt_label"])
+            >>> f1_score.update(batch)  # Can update with batch directly
+            >>> f1_score.compute()
+            tensor(0.6667)
     """
     assert issubclass(metric_cls, Metric), "The wrapped metric must be a subclass of torchmetrics.Metric."
     return type(metric_cls.__name__, (AnomalibMetric, metric_cls), {})
diff --git a/src/anomalib/metrics/binning.py b/src/anomalib/metrics/binning.py
index b56c234800..7b36299791 100644
--- a/src/anomalib/metrics/binning.py
+++ b/src/anomalib/metrics/binning.py
@@ -1,4 +1,22 @@
-"""Binning functions for metrics."""
+"""Binning functions for metrics.
+
+This module provides utility functions for generating threshold values used in
+various metrics calculations.
+
+Example:
+    >>> import torch
+    >>> from anomalib.metrics.binning import thresholds_between_min_and_max
+    >>> preds = torch.tensor([0.1, 0.5, 0.8])
+    >>> thresholds = thresholds_between_min_and_max(preds, num_thresholds=3)
+    >>> thresholds
+    tensor([0.1000, 0.4500, 0.8000])
+
+    Generate thresholds between 0 and 1:
+    >>> from anomalib.metrics.binning import thresholds_between_0_and_1
+    >>> thresholds = thresholds_between_0_and_1(num_thresholds=3)
+    >>> thresholds
+    tensor([0.0000, 0.5000, 1.0000])
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,29 +30,48 @@ def thresholds_between_min_and_max(
     num_thresholds: int = 100,
     device: torch.device | None = None,
 ) -> torch.Tensor:
-    """Threshold values between min and max of the predictions.
+    """Generate evenly spaced threshold values between min and max predictions.
 
     Args:
-        preds (torch.Tensor): Predictions.
-        num_thresholds (int, optional): Number of thresholds to generate. Defaults to 100.
-        device (torch_device | None, optional): Device to use for computation. Defaults to None.
+        preds (torch.Tensor): Input tensor containing predictions or scores.
+        num_thresholds (int, optional): Number of threshold values to generate.
+            Defaults to ``100``.
+        device (torch.device | None, optional): Device on which to place the
+            output tensor. If ``None``, uses the device of input tensor.
+            Defaults to ``None``.
 
     Returns:
-        Tensor:
-            Array of size ``num_thresholds`` that contains evenly spaced values
-            between ``preds.min()`` and ``preds.max()`` on ``device``.
+        torch.Tensor: A 1D tensor of size ``num_thresholds`` containing evenly
+            spaced values between ``preds.min()`` and ``preds.max()``.
+
+    Example:
+        >>> preds = torch.tensor([0.1, 0.3, 0.5, 0.7, 0.9])
+        >>> thresholds = thresholds_between_min_and_max(preds, num_thresholds=3)
+        >>> thresholds
+        tensor([0.1000, 0.5000, 0.9000])
     """
     return linspace(start=preds.min(), end=preds.max(), steps=num_thresholds, device=device)
 
 
-def thresholds_between_0_and_1(num_thresholds: int = 100, device: torch.device | None = None) -> torch.Tensor:
-    """Threshold values between 0 and 1.
+def thresholds_between_0_and_1(
+    num_thresholds: int = 100,
+    device: torch.device | None = None,
+) -> torch.Tensor:
+    """Generate evenly spaced threshold values between 0 and 1.
 
     Args:
-        num_thresholds (int, optional): Number of thresholds to generate. Defaults to 100.
-        device (torch_device | None, optional): Device to use for computation. Defaults to None.
+        num_thresholds (int, optional): Number of threshold values to generate.
+            Defaults to ``100``.
+        device (torch.device | None, optional): Device on which to place the
+            output tensor. Defaults to ``None``.
 
     Returns:
-        Tensor: Threshold values between 0 and 1.
+        torch.Tensor: A 1D tensor of size ``num_thresholds`` containing evenly
+            spaced values between ``0`` and ``1``.
+
+    Example:
+        >>> thresholds = thresholds_between_0_and_1(num_thresholds=5)
+        >>> thresholds
+        tensor([0.0000, 0.2500, 0.5000, 0.7500, 1.0000])
     """
     return linspace(start=0, end=1, steps=num_thresholds, device=device)
diff --git a/src/anomalib/metrics/evaluator.py b/src/anomalib/metrics/evaluator.py
index 460a2a4b0b..76e1893b27 100644
--- a/src/anomalib/metrics/evaluator.py
+++ b/src/anomalib/metrics/evaluator.py
@@ -1,4 +1,51 @@
-"""Evaluator module for LightningModule."""
+"""Evaluator module for LightningModule.
+
+The Evaluator module computes and logs metrics during validation and test steps.
+Each ``AnomalibModule`` should have an Evaluator module as a submodule to compute
+and log metrics. An Evaluator module can be passed to the ``AnomalibModule`` as a
+parameter during initialization. When no Evaluator module is provided, the
+``AnomalibModule`` will use a default Evaluator module that logs a default set of
+metrics.
+
+Args:
+    val_metrics (Sequence[AnomalibMetric] | AnomalibMetric | None, optional):
+        Validation metrics. Defaults to ``None``.
+    test_metrics (Sequence[AnomalibMetric] | AnomalibMetric | None, optional):
+        Test metrics. Defaults to ``None``.
+    compute_on_cpu (bool, optional): Whether to compute metrics on CPU.
+        Defaults to ``True``.
+
+Example:
+    >>> from anomalib.metrics import F1Score, AUROC
+    >>> from anomalib.data import ImageBatch
+    >>> import torch
+    >>>
+    >>> # Initialize metrics with fields to use from batch
+    >>> f1_score = F1Score(fields=["pred_label", "gt_label"])
+    >>> auroc = AUROC(fields=["pred_score", "gt_label"])
+    >>>
+    >>> # Create evaluator with test metrics
+    >>> evaluator = Evaluator(test_metrics=[f1_score, auroc])
+    >>>
+    >>> # Create sample batch
+    >>> batch = ImageBatch(
+    ...     image=torch.rand(4, 3, 256, 256),
+    ...     pred_label=torch.tensor([0, 0, 1, 1]),
+    ...     gt_label=torch.tensor([0, 0, 1, 1]),
+    ...     pred_score=torch.tensor([0.1, 0.2, 0.8, 0.9])
+    ... )
+    >>>
+    >>> # Update metrics with batch
+    >>> evaluator.on_test_batch_end(None, None, None, batch, 0)
+    >>>
+    >>> # Compute and log metrics at end of epoch
+    >>> evaluator.on_test_epoch_end(None, None)
+
+Note:
+    The evaluator will automatically move metrics to CPU for computation if
+    ``compute_on_cpu=True`` and only one device is used. For multi-GPU training,
+    ``compute_on_cpu`` is automatically set to ``False``.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/metrics/f1_score.py b/src/anomalib/metrics/f1_score.py
index ab85c0cc03..68a753dc7b 100644
--- a/src/anomalib/metrics/f1_score.py
+++ b/src/anomalib/metrics/f1_score.py
@@ -1,4 +1,31 @@
-"""F1 Score and F1Max Metrics for Binary Classification Tasks."""
+"""F1 Score and F1Max metrics for binary classification tasks.
+
+This module provides two metrics for evaluating binary classification performance:
+
+- ``F1Score``: Standard F1 score metric that computes the harmonic mean of
+  precision and recall at a fixed threshold
+- ``F1Max``: Maximum F1 score metric that finds the optimal threshold by
+  computing F1 scores across different thresholds
+
+Example:
+    >>> from anomalib.metrics import F1Score, F1Max
+    >>> import torch
+    >>> # Create sample data
+    >>> preds = torch.tensor([0.1, 0.4, 0.35, 0.8])
+    >>> target = torch.tensor([0, 0, 1, 1])
+    >>> # Compute standard F1 score
+    >>> f1 = F1Score()
+    >>> f1.update(preds > 0.5, target)
+    >>> f1.compute()
+    tensor(1.0)
+    >>> # Compute maximum F1 score
+    >>> f1_max = F1Max()
+    >>> f1_max.update(preds, target)
+    >>> f1_max.compute()
+    tensor(1.0)
+    >>> f1_max.threshold
+    tensor(0.6000)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,56 +40,60 @@
 
 
 class F1Score(AnomalibMetric, BinaryF1Score):
-    """Wrapper to add AnomalibMetric functionality to F1Score metric."""
+    """Wrapper to add AnomalibMetric functionality to F1Score metric.
+
+    This class wraps the torchmetrics ``BinaryF1Score`` to make it compatible
+    with Anomalib's batch processing capabilities.
+
+    Example:
+        >>> from anomalib.metrics import F1Score
+        >>> import torch
+        >>> # Create metric
+        >>> f1 = F1Score()
+        >>> # Create sample data
+        >>> preds = torch.tensor([0, 0, 1, 1])
+        >>> target = torch.tensor([0, 1, 1, 1])
+        >>> # Update and compute
+        >>> f1.update(preds, target)
+        >>> f1.compute()
+        tensor(0.8571)
+    """
 
 
 class _F1Max(Metric):
-    """F1Max Metric for Computing the Maximum F1 Score.
+    """F1Max metric for computing the maximum F1 score.
 
-    This class is designed to calculate the maximum F1 score from the precision-
-    recall curve for binary classification tasks. The F1 score is a harmonic
-    mean of precision and recall, offering a balance between these two metrics.
-    The maximum F1 score (F1-Max) is particularly useful in scenarios where an
-    optimal balance between precision and recall is desired, such as in
-    imbalanced datasets or when both false positives and false negatives carry
-    significant costs.
+    This class calculates the maximum F1 score by varying the classification
+    threshold. The F1 score is the harmonic mean of precision and recall,
+    providing a balanced metric for imbalanced datasets.
 
-    After computing the F1Max score, the class also identifies and stores the
-    threshold that yields this maximum F1 score, which providing insight into
-    the optimal point for the classification decision.
+    After computing the maximum F1 score, the class stores the threshold that
+    achieved this score in the ``threshold`` attribute.
 
     Args:
-        **kwargs: Variable keyword arguments that can be passed to the parent class.
+        **kwargs: Additional arguments passed to the parent ``Metric`` class.
 
     Attributes:
-        full_state_update (bool): Indicates whether the metric requires updating
-            the entire state. Set to False for this metric as it calculates the
-            F1 score based on the current state without needing historical data.
+        full_state_update (bool): Whether to update entire state on each batch.
+            Set to ``False`` as metric only needs current batch.
         precision_recall_curve (BinaryPrecisionRecallCurve): Utility to compute
-            precision and recall values across different thresholds.
-        threshold (torch.Tensor): Stores the threshold value that results in the
-            maximum F1 score.
+            precision-recall values across thresholds.
+        threshold (torch.Tensor): Threshold value that yields maximum F1 score.
 
-    Examples:
+    Example:
         >>> from anomalib.metrics import F1Max
         >>> import torch
-
+        >>> # Create metric
+        >>> f1_max = F1Max()
+        >>> # Create sample data
         >>> preds = torch.tensor([0.1, 0.4, 0.35, 0.8])
         >>> target = torch.tensor([0, 0, 1, 1])
-
-        >>> f1_max = F1Max()
+        >>> # Update and compute
         >>> f1_max.update(preds, target)
-
-        >>> optimal_f1_score = f1_max.compute()
-        >>> print(f"Optimal F1 Score: {f1_max_score}")
-        >>> print(f"Optimal Threshold: {f1_max.threshold}")
-
-    Note:
-        - Use `update` method to input predictions and target labels.
-        - Use `compute` method to calculate the maximum F1 score after all
-          updates.
-        - Use `reset` method to clear the current state and prepare for a new
-          set of calculations.
+        >>> f1_max.compute()
+        tensor(1.0)
+        >>> f1_max.threshold
+        tensor(0.6000)
     """
 
     full_state_update: bool = False
@@ -75,19 +106,27 @@ def __init__(self, **kwargs) -> None:
         self.threshold: torch.Tensor
 
     def update(self, preds: torch.Tensor, target: torch.Tensor, *args, **kwargs) -> None:
-        """Update the precision-recall curve metric."""
+        """Update the precision-recall curve with new predictions and targets.
+
+        Args:
+            preds (torch.Tensor): Predicted scores or probabilities.
+            target (torch.Tensor): Ground truth binary labels.
+            *args: Additional positional arguments (unused).
+            **kwargs: Additional keyword arguments (unused).
+        """
         del args, kwargs  # These variables are not used.
 
         self.precision_recall_curve.update(preds, target)
 
     def compute(self) -> torch.Tensor:
-        """Compute the value of the optimal F1 score.
+        """Compute the maximum F1 score across all thresholds.
 
-        Compute the F1 scores while varying the threshold. Store the optimal
-        threshold as attribute and return the maximum value of the F1 score.
+        Computes F1 scores at different thresholds using the precision-recall
+        curve. Stores the threshold that achieves maximum F1 score in the
+        ``threshold`` attribute.
 
         Returns:
-            Value of the F1 score at the optimal threshold.
+            torch.Tensor: Maximum F1 score value.
         """
         precision: torch.Tensor
         recall: torch.Tensor
@@ -99,9 +138,30 @@ def compute(self) -> torch.Tensor:
         return torch.max(f1_score)
 
     def reset(self) -> None:
-        """Reset the metric."""
+        """Reset the metric state."""
         self.precision_recall_curve.reset()
 
 
 class F1Max(AnomalibMetric, _F1Max):  # type: ignore[misc]
-    """Wrapper to add AnomalibMetric functionality to F1Max metric."""
+    """Wrapper to add AnomalibMetric functionality to F1Max metric.
+
+    This class wraps the internal ``_F1Max`` metric to make it compatible with
+    Anomalib's batch processing capabilities.
+
+    Example:
+        >>> from anomalib.metrics import F1Max
+        >>> from anomalib.data import ImageBatch
+        >>> import torch
+        >>> # Create metric with batch fields
+        >>> f1_max = F1Max(fields=["pred_score", "gt_label"])
+        >>> # Create sample batch
+        >>> batch = ImageBatch(
+        ...     image=torch.rand(4, 3, 32, 32),
+        ...     pred_score=torch.tensor([0.1, 0.4, 0.35, 0.8]),
+        ...     gt_label=torch.tensor([0, 0, 1, 1])
+        ... )
+        >>> # Update and compute
+        >>> f1_max.update(batch)
+        >>> f1_max.compute()
+        tensor(1.0)
+    """
diff --git a/src/anomalib/metrics/min_max.py b/src/anomalib/metrics/min_max.py
index 8456174ec9..4ca3e71245 100644
--- a/src/anomalib/metrics/min_max.py
+++ b/src/anomalib/metrics/min_max.py
@@ -1,4 +1,28 @@
-"""Module that tracks the min and max values of the observations in each batch."""
+"""Module that tracks the min and max values of the observations in each batch.
+
+This module provides the ``MinMax`` metric class which tracks the minimum and
+maximum values seen across batches of data. This is useful for normalizing
+predictions or monitoring value ranges during training.
+
+Example:
+    >>> from anomalib.metrics import MinMax
+    >>> import torch
+    >>> # Create sample predictions
+    >>> predictions = torch.tensor([0.0807, 0.6329, 0.0559, 0.9860, 0.3595])
+    >>> # Initialize and compute min/max
+    >>> minmax = MinMax()
+    >>> min_val, max_val = minmax(predictions)
+    >>> min_val, max_val
+    (tensor(0.0559), tensor(0.9860))
+
+    The metric can be updated incrementally with new batches:
+
+    >>> new_predictions = torch.tensor([0.3251, 0.3169, 0.3072, 0.6247, 0.9999])
+    >>> minmax.update(new_predictions)
+    >>> min_val, max_val = minmax.compute()
+    >>> min_val, max_val
+    (tensor(0.0559), tensor(0.9999))
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -8,29 +32,35 @@
 
 
 class MinMax(Metric):
-    """Track the min and max values of the observations in each batch.
+    """Track minimum and maximum values across batches.
+
+    This metric maintains running minimum and maximum values across all batches
+    it processes. It is useful for tasks like normalization or monitoring the
+    range of values during training.
 
     Args:
-        full_state_update (bool, optional): Whether to update the state with the
-            new values.
-            Defaults to ``True``.
-        kwargs: Any keyword arguments.
+        full_state_update (bool, optional): Whether to update the internal state
+            with each new batch. Defaults to ``True``.
+        kwargs: Additional keyword arguments passed to the parent class.
 
-    Examples:
+    Attributes:
+        min (torch.Tensor): Running minimum value seen across all batches
+        max (torch.Tensor): Running maximum value seen across all batches
+
+    Example:
         >>> from anomalib.metrics import MinMax
         >>> import torch
-        ...
-        >>> predictions = torch.tensor([0.0807, 0.6329, 0.0559, 0.9860, 0.3595])
+        >>> # Create metric
         >>> minmax = MinMax()
-        >>> minmax(predictions)
-        (tensor(0.0559), tensor(0.9860))
-
-        It is possible to update the minmax values with a new tensor of predictions.
-
-        >>> new_predictions = torch.tensor([0.3251, 0.3169, 0.3072, 0.6247, 0.9999])
-        >>> minmax.update(new_predictions)
-        >>> minmax.compute()
-        (tensor(0.0559), tensor(0.9999))
+        >>> # Update with batches
+        >>> batch1 = torch.tensor([0.1, 0.2, 0.3])
+        >>> batch2 = torch.tensor([0.2, 0.4, 0.5])
+        >>> minmax.update(batch1)
+        >>> minmax.update(batch2)
+        >>> # Get final min/max values
+        >>> min_val, max_val = minmax.compute()
+        >>> min_val, max_val
+        (tensor(0.1000), tensor(0.5000))
     """
 
     full_state_update: bool = True
@@ -44,12 +74,24 @@ def __init__(self, **kwargs) -> None:
         self.max = torch.tensor(float("-inf"))
 
     def update(self, predictions: torch.Tensor, *args, **kwargs) -> None:
-        """Update the min and max values."""
+        """Update running min and max values with new predictions.
+
+        Args:
+            predictions (torch.Tensor): New tensor of values to include in min/max
+                tracking
+            *args: Additional positional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
+        """
         del args, kwargs  # These variables are not used.
 
         self.max = torch.max(self.max, torch.max(predictions))
         self.min = torch.min(self.min, torch.min(predictions))
 
     def compute(self) -> tuple[torch.Tensor, torch.Tensor]:
-        """Return min and max values."""
+        """Compute final minimum and maximum values.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing the (min, max)
+                values tracked across all batches
+        """
         return self.min, self.max
diff --git a/src/anomalib/metrics/pimo/__init__.py b/src/anomalib/metrics/pimo/__init__.py
index 174f546e4d..f84a8da5d5 100644
--- a/src/anomalib/metrics/pimo/__init__.py
+++ b/src/anomalib/metrics/pimo/__init__.py
@@ -1,4 +1,22 @@
-"""Per-Image Metrics."""
+"""Per-Image Metrics for anomaly detection.
+
+This module provides metrics for evaluating anomaly detection performance on a
+per-image basis. The metrics include:
+
+- ``PIMO``: Per-Image Metric Optimization for anomaly detection
+- ``AUPIMO``: Area Under PIMO curve
+- ``ThresholdMethod``: Methods for determining optimal thresholds
+- ``PIMOResult``: Container for PIMO metric results
+- ``AUPIMOResult``: Container for AUPIMO metric results
+
+The implementation is based on the original work from:
+https://github.com/jpcbertoldo/aupimo
+
+Example:
+    >>> from anomalib.metrics.pimo import PIMO, AUPIMO
+    >>> pimo = PIMO()  # doctest: +SKIP
+    >>> aupimo = AUPIMO()  # doctest: +SKIP
+"""
 
 # Original Code
 # https://github.com/jpcbertoldo/aupimo
diff --git a/src/anomalib/metrics/pimo/_validate.py b/src/anomalib/metrics/pimo/_validate.py
index f0ba7af4bf..4ca27ede6b 100644
--- a/src/anomalib/metrics/pimo/_validate.py
+++ b/src/anomalib/metrics/pimo/_validate.py
@@ -1,7 +1,26 @@
-"""Utils for validating arguments and results.
+"""Utilities for validating arguments and results.
 
-TODO(jpcbertoldo): Move validations to a common place and reuse them across the codebase.
-https://github.com/openvinotoolkit/anomalib/issues/2093
+This module provides validation functions for various inputs and outputs used in
+the PIMO metrics. The functions check for correct data types, shapes, ranges and
+other constraints.
+
+The validation functions include:
+
+- Threshold validation (number, bounds, etc)
+- Rate validation (ranges, curves, etc)
+- Tensor validation (anomaly maps, masks, etc)
+- Binary classification curve validation
+- Score validation
+- Ground truth validation
+
+TODO(jpcbertoldo): Move validations to a common place and reuse them across the
+codebase. https://github.com/openvinotoolkit/anomalib/issues/2093
+
+Example:
+    >>> from anomalib.metrics.pimo._validate import is_rate
+    >>> is_rate(0.5, zero_ok=True, one_ok=True)  # No error
+    >>> is_rate(-0.1, zero_ok=True, one_ok=True)  # Raises ValueError
+    ValueError: Expected rate to be in [0, 1], but got -0.1.
 """
 
 # Original Code
@@ -22,7 +41,20 @@
 
 
 def is_num_thresholds_gte2(num_thresholds: int) -> None:
-    """Validate the number of thresholds is a positive integer >= 2."""
+    """Validate that the number of thresholds is a positive integer >= 2.
+
+    Args:
+        num_thresholds: Number of thresholds to validate.
+
+    Raises:
+        TypeError: If ``num_thresholds`` is not an integer.
+        ValueError: If ``num_thresholds`` is less than 2.
+
+    Example:
+        >>> is_num_thresholds_gte2(5)  # No error
+        >>> is_num_thresholds_gte2(1)  # Raises ValueError
+        ValueError: Expected the number of thresholds to be larger than 1, but got 1
+    """
     if not isinstance(num_thresholds, int):
         msg = f"Expected the number of thresholds to be an integer, but got {type(num_thresholds)}"
         raise TypeError(msg)
@@ -33,7 +65,25 @@ def is_num_thresholds_gte2(num_thresholds: int) -> None:
 
 
 def is_same_shape(*args) -> None:
-    """Works both for tensors and ndarrays."""
+    """Validate that all arguments have the same shape.
+
+    Works for both tensors and ndarrays.
+
+    Args:
+        *args: Variable number of tensors or ndarrays to compare shapes.
+
+    Raises:
+        ValueError: If arguments have different shapes.
+
+    Example:
+        >>> import torch
+        >>> t1 = torch.zeros(2, 3)
+        >>> t2 = torch.ones(2, 3)
+        >>> is_same_shape(t1, t2)  # No error
+        >>> t3 = torch.zeros(3, 2)
+        >>> is_same_shape(t1, t3)  # Raises ValueError
+        ValueError: Expected arguments to have the same shape, but got [(2, 3), (3, 2)]
+    """
     assert len(args) > 0
     shapes = sorted({tuple(arg.shape) for arg in args})
     if len(shapes) > 1:
@@ -42,12 +92,21 @@ def is_same_shape(*args) -> None:
 
 
 def is_rate(rate: float | int, zero_ok: bool, one_ok: bool) -> None:
-    """Validates a rate parameter.
+    """Validate a rate parameter.
 
     Args:
-        rate (float | int): The rate to be validated.
-        zero_ok (bool): Flag indicating if rate can be 0.
-        one_ok (bool): Flag indicating if rate can be 1.
+        rate: The rate value to validate.
+        zero_ok: Whether 0.0 is an acceptable value.
+        one_ok: Whether 1.0 is an acceptable value.
+
+    Raises:
+        TypeError: If ``rate`` is not a float or int.
+        ValueError: If ``rate`` is outside [0,1] or equals 0/1 when not allowed.
+
+    Example:
+        >>> is_rate(0.5, zero_ok=True, one_ok=True)  # No error
+        >>> is_rate(0.0, zero_ok=False, one_ok=True)  # Raises ValueError
+        ValueError: Rate cannot be 0.
     """
     if not isinstance(rate, float | int):
         msg = f"Expected rate to be a float or int, but got {type(rate)}."
@@ -67,10 +126,19 @@ def is_rate(rate: float | int, zero_ok: bool, one_ok: bool) -> None:
 
 
 def is_rate_range(bounds: tuple[float, float]) -> None:
-    """Validates the range of rates within the bounds.
+    """Validate that rate bounds form a valid range.
 
     Args:
-        bounds (tuple[float, float]): The lower and upper bounds of the rates.
+        bounds: Tuple of (lower, upper) rate bounds.
+
+    Raises:
+        TypeError: If ``bounds`` is not a tuple of length 2.
+        ValueError: If bounds are invalid or lower >= upper.
+
+    Example:
+        >>> is_rate_range((0.1, 0.9))  # No error
+        >>> is_rate_range((0.9, 0.1))  # Raises ValueError
+        ValueError: Expected the upper bound to be larger than the lower bound
     """
     if not isinstance(bounds, tuple):
         msg = f"Expected the bounds to be a tuple, but got {type(bounds)}"
@@ -90,7 +158,22 @@ def is_rate_range(bounds: tuple[float, float]) -> None:
 
 
 def is_valid_threshold(thresholds: Tensor) -> None:
-    """Validate that the thresholds are valid and monotonically increasing."""
+    """Validate that thresholds are valid and monotonically increasing.
+
+    Args:
+        thresholds: Tensor of threshold values.
+
+    Raises:
+        TypeError: If ``thresholds`` is not a floating point Tensor.
+        ValueError: If ``thresholds`` is not 1D or not strictly increasing.
+
+    Example:
+        >>> thresholds = torch.tensor([0.1, 0.2, 0.3])
+        >>> is_valid_threshold(thresholds)  # No error
+        >>> bad_thresholds = torch.tensor([0.3, 0.2, 0.1])
+        >>> is_valid_threshold(bad_thresholds)  # Raises ValueError
+        ValueError: Expected thresholds to be strictly increasing
+    """
     if not isinstance(thresholds, Tensor):
         msg = f"Expected thresholds to be an Tensor, but got {type(thresholds)}"
         raise TypeError(msg)
@@ -110,6 +193,20 @@ def is_valid_threshold(thresholds: Tensor) -> None:
 
 
 def validate_threshold_bounds(threshold_bounds: tuple[float, float]) -> None:
+    """Validate threshold bounds form a valid range.
+
+    Args:
+        threshold_bounds: Tuple of (lower, upper) threshold bounds.
+
+    Raises:
+        TypeError: If bounds are not floats or not a tuple of length 2.
+        ValueError: If upper <= lower.
+
+    Example:
+        >>> validate_threshold_bounds((0.1, 0.9))  # No error
+        >>> validate_threshold_bounds((0.9, 0.1))  # Raises ValueError
+        ValueError: Expected the upper bound to be greater than the lower bound
+    """
     if not isinstance(threshold_bounds, tuple):
         msg = f"Expected threshold bounds to be a tuple, but got {type(threshold_bounds)}."
         raise TypeError(msg)
@@ -134,6 +231,21 @@ def validate_threshold_bounds(threshold_bounds: tuple[float, float]) -> None:
 
 
 def is_anomaly_maps(anomaly_maps: Tensor) -> None:
+    """Validate anomaly maps tensor.
+
+    Args:
+        anomaly_maps: Tensor of shape (N, H, W) containing anomaly scores.
+
+    Raises:
+        ValueError: If tensor does not have 3 dimensions.
+        TypeError: If tensor is not floating point.
+
+    Example:
+        >>> maps = torch.randn(10, 32, 32)
+        >>> is_anomaly_maps(maps)  # No error
+        >>> bad_maps = torch.zeros(10, 32, 32, dtype=torch.long)
+        >>> is_anomaly_maps(bad_maps)  # Raises TypeError
+    """
     if anomaly_maps.ndim != 3:
         msg = f"Expected anomaly maps have 3 dimensions (N, H, W), but got {anomaly_maps.ndim} dimensions"
         raise ValueError(msg)
@@ -147,6 +259,22 @@ def is_anomaly_maps(anomaly_maps: Tensor) -> None:
 
 
 def is_masks(masks: Tensor) -> None:
+    """Validate ground truth mask tensor.
+
+    Args:
+        masks: Binary tensor of shape (N, H, W) containing ground truth labels.
+
+    Raises:
+        ValueError: If tensor does not have 3 dimensions or contains non-binary
+            values.
+        TypeError: If tensor has invalid dtype.
+
+    Example:
+        >>> masks = torch.zeros(10, 32, 32, dtype=torch.bool)
+        >>> is_masks(masks)  # No error
+        >>> bad_masks = torch.ones(10, 32, 32) * 2
+        >>> is_masks(bad_masks)  # Raises ValueError
+    """
     if masks.ndim != 3:
         msg = f"Expected masks have 3 dimensions (N, H, W), but got {masks.ndim} dimensions"
         raise ValueError(msg)
@@ -155,8 +283,8 @@ def is_masks(masks: Tensor) -> None:
         pass
     elif masks.dtype.is_floating_point:
         msg = (
-            "Expected masks to be an integer or boolean Tensor with ground truth labels, "
-            f"but got Tensor with dtype {masks.dtype}"
+            "Expected masks to be an integer or boolean Tensor with ground truth "
+            f"labels, but got Tensor with dtype {masks.dtype}"
         )
         raise TypeError(msg)
     else:
@@ -165,13 +293,35 @@ def is_masks(masks: Tensor) -> None:
         masks_unique_vals = torch.unique(masks)
         if torch.any((masks_unique_vals != 0) & (masks_unique_vals != 1)):
             msg = (
-                "Expected masks to be a *binary* Tensor with ground truth labels, "
-                f"but got Tensor with unique values {sorted(masks_unique_vals)}"
+                "Expected masks to be a *binary* Tensor with ground truth "
+                f"labels, but got Tensor with unique values "
+                f"{sorted(masks_unique_vals)}"
             )
             raise ValueError(msg)
 
 
-def is_binclf_curves(binclf_curves: Tensor, valid_thresholds: Tensor | None) -> None:
+def is_binclf_curves(
+    binclf_curves: Tensor,
+    valid_thresholds: Tensor | None,
+) -> None:
+    """Validate binary classification curves tensor.
+
+    Args:
+        binclf_curves: Tensor of shape (N, T, 2, 2) containing confusion matrices
+            for N images and T thresholds.
+        valid_thresholds: Optional tensor of T threshold values.
+
+    Raises:
+        ValueError: If tensor has wrong shape or invalid values.
+        TypeError: If tensor has wrong dtype.
+        RuntimeError: If number of thresholds doesn't match.
+
+    Example:
+        >>> curves = torch.zeros(10, 5, 2, 2, dtype=torch.int64)
+        >>> is_binclf_curves(curves, None)  # No error
+        >>> bad_curves = torch.zeros(10, 5, 3, 2, dtype=torch.int64)
+        >>> is_binclf_curves(bad_curves, None)  # Raises ValueError
+    """
     if binclf_curves.ndim != 4:
         msg = f"Expected binclf curves to be 4D, but got {binclf_curves.ndim}D"
         raise ValueError(msg)
@@ -188,13 +338,13 @@ def is_binclf_curves(binclf_curves: Tensor, valid_thresholds: Tensor | None) ->
         msg = "Expected binclf curves to have non-negative values, but got negative values."
         raise ValueError(msg)
 
-    neg = binclf_curves[:, :, 0, :].sum(axis=-1)  # (num_images, num_thresholds)
+    neg = binclf_curves[:, :, 0, :].sum(dim=-1)  # (num_images, num_thresholds)
 
     if (neg != neg[:, :1]).any():
         msg = "Expected binclf curves to have the same number of negatives per image for every thresh."
         raise ValueError(msg)
 
-    pos = binclf_curves[:, :, 1, :].sum(axis=-1)  # (num_images, num_thresholds)
+    pos = binclf_curves[:, :, 1, :].sum(dim=-1)  # (num_images, num_thresholds)
 
     if (pos != pos[:, :1]).any():
         msg = "Expected binclf curves to have the same number of positives per image for every thresh."
@@ -205,13 +355,29 @@ def is_binclf_curves(binclf_curves: Tensor, valid_thresholds: Tensor | None) ->
 
     if binclf_curves.shape[1] != valid_thresholds.shape[0]:
         msg = (
-            "Expected the binclf curves to have as many confusion matrices as the thresholds sequence, "
-            f"but got {binclf_curves.shape[1]} and {valid_thresholds.shape[0]}"
+            "Expected the binclf curves to have as many confusion matrices as "
+            f"the thresholds sequence, but got {binclf_curves.shape[1]} and "
+            f"{valid_thresholds.shape[0]}"
         )
         raise RuntimeError(msg)
 
 
 def is_images_classes(images_classes: Tensor) -> None:
+    """Validate image-level ground truth labels tensor.
+
+    Args:
+        images_classes: Binary tensor of shape (N,) containing image labels.
+
+    Raises:
+        ValueError: If tensor is not 1D or contains non-binary values.
+        TypeError: If tensor has invalid dtype.
+
+    Example:
+        >>> classes = torch.zeros(10, dtype=torch.bool)
+        >>> is_images_classes(classes)  # No error
+        >>> bad_classes = torch.ones(10) * 2
+        >>> is_images_classes(bad_classes)  # Raises ValueError
+    """
     if images_classes.ndim != 1:
         msg = f"Expected image classes to be 1D, but got {images_classes.ndim}D."
         raise ValueError(msg)
@@ -220,8 +386,9 @@ def is_images_classes(images_classes: Tensor) -> None:
         pass
     elif images_classes.dtype.is_floating_point:
         msg = (
-            "Expected image classes to be an integer or boolean Tensor with ground truth labels, "
-            f"but got Tensor with dtype {images_classes.dtype}"
+            "Expected image classes to be an integer or boolean Tensor with "
+            f"ground truth labels, but got Tensor with dtype "
+            f"{images_classes.dtype}"
         )
         raise TypeError(msg)
     else:
@@ -230,20 +397,38 @@ def is_images_classes(images_classes: Tensor) -> None:
         unique_vals = torch.unique(images_classes)
         if torch.any((unique_vals != 0) & (unique_vals != 1)):
             msg = (
-                "Expected image classes to be a *binary* Tensor with ground truth labels, "
-                f"but got Tensor with unique values {sorted(unique_vals)}"
+                "Expected image classes to be a *binary* Tensor with ground "
+                f"truth labels, but got Tensor with unique values "
+                f"{sorted(unique_vals)}"
             )
             raise ValueError(msg)
 
 
 def is_rates(rates: Tensor, nan_allowed: bool) -> None:
+    """Validate rates tensor.
+
+    Args:
+        rates: Tensor of shape (N,) containing rate values in [0,1].
+        nan_allowed: Whether NaN values are allowed.
+
+    Raises:
+        ValueError: If tensor is not 1D, contains values outside [0,1], or has
+            NaN when not allowed.
+        TypeError: If tensor is not floating point.
+
+    Example:
+        >>> rates = torch.tensor([0.1, 0.5, 0.9])
+        >>> is_rates(rates, nan_allowed=False)  # No error
+        >>> bad_rates = torch.tensor([0.1, float('nan'), 0.9])
+        >>> is_rates(bad_rates, nan_allowed=False)  # Raises ValueError
+    """
     if rates.ndim != 1:
         msg = f"Expected rates to be 1D, but got {rates.ndim}D."
         raise ValueError(msg)
 
     if not rates.dtype.is_floating_point:
         msg = f"Expected rates to have dtype of float type, but got {rates.dtype}."
-        raise ValueError(msg)
+        raise TypeError(msg)
 
     isnan_mask = torch.isnan(rates)
     if nan_allowed:
@@ -266,7 +451,28 @@ def is_rates(rates: Tensor, nan_allowed: bool) -> None:
         raise ValueError(msg)
 
 
-def is_rate_curve(rate_curve: Tensor, nan_allowed: bool, decreasing: bool) -> None:
+def is_rate_curve(
+    rate_curve: Tensor,
+    nan_allowed: bool,
+    decreasing: bool,
+) -> None:
+    """Validate rate curve tensor.
+
+    Args:
+        rate_curve: Tensor of shape (N,) containing rate values.
+        nan_allowed: Whether NaN values are allowed.
+        decreasing: Whether curve should be monotonically decreasing.
+
+    Raises:
+        ValueError: If curve is not monotonic in specified direction.
+
+    Example:
+        >>> curve = torch.tensor([0.9, 0.5, 0.1])
+        >>> is_rate_curve(curve, nan_allowed=False, decreasing=True)  # No error
+        >>> bad_curve = torch.tensor([0.1, 0.5, 0.9])
+        >>> is_rate_curve(bad_curve, nan_allowed=False, decreasing=True)
+        ValueError: Expected rate curve to be monotonically decreasing
+    """
     is_rates(rate_curve, nan_allowed=nan_allowed)
 
     diffs = torch.diff(rate_curve)
@@ -281,14 +487,34 @@ def is_rate_curve(rate_curve: Tensor, nan_allowed: bool, decreasing: bool) -> No
         raise ValueError(msg)
 
 
-def is_per_image_rate_curves(rate_curves: Tensor, nan_allowed: bool, decreasing: bool | None) -> None:
+def is_per_image_rate_curves(
+    rate_curves: Tensor,
+    nan_allowed: bool,
+    decreasing: bool | None,
+) -> None:
+    """Validate per-image rate curves tensor.
+
+    Args:
+        rate_curves: Tensor of shape (N, T) containing rate curves for N images.
+        nan_allowed: Whether NaN values are allowed.
+        decreasing: Whether curves should be monotonically decreasing.
+
+    Raises:
+        ValueError: If curves have invalid values or wrong monotonicity.
+        TypeError: If tensor has wrong dtype.
+
+    Example:
+        >>> curves = torch.zeros(10, 5)  # 10 images, 5 thresholds
+        >>> is_per_image_rate_curves(curves, nan_allowed=False, decreasing=None)
+        >>> # No error
+    """
     if rate_curves.ndim != 2:
         msg = f"Expected per-image rate curves to be 2D, but got {rate_curves.ndim}D."
         raise ValueError(msg)
 
     if not rate_curves.dtype.is_floating_point:
         msg = f"Expected per-image rate curves to have dtype of float type, but got {rate_curves.dtype}."
-        raise ValueError(msg)
+        raise TypeError(msg)
 
     isnan_mask = torch.isnan(rate_curves)
     if nan_allowed:
@@ -313,7 +539,7 @@ def is_per_image_rate_curves(rate_curves: Tensor, nan_allowed: bool, decreasing:
     if decreasing is None:
         return
 
-    diffs = torch.diff(rate_curves, axis=1)
+    diffs = torch.diff(rate_curves, dim=1)
     diffs_valid = diffs[~torch.isnan(diffs)] if nan_allowed else diffs
 
     if decreasing and (diffs_valid > 0).any():
@@ -332,15 +558,30 @@ def is_per_image_rate_curves(rate_curves: Tensor, nan_allowed: bool, decreasing:
 
 
 def is_scores_batch(scores_batch: torch.Tensor) -> None:
-    """scores_batch (torch.Tensor): floating (N, D)."""
+    """Validate batch of anomaly scores.
+
+    Args:
+        scores_batch: Floating point tensor of shape (N, D).
+
+    Raises:
+        TypeError: If tensor is not floating point.
+        ValueError: If tensor is not 2D.
+
+    Example:
+        >>> scores = torch.randn(10, 5)  # 10 samples, 5 features
+        >>> is_scores_batch(scores)  # No error
+        >>> bad_scores = torch.randn(10)  # 1D tensor
+        >>> is_scores_batch(bad_scores)  # Raises ValueError
+    """
     if not isinstance(scores_batch, torch.Tensor):
         msg = f"Expected `scores_batch` to be an torch.Tensor, but got {type(scores_batch)}"
         raise TypeError(msg)
 
     if not scores_batch.dtype.is_floating_point:
         msg = (
-            "Expected `scores_batch` to be an floating torch.Tensor with anomaly scores_batch,"
-            f" but got torch.Tensor with dtype {scores_batch.dtype}"
+            "Expected `scores_batch` to be an floating torch.Tensor with "
+            f"anomaly scores_batch, but got torch.Tensor with dtype "
+            f"{scores_batch.dtype}"
         )
         raise TypeError(msg)
 
@@ -350,15 +591,29 @@ def is_scores_batch(scores_batch: torch.Tensor) -> None:
 
 
 def is_gts_batch(gts_batch: torch.Tensor) -> None:
-    """gts_batch (torch.Tensor): boolean (N, D)."""
+    """Validate batch of ground truth labels.
+
+    Args:
+        gts_batch: Boolean tensor of shape (N, D).
+
+    Raises:
+        TypeError: If tensor is not boolean.
+        ValueError: If tensor is not 2D.
+
+    Example:
+        >>> gts = torch.zeros(10, 5, dtype=torch.bool)
+        >>> is_gts_batch(gts)  # No error
+        >>> bad_gts = torch.zeros(10, dtype=torch.bool)
+        >>> is_gts_batch(bad_gts)  # Raises ValueError
+    """
     if not isinstance(gts_batch, torch.Tensor):
         msg = f"Expected `gts_batch` to be an torch.Tensor, but got {type(gts_batch)}"
         raise TypeError(msg)
 
     if gts_batch.dtype != torch.bool:
         msg = (
-            "Expected `gts_batch` to be an boolean torch.Tensor with anomaly scores_batch,"
-            f" but got torch.Tensor with dtype {gts_batch.dtype}"
+            "Expected `gts_batch` to be an boolean torch.Tensor with anomaly "
+            f"scores_batch, but got torch.Tensor with dtype {gts_batch.dtype}"
         )
         raise TypeError(msg)
 
@@ -368,6 +623,20 @@ def is_gts_batch(gts_batch: torch.Tensor) -> None:
 
 
 def has_at_least_one_anomalous_image(masks: torch.Tensor) -> None:
+    """Validate presence of at least one anomalous image.
+
+    Args:
+        masks: Binary tensor of shape (N, H, W) containing ground truth masks.
+
+    Raises:
+        ValueError: If no anomalous images are found.
+
+    Example:
+        >>> masks = torch.ones(10, 32, 32, dtype=torch.bool)  # All anomalous
+        >>> has_at_least_one_anomalous_image(masks)  # No error
+        >>> normal_masks = torch.zeros(10, 32, 32, dtype=torch.bool)
+        >>> has_at_least_one_anomalous_image(normal_masks)  # Raises ValueError
+    """
     is_masks(masks)
     image_classes = images_classes_from_masks(masks)
     if (image_classes == 1).sum() == 0:
@@ -376,6 +645,20 @@ def has_at_least_one_anomalous_image(masks: torch.Tensor) -> None:
 
 
 def has_at_least_one_normal_image(masks: torch.Tensor) -> None:
+    """Validate presence of at least one normal image.
+
+    Args:
+        masks: Binary tensor of shape (N, H, W) containing ground truth masks.
+
+    Raises:
+        ValueError: If no normal images are found.
+
+    Example:
+        >>> masks = torch.zeros(10, 32, 32, dtype=torch.bool)  # All normal
+        >>> has_at_least_one_normal_image(masks)  # No error
+        >>> anomalous_masks = torch.ones(10, 32, 32, dtype=torch.bool)
+        >>> has_at_least_one_normal_image(anomalous_masks)  # Raises ValueError
+    """
     is_masks(masks)
     image_classes = images_classes_from_masks(masks)
     if (image_classes == 0).sum() == 0:
@@ -383,16 +666,53 @@ def has_at_least_one_normal_image(masks: torch.Tensor) -> None:
         raise ValueError(msg)
 
 
-def joint_validate_thresholds_shared_fpr(thresholds: torch.Tensor, shared_fpr: torch.Tensor) -> None:
+def joint_validate_thresholds_shared_fpr(
+    thresholds: torch.Tensor,
+    shared_fpr: torch.Tensor,
+) -> None:
+    """Validate matching dimensions between thresholds and shared FPR.
+
+    Args:
+        thresholds: Tensor of threshold values.
+        shared_fpr: Tensor of shared false positive rates.
+
+    Raises:
+        ValueError: If tensors have different lengths.
+
+    Example:
+        >>> t = torch.linspace(0, 1, 5)
+        >>> fpr = torch.zeros(5)
+        >>> joint_validate_thresholds_shared_fpr(t, fpr)  # No error
+        >>> bad_fpr = torch.zeros(4)
+        >>> joint_validate_thresholds_shared_fpr(t, bad_fpr)  # Raises ValueError
+    """
     if thresholds.shape[0] != shared_fpr.shape[0]:
         msg = (
-            "Expected `thresholds` and `shared_fpr` to have the same number of elements, "
-            f"but got {thresholds.shape[0]} != {shared_fpr.shape[0]}"
+            "Expected `thresholds` and `shared_fpr` to have the same number of "
+            f"elements, but got {thresholds.shape[0]} != {shared_fpr.shape[0]}"
         )
         raise ValueError(msg)
 
 
-def is_per_image_tprs(per_image_tprs: torch.Tensor, image_classes: torch.Tensor) -> None:
+def is_per_image_tprs(
+    per_image_tprs: torch.Tensor,
+    image_classes: torch.Tensor,
+) -> None:
+    """Validate per-image true positive rates.
+
+    Args:
+        per_image_tprs: Tensor of TPR values for each image.
+        image_classes: Binary tensor indicating normal (0) or anomalous (1)
+            images.
+
+    Raises:
+        ValueError: If TPRs have invalid values or wrong monotonicity.
+
+    Example:
+        >>> tprs = torch.zeros(10, 5)  # 10 images, 5 thresholds
+        >>> classes = torch.zeros(10, dtype=torch.bool)
+        >>> is_per_image_tprs(tprs, classes)  # No error
+    """
     is_images_classes(image_classes)
     # general validations
     is_per_image_rate_curves(
diff --git a/src/anomalib/metrics/pimo/binary_classification_curve.py b/src/anomalib/metrics/pimo/binary_classification_curve.py
index 1a80944041..063090c1a7 100644
--- a/src/anomalib/metrics/pimo/binary_classification_curve.py
+++ b/src/anomalib/metrics/pimo/binary_classification_curve.py
@@ -1,8 +1,26 @@
 """Binary classification curve (numpy-only implementation).
 
-A binary classification (binclf) matrix (TP, FP, FN, TN) is evaluated at multiple thresholds.
-
-The thresholds are shared by all instances/images, but their binclf are computed independently for each instance/image.
+This module provides functionality to compute binary classification matrices at
+multiple thresholds. The thresholds are shared across all instances/images, but
+binary classification metrics are computed independently for each instance/image.
+
+The binary classification matrix contains:
+- True Positives (TP)
+- False Positives (FP)
+- False Negatives (FN)
+- True Negatives (TN)
+
+Example:
+    >>> import torch
+    >>> from anomalib.metrics.pimo.binary_classification_curve import (
+    ...     binary_classification_curve
+    ... )
+    >>> scores = torch.rand(10, 100)  # 10 images, 100 pixels each
+    >>> gts = torch.randint(0, 2, (10, 100)).bool()  # Binary ground truth
+    >>> thresholds = torch.linspace(0, 1, 10)  # 10 thresholds
+    >>> curves = binary_classification_curve(scores, gts, thresholds)
+    >>> curves.shape
+    torch.Size([10, 10, 2, 2])
 """
 
 # Original Code
@@ -26,31 +44,36 @@
 
 
 class ThresholdMethod(Enum):
-    """Sequence of thresholds to use."""
+    """Methods for selecting threshold sequences.
+
+    Available methods:
+        - ``GIVEN``: Use provided thresholds
+        - ``MINMAX_LINSPACE``: Linear spacing between min and max scores
+        - ``MEAN_FPR_OPTIMIZED``: Optimize based on mean false positive rate
+    """
 
-    GIVEN: str = "given"
-    MINMAX_LINSPACE: str = "minmax-linspace"
-    MEAN_FPR_OPTIMIZED: str = "mean-fpr-optimized"
+    GIVEN = "given"
+    MINMAX_LINSPACE = "minmax-linspace"
+    MEAN_FPR_OPTIMIZED = "mean-fpr-optimized"
 
 
 def _binary_classification_curve(scores: np.ndarray, gts: np.ndarray, thresholds: np.ndarray) -> np.ndarray:
-    """One binary classification matrix at each threshold.
+    """Compute binary classification matrices at multiple thresholds.
+
+    This implementation is optimized for CPU performance compared to torchmetrics
+    alternatives when using pre-defined thresholds.
 
-    In the case where the thresholds are given (i.e. not considering all possible thresholds based on the scores),
-    this weird-looking function is faster than the two options in `torchmetrics` on the CPU:
-        - `_binary_precision_recall_curve_update_vectorized`
-        - `_binary_precision_recall_curve_update_loop`
-    (both in module `torchmetrics.functional.classification.precision_recall_curve` in `torchmetrics==1.1.0`).
-    Note: VALIDATION IS NOT DONE HERE. Make sure to validate the arguments before calling this function.
+    Note:
+        Arguments must be validated before calling this function.
 
     Args:
-        scores (np.ndarray): Anomaly scores (D,).
-        gts (np.ndarray): Binary (bool) ground truth of shape (D,).
-        thresholds (np.ndarray): Sequence of thresholds in ascending order (K,).
+        scores: Anomaly scores of shape ``(D,)``
+        gts: Binary ground truth of shape ``(D,)``
+        thresholds: Sequence of thresholds in ascending order ``(K,)``
 
     Returns:
-        np.ndarray: Binary classification matrix curve (K, 2, 2)
-        Details: `anomalib.metrics.per_image.binclf_curve_numpy.binclf_multiple_curves`.
+        Binary classification matrix curve of shape ``(K, 2, 2)``
+        containing TP, FP, FN, TN counts at each threshold
     """
     num_th = len(thresholds)
 
@@ -58,7 +81,8 @@ def _binary_classification_curve(scores: np.ndarray, gts: np.ndarray, thresholds
     scores_positives = scores[gts]
     # the sorting is very important for the algorithm to work and the speedup
     scores_positives = np.sort(scores_positives)
-    # variable updated in the loop; start counting with lowest thresh ==> everything is predicted as positive
+    # variable updated in the loop; start counting with lowest thresh ==>
+    # everything is predicted as positive
     num_pos = current_count_tp = scores_positives.size
     tps = np.empty((num_th,), dtype=np.int64)
 
@@ -92,7 +116,7 @@ def score_less_than_thresh(score: float, thresh: float) -> bool:
     fns = num_pos * np.ones((num_th,), dtype=np.int64) - tps
     tns = num_neg * np.ones((num_th,), dtype=np.int64) - fps
 
-    # sequence of dimensions is (thresholds, true class, predicted class) (see docstring)
+    # sequence of dimensions is (thresholds, true class, predicted class)
     return np.stack(
         [
             np.stack([tns, fps], axis=-1),
@@ -107,48 +131,45 @@ def binary_classification_curve(
     gts_batch: torch.Tensor,
     thresholds: torch.Tensor,
 ) -> torch.Tensor:
-    """Returns a binary classification matrix at each threshold for each image in the batch.
+    """Compute binary classification matrices for a batch of images.
 
-    This is a wrapper around `_binary_classification_curve`.
-    Validation of the arguments is done here (not in the actual implementation functions).
+    This is a wrapper around :func:`_binary_classification_curve` that handles
+    input validation and batching.
 
-    Note: predicted as positive condition is `score >= thresh`.
+    Note:
+        Predicted positives are determined by ``score >= thresh``
 
     Args:
-        scores_batch (torch.Tensor): Anomaly scores (N, D,).
-        gts_batch (torch.Tensor): Binary (bool) ground truth of shape (N, D,).
-        thresholds (torch.Tensor): Sequence of thresholds in ascending order (K,).
+        scores_batch: Anomaly scores of shape ``(N, D)``
+        gts_batch: Binary ground truth of shape ``(N, D)``
+        thresholds: Sequence of thresholds in ascending order ``(K,)``
 
     Returns:
-        torch.Tensor: Binary classification matrix curves (N, K, 2, 2)
-
-        The last two dimensions are the confusion matrix (ground truth, predictions)
-        So for each thresh it gives:
-            - `tp`: `[... , 1, 1]`
-            - `fp`: `[... , 0, 1]`
-            - `fn`: `[... , 1, 0]`
-            - `tn`: `[... , 0, 0]`
-
-        `t` is for `true` and `f` is for `false`, `p` is for `positive` and `n` is for `negative`, so:
-            - `tp` stands for `true positive`
-            - `fp` stands for `false positive`
-            - `fn` stands for `false negative`
-            - `tn` stands for `true negative`
-
-        The numbers in each confusion matrix are the counts (not the ratios).
-
-        Counts are relative to each instance (i.e. from 0 to D, e.g. the total is the number of pixels in the image).
-
-        Thresholds are shared across all instances, so all confusion matrices, for instance,
-        at position [:, 0, :, :] are relative to the 1st threshold in `thresholds`.
-
-        Thresholds are sorted in ascending order.
+        Binary classification matrix curves of shape ``(N, K, 2, 2)``
+        where:
+
+        - ``[..., 1, 1]``: True Positives (TP)
+        - ``[..., 0, 1]``: False Positives (FP)
+        - ``[..., 1, 0]``: False Negatives (FN)
+        - ``[..., 0, 0]``: True Negatives (TN)
+
+        The counts are per-instance (e.g. number of pixels in each image).
+        Thresholds are shared across instances.
+
+    Example:
+        >>> scores = torch.rand(10, 100)  # 10 images, 100 pixels each
+        >>> gts = torch.randint(0, 2, (10, 100)).bool()
+        >>> thresholds = torch.linspace(0, 1, 10)
+        >>> curves = binary_classification_curve(scores, gts, thresholds)
+        >>> curves.shape
+        torch.Size([10, 10, 2, 2])
     """
     _validate.is_scores_batch(scores_batch)
     _validate.is_gts_batch(gts_batch)
     _validate.is_same_shape(scores_batch, gts_batch)
     _validate.is_valid_threshold(thresholds)
-    # TODO(ashwinvaidya17): this is kept as numpy for now because it is much faster.
+    # TODO(ashwinvaidya17): this is kept as numpy for now because it is much
+    # faster.
     # TEMP-0
     result = np.vectorize(_binary_classification_curve, signature="(n),(n),(k)->(k,2,2)")(
         scores_batch.detach().cpu().numpy(),
@@ -159,7 +180,18 @@ def binary_classification_curve(
 
 
 def _get_linspaced_thresholds(anomaly_maps: torch.Tensor, num_thresholds: int) -> torch.Tensor:
-    """Get thresholds linearly spaced between the min and max of the anomaly maps."""
+    """Get linearly spaced thresholds between min and max anomaly scores.
+
+    Args:
+        anomaly_maps: Anomaly score maps
+        num_thresholds: Number of thresholds to generate
+
+    Returns:
+        Linearly spaced thresholds of shape ``(num_thresholds,)``
+
+    Raises:
+        ValueError: If threshold bounds are invalid
+    """
     _validate.is_num_thresholds_gte2(num_thresholds)
     # this operation can be a bit expensive
     thresh_low, thresh_high = thresh_bounds = (anomaly_maps.min().item(), anomaly_maps.max().item())
@@ -178,45 +210,42 @@ def threshold_and_binary_classification_curve(
     thresholds: torch.Tensor | None = None,
     num_thresholds: int | None = None,
 ) -> tuple[torch.Tensor, torch.Tensor]:
-    """Return thresholds and binary classification matrix at each threshold for each image in the batch.
+    """Get thresholds and binary classification matrices for a batch of images.
 
     Args:
-        anomaly_maps (torch.Tensor): Anomaly score maps of shape (N, H, W)
-        masks (torch.Tensor): Binary ground truth masks of shape (N, H, W)
-        threshold_choice (str, optional): Sequence of thresholds to use. Defaults to THRESH_SEQUENCE_MINMAX_LINSPACE.
-        thresholds (torch.Tensor, optional): Sequence of thresholds to use.
-            Only applicable when threshold_choice is THRESH_SEQUENCE_GIVEN.
-        num_thresholds (int, optional): Number of thresholds between the min and max of the anomaly maps.
-            Only applicable when threshold_choice is THRESH_SEQUENCE_MINMAX_LINSPACE.
+        anomaly_maps: Anomaly score maps of shape ``(N, H, W)``
+        masks: Binary ground truth masks of shape ``(N, H, W)``
+        threshold_choice: Method for selecting thresholds. Defaults to
+            ``MINMAX_LINSPACE``
+        thresholds: Sequence of thresholds to use. Only used when
+            ``threshold_choice`` is ``GIVEN``
+        num_thresholds: Number of thresholds between min and max scores. Only
+            used when ``threshold_choice`` is ``MINMAX_LINSPACE``
 
     Returns:
-        tuple[torch.Tensor, torch.Tensor]:
-            [0] Thresholds of shape (K,) and dtype is the same as `anomaly_maps.dtype`.
-
-            [1] Binary classification matrices of shape (N, K, 2, 2)
-
-                N: number of images/instances
-                K: number of thresholds
-
-            The last two dimensions are the confusion matrix (ground truth, predictions)
-            So for each thresh it gives:
-                - `tp`: `[... , 1, 1]`
-                - `fp`: `[... , 0, 1]`
-                - `fn`: `[... , 1, 0]`
-                - `tn`: `[... , 0, 0]`
-
-            `t` is for `true` and `f` is for `false`, `p` is for `positive` and `n` is for `negative`, so:
-                - `tp` stands for `true positive`
-                - `fp` stands for `false positive`
-                - `fn` stands for `false negative`
-                - `tn` stands for `true negative`
-
-            The numbers in each confusion matrix are the counts of pixels in the image (not the ratios).
-
-            Thresholds are shared across all images, so all confusion matrices, for instance,
-            at position [:, 0, :, :] are relative to the 1st threshold in `thresholds`.
-
-            Thresholds are sorted in ascending order.
+        Tuple containing:
+
+        - Thresholds of shape ``(K,)`` with same dtype as ``anomaly_maps``
+        - Binary classification matrices of shape ``(N, K, 2, 2)`` where:
+
+          - ``[..., 1, 1]``: True Positives (TP)
+          - ``[..., 0, 1]``: False Positives (FP)
+          - ``[..., 1, 0]``: False Negatives (FN)
+          - ``[..., 0, 0]``: True Negatives (TN)
+
+        The counts are per-instance pixel counts. Thresholds are shared across
+        instances and sorted in ascending order.
+
+    Example:
+        >>> maps = torch.rand(10, 32, 32)  # 10 images
+        >>> masks = torch.randint(0, 2, (10, 32, 32)).bool()
+        >>> thresh, curves = threshold_and_binary_classification_curve(
+        ...     maps,
+        ...     masks,
+        ...     num_thresholds=10,
+        ... )
+        >>> thresh.shape, curves.shape
+        (torch.Size([10]), torch.Size([10, 10, 2, 2]))
     """
     threshold_choice = ThresholdMethod(threshold_choice)
     _validate.is_anomaly_maps(anomaly_maps)
@@ -255,7 +284,7 @@ def threshold_and_binary_classification_curve(
 
     # keep the batch dimension and flatten the rest
     scores_batch = anomaly_maps.reshape(anomaly_maps.shape[0], -1)
-    gts_batch = masks.reshape(masks.shape[0], -1).to(bool)  # make sure it is boolean
+    gts_batch = masks.reshape(masks.shape[0], -1).to(dtype=torch.bool)
 
     binclf_curves = binary_classification_curve(scores_batch, gts_batch, thresholds)
 
@@ -264,8 +293,9 @@ def threshold_and_binary_classification_curve(
     try:
         _validate.is_binclf_curves(binclf_curves, valid_thresholds=thresholds)
 
-        # these two validations cannot be done in `_validate.binclf_curves` because it does not have access to the
-        # original shapes of `anomaly_maps`
+        # these two validations cannot be done in `_validate.binclf_curves`
+        # because it does not have access to the original shapes of
+        # `anomaly_maps`
         if binclf_curves.shape[0] != num_images:
             msg = (
                 "Expected `binclf_curves` to have the same number of images as `anomaly_maps`, "
@@ -281,54 +311,72 @@ def threshold_and_binary_classification_curve(
 
 
 def per_image_tpr(binclf_curves: torch.Tensor) -> torch.Tensor:
-    """True positive rates (TPR) for image for each thresh.
+    """Compute True Positive Rate (TPR) for each image at each threshold.
 
     TPR = TP / P = TP / (TP + FN)
 
-    TP: true positives
-    FM: false negatives
-    P: positives (TP + FN)
+    Where:
+        - TP: True Positives
+        - FN: False Negatives
+        - P: Total Positives (TP + FN)
 
     Args:
-        binclf_curves (torch.Tensor): Binary classification matrix curves (N, K, 2, 2). See `per_image_binclf_curve`.
+        binclf_curves: Binary classification curves of shape ``(N, K, 2, 2)``
+            See :func:`binary_classification_curve`
 
     Returns:
-        torch.Tensor: shape (N, K), dtype float64
-        N: number of images
-        K: number of thresholds
-
-        Thresholds are sorted in ascending order, so TPR is in descending order.
+        TPR values of shape ``(N, K)`` and dtype ``float64`` where:
+            - N: number of images
+            - K: number of thresholds
+
+        TPR is in descending order since thresholds are sorted ascending.
+        TPR will be NaN for normal images (P = 0).
+
+    Example:
+        >>> curves = torch.randint(0, 10, (5, 10, 2, 2))  # 5 imgs, 10 thresh
+        >>> tpr = per_image_tpr(curves)
+        >>> tpr.shape
+        torch.Size([5, 10])
     """
     # shape: (num images, num thresholds)
     tps = binclf_curves[..., 1, 1]
-    pos = binclf_curves[..., 1, :].sum(axis=2)  # 2 was the 3 originally
+    pos = binclf_curves[..., 1, :].sum(dim=2)
 
     # tprs will be nan if pos == 0 (normal image), which is expected
     return tps.to(torch.float64) / pos.to(torch.float64)
 
 
 def per_image_fpr(binclf_curves: torch.Tensor) -> torch.Tensor:
-    """False positive rates (TPR) for image for each thresh.
+    """Compute False Positive Rate (FPR) for each image at each threshold.
 
     FPR = FP / N = FP / (FP + TN)
 
-    FP: false positives
-    TN: true negatives
-    N: negatives (FP + TN)
+    Where:
+        - FP: False Positives
+        - TN: True Negatives
+        - N: Total Negatives (FP + TN)
 
     Args:
-        binclf_curves (torch.Tensor): Binary classification matrix curves (N, K, 2, 2). See `per_image_binclf_curve`.
+        binclf_curves: Binary classification curves of shape ``(N, K, 2, 2)``
+            See :func:`binary_classification_curve`
 
     Returns:
-        torch.Tensor: shape (N, K), dtype float64
-        N: number of images
-        K: number of thresholds
-
-        Thresholds are sorted in ascending order, so FPR is in descending order.
+        FPR values of shape ``(N, K)`` and dtype ``float64`` where:
+            - N: number of images
+            - K: number of thresholds
+
+        FPR is in descending order since thresholds are sorted ascending.
+        FPR will be NaN for fully anomalous images (N = 0).
+
+    Example:
+        >>> curves = torch.randint(0, 10, (5, 10, 2, 2))  # 5 imgs, 10 thresh
+        >>> fpr = per_image_fpr(curves)
+        >>> fpr.shape
+        torch.Size([5, 10])
     """
     # shape: (num images, num thresholds)
     fps = binclf_curves[..., 0, 1]
-    neg = binclf_curves[..., 0, :].sum(axis=2)  # 2 was the 3 originally
+    neg = binclf_curves[..., 0, :].sum(dim=2)
 
     # it can be `nan` if an anomalous image is fully covered by the mask
     return fps.to(torch.float64) / neg.to(torch.float64)
diff --git a/src/anomalib/metrics/pimo/dataclasses.py b/src/anomalib/metrics/pimo/dataclasses.py
index 3eaa04cd12..636261f1be 100644
--- a/src/anomalib/metrics/pimo/dataclasses.py
+++ b/src/anomalib/metrics/pimo/dataclasses.py
@@ -1,4 +1,23 @@
-"""Dataclasses for PIMO metrics."""
+"""Dataclasses for PIMO metrics.
+
+This module provides dataclasses for storing and manipulating PIMO (Per-Image
+Metric Optimization) and AUPIMO (Area Under PIMO) results.
+
+The dataclasses include:
+
+- ``PIMOResult``: Container for PIMO curve data and metadata
+- ``AUPIMOResult``: Container for AUPIMO curve data and metadata
+
+Example:
+    >>> from anomalib.metrics.pimo.dataclasses import PIMOResult
+    >>> import torch
+    >>> thresholds = torch.linspace(0, 1, 10)
+    >>> shared_fpr = torch.linspace(1, 0, 10)  # Decreasing FPR
+    >>> per_image_tprs = torch.rand(5, 10)  # 5 images, 10 thresholds
+    >>> result = PIMOResult(thresholds, shared_fpr, per_image_tprs)
+    >>> result.num_images
+    5
+"""
 
 # Based on the code: https://github.com/jpcbertoldo/aupimo
 #
@@ -16,19 +35,31 @@
 class PIMOResult:
     """Per-Image Overlap (PIMO, pronounced pee-mo) curve.
 
-    This interface gathers the PIMO curve data and metadata and provides several utility methods.
+    This class stores PIMO curve data and metadata and provides utility methods
+    for analysis.
 
     Notation:
-        - N: number of images
-        - K: number of thresholds
-        - FPR: False Positive Rate
-        - TPR: True Positive Rate
-
-    Attributes:
-        thresholds (torch.Tensor): sequence of K (monotonically increasing) thresholds used to compute the PIMO curve
-        shared_fpr (torch.Tensor): K values of the shared FPR metric at the corresponding thresholds
-        per_image_tprs (torch.Tensor): for each of the N images, the K values of in-image TPR at the corresponding
-            thresholds
+        - ``N``: number of images
+        - ``K``: number of thresholds
+        - ``FPR``: False Positive Rate
+        - ``TPR``: True Positive Rate
+
+    Args:
+        thresholds: Sequence of ``K`` monotonically increasing thresholds used
+            to compute the PIMO curve. Shape: ``(K,)``
+        shared_fpr: ``K`` values of the shared FPR metric at corresponding
+            thresholds. Shape: ``(K,)``
+        per_image_tprs: For each of the ``N`` images, the ``K`` values of
+            in-image TPR at corresponding thresholds. Shape: ``(N, K)``
+
+    Example:
+        >>> import torch
+        >>> thresholds = torch.linspace(0, 1, 10)
+        >>> shared_fpr = torch.linspace(1, 0, 10)  # Decreasing FPR
+        >>> per_image_tprs = torch.rand(5, 10)  # 5 images, 10 thresholds
+        >>> result = PIMOResult(thresholds, shared_fpr, per_image_tprs)
+        >>> result.num_images
+        5
     """
 
     # data
@@ -38,25 +69,40 @@ class PIMOResult:
 
     @property
     def num_threshsholds(self) -> int:
-        """Number of thresholds."""
+        """Get number of thresholds.
+
+        Returns:
+            Number of thresholds used in the PIMO curve.
+        """
         return self.thresholds.shape[0]
 
     @property
     def num_images(self) -> int:
-        """Number of images."""
+        """Get number of images.
+
+        Returns:
+            Number of images in the dataset.
+        """
         return self.per_image_tprs.shape[0]
 
     @property
     def image_classes(self) -> torch.Tensor:
-        """Image classes (0: normal, 1: anomalous).
+        """Get image classes (0: normal, 1: anomalous).
 
-        Deduced from the per-image TPRs.
-        If any TPR value is not NaN, the image is considered anomalous.
+        The class is deduced from the per-image TPRs. If any TPR value is not
+        NaN, the image is considered anomalous.
+
+        Returns:
+            Tensor of shape ``(N,)`` containing image classes.
         """
         return (~torch.isnan(self.per_image_tprs)).any(dim=1).to(torch.int32)
 
     def __post_init__(self) -> None:
-        """Validate the inputs for the result object are consistent."""
+        """Validate inputs for result object consistency.
+
+        Raises:
+            TypeError: If inputs are invalid or have inconsistent shapes.
+        """
         try:
             _validate.is_valid_threshold(self.thresholds)
             _validate.is_rate_curve(self.shared_fpr, nan_allowed=False, decreasing=True)  # is_shared_apr
@@ -68,53 +114,74 @@ def __post_init__(self) -> None:
 
         if self.thresholds.shape != self.shared_fpr.shape:
             msg = (
-                f"Invalid {self.__class__.__name__} object. Attributes have inconsistent shapes: "
+                f"Invalid {self.__class__.__name__} object. "
+                f"Attributes have inconsistent shapes: "
                 f"{self.thresholds.shape=} != {self.shared_fpr.shape=}."
             )
             raise TypeError(msg)
 
         if self.thresholds.shape[0] != self.per_image_tprs.shape[1]:
             msg = (
-                f"Invalid {self.__class__.__name__} object. Attributes have inconsistent shapes: "
+                f"Invalid {self.__class__.__name__} object. "
+                f"Attributes have inconsistent shapes: "
                 f"{self.thresholds.shape[0]=} != {self.per_image_tprs.shape[1]=}."
             )
             raise TypeError(msg)
 
     def thresh_at(self, fpr_level: float) -> tuple[int, float, float]:
-        """Return the threshold at the given shared FPR.
+        """Get threshold at given shared FPR level.
 
-        See `anomalib.metrics.per_image.pimo_numpy.thresh_at_shared_fpr_level` for details.
+        For details see
+        :func:`anomalib.metrics.per_image.pimo_numpy.thresh_at_shared_fpr_level`.
 
         Args:
-            fpr_level (float): shared FPR level
+            fpr_level: Target shared FPR level to find threshold for.
 
         Returns:
-            tuple[int, float, float]:
-                [0] index of the threshold
-                [1] threshold
-                [2] the actual shared FPR value at the returned threshold
+            Tuple containing:
+                - Index of the threshold
+                - Threshold value
+                - Actual shared FPR value at returned threshold
+
+        Example:
+            >>> result = PIMOResult(...)  # doctest: +SKIP
+            >>> idx, thresh, fpr = result.thresh_at(0.1)  # doctest: +SKIP
         """
-        return functional.thresh_at_shared_fpr_level(
+        idx, thresh, fpr = functional.thresh_at_shared_fpr_level(
             self.thresholds,
             self.shared_fpr,
             fpr_level,
         )
+        return idx, thresh, float(fpr)
 
 
 @dataclass
 class AUPIMOResult:
-    """Area Under the Per-Image Overlap (AUPIMO, pronounced a-u-pee-mo) curve.
-
-    This interface gathers the AUPIMO data and metadata and provides several utility methods.
-
-    Attributes:
-        fpr_lower_bound (float): [metadata] LOWER bound of the FPR integration range
-        fpr_upper_bound (float): [metadata] UPPER bound of the FPR integration range
-        num_thresholds (int): [metadata] number of thresholds used to effectively compute AUPIMO;
-                            should not be confused with the number of thresholds used to compute the PIMO curve
-        thresh_lower_bound (float): LOWER threshold bound --> corresponds to the UPPER FPR bound
-        thresh_upper_bound (float): UPPER threshold bound --> corresponds to the LOWER FPR bound
-        aupimos (torch.Tensor): values of AUPIMO scores (1 per image)
+    """Area Under Per-Image Overlap (AUPIMO, pronounced a-u-pee-mo) curve.
+
+    This class stores AUPIMO data and metadata and provides utility methods for
+    analysis.
+
+    Args:
+        fpr_lower_bound: Lower bound of the FPR integration range.
+        fpr_upper_bound: Upper bound of the FPR integration range.
+        num_thresholds: Number of thresholds used to compute AUPIMO. Note this
+            is different from thresholds used for PIMO curve.
+        thresh_lower_bound: Lower threshold bound (corresponds to upper FPR).
+        thresh_upper_bound: Upper threshold bound (corresponds to lower FPR).
+        aupimos: AUPIMO scores, one per image. Shape: ``(N,)``
+
+    Example:
+        >>> import torch
+        >>> aupimos = torch.rand(5)  # 5 images
+        >>> result = AUPIMOResult(  # doctest: +SKIP
+        ...     fpr_lower_bound=0.0,
+        ...     fpr_upper_bound=0.3,
+        ...     num_thresholds=100,
+        ...     thresh_lower_bound=0.5,
+        ...     thresh_upper_bound=0.9,
+        ...     aupimos=aupimos
+        ... )
     """
 
     # metadata
@@ -129,51 +196,83 @@ class AUPIMOResult:
 
     @property
     def num_images(self) -> int:
-        """Number of images."""
+        """Get number of images.
+
+        Returns:
+            Number of images in dataset.
+        """
         return self.aupimos.shape[0]
 
     @property
     def num_normal_images(self) -> int:
-        """Number of normal images."""
+        """Get number of normal images.
+
+        Returns:
+            Count of images with class 0 (normal).
+        """
         return int((self.image_classes == 0).sum())
 
     @property
     def num_anomalous_images(self) -> int:
-        """Number of anomalous images."""
+        """Get number of anomalous images.
+
+        Returns:
+            Count of images with class 1 (anomalous).
+        """
         return int((self.image_classes == 1).sum())
 
     @property
     def image_classes(self) -> torch.Tensor:
-        """Image classes (0: normal, 1: anomalous)."""
-        # if an instance has `nan` aupimo it's because it's a normal image
+        """Get image classes (0: normal, 1: anomalous).
+
+        An image is considered normal if its AUPIMO score is NaN.
+
+        Returns:
+            Tensor of shape ``(N,)`` containing image classes.
+        """
         return self.aupimos.isnan().to(torch.int32)
 
     @property
     def fpr_bounds(self) -> tuple[float, float]:
-        """Lower and upper bounds of the FPR integration range."""
+        """Get FPR integration range bounds.
+
+        Returns:
+            Tuple of (lower bound, upper bound) for FPR range.
+        """
         return self.fpr_lower_bound, self.fpr_upper_bound
 
     @property
     def thresh_bounds(self) -> tuple[float, float]:
-        """Lower and upper bounds of the threshold integration range.
+        """Get threshold integration range bounds.
+
+        Note:
+            Bounds correspond to FPR bounds in reverse order:
+                - ``fpr_lower_bound`` -> ``thresh_upper_bound``
+                - ``fpr_upper_bound`` -> ``thresh_lower_bound``
 
-        Recall: they correspond to the FPR bounds in reverse order.
-        I.e.:
-            fpr_lower_bound --> thresh_upper_bound
-            fpr_upper_bound --> thresh_lower_bound
+        Returns:
+            Tuple of (lower bound, upper bound) for threshold range.
         """
         return self.thresh_lower_bound, self.thresh_upper_bound
 
     def __post_init__(self) -> None:
-        """Validate the inputs for the result object are consistent."""
+        """Validate inputs for result object consistency.
+
+        Raises:
+            TypeError: If inputs are invalid.
+        """
         try:
-            _validate.is_rate_range((self.fpr_lower_bound, self.fpr_upper_bound))
-            # TODO(jpcbertoldo): warn when it's too low (use parameters from the numpy code)  # noqa: TD003
+            _validate.is_rate_range(
+                (self.fpr_lower_bound, self.fpr_upper_bound),
+            )
+            # TODO(jpcbertoldo): warn when too low (use numpy code params)  # noqa: TD003
             if self.num_thresholds is not None:
                 _validate.is_num_thresholds_gte2(self.num_thresholds)
-            _validate.is_rates(self.aupimos, nan_allowed=True)  # validate is_aupimos
+            _validate.is_rates(self.aupimos, nan_allowed=True)
 
-            _validate.validate_threshold_bounds((self.thresh_lower_bound, self.thresh_upper_bound))
+            _validate.validate_threshold_bounds(
+                (self.thresh_lower_bound, self.thresh_upper_bound),
+            )
 
         except (TypeError, ValueError) as ex:
             msg = f"Invalid inputs for {self.__class__.__name__} object. Cause: {ex}."
@@ -187,19 +286,37 @@ def from_pimo_result(
         num_thresholds_auc: int,
         aupimos: torch.Tensor,
     ) -> "AUPIMOResult":
-        """Return an AUPIMO result object from a PIMO result object.
+        """Create AUPIMO result from PIMO result.
 
         Args:
-            pimo_result: PIMO result object
-            fpr_bounds: lower and upper bounds of the FPR integration range
-            num_thresholds_auc: number of thresholds used to effectively compute AUPIMO;
-                         NOT the number of thresholds used to compute the PIMO curve!
-            aupimos: AUPIMO scores
+            pimo_result: Source PIMO result object.
+            fpr_bounds: Tuple of (lower, upper) bounds for FPR range.
+            num_thresholds_auc: Number of thresholds for AUPIMO computation.
+                Note this differs from PIMO curve thresholds.
+            aupimos: AUPIMO scores, one per image.
+
+        Returns:
+            New AUPIMO result object.
+
+        Raises:
+            TypeError: If inputs are invalid or inconsistent.
+
+        Example:
+            >>> pimo_result = PIMOResult(...)  # doctest: +SKIP
+            >>> aupimos = torch.rand(5)  # 5 images
+            >>> result = AUPIMOResult.from_pimo_result(  # doctest: +SKIP
+            ...     pimo_result=pimo_result,
+            ...     fpr_bounds=(0.0, 0.3),
+            ...     num_thresholds_auc=100,
+            ...     aupimos=aupimos
+            ... )
         """
         if pimo_result.per_image_tprs.shape[0] != aupimos.shape[0]:
             msg = (
-                f"Invalid {cls.__name__} object. Attributes have inconsistent shapes: "
-                f"there are {pimo_result.per_image_tprs.shape[0]} PIMO curves but {aupimos.shape[0]} AUPIMO scores."
+                f"Invalid {cls.__name__} object. "
+                f"Attributes have inconsistent shapes: "
+                f"there are {pimo_result.per_image_tprs.shape[0]} PIMO curves "
+                f"but {aupimos.shape[0]} AUPIMO scores."
             )
             raise TypeError(msg)
 
@@ -212,10 +329,10 @@ def from_pimo_result(
             raise TypeError(msg)
 
         fpr_lower_bound, fpr_upper_bound = fpr_bounds
-        # recall: fpr upper/lower bounds are the same as the thresh lower/upper bounds
+        # recall: fpr upper/lower bounds are same as thresh lower/upper bounds
         _, thresh_lower_bound, __ = pimo_result.thresh_at(fpr_upper_bound)
         _, thresh_upper_bound, __ = pimo_result.thresh_at(fpr_lower_bound)
-        # `_` is the threshold's index, `__` is the actual fpr value
+        # `_` is threshold's index, `__` is actual fpr value
         return cls(
             fpr_lower_bound=fpr_lower_bound,
             fpr_upper_bound=fpr_upper_bound,
diff --git a/src/anomalib/metrics/pimo/functional.py b/src/anomalib/metrics/pimo/functional.py
index 7eac07b1bd..e3d930de05 100644
--- a/src/anomalib/metrics/pimo/functional.py
+++ b/src/anomalib/metrics/pimo/functional.py
@@ -1,6 +1,33 @@
 """Per-Image Overlap curve (PIMO, pronounced pee-mo) and its area under the curve (AUPIMO).
 
-Details: `anomalib.metrics.per_image.pimo`.
+This module provides functions for computing PIMO curves and AUPIMO scores for
+anomaly detection evaluation.
+
+The PIMO curve plots True Positive Rate (TPR) values for each image across
+multiple anomaly score thresholds. The thresholds are indexed by a shared False
+Positive Rate (FPR) measure computed on normal images.
+
+The AUPIMO score is the area under a PIMO curve within specified FPR bounds,
+normalized to the range [0,1].
+
+See Also:
+    :mod:`anomalib.metrics.per_image.pimo` for detailed documentation.
+
+Example:
+    >>> import torch
+    >>> anomaly_maps = torch.rand(10, 32, 32)  # 10 images of 32x32
+    >>> masks = torch.randint(0, 2, (10, 32, 32))  # Binary masks
+    >>> thresholds, shared_fpr, per_image_tprs, classes = pimo_curves(
+    ...     anomaly_maps,
+    ...     masks,
+    ...     num_thresholds=100
+    ... )
+    >>> aupimo_scores = aupimo_scores(
+    ...     anomaly_maps,
+    ...     masks,
+    ...     num_thresholds=100,
+    ...     fpr_bounds=(1e-5, 1e-4)
+    ... )
 """
 
 # Original Code
@@ -33,31 +60,40 @@ def pimo_curves(
     masks: torch.Tensor,
     num_thresholds: int,
 ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
-    """Compute the Per-IMage Overlap (PIMO, pronounced pee-mo) curves.
+    """Compute the Per-IMage Overlap (PIMO) curves.
 
-    PIMO is a curve of True Positive Rate (TPR) values on each image across multiple anomaly score thresholds.
-    The anomaly score thresholds are indexed by a (cross-image shared) value of False Positive Rate (FPR) measure on
-    the normal images.
-
-    Details: `anomalib.metrics.per_image.pimo`.
-
-    Args' notation:
-        N: number of images
-        H: image height
-        W: image width
-        K: number of thresholds
+    PIMO curves plot True Positive Rate (TPR) values for each image across
+    multiple anomaly score thresholds. The thresholds are indexed by a shared
+    False Positive Rate (FPR) measure computed on normal images.
 
     Args:
-        anomaly_maps: floating point anomaly score maps of shape (N, H, W)
-        masks: binary (bool or int) ground truth masks of shape (N, H, W)
-        num_thresholds: number of thresholds to compute (K)
+        anomaly_maps: Anomaly score maps of shape ``(N, H, W)`` where:
+            - ``N``: number of images
+            - ``H``: image height
+            - ``W``: image width
+        masks: Binary ground truth masks of shape ``(N, H, W)``
+        num_thresholds: Number of thresholds ``K`` to compute
 
     Returns:
-        tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
-            [0] thresholds of shape (K,) in ascending order
-            [1] shared FPR values of shape (K,) in descending order (indices correspond to the thresholds)
-            [2] per-image TPR curves of shape (N, K), axis 1 in descending order (indices correspond to the thresholds)
-            [3] image classes of shape (N,) with values 0 (normal) or 1 (anomalous)
+        tuple containing:
+            - thresholds: Shape ``(K,)`` in ascending order
+            - shared_fpr: Shape ``(K,)`` in descending order
+            - per_image_tprs: Shape ``(N, K)`` in descending order
+            - image_classes: Shape ``(N,)`` with values 0 (normal) or 1
+              (anomalous)
+
+    Raises:
+        ValueError: If inputs are invalid or have inconsistent shapes
+        RuntimeError: If per-image FPR curves from normal images are invalid
+
+    Example:
+        >>> anomaly_maps = torch.rand(10, 32, 32)  # 10 images of 32x32
+        >>> masks = torch.randint(0, 2, (10, 32, 32))  # Binary masks
+        >>> thresholds, shared_fpr, per_image_tprs, classes = pimo_curves(
+        ...     anomaly_maps,
+        ...     masks,
+        ...     num_thresholds=100
+        ... )
     """
     # validate the strings are valid
     _validate.is_num_thresholds_gte2(num_thresholds)
@@ -69,10 +105,11 @@ def pimo_curves(
 
     image_classes = images_classes_from_masks(masks)
 
-    # the thresholds are computed here so that they can be restrained to the normal images
-    # therefore getting a better resolution in terms of FPR quantization
-    # otherwise the function `binclf_curve_numpy.per_image_binclf_curve` would have the range of thresholds
-    # computed from all the images (normal + anomalous)
+    # the thresholds are computed here so that they can be restrained to the
+    # normal images therefore getting a better resolution in terms of FPR
+    # quantization otherwise the function
+    # `binclf_curve_numpy.per_image_binclf_curve` would have the range of
+    # thresholds computed from all the images (normal + anomalous)
     thresholds = _get_linspaced_thresholds(
         anomaly_maps[image_classes == 0],
         num_thresholds,
@@ -109,7 +146,7 @@ def pimo_curves(
     return thresholds, shared_fpr, per_image_tprs, image_classes
 
 
-# =========================================== AUPIMO ===========================================
+# =========================================== AUPIMO =====================================
 
 
 def aupimo_scores(
@@ -119,34 +156,47 @@ def aupimo_scores(
     fpr_bounds: tuple[float, float] = (1e-5, 1e-4),
     force: bool = False,
 ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, int]:
-    """Compute the PIMO curves and their Area Under the Curve (i.e. AUPIMO) scores.
-
-    Scores are computed from the integration of the PIMO curves within the given FPR bounds, then normalized to [0, 1].
-    It can be thought of as the average TPR of the PIMO curves within the given FPR bounds.
+    """Compute PIMO curves and their Area Under the Curve (AUPIMO) scores.
 
-    Details: `anomalib.metrics.per_image.pimo`.
-
-    Args' notation:
-        N: number of images
-        H: image height
-        W: image width
-        K: number of thresholds
+    AUPIMO scores are computed by integrating PIMO curves within specified FPR
+    bounds and normalizing to [0,1]. The score represents the average TPR within
+    the FPR bounds.
 
     Args:
-        anomaly_maps: floating point anomaly score maps of shape (N, H, W)
-        masks: binary (bool or int) ground truth masks of shape (N, H, W)
-        num_thresholds: number of thresholds to compute (K)
-        fpr_bounds: lower and upper bounds of the FPR integration range
-        force: whether to force the computation despite bad conditions
+        anomaly_maps: Anomaly score maps of shape ``(N, H, W)`` where:
+            - ``N``: number of images
+            - ``H``: image height
+            - ``W``: image width
+        masks: Binary ground truth masks of shape ``(N, H, W)``
+        num_thresholds: Number of thresholds ``K`` to compute
+        fpr_bounds: Lower and upper bounds of FPR integration range
+        force: Whether to force computation despite bad conditions
 
     Returns:
-        tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
-            [0] thresholds of shape (K,) in ascending order
-            [1] shared FPR values of shape (K,) in descending order (indices correspond to the thresholds)
-            [2] per-image TPR curves of shape (N, K), axis 1 in descending order (indices correspond to the thresholds)
-            [3] image classes of shape (N,) with values 0 (normal) or 1 (anomalous)
-            [4] AUPIMO scores of shape (N,) in [0, 1]
-            [5] number of points used in the AUC integration
+        tuple containing:
+            - thresholds: Shape ``(K,)`` in ascending order
+            - shared_fpr: Shape ``(K,)`` in descending order
+            - per_image_tprs: Shape ``(N, K)`` in descending order
+            - image_classes: Shape ``(N,)`` with values 0 (normal) or 1
+              (anomalous)
+            - aupimo_scores: Shape ``(N,)`` in range [0,1]
+            - num_points: Number of points used in AUC integration
+
+    Raises:
+        ValueError: If inputs are invalid
+        RuntimeError: If PIMO curves are invalid or integration range has too few
+            points
+
+    Example:
+        >>> anomaly_maps = torch.rand(10, 32, 32)  # 10 images of 32x32
+        >>> masks = torch.randint(0, 2, (10, 32, 32))  # Binary masks
+        >>> results = aupimo_scores(
+        ...     anomaly_maps,
+        ...     masks,
+        ...     num_thresholds=100,
+        ...     fpr_bounds=(1e-5, 1e-4)
+        ... )
+        >>> thresholds, shared_fpr, tprs, classes, scores, n_points = results
     """
     _validate.is_rate_range(fpr_bounds)
 
@@ -186,8 +236,9 @@ def aupimo_scores(
         rtol=(rtol := 1e-2),
     ):
         logger.warning(
-            "The lower bound of the shared FPR integration range is not exactly achieved. "
-            f"Expected {fpr_lower_bound} but got {fpr_lower_bound_defacto}, which is not within {rtol=}.",
+            "The lower bound of the shared FPR integration range is not exactly "
+            f"achieved. Expected {fpr_lower_bound} but got "
+            f"{fpr_lower_bound_defacto}, which is not within {rtol=}.",
         )
 
     if not torch.isclose(
@@ -196,8 +247,9 @@ def aupimo_scores(
         rtol=rtol,
     ):
         logger.warning(
-            "The upper bound of the shared FPR integration range is not exactly achieved. "
-            f"Expected {fpr_upper_bound} but got {fpr_upper_bound_defacto}, which is not within {rtol=}.",
+            "The upper bound of the shared FPR integration range is not exactly "
+            f"achieved. Expected {fpr_upper_bound} but got "
+            f"{fpr_upper_bound_defacto}, which is not within {rtol=}.",
         )
 
     # reminder: fpr lower/upper bound is threshold upper/lower bound (reversed)
@@ -207,9 +259,10 @@ def aupimo_scores(
     # deal with edge cases
     if thresh_lower_bound_idx >= thresh_upper_bound_idx:
         msg = (
-            "The thresholds corresponding to the given `fpr_bounds` are not valid because "
-            "they matched the same threshold or the are in the wrong order. "
-            f"FPR upper/lower = threshold lower/upper = {thresh_lower_bound_idx} and {thresh_upper_bound_idx}."
+            "The thresholds corresponding to the given `fpr_bounds` are not "
+            "valid because they matched the same threshold or the are in the "
+            "wrong order. FPR upper/lower = threshold lower/upper = "
+            f"{thresh_lower_bound_idx} and {thresh_upper_bound_idx}."
         )
         raise RuntimeError(msg)
 
@@ -217,11 +270,13 @@ def aupimo_scores(
     shared_fpr_bounded: torch.Tensor = shared_fpr[thresh_lower_bound_idx : (thresh_upper_bound_idx + 1)]
     per_image_tprs_bounded: torch.Tensor = per_image_tprs[:, thresh_lower_bound_idx : (thresh_upper_bound_idx + 1)]
 
-    # `shared_fpr` and `tprs` are in descending order; `flip()` reverts to ascending order
+    # `shared_fpr` and `tprs` are in descending order; `flip()` reverts to
+    # ascending order
     shared_fpr_bounded = torch.flip(shared_fpr_bounded, dims=[0])
     per_image_tprs_bounded = torch.flip(per_image_tprs_bounded, dims=[1])
 
-    # the log's base does not matter because it's a constant factor canceled by normalization factor
+    # the log's base does not matter because it's a constant factor canceled by
+    # normalization factor
     shared_fpr_bounded_log = torch.log(shared_fpr_bounded)
 
     # deal with edge cases
@@ -229,8 +284,8 @@ def aupimo_scores(
 
     if invalid_shared_fpr.all():
         msg = (
-            "Cannot compute AUPIMO because the shared fpr integration range is invalid). "
-            "Try increasing the number of thresholds."
+            "Cannot compute AUPIMO because the shared fpr integration range is "
+            "invalid). Try increasing the number of thresholds."
         )
         raise RuntimeError(msg)
 
@@ -248,9 +303,9 @@ def aupimo_scores(
 
     if num_points_integral <= 30:
         msg = (
-            "Cannot compute AUPIMO because the shared fpr integration range doesn't have enough points. "
-            f"Found {num_points_integral} points in the integration range. "
-            "Try increasing `num_thresholds`."
+            "Cannot compute AUPIMO because the shared fpr integration range "
+            f"doesn't have enough points. Found {num_points_integral} points in "
+            "the integration range. Try increasing `num_thresholds`."
         )
         if not force:
             raise RuntimeError(msg)
@@ -259,21 +314,22 @@ def aupimo_scores(
 
     if num_points_integral < 300:
         logger.warning(
-            "The AUPIMO may be inaccurate because the shared fpr integration range doesn't have enough points. "
-            f"Found {num_points_integral} points in the integration range. "
-            "Try increasing `num_thresholds`.",
+            "The AUPIMO may be inaccurate because the shared fpr integration "
+            f"range doesn't have enough points. Found {num_points_integral} "
+            "points in the integration range. Try increasing `num_thresholds`.",
         )
 
     aucs: torch.Tensor = torch.trapezoid(per_image_tprs_bounded, x=shared_fpr_bounded_log, axis=1)
 
-    # normalize, then clip(0, 1) makes sure that the values are in [0, 1] in case of numerical errors
+    # normalize, then clip(0, 1) makes sure that the values are in [0, 1] in
+    # case of numerical errors
     normalization_factor = aupimo_normalizing_factor(fpr_bounds)
     aucs = (aucs / normalization_factor).clip(0, 1)
 
-    return thresholds, shared_fpr, per_image_tprs, image_classes, aucs, num_points_integral
+    return (thresholds, shared_fpr, per_image_tprs, image_classes, aucs, num_points_integral)
 
 
-# =========================================== AUX ===========================================
+# =========================================== AUX =====================================
 
 
 def thresh_at_shared_fpr_level(
@@ -284,20 +340,32 @@ def thresh_at_shared_fpr_level(
     """Return the threshold and its index at the given shared FPR level.
 
     Three cases are possible:
-    - fpr_level == 0: the lowest threshold that achieves 0 FPR is returned
-    - fpr_level == 1: the highest threshold that achieves 1 FPR is returned
-    - 0 < fpr_level < 1: the threshold that achieves the closest (higher or lower) FPR to `fpr_level` is returned
+        - ``fpr_level == 0``: lowest threshold achieving 0 FPR is returned
+        - ``fpr_level == 1``: highest threshold achieving 1 FPR is returned
+        - ``0 < fpr_level < 1``: threshold achieving closest FPR is returned
 
     Args:
-        thresholds: thresholds at which the shared FPR was computed.
-        shared_fpr: shared FPR values.
-        fpr_level: shared FPR value at which to get the threshold.
+        thresholds: Thresholds at which shared FPR was computed
+        shared_fpr: Shared FPR values
+        fpr_level: Shared FPR value at which to get threshold
 
     Returns:
-        tuple[int, float, float]:
-            [0] index of the threshold
-            [1] threshold
-            [2] the actual shared FPR value at the returned threshold
+        tuple containing:
+            - index: Index of the threshold
+            - threshold: Threshold value
+            - actual_fpr: Actual shared FPR value at returned threshold
+
+    Raises:
+        ValueError: If inputs are invalid or FPR level is out of range
+
+    Example:
+        >>> thresholds = torch.linspace(0, 1, 100)
+        >>> shared_fpr = torch.linspace(1, 0, 100)  # Decreasing FPR
+        >>> idx, thresh, fpr = thresh_at_shared_fpr_level(
+        ...     thresholds,
+        ...     shared_fpr,
+        ...     fpr_level=0.5
+        ... )
     """
     _validate.is_valid_threshold(thresholds)
     _validate.is_rate_curve(shared_fpr, nan_allowed=False, decreasing=True)
@@ -308,20 +376,21 @@ def thresh_at_shared_fpr_level(
 
     if fpr_level < shared_fpr_min:
         msg = (
-            "Invalid `fpr_level` because it's out of the range of `shared_fpr` = "
-            f"[{shared_fpr_min}, {shared_fpr_max}], and got {fpr_level}."
+            "Invalid `fpr_level` because it's out of the range of `shared_fpr` "
+            f"= [{shared_fpr_min}, {shared_fpr_max}], and got {fpr_level}."
         )
         raise ValueError(msg)
 
     if fpr_level > shared_fpr_max:
         msg = (
-            "Invalid `fpr_level` because it's out of the range of `shared_fpr` = "
-            f"[{shared_fpr_min}, {shared_fpr_max}], and got {fpr_level}."
+            "Invalid `fpr_level` because it's out of the range of `shared_fpr` "
+            f"= [{shared_fpr_min}, {shared_fpr_max}], and got {fpr_level}."
         )
         raise ValueError(msg)
 
     # fpr_level == 0 or 1 are special case
-    # because there may be multiple solutions, and the chosen should their MINIMUM/MAXIMUM respectively
+    # because there may be multiple solutions, and the chosen should their
+    # MINIMUM/MAXIMUM respectively
     if fpr_level == 0.0:
         index = torch.min(torch.where(shared_fpr == fpr_level)[0])
 
@@ -338,16 +407,21 @@ def thresh_at_shared_fpr_level(
 
 
 def aupimo_normalizing_factor(fpr_bounds: tuple[float, float]) -> float:
-    """Constant that normalizes the AUPIMO integral to 0-1 range.
+    """Compute constant that normalizes AUPIMO integral to 0-1 range.
 
-    It is the maximum possible value from the integral in AUPIMO's definition.
-    It corresponds to assuming a constant function T_i: thresh --> 1.
+    The factor is the maximum possible value from the integral in AUPIMO's
+    definition. It corresponds to assuming a constant function T_i: thresh --> 1.
 
     Args:
-        fpr_bounds: lower and upper bounds of the FPR integration range.
+        fpr_bounds: Lower and upper bounds of FPR integration range
 
     Returns:
-        float: the normalization factor (>0).
+        float: Normalization factor (>0)
+
+    Example:
+        >>> factor = aupimo_normalizing_factor((1e-5, 1e-4))
+        >>> print(f"{factor:.3f}")
+        2.303
     """
     _validate.is_rate_range(fpr_bounds)
     fpr_lower_bound, fpr_upper_bound = fpr_bounds
diff --git a/src/anomalib/metrics/pimo/pimo.py b/src/anomalib/metrics/pimo/pimo.py
index ef3e22ed3c..4c367f0a40 100644
--- a/src/anomalib/metrics/pimo/pimo.py
+++ b/src/anomalib/metrics/pimo/pimo.py
@@ -1,35 +1,50 @@
-"""Per-Image Overlap curve (PIMO, pronounced pee-mo) and its area under the curve (AUPIMO).
-
-# PIMO
-
-PIMO is a curve of True Positive Rate (TPR) values on each image across multiple anomaly score thresholds.
-The anomaly score thresholds are indexed by a (shared) valued of False Positive Rate (FPR) measure on the normal images.
-
-Each *anomalous* image has its own curve such that the X-axis is shared by all of them.
-
-At a given threshold:
-    X-axis: Shared FPR (may vary)
-        1. Log of the Average of per-image FPR on normal images.
-        SEE NOTE BELOW.
-    Y-axis: per-image TP Rate (TPR), or "Overlap" between the ground truth and the predicted masks.
-
-*** Note about other shared FPR alternatives ***
-The shared FPR metric can be made harder by using the cross-image max (or high-percentile) FPRs instead of the mean.
-Rationale: this will further punish models that have exceptional FPs in normal images.
-So far there is only one shared FPR metric implemented but others will be added in the future.
-
-# AUPIMO
-
-`AUPIMO` is the area under each `PIMO` curve with bounded integration range in terms of shared FPR.
-
-# Disclaimer
-
-This module implements torch interfaces to access the numpy code in `pimo_numpy.py`.
-Tensors are converted to numpy arrays and then passed and validated in the numpy code.
-The results are converted back to tensors and eventually wrapped in an dataclass object.
-
-Validations will preferably happen in ndarray so the numpy code can be reused without torch,
-so often times the Tensor arguments will be converted to ndarray and then validated.
+"""Per-Image Overlap curve (PIMO) and its area under the curve (AUPIMO).
+
+This module provides metrics for evaluating anomaly detection performance using
+Per-Image Overlap (PIMO) curves and their area under the curve (AUPIMO).
+
+PIMO Curves
+----------
+PIMO curves plot True Positive Rate (TPR) values for each image across multiple
+anomaly score thresholds. The thresholds are indexed by a shared False Positive
+Rate (FPR) measure computed on normal images.
+
+Each anomalous image has its own curve with:
+
+- X-axis: Shared FPR (logarithmic average of per-image FPR on normal images)
+- Y-axis: Per-image TPR ("Overlap" between ground truth and predicted masks)
+
+Note on Shared FPR
+----------------
+The shared FPR metric can be made stricter by using cross-image max or high
+percentile FPRs instead of mean. This further penalizes models with exceptional
+false positives in normal images. Currently only mean FPR is implemented.
+
+AUPIMO Score
+-----------
+AUPIMO is the area under each PIMO curve within bounded FPR integration range.
+The score is normalized to [0,1].
+
+Implementation Notes
+------------------
+This module implements PyTorch interfaces to the numpy implementation in
+``pimo_numpy.py``. Tensors are converted to numpy arrays for computation and
+validation, then converted back to tensors and wrapped in dataclass objects.
+
+Example:
+    >>> import torch
+    >>> from anomalib.metrics.pimo import PIMO
+    >>> metric = PIMO(num_thresholds=10)
+    >>> anomaly_maps = torch.rand(5, 32, 32)  # 5 images
+    >>> masks = torch.randint(0, 2, (5, 32, 32))  # Binary masks
+    >>> metric.update(anomaly_maps, masks)
+    >>> result = metric.compute()
+    >>> result.num_images
+    5
+
+See Also:
+    - :class:`PIMOResult`: Container for PIMO curve data
+    - :class:`AUPIMOResult`: Container for AUPIMO score data
 """
 
 # Original Code
@@ -53,34 +68,35 @@
 
 
 class _PIMO(Metric):
-    """Per-IMage Overlap (PIMO, pronounced pee-mo) curves.
-
-    This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code.
-    The tensors are converted to numpy arrays and then passed and validated in the numpy code.
-    The results are converted back to tensors and wrapped in an dataclass object.
+    """Per-Image Overlap (PIMO) curve metric.
 
-    PIMO is a curve of True Positive Rate (TPR) values on each image across multiple anomaly score thresholds.
-    The anomaly score thresholds are indexed by a (cross-image shared) value of False Positive Rate (FPR) measure on
-    the normal images.
-
-    Details: `anomalib.metrics.per_image.pimo`.
-
-    Notation:
-        N: number of images
-        H: image height
-        W: image width
-        K: number of thresholds
-
-    Attributes:
-        anomaly_maps: floating point anomaly score maps of shape (N, H, W)
-        masks: binary (bool or int) ground truth masks of shape (N, H, W)
+    This metric computes PIMO curves which plot True Positive Rate (TPR) values
+    for each image across multiple anomaly score thresholds. The thresholds are
+    indexed by a shared False Positive Rate (FPR) measure on normal images.
 
     Args:
-        num_thresholds: number of thresholds to compute (K)
-        binclf_algorithm: algorithm to compute the binary classifier curve (see `binclf_curve_numpy.Algorithm`)
+        num_thresholds: Number of thresholds to compute (K). Must be >= 2.
 
-    Returns:
-        PIMOResult: PIMO curves dataclass object. See `PIMOResult` for details.
+    Attributes:
+        anomaly_maps: List of anomaly score maps, each of shape ``(N, H, W)``
+        masks: List of binary ground truth masks, each of shape ``(N, H, W)``
+        is_differentiable: Whether metric is differentiable
+        higher_is_better: Whether higher values are better
+        full_state_update: Whether to update full state
+
+    Example:
+        >>> import torch
+        >>> metric = _PIMO(num_thresholds=10)
+        >>> anomaly_maps = torch.rand(5, 32, 32)  # 5 images
+        >>> masks = torch.randint(0, 2, (5, 32, 32))  # Binary masks
+        >>> metric.update(anomaly_maps, masks)
+        >>> result = metric.compute()
+        >>> result.num_images
+        5
+
+    Note:
+        This metric stores all predictions and targets in memory, which may
+        require significant memory for large datasets.
     """
 
     is_differentiable: bool = False
@@ -95,35 +111,47 @@ class _PIMO(Metric):
 
     @property
     def _is_empty(self) -> bool:
-        """Return True if the metric has not been updated yet."""
+        """Check if metric has been updated.
+
+        Returns:
+            bool: True if no updates have been made yet.
+        """
         return len(self.anomaly_maps) == 0
 
     @property
     def num_images(self) -> int:
-        """Number of images."""
+        """Get total number of images.
+
+        Returns:
+            int: Total number of images across all batches.
+        """
         return sum(am.shape[0] for am in self.anomaly_maps)
 
     @property
     def image_classes(self) -> torch.Tensor:
-        """Image classes (0: normal, 1: anomalous)."""
+        """Get image classes (0: normal, 1: anomalous).
+
+        Returns:
+            torch.Tensor: Binary tensor of image classes.
+        """
         return functional.images_classes_from_masks(self.masks)
 
     def __init__(self, num_thresholds: int) -> None:
-        """Per-Image Overlap (PIMO) curve.
+        """Initialize PIMO metric.
 
         Args:
-            num_thresholds: number of thresholds used to compute the PIMO curve (K)
+            num_thresholds: Number of thresholds for curve computation (K).
+                Must be >= 2.
         """
         super().__init__()
 
         logger.warning(
-            f"Metric `{self.__class__.__name__}` will save all targets and predictions in buffer."
-            " For large datasets this may lead to large memory footprint.",
+            f"Metric `{self.__class__.__name__}` will save all targets and "
+            "predictions in buffer. For large datasets this may lead to large "
+            "memory footprint.",
         )
 
-        # the options below are, redundantly, validated here to avoid reaching
-        # an error later in the execution
-
+        # Validate options early to avoid later errors
         _validate.is_num_thresholds_gte2(num_thresholds)
         self.num_thresholds = num_thresholds
 
@@ -131,11 +159,15 @@ def __init__(self, num_thresholds: int) -> None:
         self.add_state("masks", default=[], dist_reduce_fx="cat")
 
     def update(self, anomaly_maps: torch.Tensor, masks: torch.Tensor) -> None:
-        """Update lists of anomaly maps and masks.
+        """Update metric state with new predictions and targets.
 
         Args:
-            anomaly_maps (torch.Tensor): predictions of the model (ndim == 2, float)
-            masks (torch.Tensor): ground truth masks (ndim == 2, binary)
+            anomaly_maps: Model predictions as float tensors of shape
+                ``(N, H, W)``
+            masks: Ground truth binary masks of shape ``(N, H, W)``
+
+        Raises:
+            ValueError: If inputs have invalid shapes or types
         """
         _validate.is_anomaly_maps(anomaly_maps)
         _validate.is_masks(masks)
@@ -144,12 +176,13 @@ def update(self, anomaly_maps: torch.Tensor, masks: torch.Tensor) -> None:
         self.masks.append(masks)
 
     def compute(self) -> PIMOResult:
-        """Compute the PIMO curves.
-
-        Call the functional interface `pimo_curves()`, which is a wrapper around the numpy code.
+        """Compute PIMO curves from accumulated data.
 
         Returns:
-            PIMOResult: PIMO curves dataclass object. See `PIMOResult` for details.
+            PIMOResult: Container with curve data and metadata.
+
+        Raises:
+            RuntimeError: If no data has been added via update()
         """
         if self._is_empty:
             msg = "No anomaly maps and masks have been added yet. Please call `update()` first."
@@ -170,7 +203,7 @@ def compute(self) -> PIMOResult:
 
 
 class PIMO(AnomalibMetric, _PIMO):  # type: ignore[misc]
-    """Wrapper to add AnomalibMetric functionality to PIMO metric."""
+    """Wrapper adding AnomalibMetric functionality to PIMO metric."""
 
     default_fields = ("anomaly_map", "gt_mask")
 
@@ -178,32 +211,29 @@ class PIMO(AnomalibMetric, _PIMO):  # type: ignore[misc]
 class _AUPIMO(_PIMO):
     """Area Under the Per-Image Overlap (PIMO) curve.
 
-    This torchmetrics interface is a wrapper around the functional interface, which is a wrapper around the numpy code.
-    The tensors are converted to numpy arrays and then passed and validated in the numpy code.
-    The results are converted back to tensors and wrapped in an dataclass object.
-
-    Scores are computed from the integration of the PIMO curves within the given FPR bounds, then normalized to [0, 1].
-    It can be thought of as the average TPR of the PIMO curves within the given FPR bounds.
-
-    Details: `anomalib.metrics.per_image.pimo`.
-
-    Notation:
-        N: number of images
-        H: image height
-        W: image width
-        K: number of thresholds
-
-    Attributes:
-        anomaly_maps: floating point anomaly score maps of shape (N, H, W)
-        masks: binary (bool or int) ground truth masks of shape (N, H, W)
+    This metric computes both PIMO curves and their area under the curve
+    (AUPIMO). AUPIMO scores are computed by integrating PIMO curves within
+    specified FPR bounds and normalizing to [0,1].
 
     Args:
-        num_thresholds: number of thresholds to compute (K)
-        fpr_bounds: lower and upper bounds of the FPR integration range
-        force: whether to force the computation despite bad conditions
-
-    Returns:
-        tuple[PIMOResult, AUPIMOResult]: PIMO and AUPIMO results dataclass objects. See `PIMOResult` and `AUPIMOResult`.
+        num_thresholds: Number of thresholds for curve computation. Default:
+            300,000
+        fpr_bounds: Lower and upper FPR integration bounds as ``(min, max)``.
+            Default: ``(1e-5, 1e-4)``
+        return_average: If True, return mean AUPIMO score across anomalous
+            images. If False, return individual scores. Default: True
+        force: If True, compute scores even in suboptimal conditions.
+            Default: False
+
+    Example:
+        >>> import torch
+        >>> metric = _AUPIMO(num_thresholds=10)
+        >>> anomaly_maps = torch.rand(5, 32, 32)  # 5 images
+        >>> masks = torch.randint(0, 2, (5, 32, 32))  # Binary masks
+        >>> metric.update(anomaly_maps, masks)
+        >>> pimo_result, aupimo_result = metric.compute()
+        >>> aupimo_result.num_images
+        5
     """
 
     fpr_bounds: tuple[float, float]
@@ -212,21 +242,25 @@ class _AUPIMO(_PIMO):
 
     @staticmethod
     def normalizing_factor(fpr_bounds: tuple[float, float]) -> float:
-        """Constant that normalizes the AUPIMO integral to 0-1 range.
+        """Get normalization factor for AUPIMO integral.
 
-        It is the maximum possible value from the integral in AUPIMO's definition.
-        It corresponds to assuming a constant function T_i: thresh --> 1.
+        The factor normalizes the integral to [0,1] range. It represents the
+        maximum possible integral value, assuming a constant TPR of 1.
 
         Args:
-            fpr_bounds: lower and upper bounds of the FPR integration range.
+            fpr_bounds: FPR integration bounds as ``(min, max)``
 
         Returns:
-            float: the normalization factor (>0).
+            float: Normalization factor (>0)
         """
         return functional.aupimo_normalizing_factor(fpr_bounds)
 
     def __repr__(self) -> str:
-        """Show the metric name and its integration bounds."""
+        """Get string representation with integration bounds.
+
+        Returns:
+            str: Metric name and FPR bounds
+        """
         lower, upper = self.fpr_bounds
         return f"{self.__class__.__name__}([{lower:.2g}, {upper:.2g}])"
 
@@ -237,34 +271,34 @@ def __init__(
         return_average: bool = True,
         force: bool = False,
     ) -> None:
-        """Area Under the Per-Image Overlap (PIMO) curve.
+        """Initialize AUPIMO metric.
 
         Args:
-            num_thresholds: [passed to parent `PIMO`] number of thresholds used to compute the PIMO curve
-            fpr_bounds: lower and upper bounds of the FPR integration range
-            return_average: if True, return the average AUPIMO score; if False, return all the individual AUPIMO scores
-            force: if True, force the computation of the AUPIMO scores even in bad conditions (e.g. few points)
+            num_thresholds: Number of thresholds for curve computation
+            fpr_bounds: FPR integration bounds as ``(min, max)``
+            return_average: If True, return mean score across anomalous images
+            force: If True, compute scores even in suboptimal conditions
         """
         super().__init__(num_thresholds=num_thresholds)
 
-        # other validations are done in PIMO.__init__()
-
         _validate.is_rate_range(fpr_bounds)
         self.fpr_bounds = fpr_bounds
         self.return_average = return_average
         self.force = force
 
     def compute(self, force: bool | None = None) -> tuple[PIMOResult, AUPIMOResult]:  # type: ignore[override]
-        """Compute the PIMO curves and their Area Under the curve (AUPIMO) scores.
-
-        Call the functional interface `aupimo_scores()`, which is a wrapper around the numpy code.
+        """Compute PIMO curves and AUPIMO scores.
 
         Args:
-            force: if given (not None), override the `force` attribute.
+            force: If provided, override instance ``force`` setting
 
         Returns:
-            tuple[PIMOResult, AUPIMOResult]: PIMO curves and AUPIMO scores dataclass objects.
-                See `PIMOResult` and `AUPIMOResult` for details.
+            tuple: Contains:
+                - PIMOResult: PIMO curve data
+                - AUPIMOResult: AUPIMO score data
+
+        Raises:
+            RuntimeError: If no data has been added via update()
         """
         if self._is_empty:
             msg = "No anomaly maps and masks have been added yet. Please call `update()` first."
@@ -305,6 +339,6 @@ def compute(self, force: bool | None = None) -> tuple[PIMOResult, AUPIMOResult]:
 
 
 class AUPIMO(AnomalibMetric, _AUPIMO):  # type: ignore[misc]
-    """Wrapper to add AnomalibMetric functionality to AUPIMO metric."""
+    """Wrapper adding AnomalibMetric functionality to AUPIMO metric."""
 
     default_fields = ("anomaly_map", "gt_mask")
diff --git a/src/anomalib/metrics/pimo/utils.py b/src/anomalib/metrics/pimo/utils.py
index f0cac45657..5f162461d4 100644
--- a/src/anomalib/metrics/pimo/utils.py
+++ b/src/anomalib/metrics/pimo/utils.py
@@ -1,4 +1,16 @@
-"""Torch-oriented interfaces for `utils.py`."""
+"""Utility functions for PIMO metrics.
+
+This module provides utility functions for working with PIMO (Per-Image Metric
+Optimization) metrics in PyTorch.
+
+Example:
+    >>> import torch
+    >>> masks = torch.zeros(3, 32, 32)  # 3 normal images
+    >>> masks[1, 10:20, 10:20] = 1  # Add anomaly to middle image
+    >>> classes = images_classes_from_masks(masks)
+    >>> classes
+    tensor([0, 1, 0])
+"""
 
 # Original Code
 # https://github.com/jpcbertoldo/aupimo
@@ -15,5 +27,28 @@
 
 
 def images_classes_from_masks(masks: torch.Tensor) -> torch.Tensor:
-    """Deduce the image classes from the masks."""
+    """Deduce binary image classes from ground truth masks.
+
+    Determines if each image contains any anomalous pixels (class 1) or is
+    completely normal (class 0).
+
+    Args:
+        masks: Binary ground truth masks of shape ``(N, H, W)`` where:
+            - ``N``: number of images
+            - ``H``: image height
+            - ``W``: image width
+            Values should be 0 (normal) or 1 (anomalous).
+
+    Returns:
+        torch.Tensor: Binary tensor of shape ``(N,)`` containing image-level
+        classes where:
+            - 0: normal image (no anomalous pixels)
+            - 1: anomalous image (contains anomalous pixels)
+
+    Example:
+        >>> masks = torch.zeros(3, 32, 32)  # 3 normal images
+        >>> masks[1, 10:20, 10:20] = 1  # Add anomaly to middle image
+        >>> images_classes_from_masks(masks)
+        tensor([0, 1, 0])
+    """
     return (masks == 1).any(axis=(1, 2)).to(torch.int32)
diff --git a/src/anomalib/metrics/plotting_utils.py b/src/anomalib/metrics/plotting_utils.py
index 0a32dfea29..8c6c7adf34 100644
--- a/src/anomalib/metrics/plotting_utils.py
+++ b/src/anomalib/metrics/plotting_utils.py
@@ -1,4 +1,8 @@
-"""Helper functions to generate ROC-style plots of various metrics."""
+"""Helper functions to generate ROC-style plots of various metrics.
+
+This module provides utility functions for generating ROC-style plots and other
+visualization helpers used by metrics in Anomalib.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -21,27 +25,45 @@ def plot_figure(
     title: str,
     sample_points: int = 1000,
 ) -> tuple[Figure, Axis]:
-    """Generate a simple, ROC-style plot, where x_vals is plotted against y_vals.
+    """Generate a ROC-style plot with x values plotted against y values.
 
-    Note that a subsampling is applied if > sample_points are present in x/y, as matplotlib plotting draws
-    every single plot which takes very long, especially for high-resolution segmentations.
+    The function creates a matplotlib figure with a single axis showing the curve
+    defined by ``x_vals`` and ``y_vals``. If the number of points exceeds
+    ``sample_points``, the data is subsampled to improve plotting performance.
 
     Args:
-        x_vals (torch.Tensor): x values to plot
-        y_vals (torch.Tensor): y values to plot
-        auc (torch.Tensor): normalized area under the curve spanned by x_vals, y_vals
-        xlim (tuple[float, float]): displayed range for x-axis
-        ylim (tuple[float, float]): displayed range for y-axis
-        xlabel (str): label of x axis
-        ylabel (str): label of y axis
-        loc (str): string-based legend location, for details see
+        x_vals (torch.Tensor): Values to plot on x-axis.
+        y_vals (torch.Tensor): Values to plot on y-axis.
+        auc (torch.Tensor): Area under curve value to display in legend.
+        xlim (tuple[float, float]): Display range for x-axis as ``(min, max)``.
+        ylim (tuple[float, float]): Display range for y-axis as ``(min, max)``.
+        xlabel (str): Label for x-axis.
+        ylabel (str): Label for y-axis.
+        loc (str): Legend location. See matplotlib documentation for valid values:
             https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.legend.html
-        title (str): title of the plot
-        sample_points (int): number of sampling points to subsample x_vals/y_vals with
-            Defaults to ``1000``.
+        title (str): Title of the plot.
+        sample_points (int, optional): Maximum number of points to plot. Data will
+            be subsampled if it exceeds this value. Defaults to ``1000``.
 
     Returns:
-        tuple[Figure, Axis]: Figure and the contained Axis
+        tuple[Figure, Axis]: Tuple containing the figure and its main axis.
+
+    Example:
+        >>> import torch
+        >>> x = torch.linspace(0, 1, 100)
+        >>> y = x ** 2
+        >>> auc = torch.tensor(0.5)
+        >>> fig, ax = plot_figure(
+        ...     x_vals=x,
+        ...     y_vals=y,
+        ...     auc=auc,
+        ...     xlim=(0, 1),
+        ...     ylim=(0, 1),
+        ...     xlabel="False Positive Rate",
+        ...     ylabel="True Positive Rate",
+        ...     loc="lower right",
+        ...     title="ROC Curve",
+        ... )
     """
     fig, axis = plt.subplots()
 
diff --git a/src/anomalib/metrics/precision_recall_curve.py b/src/anomalib/metrics/precision_recall_curve.py
index a6a6338410..bedd30dd4c 100644
--- a/src/anomalib/metrics/precision_recall_curve.py
+++ b/src/anomalib/metrics/precision_recall_curve.py
@@ -1,7 +1,23 @@
-"""Custom PrecisionRecallCurve.
+"""Custom implementation of Precision-Recall Curve metric.
+
+This module provides a custom implementation of the binary precision-recall curve
+metric that does not apply sigmoid normalization to prediction thresholds, unlike
+the standard torchmetrics implementation.
 
-The one in torchmetrics adds a sigmoid operation on top of the thresholds.
 See: https://github.com/Lightning-AI/torchmetrics/issues/1526
+
+Example:
+    >>> import torch
+    >>> from anomalib.metrics import BinaryPrecisionRecallCurve
+    >>> # Create sample predictions and targets
+    >>> preds = torch.tensor([0.1, 0.4, 0.35, 0.8])
+    >>> target = torch.tensor([0, 0, 1, 1])
+    >>> # Initialize metric
+    >>> pr_curve = BinaryPrecisionRecallCurve()
+    >>> # Update metric state
+    >>> pr_curve.update(preds, target)
+    >>> # Compute precision, recall and thresholds
+    >>> precision, recall, thresholds = pr_curve.compute()
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -16,7 +32,20 @@
 
 
 class BinaryPrecisionRecallCurve(_BinaryPrecisionRecallCurve):
-    """Binary precision-recall curve with without threshold prediction normalization."""
+    """Binary precision-recall curve without threshold prediction normalization.
+
+    This class extends the torchmetrics ``BinaryPrecisionRecallCurve`` class but
+    removes the sigmoid normalization step applied to prediction thresholds.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.metrics import BinaryPrecisionRecallCurve
+        >>> metric = BinaryPrecisionRecallCurve()
+        >>> preds = torch.tensor([0.1, 0.4, 0.35, 0.8])
+        >>> target = torch.tensor([0, 0, 1, 1])
+        >>> metric.update(preds, target)
+        >>> precision, recall, thresholds = metric.compute()
+    """
 
     @staticmethod
     def _binary_precision_recall_curve_format(
@@ -25,7 +54,25 @@ def _binary_precision_recall_curve_format(
         thresholds: int | list[float] | Tensor | None = None,
         ignore_index: int | None = None,
     ) -> tuple[Tensor, Tensor, Tensor | None]:
-        """Similar to torchmetrics' ``_binary_precision_recall_curve_format`` except it does not apply sigmoid."""
+        """Format predictions and targets for binary precision-recall curve.
+
+        Similar to torchmetrics' ``_binary_precision_recall_curve_format`` but
+        without sigmoid normalization of predictions.
+
+        Args:
+            preds (Tensor): Predicted scores or probabilities
+            target (Tensor): Ground truth binary labels
+            thresholds (int | list[float] | Tensor | None, optional): Thresholds
+                used for computing curve points. Defaults to ``None``.
+            ignore_index (int | None, optional): Label to ignore in evaluation.
+                Defaults to ``None``.
+
+        Returns:
+            tuple[Tensor, Tensor, Tensor | None]: Tuple containing:
+                - Flattened predictions
+                - Flattened targets
+                - Adjusted thresholds
+        """
         preds = preds.flatten()
         target = target.flatten()
         if ignore_index is not None:
@@ -39,11 +86,12 @@ def _binary_precision_recall_curve_format(
     def update(self, preds: Tensor, target: Tensor) -> None:
         """Update metric state with new predictions and targets.
 
-        Unlike the base class, this accepts raw predictions and targets.
+        Unlike the base class, this method accepts raw predictions without
+        applying sigmoid normalization.
 
         Args:
-            preds (Tensor): Predicted probabilities
-            target (Tensor): Ground truth labels
+            preds (Tensor): Raw predicted scores or probabilities
+            target (Tensor): Ground truth binary labels (0 or 1)
         """
         preds, target, _ = BinaryPrecisionRecallCurve._binary_precision_recall_curve_format(
             preds,
diff --git a/src/anomalib/metrics/pro.py b/src/anomalib/metrics/pro.py
index d05d8def0d..2d4ff22d01 100644
--- a/src/anomalib/metrics/pro.py
+++ b/src/anomalib/metrics/pro.py
@@ -1,4 +1,23 @@
-"""Implementation of PRO metric based on TorchMetrics."""
+"""Implementation of PRO metric based on TorchMetrics.
+
+This module provides the Per-Region Overlap (PRO) metric for evaluating anomaly
+segmentation performance. The PRO metric computes the macro average of the
+per-region overlap between predicted anomaly masks and ground truth masks.
+
+Example:
+    >>> import torch
+    >>> from anomalib.metrics import PRO
+    >>> # Create sample predictions and targets
+    >>> preds = torch.rand(2, 1, 32, 32)  # Batch of 2 images
+    >>> target = torch.zeros(2, 1, 32, 32)
+    >>> target[0, 0, 10:20, 10:20] = 1  # Add anomalous region
+    >>> # Initialize metric
+    >>> pro = PRO()
+    >>> # Update metric state
+    >>> pro.update(preds, target)
+    >>> # Compute PRO score
+    >>> score = pro.compute()
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -17,35 +36,31 @@ class _PRO(Metric):
     """Per-Region Overlap (PRO) Score.
 
     This metric computes the macro average of the per-region overlap between the
-    predicted anomaly masks and the ground truth masks.
+    predicted anomaly masks and the ground truth masks. It first identifies
+    connected components in the ground truth mask and then computes the overlap
+    between each component and the predicted mask.
 
     Args:
-        threshold (float): Threshold used to binarize the predictions.
+        threshold (float, optional): Threshold used to binarize the predictions.
             Defaults to ``0.5``.
-        kwargs: Additional arguments to the TorchMetrics base class.
+        kwargs: Additional arguments passed to the TorchMetrics base class.
 
-    Example:
-        Import the metric from the package:
+    Attributes:
+        target (list[torch.Tensor]): List storing ground truth masks from batches
+        preds (list[torch.Tensor]): List storing predicted masks from batches
+        threshold (float): Threshold for binarizing predictions
 
+    Example:
         >>> import torch
         >>> from anomalib.metrics import PRO
-
-        Create random ``preds`` and ``labels`` tensors:
-
-        >>> labels = torch.randint(low=0, high=2, size=(1, 10, 5), dtype=torch.float32)
-        >>> preds = torch.rand_like(labels)
-
-        Compute the PRO score for labels and preds:
-
+        >>> # Create random predictions and targets
+        >>> preds = torch.rand(2, 1, 32, 32)  # Batch of 2 images
+        >>> target = torch.zeros(2, 1, 32, 32)
+        >>> target[0, 0, 10:20, 10:20] = 1  # Add anomalous region
+        >>> # Initialize and compute PRO score
         >>> pro = PRO(threshold=0.5)
-        >>> pro.update(preds, labels)
-        >>> pro.compute()
-        tensor(0.5433)
-
-        .. note::
-            Note that the example above shows random predictions and labels.
-            Therefore, the PRO score above may not be reproducible.
-
+        >>> pro.update(preds, target)
+        >>> score = pro.compute()
     """
 
     target: list[torch.Tensor]
@@ -59,47 +74,66 @@ def __init__(self, threshold: float = 0.5, **kwargs) -> None:
         self.add_state("target", default=[], dist_reduce_fx="cat")
 
     def update(self, predictions: torch.Tensor, targets: torch.Tensor) -> None:
-        """Compute the PRO score for the current batch.
+        """Update metric state with new predictions and targets.
 
         Args:
-            predictions (torch.Tensor): Predicted anomaly masks (Bx1xHxW)
-            targets (torch.Tensor): Ground truth anomaly masks (Bx1xHxW)
+            predictions (torch.Tensor): Predicted anomaly masks of shape
+                ``(B, 1, H, W)`` where B is batch size
+            targets (torch.Tensor): Ground truth anomaly masks of shape
+                ``(B, 1, H, W)``
 
         Example:
-            To update the metric state for the current batch, use the ``update`` method:
-
-            >>> pro.update(preds, labels)
+            >>> pro = PRO()
+            >>> # Assuming preds and target are properly shaped tensors
+            >>> pro.update(preds, target)
         """
         self.target.append(targets)
         self.preds.append(predictions)
 
     def compute(self) -> torch.Tensor:
-        """Compute the macro average of the PRO score across all regions in all batches.
+        """Compute the macro average PRO score across all regions.
 
-        Example:
-            To compute the metric based on the state accumulated from multiple batches, use the ``compute`` method:
+        Returns:
+            torch.Tensor: Scalar tensor containing the PRO score averaged across
+                all regions in all batches
 
-            >>> pro.compute()
-            tensor(0.5433)
+        Example:
+            >>> pro = PRO()
+            >>> # After updating with several batches
+            >>> score = pro.compute()
+            >>> print(f"PRO Score: {score:.4f}")
         """
         target = dim_zero_cat(self.target)
         preds = dim_zero_cat(self.preds)
 
-        target = target.unsqueeze(1).type(torch.float)  # kornia expects N1HW and FloatTensor format
+        # kornia expects N1HW format and float dtype
+        target = target.unsqueeze(1).type(torch.float)
         comps = connected_components_gpu(target) if target.is_cuda else connected_components_cpu(target)
         return pro_score(preds, comps, threshold=self.threshold)
 
 
-def pro_score(predictions: torch.Tensor, comps: torch.Tensor, threshold: float = 0.5) -> torch.Tensor:
+def pro_score(
+    predictions: torch.Tensor,
+    comps: torch.Tensor,
+    threshold: float = 0.5,
+) -> torch.Tensor:
     """Calculate the PRO score for a batch of predictions.
 
     Args:
-        predictions (torch.Tensor): Predicted anomaly masks (Bx1xHxW)
-        comps: (torch.Tensor): Labeled connected components (BxHxW). The components should be labeled from 0 to N
-        threshold (float): When predictions are passed as float, the threshold is used to binarize the predictions.
+        predictions (torch.Tensor): Predicted anomaly masks of shape
+            ``(B, 1, H, W)``
+        comps (torch.Tensor): Labeled connected components of shape ``(B, H, W)``.
+            Components should be labeled from 0 to N
+        threshold (float, optional): Threshold for binarizing float predictions.
+            Defaults to ``0.5``
 
     Returns:
-        torch.Tensor: Scalar value representing the average PRO score for the input batch.
+        torch.Tensor: Scalar tensor containing the average PRO score
+
+    Example:
+        >>> # Assuming predictions and components are properly shaped tensors
+        >>> score = pro_score(predictions, components, threshold=0.5)
+        >>> print(f"PRO Score: {score:.4f}")
     """
     if predictions.dtype == torch.float:
         predictions = predictions > threshold
@@ -113,9 +147,10 @@ def pro_score(predictions: torch.Tensor, comps: torch.Tensor, threshold: float =
     if n_comps == 1:  # only background
         return torch.Tensor([1.0])
 
-    # Even though ignore_index is set to 0, the final average computed with "macro"
-    # takes the entire length of the tensor into account. That's why we need to manually
-    # subtract 1 from the number of components after taking the sum
+    # Even though ignore_index is set to 0, the final average computed with
+    # "macro" takes the entire length of the tensor into account. That's why we
+    # need to manually subtract 1 from the number of components after taking the
+    # sum
     recall_tensor = recall(
         preds.flatten(),
         comps.flatten(),
@@ -128,4 +163,8 @@ def pro_score(predictions: torch.Tensor, comps: torch.Tensor, threshold: float =
 
 
 class PRO(AnomalibMetric, _PRO):  # type: ignore[misc]
-    """Wrapper to add AnomalibMetric functionality to PRO metric."""
+    """Wrapper to add AnomalibMetric functionality to PRO metric.
+
+    This class inherits from both ``AnomalibMetric`` and ``_PRO`` to combine
+    Anomalib's metric functionality with the PRO score computation.
+    """
diff --git a/src/anomalib/metrics/threshold/__init__.py b/src/anomalib/metrics/threshold/__init__.py
index 13d3bf3288..8534a21930 100644
--- a/src/anomalib/metrics/threshold/__init__.py
+++ b/src/anomalib/metrics/threshold/__init__.py
@@ -1,4 +1,22 @@
-"""Thresholding metrics."""
+"""Thresholding metrics for anomaly detection.
+
+This module provides various thresholding techniques to convert anomaly scores into
+binary predictions.
+
+Available Thresholds:
+    - ``BaseThreshold``: Abstract base class for implementing threshold methods
+    - ``Threshold``: Generic threshold class that can be initialized with a value
+    - ``F1AdaptiveThreshold``: Automatically finds optimal threshold by maximizing
+      F1 score
+    - ``ManualThreshold``: Allows manual setting of threshold value
+
+Example:
+    >>> from anomalib.metrics.threshold import ManualThreshold
+    >>> threshold = ManualThreshold(threshold=0.5)
+    >>> predictions = threshold(anomaly_scores=[0.1, 0.6, 0.3, 0.9])
+    >>> print(predictions)
+    [0, 1, 0, 1]
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/metrics/threshold/base.py b/src/anomalib/metrics/threshold/base.py
index eef57789cd..3f100e09bf 100644
--- a/src/anomalib/metrics/threshold/base.py
+++ b/src/anomalib/metrics/threshold/base.py
@@ -1,4 +1,28 @@
-"""Base class for thresholding metrics."""
+"""Base classes for thresholding metrics.
+
+This module provides base classes for implementing threshold-based metrics for
+anomaly detection. The main classes are:
+
+- ``Threshold``: Abstract base class for all threshold metrics
+- ``BaseThreshold``: Deprecated alias for ``Threshold`` class
+
+Example:
+    >>> from anomalib.metrics.threshold import Threshold
+    >>> class MyThreshold(Threshold):
+    ...     def __init__(self):
+    ...         super().__init__()
+    ...         self.add_state("scores", default=[])
+    ...
+    ...     def update(self, scores):
+    ...         self.scores.append(scores)
+    ...
+    ...     def compute(self):
+    ...         return torch.tensor(0.5)
+    >>> threshold = MyThreshold()
+    >>> threshold.update(torch.tensor([0.1, 0.9]))
+    >>> threshold.compute()
+    tensor(0.5)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,43 +34,76 @@
 
 
 class Threshold(Metric):
-    """Base class for thresholding metrics.
+    """Abstract base class for thresholding metrics.
+
+    This class serves as the foundation for implementing threshold-based metrics
+    in anomaly detection. It inherits from ``torchmetrics.Metric`` and defines
+    a common interface for threshold computation and state updates.
 
-    This class serves as the foundation for all threshold-based metrics in the system.
-    It inherits from torchmetrics.Metric and provides a common interface for
-    threshold computation and updates.
+    Subclasses must implement:
+        - ``compute()``: Calculate and return the threshold value
+        - ``update()``: Update internal state with new data
 
-    Subclasses should implement the `compute` and `update` methods to define
-    specific threshold calculation logic.
+    Example:
+        >>> class MyThreshold(Threshold):
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.add_state("scores", default=[])
+        ...
+        ...     def update(self, scores):
+        ...         self.scores.append(scores)
+        ...
+        ...     def compute(self):
+        ...         return torch.tensor(0.5)
     """
 
     def __init__(self, **kwargs) -> None:
+        """Initialize the threshold metric.
+
+        Args:
+            **kwargs: Keyword arguments passed to parent ``Metric`` class.
+        """
         super().__init__(**kwargs)
 
     def compute(self) -> torch.Tensor:  # noqa: PLR6301
-        """Compute the threshold.
+        """Compute the threshold value.
 
         Returns:
-            Value of the optimal threshold.
+            torch.Tensor: Optimal threshold value.
+
+        Raises:
+            NotImplementedError: If not implemented by subclass.
         """
         msg = "Subclass of Threshold must implement the compute method"
         raise NotImplementedError(msg)
 
     def update(self, *args, **kwargs) -> None:  # noqa: ARG002, PLR6301
-        """Update the metric state.
+        """Update the metric state with new data.
 
         Args:
-            *args: Any positional arguments.
-            **kwargs: Any keyword arguments.
+            *args: Positional arguments specific to subclass implementation.
+            **kwargs: Keyword arguments specific to subclass implementation.
+
+        Raises:
+            NotImplementedError: If not implemented by subclass.
         """
         msg = "Subclass of Threshold must implement the update method"
         raise NotImplementedError(msg)
 
 
 class BaseThreshold(Threshold):
-    """Alias for Threshold class for backward compatibility."""
+    """Deprecated alias for ``Threshold`` class.
+
+    .. deprecated:: 0.4.0
+        Use ``Threshold`` instead. This class will be removed in a future version.
+    """
 
     def __init__(self, **kwargs) -> None:
+        """Initialize with deprecation warning.
+
+        Args:
+            **kwargs: Keyword arguments passed to parent ``Threshold`` class.
+        """
         warnings.warn(
             "BaseThreshold is deprecated and will be removed in a future version. Use Threshold instead.",
             DeprecationWarning,
diff --git a/src/anomalib/metrics/threshold/f1_adaptive_threshold.py b/src/anomalib/metrics/threshold/f1_adaptive_threshold.py
index cb2ba1cd19..1d1461ddaf 100644
--- a/src/anomalib/metrics/threshold/f1_adaptive_threshold.py
+++ b/src/anomalib/metrics/threshold/f1_adaptive_threshold.py
@@ -1,4 +1,30 @@
-"""Implementation of F1AdaptiveThreshold based on TorchMetrics."""
+"""F1 adaptive threshold metric for anomaly detection.
+
+This module provides the ``F1AdaptiveThreshold`` class which automatically finds
+the optimal threshold value by maximizing the F1 score on validation data.
+
+The threshold is computed by:
+1. Computing precision-recall curve across multiple thresholds
+2. Calculating F1 score at each threshold point
+3. Selecting threshold that yields maximum F1 score
+
+Example:
+    >>> from anomalib.metrics import F1AdaptiveThreshold
+    >>> import torch
+    >>> # Create sample data
+    >>> labels = torch.tensor([0, 0, 0, 1, 1])  # Binary labels
+    >>> scores = torch.tensor([2.3, 1.6, 2.6, 7.9, 3.3])  # Anomaly scores
+    >>> # Initialize and compute threshold
+    >>> threshold = F1AdaptiveThreshold(default_value=0.5)
+    >>> optimal_threshold = threshold(scores, labels)
+    >>> optimal_threshold
+    tensor(3.3000)
+
+Note:
+    The validation set should contain both normal and anomalous samples for
+    reliable threshold computation. A warning is logged if no anomalous samples
+    are found.
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -15,30 +41,31 @@
 
 
 class F1AdaptiveThreshold(BinaryPrecisionRecallCurve, Threshold):
-    """Anomaly Score Threshold.
+    """Adaptive threshold that maximizes F1 score.
 
-    This class computes/stores the threshold that determines the anomalous label
-    given anomaly scores. It initially computes the adaptive threshold to find
-    the optimal f1_score and stores the computed adaptive threshold value.
+    This class computes and stores the optimal threshold for converting anomaly
+    scores to binary predictions by maximizing the F1 score on validation data.
 
     Args:
-        default_value: Default value of the threshold.
+        default_value: Initial threshold value used before computation.
             Defaults to ``0.5``.
+        **kwargs: Additional arguments passed to parent classes.
 
-    Examples:
-        To find the best threshold that maximizes the F1 score, we could run the
-        following:
+    Attributes:
+        value (torch.Tensor): Current threshold value.
 
+    Example:
         >>> from anomalib.metrics import F1AdaptiveThreshold
         >>> import torch
-        ...
-        >>> labels = torch.tensor([0, 0, 0, 1, 1])
-        >>> preds = torch.tensor([2.3, 1.6, 2.6, 7.9, 3.3])
-        ...
-        >>> adaptive_threshold = F1AdaptiveThreshold(default_value=0.5)
-        >>> threshold = adaptive_threshold(preds, labels)
-        >>> threshold
-        tensor(3.3000)
+        >>> # Create validation data
+        >>> labels = torch.tensor([0, 0, 1, 1])  # 2 normal, 2 anomalous
+        >>> scores = torch.tensor([0.1, 0.2, 0.8, 0.9])  # Anomaly scores
+        >>> # Initialize threshold
+        >>> threshold = F1AdaptiveThreshold()
+        >>> # Compute optimal threshold
+        >>> optimal_value = threshold(scores, labels)
+        >>> print(f"Optimal threshold: {optimal_value:.4f}")
+        Optimal threshold: 0.5000
     """
 
     def __init__(self, default_value: float = 0.5, **kwargs) -> None:
@@ -48,13 +75,18 @@ def __init__(self, default_value: float = 0.5, **kwargs) -> None:
         self.value = torch.tensor(default_value)
 
     def compute(self) -> torch.Tensor:
-        """Compute the threshold that yields the optimal F1 score.
+        """Compute optimal threshold by maximizing F1 score.
 
-        Compute the F1 scores while varying the threshold. Store the optimal
-        threshold as attribute and return the maximum value of the F1 score.
+        Calculates precision-recall curve and corresponding thresholds, then
+        finds the threshold that maximizes the F1 score.
 
         Returns:
-            Value of the F1 score at the optimal threshold.
+            torch.Tensor: Optimal threshold value.
+
+        Warning:
+            If validation set contains no anomalous samples, the threshold will
+            default to the maximum anomaly score, which may lead to poor
+            performance.
         """
         precision: torch.Tensor
         recall: torch.Tensor
@@ -62,9 +94,11 @@ def compute(self) -> torch.Tensor:
 
         if not any(1 in batch for batch in self.target):
             msg = (
-                "The validation set does not contain any anomalous images. As a result, the adaptive threshold will "
-                "take the value of the highest anomaly score observed in the normal validation images, which may lead "
-                "to poor predictions. For a more reliable adaptive threshold computation, please add some anomalous "
+                "The validation set does not contain any anomalous images. As a "
+                "result, the adaptive threshold will take the value of the "
+                "highest anomaly score observed in the normal validation images, "
+                "which may lead to poor predictions. For a more reliable "
+                "adaptive threshold computation, please add some anomalous "
                 "images to the validation set."
             )
             logging.warning(msg)
@@ -80,9 +114,9 @@ def compute(self) -> torch.Tensor:
         return self.value
 
     def __repr__(self) -> str:
-        """Return threshold value within the string representation.
+        """Return string representation including current threshold value.
 
         Returns:
-            str: String representation of the class.
+            str: String in format "ClassName(value=X.XX)"
         """
         return f"{super().__repr__()} (value={self.value:.2f})"
diff --git a/src/anomalib/metrics/threshold/manual_threshold.py b/src/anomalib/metrics/threshold/manual_threshold.py
index e42860db01..d7179be7df 100644
--- a/src/anomalib/metrics/threshold/manual_threshold.py
+++ b/src/anomalib/metrics/threshold/manual_threshold.py
@@ -1,4 +1,28 @@
-"""Container to hold manual threshold values for image and pixel metrics."""
+"""Manual threshold metric for anomaly detection.
+
+This module provides the ``ManualThreshold`` class which allows setting a fixed
+threshold value for converting anomaly scores to binary predictions.
+
+The threshold value is manually specified and remains constant regardless of the
+input data.
+
+Example:
+    >>> from anomalib.metrics import ManualThreshold
+    >>> import torch
+    >>> # Create sample data
+    >>> labels = torch.tensor([0, 0, 1, 1])  # Binary labels
+    >>> scores = torch.tensor([0.1, 0.3, 0.7, 0.9])  # Anomaly scores
+    >>> # Initialize with fixed threshold
+    >>> threshold = ManualThreshold(default_value=0.5)
+    >>> # Threshold remains constant
+    >>> threshold(scores, labels)
+    tensor(0.5000)
+
+Note:
+    Unlike adaptive thresholds, this metric does not optimize the threshold value
+    based on the data. The threshold remains fixed at the manually specified
+    value.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/__init__.py b/src/anomalib/models/__init__.py
index 1e383530d0..ed4b78c05e 100644
--- a/src/anomalib/models/__init__.py
+++ b/src/anomalib/models/__init__.py
@@ -1,4 +1,45 @@
-"""Load Anomaly Model."""
+"""Anomaly detection models.
+
+This module contains all the anomaly detection models available in anomalib.
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Padim
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and datamodule
+    >>> datamodule = MVTec()
+    >>> model = Padim()
+
+    >>> # Train using the engine
+    >>> engine = Engine()
+    >>> engine.fit(model=model, datamodule=datamodule)
+
+The module provides both image and video anomaly detection models:
+
+Image Models:
+    - CFA (:class:`anomalib.models.image.Cfa`)
+    - Cflow (:class:`anomalib.models.image.Cflow`)
+    - CSFlow (:class:`anomalib.models.image.Csflow`)
+    - DFKDE (:class:`anomalib.models.image.Dfkde`)
+    - DFM (:class:`anomalib.models.image.Dfm`)
+    - DRAEM (:class:`anomalib.models.image.Draem`)
+    - DSR (:class:`anomalib.models.image.Dsr`)
+    - EfficientAd (:class:`anomalib.models.image.EfficientAd`)
+    - FastFlow (:class:`anomalib.models.image.Fastflow`)
+    - FRE (:class:`anomalib.models.image.Fre`)
+    - GANomaly (:class:`anomalib.models.image.Ganomaly`)
+    - PaDiM (:class:`anomalib.models.image.Padim`)
+    - PatchCore (:class:`anomalib.models.image.Patchcore`)
+    - Reverse Distillation (:class:`anomalib.models.image.ReverseDistillation`)
+    - STFPM (:class:`anomalib.models.image.Stfpm`)
+    - UFlow (:class:`anomalib.models.image.Uflow`)
+    - VLM-AD (:class:`anomalib.models.image.VlmAd`)
+    - WinCLIP (:class:`anomalib.models.image.WinClip`)
+
+Video Models:
+    - AI-VAD (:class:`anomalib.models.video.AiVad`)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -65,33 +106,51 @@ class UnknownModelError(ModuleNotFoundError):
 
 
 def convert_snake_to_pascal_case(snake_case: str) -> str:
-    """Convert snake_case to PascalCase.
+    """Convert snake_case string to PascalCase.
+
+    This function takes a string in snake_case format (words separated by underscores)
+    and converts it to PascalCase format (each word capitalized and concatenated).
 
     Args:
-        snake_case (str): Input string in snake_case
+        snake_case (str): Input string in snake_case format (e.g. ``"efficient_ad"``)
 
     Returns:
-        str: Output string in PascalCase
+        str: Output string in PascalCase format (e.g. ``"EfficientAd"``)
 
     Examples:
-        >>> _convert_snake_to_pascal_case("efficient_ad")
-        EfficientAd
-
-        >>> _convert_snake_to_pascal_case("patchcore")
-        Patchcore
+        >>> convert_snake_to_pascal_case("efficient_ad")
+        'EfficientAd'
+        >>> convert_snake_to_pascal_case("patchcore")
+        'Patchcore'
+        >>> convert_snake_to_pascal_case("reverse_distillation")
+        'ReverseDistillation'
     """
     return "".join(word.capitalize() for word in snake_case.split("_"))
 
 
 def get_available_models() -> set[str]:
-    """Get set of available models.
+    """Get set of available anomaly detection models.
+
+    Returns a set of model names in snake_case format that are available in the
+    anomalib library. This includes both image and video anomaly detection models.
 
     Returns:
-        set[str]: List of available models.
+        set[str]: Set of available model names in snake_case format (e.g.
+            ``'efficient_ad'``, ``'padim'``, etc.)
 
     Example:
-        >>> get_available_models()
-        ['ai_vad', 'cfa', 'cflow', 'csflow', 'dfkde', 'dfm', 'draem', 'efficient_ad', 'fastflow', ...]
+        Get all available models:
+
+        >>> from anomalib.models import get_available_models
+        >>> models = get_available_models()
+        >>> print(sorted(list(models)))  # doctest: +NORMALIZE_WHITESPACE
+        ['ai_vad', 'cfa', 'cflow', 'csflow', 'dfkde', 'dfm', 'draem',
+         'efficient_ad', 'fastflow', 'fre', 'ganomaly', 'padim', 'patchcore',
+         'reverse_distillation', 'stfpm', 'uflow', 'vlm_ad', 'winclip']
+
+    Note:
+        The returned model names can be used with :func:`get_model` to instantiate
+        the corresponding model class.
     """
     return {
         convert_to_snake_case(cls.__name__)
@@ -101,16 +160,32 @@ def get_available_models() -> set[str]:
 
 
 def _get_model_class_by_name(name: str) -> type[AnomalibModule]:
-    """Retrieves an anomaly model based on its name.
+    """Retrieve an anomaly model class based on its name.
+
+    This internal function takes a model name and returns the corresponding model class.
+    The name matching is case-insensitive and supports both snake_case and PascalCase
+    formats.
 
     Args:
-        name (str): The name of the model to retrieve. The name is case insensitive.
+        name (str): Name of the model to retrieve. Can be in snake_case (e.g.
+            ``"efficient_ad"``) or PascalCase (e.g. ``"EfficientAd"``). The name is
+            case-insensitive.
 
     Raises:
-        UnknownModelError: If the model is not found.
+        UnknownModelError: If no model is found matching the provided name. The error
+            message includes the list of available models.
 
     Returns:
-        type[AnomalibModule]: Anomaly Model
+        type[AnomalibModule]: Model class that inherits from ``AnomalibModule``.
+
+    Examples:
+        >>> from anomalib.models import _get_model_class_by_name
+        >>> model_class = _get_model_class_by_name("padim")
+        >>> model_class.__name__
+        'Padim'
+        >>> model_class = _get_model_class_by_name("efficient_ad")
+        >>> model_class.__name__
+        'EfficientAd'
     """
     logger.info("Loading the model.")
     model_class: type[AnomalibModule] | None = None
@@ -127,27 +202,53 @@ def _get_model_class_by_name(name: str) -> type[AnomalibModule]:
 
 
 def get_model(model: DictConfig | str | dict | Namespace, *args, **kwdargs) -> AnomalibModule:
-    """Get Anomaly Model.
+    """Get an anomaly detection model instance.
+
+    This function instantiates an anomaly detection model based on the provided
+    configuration or model name. It supports multiple ways of model specification
+    including string names, dictionaries and OmegaConf configurations.
 
     Args:
-        model (DictConfig | str): Can either be a configuration or a string.
-        *args: Variable length argument list for model init.
-        **kwdargs: Arbitrary keyword arguments for model init.
+        model (DictConfig | str | dict | Namespace): Model specification that can be:
+            - A string with model name (e.g. ``"padim"``, ``"efficient_ad"``)
+            - A dictionary with ``class_path`` and optional ``init_args``
+            - An OmegaConf DictConfig with similar structure as dict
+            - A Namespace object with similar structure as dict
+        *args: Variable length argument list passed to model initialization.
+        **kwdargs: Arbitrary keyword arguments passed to model initialization.
 
-    Examples:
-        >>> get_model("Padim")
-        >>> get_model("efficient_ad")
-        >>> get_model("Patchcore", input_size=(100, 100))
-        >>> get_model({"class_path": "Padim"})
-        >>> get_model({"class_path": "Patchcore"}, input_size=(100, 100))
-        >>> get_model({"class_path": "Padim", "init_args": {"input_size": (100, 100)}})
-        >>> get_model({"class_path": "anomalib.models.Padim", "init_args": {"input_size": (100, 100)}}})
+    Returns:
+        AnomalibModule: Instantiated anomaly detection model.
 
     Raises:
-        TypeError: If unsupported type is passed.
+        TypeError: If ``model`` argument is of unsupported type.
+        UnknownModelError: If specified model class cannot be found.
 
-    Returns:
-        AnomalibModule: Anomaly Model
+    Examples:
+        Get model by name:
+
+        >>> model = get_model("padim")
+        >>> model = get_model("efficient_ad")
+        >>> model = get_model("patchcore", input_size=(100, 100))
+
+        Get model using dictionary config:
+
+        >>> model = get_model({"class_path": "Padim"})
+        >>> model = get_model(
+        ...     {"class_path": "Patchcore"},
+        ...     input_size=(100, 100)
+        ... )
+        >>> model = get_model({
+        ...     "class_path": "Padim",
+        ...     "init_args": {"input_size": (100, 100)}
+        ... })
+
+        Get model using fully qualified path:
+
+        >>> model = get_model({
+        ...     "class_path": "anomalib.models.Padim",
+        ...     "init_args": {"input_size": (100, 100)}
+        ... })
     """
     _model: AnomalibModule
     if isinstance(model, str):
diff --git a/src/anomalib/models/components/__init__.py b/src/anomalib/models/components/__init__.py
index 762345a93d..2bc64990bd 100644
--- a/src/anomalib/models/components/__init__.py
+++ b/src/anomalib/models/components/__init__.py
@@ -1,4 +1,38 @@
-"""Components used within the models."""
+"""Components used within the anomaly detection models.
+
+This module provides various components that are used across different anomaly
+detection models in the library.
+
+Components:
+    Base Components:
+        - ``AnomalibModule``: Base module for all anomaly detection models
+        - ``BufferListMixin``: Mixin for managing lists of buffers
+        - ``DynamicBufferMixin``: Mixin for dynamic buffer management
+        - ``MemoryBankMixin``: Mixin for memory bank functionality
+
+    Dimensionality Reduction:
+        - ``PCA``: Principal Component Analysis
+        - ``SparseRandomProjection``: Random projection with sparse matrices
+
+    Feature Extraction:
+        - ``TimmFeatureExtractor``: Feature extractor using timm models
+        - ``TorchFXFeatureExtractor``: Feature extractor using TorchFX
+
+    Image Processing:
+        - ``GaussianBlur2d``: 2D Gaussian blur filter
+
+    Sampling:
+        - ``KCenterGreedy``: K-center greedy sampling algorithm
+
+    Statistical Methods:
+        - ``GaussianKDE``: Gaussian kernel density estimation
+        - ``MultiVariateGaussian``: Multivariate Gaussian distribution
+
+Example:
+    >>> from anomalib.models.components import GaussianKDE
+    >>> kde = GaussianKDE()
+    >>> # Use components in anomaly detection models
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/components/base/__init__.py b/src/anomalib/models/components/base/__init__.py
index 250eec5045..a010551fe1 100644
--- a/src/anomalib/models/components/base/__init__.py
+++ b/src/anomalib/models/components/base/__init__.py
@@ -1,4 +1,21 @@
-"""Base classes for all anomaly components."""
+"""Base classes for all anomaly components.
+
+This module provides the foundational classes used across anomalib's model
+components. These include:
+
+- ``AnomalibModule``: Base class for all anomaly detection modules
+- ``BufferListMixin``: Mixin for managing lists of model buffers
+- ``DynamicBufferMixin``: Mixin for handling dynamic model buffers
+- ``MemoryBankMixin``: Mixin for models requiring feature memory banks
+
+Example:
+    >>> from anomalib.models.components.base import AnomalibModule
+    >>> class MyAnomalyModel(AnomalibModule):
+    ...     def __init__(self):
+    ...         super().__init__()
+    ...     def forward(self, x):
+    ...         return x
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/components/base/anomalib_module.py b/src/anomalib/models/components/base/anomalib_module.py
index 3fd5557032..b5fc6a57cf 100644
--- a/src/anomalib/models/components/base/anomalib_module.py
+++ b/src/anomalib/models/components/base/anomalib_module.py
@@ -1,4 +1,41 @@
-"""Base Anomaly Module for Training Task."""
+"""Base Anomaly Module for Training Task.
+
+This module provides the foundational class for all anomaly detection models in
+anomalib. The ``AnomalibModule`` class extends PyTorch Lightning's
+``LightningModule`` and provides common functionality for training, validation,
+testing and inference of anomaly detection models.
+
+The class handles:
+- Model initialization and setup
+- Pre-processing of input data
+- Post-processing of model outputs
+- Evaluation metrics computation
+- Visualization of results
+- Model export capabilities
+
+Example:
+    Create a custom anomaly detection model:
+
+    >>> from anomalib.models.components.base import AnomalibModule
+    >>> class MyModel(AnomalibModule):
+    ...     def __init__(self):
+    ...         super().__init__()
+    ...         self.model = torch.nn.Linear(10, 1)
+    ...
+    ...     def training_step(self, batch, batch_idx):
+    ...         return self.model(batch)
+
+    Create model with custom components:
+
+    >>> from anomalib.pre_processing import PreProcessor
+    >>> from anomalib.post_processing import PostProcessor
+    >>> model = MyModel(
+    ...     pre_processor=PreProcessor(),
+    ...     post_processor=PostProcessor(),
+    ...     evaluator=True,
+    ...     visualizer=True
+    ... )
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -33,9 +70,56 @@
 
 
 class AnomalibModule(ExportMixin, pl.LightningModule, ABC):
-    """AnomalibModule to train, validate, predict and test images.
-
-    Acts as a base class for all the Anomaly Modules in the library.
+    """Base class for all anomaly detection modules in anomalib.
+
+    This class provides the core functionality for training, validation, testing
+    and inference of anomaly detection models. It handles data pre-processing,
+    post-processing, evaluation and visualization.
+
+    Args:
+        pre_processor (PreProcessor | bool, optional): Pre-processor instance or
+            flag to use default. Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor instance
+            or flag to use default. Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator instance or flag to use
+            default. Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer instance or flag to
+            use default. Defaults to ``True``.
+
+    Attributes:
+        model (nn.Module): PyTorch model to be trained
+        loss (nn.Module): Loss function for training
+        callbacks (list[Callback]): List of callbacks
+        pre_processor (PreProcessor | None): Component for pre-processing inputs
+        post_processor (PostProcessor | None): Component for post-processing
+            outputs
+        evaluator (Evaluator | None): Component for computing metrics
+        visualizer (Visualizer | None): Component for visualization
+
+    Example:
+        Create a model with default components:
+
+        >>> model = AnomalibModule()
+
+        Create a model with custom components:
+
+        >>> from anomalib.pre_processing import PreProcessor
+        >>> from anomalib.post_processing import PostProcessor
+        >>> model = AnomalibModule(
+        ...     pre_processor=PreProcessor(),
+        ...     post_processor=PostProcessor(),
+        ...     evaluator=True,
+        ...     visualizer=True
+        ... )
+
+        Disable certain components:
+
+        >>> model = AnomalibModule(
+        ...     pre_processor=False,
+        ...     post_processor=False,
+        ...     evaluator=False,
+        ...     visualizer=False
+        ... )
     """
 
     def __init__(
@@ -63,31 +147,52 @@ def __init__(
 
     @property
     def name(self) -> str:
-        """Name of the model."""
+        """Get name of the model.
+
+        Returns:
+            str: Name of the model class
+        """
         return self.__class__.__name__
 
     def setup(self, stage: str | None = None) -> None:
-        """Calls the _setup method to build the model if the model is not already built."""
+        """Set up the model if not already done.
+
+        This method ensures the model is built by calling ``_setup()`` if needed.
+
+        Args:
+            stage (str | None, optional): Current stage of training.
+                Defaults to ``None``.
+        """
         if getattr(self, "model", None) is None or not self._is_setup:
             self._setup()
             if isinstance(stage, TrainerFn):
-                # only set the flag if the stage is a TrainerFn, which means the setup has been called from a trainer
+                # only set the flag if the stage is a TrainerFn, which means the
+                # setup has been called from a trainer
                 self._is_setup = True
 
     def _setup(self) -> None:
-        """The _setup method is used to build the torch model dynamically or adjust something about them.
+        """Set up the model architecture.
+
+        This method should be overridden by subclasses to build their model
+        architecture. It is called by ``setup()`` when the model needs to be
+        initialized.
 
-        The model implementer may override this method to build the model. This is useful when the model cannot be set
-        in the `__init__` method because it requires some information or data that is not available at the time of
-        initialization.
+        This is useful when the model cannot be fully initialized in ``__init__``
+        because it requires data-dependent parameters.
         """
 
     def configure_callbacks(self) -> Sequence[Callback] | Callback:
-        """Configure default callbacks for AnomalibModule.
+        """Configure callbacks for the model.
 
         Returns:
-            List of callbacks that includes the pre-processor, post-processor, evaluator,
-            and visualizer if they are available and inherit from Callback.
+            Sequence[Callback] | Callback: List of callbacks including components
+                that inherit from ``Callback``
+
+        Example:
+            >>> model = AnomalibModule()
+            >>> callbacks = model.configure_callbacks()
+            >>> isinstance(callbacks, (Sequence, Callback))
+            True
         """
         callbacks: list[Callback] = []
         callbacks.extend(
@@ -98,15 +203,27 @@ def configure_callbacks(self) -> Sequence[Callback] | Callback:
         return callbacks
 
     def forward(self, batch: torch.Tensor, *args, **kwargs) -> InferenceBatch:
-        """Perform the forward-pass by passing input tensor to the module.
+        """Perform forward pass through the model pipeline.
+
+        The input batch is passed through:
+        1. Pre-processor (if configured)
+        2. Model
+        3. Post-processor (if configured)
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch.
-            *args: Arguments.
-            **kwargs: Keyword arguments.
+            batch (torch.Tensor): Input batch
+            *args: Additional positional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-            Tensor: Output tensor from the model.
+            InferenceBatch: Processed batch with model predictions
+
+        Example:
+            >>> model = AnomalibModule()
+            >>> batch = torch.randn(1, 3, 256, 256)
+            >>> output = model(batch)
+            >>> isinstance(output, InferenceBatch)
+            True
         """
         del args, kwargs  # These variables are not used.
         batch = self.pre_processor(batch) if self.pre_processor else batch
@@ -119,35 +236,38 @@ def predict_step(
         batch_idx: int,
         dataloader_idx: int = 0,
     ) -> STEP_OUTPUT:
-        """Step function called during :meth:`~lightning.pytorch.trainer.Trainer.predict`.
+        """Perform prediction step.
 
-        By default, it calls :meth:`~lightning.pytorch.core.lightning.LightningModule.forward`.
-        Override to add any processing logic.
+        This method is called during the predict stage of training. By default,
+        it calls the validation step.
 
         Args:
-            batch (Any): Current batch
-            batch_idx (int): Index of current batch
-            dataloader_idx (int): Index of the current dataloader
+            batch (Batch): Input batch
+            batch_idx (int): Index of the batch
+            dataloader_idx (int, optional): Index of the dataloader.
+                Defaults to ``0``.
 
-        Return:
-            Predicted output
+        Returns:
+            STEP_OUTPUT: Model predictions
         """
         del dataloader_idx  # These variables are not used.
 
         return self.validation_step(batch, batch_idx)
 
     def test_step(self, batch: Batch, batch_idx: int, *args, **kwargs) -> STEP_OUTPUT:
-        """Calls validation_step for anomaly map/score calculation.
+        """Perform test step.
+
+        This method is called during the test stage of training. By default,
+        it calls the predict step.
 
         Args:
-          batch (Batch): Input batch
-          batch_idx (int): Batch index
-          args: Arguments.
-          kwargs: Keyword arguments.
+            batch (Batch): Input batch
+            batch_idx (int): Index of the batch
+            *args: Additional positional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-          Dictionary containing images, features, true labels and masks.
-          These are required in `validation_epoch_end` for feature concatenation.
+            STEP_OUTPUT: Model predictions
         """
         del args, kwargs  # These variables are not used.
 
@@ -156,26 +276,43 @@ def test_step(self, batch: Batch, batch_idx: int, *args, **kwargs) -> STEP_OUTPU
     @property
     @abstractmethod
     def trainer_arguments(self) -> dict[str, Any]:
-        """Arguments used to override the trainer parameters so as to train the model correctly."""
+        """Get trainer arguments specific to this model.
+
+        Returns:
+            dict[str, Any]: Dictionary of trainer arguments
+
+        Raises:
+            NotImplementedError: If not implemented by subclass
+        """
         raise NotImplementedError
 
     @property
     @abstractmethod
     def learning_type(self) -> LearningType:
-        """Learning type of the model."""
+        """Get learning type of the model.
+
+        Returns:
+            LearningType: Type of learning (e.g. one-class, supervised)
+
+        Raises:
+            NotImplementedError: If not implemented by subclass
+        """
         raise NotImplementedError
 
     def _resolve_pre_processor(self, pre_processor: PreProcessor | bool) -> PreProcessor | None:
-        """Resolve and validate which pre-processor to use..
+        """Resolve and validate the pre-processor configuration.
 
         Args:
-            pre_processor: Pre-processor configuration
-                - True -> use default pre-processor
-                - False -> no pre-processor
-                - PreProcessor -> use the provided pre-processor
+            pre_processor (PreProcessor | bool): Pre-processor configuration
+                - ``True`` -> use default pre-processor
+                - ``False`` -> no pre-processor
+                - ``PreProcessor`` -> use provided pre-processor
 
         Returns:
-            Configured pre-processor
+            PreProcessor | None: Configured pre-processor
+
+        Raises:
+            TypeError: If pre_processor is invalid type
         """
         if isinstance(pre_processor, PreProcessor):
             return pre_processor
@@ -186,39 +323,22 @@ def _resolve_pre_processor(self, pre_processor: PreProcessor | bool) -> PreProce
 
     @classmethod
     def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
-        """Configure the pre-processor.
+        """Configure the default pre-processor.
 
-        The default pre-processor resizes images to 256x256 and normalizes using ImageNet statistics.
-        Individual models can override this method to provide custom transforms and pre-processing pipelines.
+        The default pre-processor resizes images and normalizes using ImageNet
+        statistics.
 
         Args:
-            image_size (tuple[int, int] | None, optional): Target size for resizing images.
-                If None, defaults to (256, 256). Defaults to None.
-            **kwargs (Any): Additional keyword arguments (unused).
+            image_size (tuple[int, int] | None, optional): Target size for
+                resizing. Defaults to ``(256, 256)``.
 
         Returns:
-            PreProcessor: Configured pre-processor instance.
-
-        Examples:
-            Get default pre-processor with custom image size:
-
-            >>> preprocessor = AnomalibModule.configure_pre_processor(image_size=(512, 512))
-
-            Create model with custom pre-processor:
+            PreProcessor: Configured pre-processor
 
-            >>> from torchvision.transforms.v2 import RandomHorizontalFlip
-            >>> custom_transform = Compose([
-            ...     Resize((256, 256), antialias=True),
-            ...     CenterCrop((224, 224)),
-            ...     RandomHorizontalFlip(p=0.5),
-            ...     Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
-            ... ])
-            >>> preprocessor.train_transform = custom_transform
-            >>> model = PatchCore(pre_processor=preprocessor)
-
-            Disable pre-processing:
-
-            >>> model = PatchCore(pre_processor=False)
+        Example:
+            >>> preprocessor = AnomalibModule.configure_pre_processor((512, 512))
+            >>> isinstance(preprocessor, PreProcessor)
+            True
         """
         image_size = image_size or (256, 256)
         return PreProcessor(
@@ -229,16 +349,19 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
         )
 
     def _resolve_post_processor(self, post_processor: PostProcessor | bool) -> PostProcessor | None:
-        """Resolve and validate which post-processor to use.
+        """Resolve and validate the post-processor configuration.
 
         Args:
-            post_processor: Post-processor configuration
-                - True -> use default post-processor
-                - False -> no post-processor
-                - PostProcessor -> use the provided post-processor
+            post_processor (PostProcessor | bool): Post-processor configuration
+                - ``True`` -> use default post-processor
+                - ``False`` -> no post-processor
+                - ``PostProcessor`` -> use provided post-processor
 
         Returns:
-            Configured post-processor
+            PostProcessor | None: Configured post-processor
+
+        Raises:
+            TypeError: If post_processor is invalid type
         """
         if isinstance(post_processor, PostProcessor):
             return post_processor
@@ -248,41 +371,43 @@ def _resolve_post_processor(self, post_processor: PostProcessor | bool) -> PostP
         raise TypeError(msg)
 
     def configure_post_processor(self) -> PostProcessor | None:
-        """Configure the default post-processor based on the learning type.
+        """Configure the default post-processor.
 
         Returns:
-            PostProcessor: Configured post-processor instance.
+            PostProcessor | None: Configured post-processor based on learning type
 
         Raises:
-            NotImplementedError: If no default post-processor is available for the model's learning type.
-
-        Examples:
-            Get default post-processor:
-
-            >>> post_processor = AnomalibModule.configure_post_processor()
-
-            Create model with custom post-processor:
-
-            >>> custom_post_processor = CustomPostProcessor()
-            >>> model = PatchCore(post_processor=custom_post_processor)
+            NotImplementedError: If no default post-processor exists for the
+                model's learning type
 
-            Disable post-processing:
-
-            >>> model = PatchCore(post_processor=False)
+        Example:
+            >>> model = AnomalibModule()
+            >>> post_processor = model.configure_post_processor()
+            >>> isinstance(post_processor, PostProcessor)
+            True
         """
         if self.learning_type == LearningType.ONE_CLASS:
             return OneClassPostProcessor()
         msg = (
-            f"No default post-processor available for model with learning type {self.learning_type}. "
-            "Please override the configure_post_processor method in the model implementation."
+            f"No default post-processor available for model with learning type "
+            f"{self.learning_type}. Please override configure_post_processor."
         )
         raise NotImplementedError(msg)
 
     def _resolve_evaluator(self, evaluator: Evaluator | bool) -> Evaluator | None:
-        """Resolve the evaluator to be used in the model.
+        """Resolve and validate the evaluator configuration.
+
+        Args:
+            evaluator (Evaluator | bool): Evaluator configuration
+                - ``True`` -> use default evaluator
+                - ``False`` -> no evaluator
+                - ``Evaluator`` -> use provided evaluator
 
-        If the evaluator is set to True, the default evaluator will be used. If the evaluator is set to False, no
-        evaluator will be used. If the evaluator is an instance of Evaluator, it will be used as the evaluator.
+        Returns:
+            Evaluator | None: Configured evaluator
+
+        Raises:
+            TypeError: If evaluator is invalid type
         """
         if isinstance(evaluator, Evaluator):
             return evaluator
@@ -293,9 +418,18 @@ def _resolve_evaluator(self, evaluator: Evaluator | bool) -> Evaluator | None:
 
     @staticmethod
     def configure_evaluator() -> Evaluator:
-        """Default evaluator.
+        """Configure the default evaluator.
 
-        Override in subclass for model-specific evaluator behaviour.
+        The default evaluator includes metrics for both image-level and
+        pixel-level evaluation.
+
+        Returns:
+            Evaluator: Configured evaluator with default metrics
+
+        Example:
+            >>> evaluator = AnomalibModule.configure_evaluator()
+            >>> isinstance(evaluator, Evaluator)
+            True
         """
         image_auroc = AUROC(fields=["pred_score", "gt_label"], prefix="image_")
         image_f1score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
@@ -305,16 +439,19 @@ def configure_evaluator() -> Evaluator:
         return Evaluator(test_metrics=test_metrics)
 
     def _resolve_visualizer(self, visualizer: Visualizer | bool) -> Visualizer | None:
-        """Resolve and validate which visualizer to use.
+        """Resolve and validate the visualizer configuration.
 
         Args:
-            visualizer: Visualizer configuration
-                - True -> use default visualizer
-                - False -> no visualizer
-                - Visualizer -> use the provided visualizer
+            visualizer (Visualizer | bool): Visualizer configuration
+                - ``True`` -> use default visualizer
+                - ``False`` -> no visualizer
+                - ``Visualizer`` -> use provided visualizer
 
         Returns:
-            Configured visualizer
+            Visualizer | None: Configured visualizer
+
+        Raises:
+            TypeError: If visualizer is invalid type
         """
         if isinstance(visualizer, Visualizer):
             return visualizer
@@ -327,46 +464,28 @@ def _resolve_visualizer(self, visualizer: Visualizer | bool) -> Visualizer | Non
     def configure_visualizer(cls) -> ImageVisualizer:
         """Configure the default visualizer.
 
-        By default, this method returns an ImageVisualizer instance, which is suitable for
-        visualizing image-based anomaly detection results. However, the visualizer can be
-        customized based on your needs - for example, using VideoVisualizer for video data
-        or implementing a custom visualizer for specific visualization requirements.
-
         Returns:
-            Visualizer: Configured visualizer instance (ImageVisualizer by default).
-
-        Examples:
-            Get default ImageVisualizer:
+            ImageVisualizer: Default image visualizer instance
 
+        Example:
             >>> visualizer = AnomalibModule.configure_visualizer()
-
-            Create model with VideoVisualizer:
-
-            >>> from custom_module import VideoVisualizer
-            >>> video_visualizer = VideoVisualizer()
-            >>> model = PatchCore(visualizer=video_visualizer)
-
-            Create model with custom visualizer:
-
-            >>> class CustomVisualizer(Visualizer):
-            ...     def __init__(self):
-            ...         super().__init__()
-            ...         # Custom visualization logic
-            >>> custom_visualizer = CustomVisualizer()
-            >>> model = PatchCore(visualizer=custom_visualizer)
-
-            Disable visualization:
-
-            >>> model = PatchCore(visualizer=False)
+            >>> isinstance(visualizer, ImageVisualizer)
+            True
         """
         return ImageVisualizer()
 
     @property
     def input_size(self) -> tuple[int, int] | None:
-        """Return the effective input size of the model.
+        """Get the effective input size of the model.
 
-        The effective input size is the size of the input tensor after the transform has been applied. If the transform
-        is not set, or if the transform does not change the shape of the input tensor, this method will return None.
+        Returns:
+            tuple[int, int] | None: Height and width of model input after
+                pre-processing, or ``None`` if size cannot be determined
+
+        Example:
+            >>> model = AnomalibModule()
+            >>> model.input_size  # Returns size after pre-processing
+            (256, 256)
         """
         transform = self.pre_processor.predict_transform if self.pre_processor else None
         if transform is None:
@@ -381,27 +500,29 @@ def from_config(
         config_path: str | Path,
         **kwargs,
     ) -> "AnomalibModule":
-        """Create a model instance from the configuration.
+        """Create a model instance from a configuration file.
 
         Args:
-            config_path (str | Path): Path to the model configuration file.
-            **kwargs (dict): Additional keyword arguments.
+            config_path (str | Path): Path to the model configuration file
+            **kwargs: Additional arguments to override config values
 
         Returns:
-            AnomalibModule: model instance.
-
-        Example:
-            The following example shows how to get model from patchcore.yaml:
-
-            .. code-block:: python
-                >>> model_config = "configs/model/patchcore.yaml"
-                >>> model = AnomalibModule.from_config(config_path=model_config)
+            AnomalibModule: Instantiated model
 
-            The following example shows overriding the configuration file with additional keyword arguments:
+        Raises:
+            FileNotFoundError: If config file does not exist
+            ValueError: If instantiated model is not AnomalibModule
 
-            .. code-block:: python
-                >>> override_kwargs = {"model.pre_trained": False}
-                >>> model = AnomalibModule.from_config(config_path=model_config, **override_kwargs)
+        Example:
+            >>> model = AnomalibModule.from_config("configs/model/patchcore.yaml")
+            >>> isinstance(model, AnomalibModule)
+            True
+
+            Override config values:
+            >>> model = AnomalibModule.from_config(
+            ...     "configs/model/patchcore.yaml",
+            ...     model__backbone="resnet18"
+            ... )
         """
         from jsonargparse import ActionConfigFile, ArgumentParser
         from lightning.pytorch import Trainer
diff --git a/src/anomalib/models/components/base/buffer_list.py b/src/anomalib/models/components/base/buffer_list.py
index f236c2e361..212880d481 100644
--- a/src/anomalib/models/components/base/buffer_list.py
+++ b/src/anomalib/models/components/base/buffer_list.py
@@ -1,4 +1,45 @@
-"""Buffer List Mixin."""
+"""Buffer List Mixin.
+
+This mixin allows registering a list of tensors as buffers in a PyTorch module.
+
+Example:
+    >>> # Create a module that uses the buffer list mixin
+    >>> class MyModule(BufferListMixin, nn.Module):
+    ...     def __init__(self):
+    ...         super().__init__()
+    ...         tensor_list = [torch.ones(3) * i for i in range(3)]
+    ...         self.register_buffer_list("my_buffer_list", tensor_list)
+    ...
+    >>> # Initialize the module
+    >>> module = MyModule()
+    ...
+    >>> # The buffer list can be accessed as a regular attribute
+    >>> module.my_buffer_list
+    [
+        tensor([0., 0., 0.]),
+        tensor([1., 1., 1.]),
+        tensor([2., 2., 2.])
+    ]
+    ...
+    >>> # Update the buffer list with new tensors
+    >>> new_tensor_list = [torch.ones(3) * i + 10 for i in range(3)]
+    >>> module.register_buffer_list("my_buffer_list", new_tensor_list)
+    >>> module.my_buffer_list
+    [
+        tensor([10., 10., 10.]),
+        tensor([11., 11., 11.]),
+        tensor([12., 12., 12.])
+    ]
+    ...
+    >>> # Move to GPU - device placement is handled automatically
+    >>> module.cuda()
+    >>> module.my_buffer_list
+    [
+        tensor([10., 10., 10.], device='cuda:0'),
+        tensor([11., 11., 11.], device='cuda:0'),
+        tensor([12., 12., 12.], device='cuda:0')
+    ]
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -8,55 +49,37 @@
 
 
 class BufferListMixin(nn.Module):
-    """Buffer List Mixin.
-
-    This mixin is used to allow registering a list of tensors as buffers in a pytorch module.
-
-    Example:
-        >>> class MyModule(BufferListMixin, nn.Module):
-        ...     def __init__(self):
-        ...         super().__init__()
-        ...         tensor_list = [torch.ones(3) * i for i in range(3)]
-        ...         self.register_buffer_list("my_buffer_list", tensor_list)
-        >>> module = MyModule()
-        >>> # The buffer list can be accessed as a regular attribute
-        >>> module.my_buffer_list
-        [
-            tensor([0., 0., 0.]),
-            tensor([1., 1., 1.]),
-            tensor([2., 2., 2.])
-        ]
-        >>> # We can update the buffer list at any time
-        >>> new_tensor_list = [torch.ones(3) * i + 10 for i in range(3)]
-        >>> module.register_buffer_list("my_buffer_list", new_tensor_list)
-        >>> module.my_buffer_list
-        [
-            tensor([10., 10., 10.]),
-            tensor([11., 11., 11.]),
-            tensor([12., 12., 12.])
-        ]
-        >>> # Move to GPU. Since the tensors are registered as buffers, device placement is handled automatically
-        >>> module.cuda()
-        >>> module.my_buffer_list
-        [
-            tensor([10., 10., 10.], device='cuda:0'),
-            tensor([11., 11., 11.], device='cuda:0'),
-            tensor([12., 12., 12.], device='cuda:0')
-        ]
+    """Mixin class that enables registering lists of tensors as module buffers.
+
+    This mixin extends PyTorch modules to support registering lists of tensors as
+    buffers, which are automatically handled during device placement and state
+    dict operations.
     """
 
-    def register_buffer_list(self, name: str, values: list[torch.Tensor], persistent: bool = True, **kwargs) -> None:
-        """Register a list of tensors as buffers in a pytorch module.
+    def register_buffer_list(
+        self,
+        name: str,
+        values: list[torch.Tensor],
+        persistent: bool = True,
+        **kwargs,
+    ) -> None:
+        """Register a list of tensors as buffers in a PyTorch module.
 
-        Each tensor is registered as a buffer with the name `_name_i` where `i` is the index of the tensor in the list.
-        To update and retrieve the list of tensors, we dynamically assign a descriptor attribute to the class.
+        Each tensor is registered as a buffer with the name ``_name_i`` where ``i``
+        is the index of the tensor in the list. The list can be accessed and
+        updated using the original ``name``.
 
         Args:
-            name (str): Name of the buffer list.
-            values (list[torch.Tensor]): List of tensors to register as buffers.
-            persistent (bool, optional): Whether the buffers should be saved as part of the module state_dict.
-                Defaults to True.
-            **kwargs: Additional keyword arguments to pass to `torch.nn.Module.register_buffer`.
+            name (str):
+                Name of the buffer list.
+            values (list[torch.Tensor]):
+                List of tensors to register as buffers.
+            persistent (bool, optional):
+                Whether the buffers should be saved as part of the module
+                state_dict. Defaults to ``True``.
+            **kwargs:
+                Additional keyword arguments to pass to
+                ``torch.nn.Module.register_buffer``.
         """
         for i, value in enumerate(values):
             self.register_buffer(f"_{name}_{i}", value, persistent=persistent, **kwargs)
@@ -65,31 +88,41 @@ def register_buffer_list(self, name: str, values: list[torch.Tensor], persistent
 
 
 class BufferListDescriptor:
-    """Buffer List Descriptor.
+    """Descriptor class for managing lists of buffer tensors.
 
-    This descriptor is used to allow registering a list of tensors as buffers in a pytorch module.
+    This descriptor provides the functionality to access and modify lists of
+    tensors that are registered as buffers in a PyTorch module.
 
     Args:
-        name (str): Name of the buffer list.
-        length (int): Length of the buffer list.
+        name (str):
+            Name of the buffer list.
+        length (int):
+            Length of the buffer list.
     """
 
     def __init__(self, name: str, length: int) -> None:
         self.name = name
         self.length = length
 
-    def __get__(self, instance: object, object_type: type | None = None) -> list[torch.Tensor]:
+    def __get__(
+        self,
+        instance: object,
+        object_type: type | None = None,
+    ) -> list[torch.Tensor]:
         """Get the list of tensors.
 
-        Each element of the buffer list is stored as a buffer with the name `name_i` where `i` is the index of the
-        element in the list. We use list comprehension to retrieve the list of tensors.
+        Retrieves the list of tensors stored as individual buffers with names
+        ``_name_i`` where ``i`` is the index.
 
         Args:
-            instance (object): Instance of the class.
-            object_type (Any, optional): Type of the class. Defaults to None.
+            instance (object):
+                Instance of the class.
+            object_type (type | None, optional):
+                Type of the class. Defaults to ``None``.
 
         Returns:
-            list[torch.Tensor]: Contents of the buffer list.
+            list[torch.Tensor]:
+                List of tensor buffers.
         """
         del object_type
         return [getattr(instance, f"_{self.name}_{i}") for i in range(self.length)]
@@ -97,11 +130,13 @@ def __get__(self, instance: object, object_type: type | None = None) -> list[tor
     def __set__(self, instance: object, values: list[torch.Tensor]) -> None:
         """Set the list of tensors.
 
-        Assigns a new list of tensors to the buffer list by updating the individual buffer attributes.
+        Updates the individual buffer attributes with new tensor values.
 
         Args:
-            instance (object): Instance of the class.
-            values (list[torch.Tensor]): List of tensors to set.
+            instance (object):
+                Instance of the class.
+            values (list[torch.Tensor]):
+                List of tensors to set as buffers.
         """
         for i, value in enumerate(values):
             setattr(instance, f"_{self.name}_{i}", value)
diff --git a/src/anomalib/models/components/base/dynamic_buffer.py b/src/anomalib/models/components/base/dynamic_buffer.py
index e1c6ad6bd6..d34ac94283 100644
--- a/src/anomalib/models/components/base/dynamic_buffer.py
+++ b/src/anomalib/models/components/base/dynamic_buffer.py
@@ -1,4 +1,27 @@
-"""Dynamic Buffer Mixin."""
+"""Dynamic Buffer Mixin.
+
+This mixin class enables loading state dictionaries with mismatched tensor shapes
+by dynamically resizing buffers to match the loaded state.
+
+Example:
+    >>> import torch
+    >>> from torch import nn
+    >>> class MyModule(DynamicBufferMixin, nn.Module):
+    ...     def __init__(self):
+    ...         super().__init__()
+    ...         self.register_buffer("buffer", torch.ones(3))
+    ...
+    >>> module = MyModule()
+    >>> # Original buffer shape is (3,)
+    >>> module.buffer
+    tensor([1., 1., 1.])
+    >>> # Load state dict with different buffer shape (5,)
+    >>> new_state = {"buffer": torch.ones(5)}
+    >>> module.load_state_dict(new_state)
+    >>> # Buffer is automatically resized
+    >>> module.buffer
+    tensor([1., 1., 1., 1., 1.])
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,19 +33,26 @@
 
 
 class DynamicBufferMixin(nn.Module, ABC):
-    """This mixin allows loading variables from the state dict even in the case of shape mismatch."""
+    """Mixin that enables loading state dicts with mismatched tensor shapes.
+
+    This mixin class extends ``nn.Module`` to allow loading state dictionaries
+    even when the shapes of tensors in the state dict do not match the shapes
+    of the module's buffers. When loading a state dict, the mixin automatically
+    resizes any mismatched buffers to match the shapes in the state dict.
+    """
 
     def get_tensor_attribute(self, attribute_name: str) -> torch.Tensor:
-        """Get attribute of the tensor given the name.
+        """Get a tensor attribute by name.
 
         Args:
-            attribute_name (str): Name of the tensor
+            attribute_name (str): Name of the tensor attribute to retrieve
 
         Raises:
-            ValueError: `attribute_name` is not a torch Tensor
+            ValueError: If the attribute with name ``attribute_name`` is not a
+                ``torch.Tensor``
 
         Returns:
-            Tensor: torch.Tensor attribute
+            torch.Tensor: The tensor attribute
         """
         attribute = getattr(self, attribute_name)
         if isinstance(attribute, torch.Tensor):
@@ -32,14 +62,17 @@ def get_tensor_attribute(self, attribute_name: str) -> torch.Tensor:
         raise ValueError(msg)
 
     def _load_from_state_dict(self, state_dict: dict, prefix: str, *args) -> None:
-        """Resizes the local buffers to match those stored in the state dict.
+        """Load a state dictionary, resizing buffers if shapes don't match.
 
-        Overrides method from parent class.
+        This method overrides the parent class implementation to handle tensor
+        shape mismatches when loading state dictionaries. It resizes any local
+        buffers whose shapes don't match the corresponding tensors in the state
+        dict.
 
         Args:
-          state_dict (dict): State dictionary containing weights
-          prefix (str): Prefix of the weight file.
-          *args: Variable length argument list.
+            state_dict (dict): Dictionary containing state to load
+            prefix (str): Prefix to prepend to parameter/buffer names
+            *args: Additional arguments passed to parent implementation
         """
         persistent_buffers = {k: v for k, v in self._buffers.items() if k not in self._non_persistent_buffers_set}
         local_buffers = {k: v for k, v in persistent_buffers.items() if v is not None}
diff --git a/src/anomalib/models/components/base/export_mixin.py b/src/anomalib/models/components/base/export_mixin.py
index baaf07ec95..96fae750fa 100644
--- a/src/anomalib/models/components/base/export_mixin.py
+++ b/src/anomalib/models/components/base/export_mixin.py
@@ -1,4 +1,38 @@
-"""Mixin for exporting models to disk."""
+"""Mixin for exporting anomaly detection models to disk.
+
+This mixin provides functionality to export models to various formats:
+- PyTorch (.pt)
+- ONNX (.onnx)
+- OpenVINO IR (.xml/.bin)
+
+The mixin supports different compression types for OpenVINO exports:
+- FP16 compression
+- INT8 quantization
+- Post-training quantization (PTQ)
+- Accuracy-aware quantization (ACQ)
+
+Example:
+    Export a trained model to different formats:
+
+    >>> from anomalib.models import Patchcore
+    >>> from anomalib.data import Visa
+    >>> from anomalib.deploy.export import CompressionType
+    ...
+    >>> # Initialize and train model
+    >>> model = Patchcore()
+    >>> datamodule = Visa()
+    >>> # Export to PyTorch format
+    >>> model.to_torch("./exports")
+    >>> # Export to ONNX
+    >>> model.to_onnx("./exports", input_size=(224, 224))
+    >>> # Export to OpenVINO with INT8 quantization
+    >>> model.to_openvino(
+    ...     "./exports",
+    ...     input_size=(224, 224),
+    ...     compression_type=CompressionType.INT8_PTQ,
+    ...     datamodule=datamodule
+    ... )
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -29,7 +63,16 @@
 
 
 class ExportMixin:
-    """This mixin allows exporting models to torch and ONNX/OpenVINO."""
+    """Mixin class that enables exporting models to various formats.
+
+    This mixin provides methods to export models to PyTorch (.pt), ONNX (.onnx),
+    and OpenVINO IR (.xml/.bin) formats. For OpenVINO exports, it supports
+    different compression types including FP16, INT8, PTQ and ACQ.
+
+    The mixin requires the host class to have:
+        - A ``model`` attribute of type ``nn.Module``
+        - A ``device`` attribute of type ``torch.device``
+    """
 
     model: nn.Module
     device: torch.device
@@ -38,37 +81,22 @@ def to_torch(
         self,
         export_root: Path | str,
     ) -> Path:
-        """Export AnomalibModel to torch.
+        """Export model to PyTorch format.
 
         Args:
-            export_root (Path): Path to the output folder.
-            transform (Transform, optional): Input transforms used for the model. If not provided, the transform is
-                taken from the model.
-                Defaults to ``None``.
-            post_processor (nn.Module, optional): Post-processing module to apply to the model output.
-                Defaults to ``None``.
+            export_root (Path | str): Path to the output folder
 
         Returns:
-            Path: Path to the exported pytorch model.
+            Path: Path to the exported PyTorch model (.pt file)
 
         Examples:
-            Assume that we have a model to train and we want to export it to torch format.
+            Export a trained model to PyTorch format:
 
-            >>> from anomalib.data import Visa
             >>> from anomalib.models import Patchcore
-            >>> from anomalib.engine import Engine
-            ...
-            >>> datamodule = Visa()
             >>> model = Patchcore()
-            >>> engine = Engine()
-            ...
-            >>> engine.fit(model, datamodule)
-
-            Now that we have a model trained, we can export it to torch format.
-
-            >>> model.to_torch(
-            ...     export_root="path/to/export",
-            ... )
+            >>> # Train model...
+            >>> model.to_torch("./exports")
+            PosixPath('./exports/weights/torch/model.pt')
         """
         export_root = _create_export_root(export_root, ExportType.TORCH)
         pt_model_path = export_root / "model.pt"
@@ -83,41 +111,29 @@ def to_onnx(
         export_root: Path | str,
         input_size: tuple[int, int] | None = None,
     ) -> Path:
-        """Export model to onnx.
+        """Export model to ONNX format.
 
         Args:
-            export_root (Path): Path to the root folder of the exported model.
-            input_size (tuple[int, int] | None, optional): Image size used as the input for onnx converter.
-                Defaults to None.
-            transform (Transform, optional): Input transforms used for the model. If not provided, the transform is
-                taken from the model.
-                Defaults to ``None``.
-            post_processor (nn.Module, optional): Post-processing module to apply to the model output.
-                Defaults to ``None``.
+            export_root (Path | str): Path to the output folder
+            input_size (tuple[int, int] | None): Input image dimensions (height, width).
+                If ``None``, uses dynamic input shape. Defaults to ``None``
 
         Returns:
-            Path: Path to the exported onnx model.
+            Path: Path to the exported ONNX model (.onnx file)
 
         Examples:
-            Export the Lightning Model to ONNX:
+            Export model with fixed input size:
 
             >>> from anomalib.models import Patchcore
-            >>> from anomalib.data import Visa
-            ...
-            >>> datamodule = Visa()
             >>> model = Patchcore()
-            ...
-            >>> model.to_onnx(
-            ...     export_root="path/to/export",
-            ...     transform=datamodule.test_data.transform,
-            ... )
+            >>> # Train model...
+            >>> model.to_onnx("./exports", input_size=(224, 224))
+            PosixPath('./exports/weights/onnx/model.onnx')
 
-            Using Custom Transforms:
-            This example shows how to use a custom ``Compose`` object for the ``transform`` argument.
+            Export model with dynamic input size:
 
-            >>> model.to_onnx(
-            ...     export_root="path/to/export",
-            ... )
+            >>> model.to_onnx("./exports")
+            PosixPath('./exports/weights/onnx/model.onnx')
         """
         export_root = _create_export_root(export_root, ExportType.ONNX)
         input_shape = torch.zeros((1, 3, *input_size)) if input_size else torch.zeros((1, 3, 1, 1))
@@ -133,7 +149,7 @@ def to_onnx(
         output_names = [name for name, value in self.eval()(input_shape)._asdict().items() if value is not None]
         torch.onnx.export(
             self,
-            input_shape.to(self.device),
+            (input_shape.to(self.device),),
             str(onnx_path),
             opset_version=14,
             dynamic_axes=dynamic_axes,
@@ -153,78 +169,46 @@ def to_openvino(
         ov_args: dict[str, Any] | None = None,
         task: TaskType | None = None,
     ) -> Path:
-        """Convert onnx model to OpenVINO IR.
+        """Export model to OpenVINO IR format.
 
         Args:
-            export_root (Path): Path to the export folder.
-            input_size (tuple[int, int] | None, optional): Input size of the model. Used for adding metadata to the IR.
-                Defaults to None.
-            transform (Transform, optional): Input transforms used for the model. If not provided, the transform is
-                taken from the model.
-                Defaults to ``None``.
-            compression_type (CompressionType, optional): Compression type for better inference performance.
-                Defaults to ``None``.
-            datamodule (AnomalibDataModule | None, optional): Lightning datamodule.
-                Must be provided if ``CompressionType.INT8_PTQ`` or ``CompressionType.INT8_ACQ`` is selected.
-                Defaults to ``None``.
-            metric (Metric | None, optional): Metric to measure quality loss when quantizing.
-                Must be provided if ``CompressionType.INT8_ACQ`` is selected and must return higher value for better
-                performance of the model.
-                Defaults to ``None``.
-            ov_args (dict | None): Model optimizer arguments for OpenVINO model conversion.
-                Defaults to ``None``.
-            task (TaskType | None): Task type.
-                Defaults to ``None``.
+            export_root (Path | str): Path to the output folder
+            input_size (tuple[int, int] | None): Input image dimensions (height, width).
+                If ``None``, uses dynamic input shape. Defaults to ``None``
+            compression_type (CompressionType | None): Type of compression to apply.
+                Options: ``FP16``, ``INT8``, ``INT8_PTQ``, ``INT8_ACQ``.
+                Defaults to ``None``
+            datamodule (AnomalibDataModule | None): DataModule for quantization.
+                Required for ``INT8_PTQ`` and ``INT8_ACQ``. Defaults to ``None``
+            metric (Metric | None): Metric for accuracy-aware quantization.
+                Required for ``INT8_ACQ``. Defaults to ``None``
+            ov_args (dict[str, Any] | None): OpenVINO model optimizer arguments.
+                Defaults to ``None``
+            task (TaskType | None): Task type (classification/segmentation).
+                Defaults to ``None``
 
         Returns:
-            Path: Path to the exported onnx model.
+            Path: Path to the exported OpenVINO model (.xml file)
 
         Raises:
-            ModuleNotFoundError: If OpenVINO is not installed.
-
-        Returns:
-            Path: Path to the exported OpenVINO IR.
+            ModuleNotFoundError: If OpenVINO is not installed
+            ValueError: If required arguments for quantization are missing
 
         Examples:
-            Export the Lightning Model to OpenVINO IR:
-            This example demonstrates how to export the Lightning Model to OpenVINO IR.
+            Export model with FP16 compression:
 
-            >>> from anomalib.models import Patchcore
-            >>> from anomalib.data import Visa
-            ...
-            >>> datamodule = Visa()
-            >>> model = Patchcore()
-            ...
             >>> model.to_openvino(
-            ...     export_root="path/to/export",
-            ...     transform=datamodule.test_data.transform,
-            ...     task=datamodule.test_data.task
+            ...     "./exports",
+            ...     input_size=(224, 224),
+            ...     compression_type=CompressionType.FP16
             ... )
 
-            Export and Quantize the Model (OpenVINO IR):
-            This example demonstrates how to export and quantize the model to OpenVINO IR.
+            Export with INT8 post-training quantization:
 
-            >>> from anomalib.models import Patchcore
-            >>> from anomalib.data import Visa
-            >>> datamodule = Visa()
-            >>> model = Patchcore()
             >>> model.to_openvino(
-            ...     export_root="path/to/export",
+            ...     "./exports",
             ...     compression_type=CompressionType.INT8_PTQ,
-            ...     datamodule=datamodule,
-            ...     task=datamodule.test_data.task
-            ... )
-
-            Using Custom Transforms:
-            This example shows how to use a custom ``Transform`` object for the ``transform`` argument.
-
-            >>> from torchvision.transforms.v2 import Resize
-            >>> transform = Resize(224, 224)
-            ...
-            >>> model.to_openvino(
-            ...     export_root="path/to/export",
-            ...     transform=transform,
-            ...     task="segmentation",
+            ...     datamodule=datamodule
             ... )
         """
         if not module_available("openvino"):
@@ -257,23 +241,25 @@ def _compress_ov_model(
         metric: Metric | None = None,
         task: TaskType | None = None,
     ) -> "CompiledModel":
-        """Compress OpenVINO model with NNCF.
-
-            model (CompiledModel): Model already exported to OpenVINO format.
-            compression_type (CompressionType, optional): Compression type for better inference performance.
-                Defaults to ``None``.
-            datamodule (AnomalibDataModule | None, optional): Lightning datamodule.
-                Must be provided if ``CompressionType.INT8_PTQ`` or ``CompressionType.INT8_ACQ`` is selected.
-                Defaults to ``None``.
-            metric (Metric | str | None, optional): Metric to measure quality loss when quantizing.
-                Must be provided if ``CompressionType.INT8_ACQ`` is selected and must return higher value for better
-                performance of the model.
-                Defaults to ``None``.
-            task (TaskType | None): Task type.
-                Defaults to ``None``.
+        """Compress OpenVINO model using NNCF.
+
+        Args:
+            model (CompiledModel): OpenVINO model to compress
+            compression_type (CompressionType | None): Type of compression to apply.
+                Defaults to ``None``
+            datamodule (AnomalibDataModule | None): DataModule for quantization.
+                Required for ``INT8_PTQ`` and ``INT8_ACQ``. Defaults to ``None``
+            metric (Metric | None): Metric for accuracy-aware quantization.
+                Required for ``INT8_ACQ``. Defaults to ``None``
+            task (TaskType | None): Task type (classification/segmentation).
+                Defaults to ``None``
 
         Returns:
-            model (CompiledModel): Model in the OpenVINO format compressed with NNCF quantization.
+            CompiledModel: Compressed OpenVINO model
+
+        Raises:
+            ModuleNotFoundError: If NNCF is not installed
+            ValueError: If compression type is not recognized
         """
         if not module_available("nncf"):
             logger.exception("Could not find NCCF. Please check NNCF installation.")
@@ -298,15 +284,18 @@ def _post_training_quantization_ov(
         model: "CompiledModel",
         datamodule: AnomalibDataModule | None = None,
     ) -> "CompiledModel":
-        """Post-Training Quantization model with NNCF.
+        """Apply post-training quantization to OpenVINO model.
 
-            model (CompiledModel): Model already exported to OpenVINO format.
-            datamodule (AnomalibDataModule | None, optional): Lightning datamodule.
-                Must be provided if ``CompressionType.INT8_PTQ`` or ``CompressionType.INT8_ACQ`` is selected.
-                Defaults to ``None``.
+        Args:
+            model (CompiledModel): OpenVINO model to quantize
+            datamodule (AnomalibDataModule | None): DataModule for calibration.
+                Must contain at least 300 images. Defaults to ``None``
 
         Returns:
-            model (CompiledModel): Quantized model.
+            CompiledModel: Quantized OpenVINO model
+
+        Raises:
+            ValueError: If datamodule is not provided
         """
         import nncf
 
@@ -336,21 +325,24 @@ def _accuracy_control_quantization_ov(
         metric: Metric | None = None,
         task: TaskType | None = None,
     ) -> "CompiledModel":
-        """Accuracy-Control Quantization with NNCF.
-
-            model (CompiledModel): Model already exported to OpenVINO format.
-            datamodule (AnomalibDataModule | None, optional): Lightning datamodule.
-                Must be provided if ``CompressionType.INT8_PTQ`` or ``CompressionType.INT8_ACQ`` is selected.
-                Defaults to ``None``.
-            metric (Metric | None, optional): Metric to measure quality loss when quantizing.
-                Must be provided if ``CompressionType.INT8_ACQ`` is selected and must return higher value for better
-                performance of the model.
-                Defaults to ``None``.
-            task (TaskType | None): Task type.
-                Defaults to ``None``.
+        """Apply accuracy-aware quantization to OpenVINO model.
+
+        Args:
+            model (CompiledModel): OpenVINO model to quantize
+            datamodule (AnomalibDataModule | None): DataModule for calibration
+                and validation. Must contain at least 300 images.
+                Defaults to ``None``
+            metric (Metric | None): Metric to measure accuracy during quantization.
+                Higher values should indicate better performance.
+                Defaults to ``None``
+            task (TaskType | None): Task type (classification/segmentation).
+                Defaults to ``None``
 
         Returns:
-            model (CompiledModel): Quantized model.
+            CompiledModel: Quantized OpenVINO model
+
+        Raises:
+            ValueError: If datamodule or metric is not provided
         """
         import nncf
 
@@ -393,14 +385,14 @@ def val_fn(nncf_model: "CompiledModel", validation_data: Iterable) -> float:
 
 
 def _create_export_root(export_root: str | Path, export_type: ExportType) -> Path:
-    """Create export directory.
+    """Create directory structure for model export.
 
     Args:
-        export_root (str | Path): Path to the root folder of the exported model.
-        export_type (ExportType): Mode to export the model. Torch, ONNX or OpenVINO.
+        export_root (str | Path): Root directory for exports
+        export_type (ExportType): Type of export (torch/onnx/openvino)
 
     Returns:
-        Path: Path to the export directory.
+        Path: Created directory path
     """
     export_root = Path(export_root) / "weights" / export_type.value
     export_root.mkdir(parents=True, exist_ok=True)
diff --git a/src/anomalib/models/components/base/memory_bank_module.py b/src/anomalib/models/components/base/memory_bank_module.py
index 501e8dc11a..07eae880bc 100644
--- a/src/anomalib/models/components/base/memory_bank_module.py
+++ b/src/anomalib/models/components/base/memory_bank_module.py
@@ -1,4 +1,25 @@
-"""Memory Bank Module."""
+"""Memory Bank Module.
+
+This module provides a mixin class for implementing memory bank-based anomaly
+detection models. Memory banks store reference features or embeddings that are
+used to detect anomalies by comparing test samples against the stored references.
+
+The mixin ensures proper initialization and fitting of the memory bank before
+validation or inference.
+
+Example:
+    Create a custom memory bank model:
+
+    >>> from anomalib.models.components.base import MemoryBankMixin
+    >>> class MyMemoryModel(MemoryBankMixin):
+    ...     def __init__(self):
+    ...         super().__init__()
+    ...         self.memory = []
+    ...
+    ...     def fit(self):
+    ...         # Implement memory bank population logic
+    ...         self.memory = [1, 2, 3]
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,8 +33,16 @@
 class MemoryBankMixin(nn.Module):
     """Memory Bank Lightning Module.
 
-    This module is used to implement memory bank lightning modules.
-    It checks if the model is fitted before validation starts.
+    This mixin class provides functionality for memory bank-based models that need
+    to store and compare against reference features/embeddings. It ensures the
+    memory bank is properly fitted before validation or inference begins.
+
+    The mixin tracks the fitting status via a persistent buffer ``_is_fitted``
+    and automatically triggers the fitting process when needed.
+
+    Attributes:
+        device (torch.device): Device where the model/tensors reside
+        _is_fitted (torch.Tensor): Boolean tensor tracking if model is fitted
     """
 
     def __init__(self, *args, **kwargs) -> None:
@@ -24,21 +53,33 @@ def __init__(self, *args, **kwargs) -> None:
 
     @abstractmethod
     def fit(self) -> None:
-        """Fit the model to the data."""
+        """Fit the memory bank model to the training data.
+
+        This method should be implemented by subclasses to define how the memory
+        bank is populated with reference features/embeddings.
+
+        Raises:
+            NotImplementedError: If the subclass does not implement this method
+        """
         msg = (
-            f"fit method not implemented for {self.__class__.__name__}. "
-            "To use a memory-bank module, implement ``fit.``"
+            f"fit method not implemented for {self.__class__.__name__}. To use a memory-bank module, implement ``fit``."
         )
         raise NotImplementedError(msg)
 
     def on_validation_start(self) -> None:
-        """Ensure that the model is fitted before validation starts."""
+        """Ensure memory bank is fitted before validation.
+
+        This hook automatically fits the memory bank if it hasn't been fitted yet.
+        """
         if not self._is_fitted:
             self.fit()
             self._is_fitted = torch.tensor([True], device=self.device)
 
     def on_train_epoch_end(self) -> None:
-        """Ensure that the model is fitted before validation starts."""
+        """Ensure memory bank is fitted after training.
+
+        This hook automatically fits the memory bank if it hasn't been fitted yet.
+        """
         if not self._is_fitted:
             self.fit()
             self._is_fitted = torch.tensor([True], device=self.device)
diff --git a/src/anomalib/models/components/classification/__init__.py b/src/anomalib/models/components/classification/__init__.py
index 253db6aee6..0f3e735a99 100644
--- a/src/anomalib/models/components/classification/__init__.py
+++ b/src/anomalib/models/components/classification/__init__.py
@@ -1,4 +1,21 @@
-"""Classification modules."""
+"""Classification modules for anomaly detection.
+
+This module provides classification components used in anomaly detection models.
+
+Classes:
+    KDEClassifier: Kernel Density Estimation based classifier for anomaly
+        detection.
+    FeatureScalingMethod: Enum class defining feature scaling methods for
+        KDE classifier.
+
+Example:
+    >>> from anomalib.models.components.classification import KDEClassifier
+    >>> from anomalib.models.components.classification import FeatureScalingMethod
+    >>> # Create KDE classifier with min-max scaling
+    >>> classifier = KDEClassifier(
+    ...     scaling_method=FeatureScalingMethod.MIN_MAX
+    ... )
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/components/classification/kde_classifier.py b/src/anomalib/models/components/classification/kde_classifier.py
index d50e5cca31..0c068c74cb 100644
--- a/src/anomalib/models/components/classification/kde_classifier.py
+++ b/src/anomalib/models/components/classification/kde_classifier.py
@@ -1,4 +1,27 @@
-"""Kernel Density Estimation Classifier."""
+"""Kernel Density Estimation Classifier.
+
+This module provides a classifier based on kernel density estimation (KDE) for
+anomaly detection. The classifier fits a KDE model to feature embeddings and uses
+it to compute anomaly probabilities.
+
+Example:
+    >>> from anomalib.models.components.classification import KDEClassifier
+    >>> from anomalib.models.components.classification import FeatureScalingMethod
+    >>> # Create classifier with default settings
+    >>> classifier = KDEClassifier()
+    >>> # Create classifier with custom settings
+    >>> classifier = KDEClassifier(
+    ...     n_pca_components=32,
+    ...     feature_scaling_method=FeatureScalingMethod.NORM,
+    ...     max_training_points=50000
+    ... )
+    >>> # Fit classifier on embeddings
+    >>> embeddings = torch.randn(1000, 512)  # Example embeddings
+    >>> classifier.fit(embeddings)
+    >>> # Get anomaly probabilities for new samples
+    >>> new_embeddings = torch.randn(10, 512)
+    >>> probabilities = classifier.predict(new_embeddings)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,21 +39,43 @@
 
 
 class FeatureScalingMethod(str, Enum):
-    """Determines how the feature embeddings are scaled."""
+    """Feature scaling methods for KDE classifier.
+
+    The scaling method determines how feature embeddings are normalized before
+    being passed to the KDE model.
+
+    Attributes:
+        NORM: Scale features to unit vector length (L2 normalization)
+        SCALE: Scale features by maximum length observed during training
+            (preserves relative magnitudes)
+    """
 
     NORM = "norm"  # scale to unit vector length
-    SCALE = "scale"  # scale to max length observed in training (preserve relative magnitude)
+    SCALE = "scale"  # scale to max length observed in training
 
 
 class KDEClassifier(nn.Module):
     """Classification module for KDE-based anomaly detection.
 
+    This classifier uses kernel density estimation to model the distribution of
+    normal samples in feature space. It first applies dimensionality reduction
+    via PCA, then fits a Gaussian KDE model to the reduced features.
+
     Args:
-        n_pca_components (int, optional): Number of PCA components. Defaults to 16.
-        feature_scaling_method (FeatureScalingMethod, optional): Scaling method applied to features before passing to
-            KDE. Options are `norm` (normalize to unit vector length) and `scale` (scale to max length observed in
-            training).
-        max_training_points (int, optional): Maximum number of training points to fit the KDE model. Defaults to 40000.
+        n_pca_components: Number of PCA components to retain. Lower values reduce
+            computational cost but may lose information.
+            Defaults to 16.
+        feature_scaling_method: Method used to scale features before KDE.
+            Options are ``norm`` (unit vector) or ``scale`` (max length).
+            Defaults to ``FeatureScalingMethod.SCALE``.
+        max_training_points: Maximum number of points used to fit the KDE model.
+            If more points are provided, a random subset is selected.
+            Defaults to 40000.
+
+    Attributes:
+        pca_model: PCA model for dimensionality reduction
+        kde_model: Gaussian KDE model for density estimation
+        max_length: Maximum feature length observed during training
     """
 
     def __init__(
@@ -56,15 +101,20 @@ def pre_process(
         feature_stack: torch.Tensor,
         max_length: torch.Tensor | None = None,
     ) -> tuple[torch.Tensor, torch.Tensor]:
-        """Pre-process the CNN features.
+        """Pre-process feature embeddings before KDE.
+
+        Scales the features according to the specified scaling method.
 
         Args:
-          feature_stack (torch.Tensor): Features extracted from CNN
-          max_length (Tensor | None): Used to unit normalize the feature_stack vector. If ``max_len`` is not
-            provided, the length is calculated from the ``feature_stack``. Defaults to None.
+            feature_stack: Features extracted from the model, shape (N, D)
+            max_length: Maximum feature length for scaling. If ``None``, computed
+                from ``feature_stack``. Defaults to None.
 
         Returns:
-            (Tuple): Stacked features and length
+            tuple: (scaled_features, max_length)
+
+        Raises:
+            RuntimeError: If unknown scaling method is specified
         """
         if max_length is None:
             max_length = torch.max(torch.linalg.norm(feature_stack, ord=2, dim=1))
@@ -79,13 +129,21 @@ def pre_process(
         return feature_stack, max_length
 
     def fit(self, embeddings: torch.Tensor) -> bool:
-        """Fit a kde model to embeddings.
+        """Fit the KDE classifier to training embeddings.
+
+        Applies PCA, scales the features, and fits the KDE model.
 
         Args:
-            embeddings (torch.Tensor): Input embeddings to fit the model.
+            embeddings: Training embeddings of shape (N, D)
 
         Returns:
-            Boolean confirming whether the training is successful.
+            bool: True if fitting succeeded, False if insufficient samples
+
+        Example:
+            >>> classifier = KDEClassifier()
+            >>> embeddings = torch.randn(1000, 512)
+            >>> success = classifier.fit(embeddings)
+            >>> assert success
         """
         if embeddings.shape[0] < self.n_pca_components:
             logger.info("Not enough features to commit. Not making a model.")
@@ -109,17 +167,17 @@ def fit(self, embeddings: torch.Tensor) -> bool:
         return True
 
     def compute_kde_scores(self, features: torch.Tensor, as_log_likelihood: bool | None = False) -> torch.Tensor:
-        """Compute the KDE scores.
+        """Compute KDE scores for input features.
 
-        The scores calculated from the KDE model are converted to densities. If `as_log_likelihood` is set to true then
-            the log of the scores are calculated.
+        Transforms features via PCA and scaling, then computes KDE scores.
 
         Args:
-            features (torch.Tensor): Features to which the PCA model is fit.
-            as_log_likelihood (bool | None, optional): If true, gets log likelihood scores. Defaults to False.
+            features: Input features of shape (N, D)
+            as_log_likelihood: If True, returns log of KDE scores.
+                Defaults to False.
 
         Returns:
-            (torch.Tensor): Score
+            torch.Tensor: KDE scores of shape (N,)
         """
         features = self.pca_model.transform(features)
         features, _ = self.pre_process(features, self.max_length)
@@ -136,28 +194,50 @@ def compute_kde_scores(self, features: torch.Tensor, as_log_likelihood: bool | N
 
     @staticmethod
     def compute_probabilities(scores: torch.Tensor) -> torch.Tensor:
-        """Convert density scores to anomaly probabilities (see https://www.desmos.com/calculator/ifju7eesg7).
+        """Convert density scores to anomaly probabilities.
+
+        Uses sigmoid function to map scores to [0,1] range.
+        See https://www.desmos.com/calculator/ifju7eesg7
 
         Args:
-          scores (torch.Tensor): density of an image.
+            scores: Density scores of shape (N,)
 
         Returns:
-          probability that image with {density} is anomalous
+            torch.Tensor: Anomaly probabilities of shape (N,)
         """
         return 1 / (1 + torch.exp(0.05 * (scores - 12)))
 
     def predict(self, features: torch.Tensor) -> torch.Tensor:
-        """Predicts the probability that the features belong to the anomalous class.
+        """Predict anomaly probabilities for input features.
+
+        Computes KDE scores and converts them to probabilities.
 
         Args:
-          features (torch.Tensor): Feature from which the output probabilities are detected.
+            features: Input features of shape (N, D)
 
         Returns:
-          Detection probabilities
+            torch.Tensor: Anomaly probabilities of shape (N,)
+
+        Example:
+            >>> classifier = KDEClassifier()
+            >>> features = torch.randn(10, 512)
+            >>> classifier.fit(features)
+            >>> probs = classifier.predict(features)
+            >>> assert probs.shape == (10,)
+            >>> assert (probs >= 0).all() and (probs <= 1).all()
         """
         scores = self.compute_kde_scores(features, as_log_likelihood=True)
         return self.compute_probabilities(scores)
 
     def forward(self, features: torch.Tensor) -> torch.Tensor:
-        """Make predictions on extracted features."""
+        """Forward pass of the classifier.
+
+        Equivalent to calling ``predict()``.
+
+        Args:
+            features: Input features of shape (N, D)
+
+        Returns:
+            torch.Tensor: Anomaly probabilities of shape (N,)
+        """
         return self.predict(features)
diff --git a/src/anomalib/models/components/cluster/__init__.py b/src/anomalib/models/components/cluster/__init__.py
index e3ce0455af..74f7601204 100644
--- a/src/anomalib/models/components/cluster/__init__.py
+++ b/src/anomalib/models/components/cluster/__init__.py
@@ -1,4 +1,22 @@
-"""Clustering algorithm implementations using PyTorch."""
+"""Clustering algorithm implementations using PyTorch.
+
+This module provides clustering algorithms implemented in PyTorch for anomaly
+detection tasks.
+
+Classes:
+    GaussianMixture: Gaussian Mixture Model for density estimation and clustering.
+    KMeans: K-Means clustering algorithm.
+
+Example:
+    >>> from anomalib.models.components.cluster import GaussianMixture, KMeans
+    >>> # Create and fit a GMM
+    >>> gmm = GaussianMixture(n_components=3)
+    >>> features = torch.randn(100, 10)  # Example features
+    >>> gmm.fit(features)
+    >>> # Create and fit KMeans
+    >>> kmeans = KMeans(n_clusters=5)
+    >>> kmeans.fit(features)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/components/cluster/gmm.py b/src/anomalib/models/components/cluster/gmm.py
index b7f94693b2..cfbb653991 100644
--- a/src/anomalib/models/components/cluster/gmm.py
+++ b/src/anomalib/models/components/cluster/gmm.py
@@ -1,4 +1,8 @@
-"""Pytorch implementation of Gaussian Mixture Model."""
+"""PyTorch implementation of Gaussian Mixture Model.
+
+This module provides a PyTorch-based implementation of Gaussian Mixture Model (GMM)
+for clustering data into multiple Gaussian distributions.
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,38 +20,43 @@
 
 
 class GaussianMixture(DynamicBufferMixin):
-    """Gaussian Mixture Model.
+    """Gaussian Mixture Model for clustering data into Gaussian distributions.
 
     Args:
-        n_components (int): Number of components.
-        n_iter (int): Maximum number of iterations to perform.
-            Defaults to ``100``.
-        tol (float): Convergence threshold.
-            Defaults to ``1e-3``.
+        n_components (int): Number of Gaussian components to fit.
+        n_iter (int, optional): Maximum number of EM iterations. Defaults to 100.
+        tol (float, optional): Convergence threshold for log-likelihood.
+            Defaults to 1e-3.
+
+    Attributes:
+        means (torch.Tensor): Means of the Gaussian components.
+            Shape: ``(n_components, n_features)``.
+        covariances (torch.Tensor): Covariance matrices of components.
+            Shape: ``(n_components, n_features, n_features)``.
+        weights (torch.Tensor): Mixing weights of components.
+            Shape: ``(n_components,)``.
 
     Example:
-        The following examples shows how to fit a Gaussian Mixture Model to some data and get the cluster means and
-        predicted labels and log-likelihood scores of the data.
-
-        .. code-block:: python
-
-            >>> import torch
-            >>> from anomalib.models.components.cluster import GaussianMixture
-            >>> model = GaussianMixture(n_components=2)
-            >>> data = torch.tensor(
-            ...     [
-            ...             [2, 1], [2, 2], [2, 3],
-            ...             [7, 5], [8, 5], [9, 5],
-            ...     ]
-            ... ).float()
-            >>> model.fit(data)
-            >>> model.means  # get the means of the gaussians
-            tensor([[8., 5.],
-                    [2., 2.]])
-            >>> model.predict(data)  # get the predicted cluster label of each sample
-            tensor([1, 1, 1, 0, 0, 0])
-            >>> model.score_samples(data)  # get the log-likelihood score of each sample
-            tensor([3.8295, 4.5795, 3.8295, 3.8295, 4.5795, 3.8295])
+        >>> import torch
+        >>> from anomalib.models.components.cluster import GaussianMixture
+        >>> # Create synthetic data with two clusters
+        >>> data = torch.tensor([
+        ...     [2, 1], [2, 2], [2, 3],  # Cluster 1
+        ...     [7, 5], [8, 5], [9, 5],  # Cluster 2
+        ... ]).float()
+        >>> # Initialize and fit GMM
+        >>> model = GaussianMixture(n_components=2)
+        >>> model.fit(data)
+        >>> # Get cluster means
+        >>> model.means
+        tensor([[8., 5.],
+                [2., 2.]])
+        >>> # Predict cluster assignments
+        >>> model.predict(data)
+        tensor([1, 1, 1, 0, 0, 0])
+        >>> # Get log-likelihood scores
+        >>> model.score_samples(data)
+        tensor([3.8295, 4.5795, 3.8295, 3.8295, 4.5795, 3.8295])
     """
 
     def __init__(self, n_components: int, n_iter: int = 100, tol: float = 1e-3) -> None:
@@ -65,10 +74,11 @@ def __init__(self, n_components: int, n_iter: int = 100, tol: float = 1e-3) -> N
         self.weights: torch.Tensor
 
     def fit(self, data: torch.Tensor) -> None:
-        """Fit the model to the data.
+        """Fit the GMM to the input data using EM algorithm.
 
         Args:
-            data (Tensor): Data to fit the model to. Tensor of shape (n_samples, n_features).
+            data (torch.Tensor): Input data to fit the model to.
+                Shape: ``(n_samples, n_features)``.
         """
         self._initialize_parameters_kmeans(data)
 
@@ -88,41 +98,50 @@ def fit(self, data: torch.Tensor) -> None:
 
         if not converged:
             logger.warning(
-                f"GMM did not converge after {self.n_iter} iterations.  \
-                        Consider increasing the number of iterations.",
+                f"GMM did not converge after {self.n_iter} iterations. Consider increasing the number of iterations.",
             )
 
     def _initialize_parameters_kmeans(self, data: torch.Tensor) -> None:
-        """Initialize parameters with K-means.
+        """Initialize GMM parameters using K-means clustering.
 
         Args:
-            data (Tensor): Data to fit the model to. Tensor of shape (n_samples, n_features).
+            data (torch.Tensor): Input data for initialization.
+                Shape: ``(n_samples, n_features)``.
         """
         labels, _ = KMeans(n_clusters=self.n_components).fit(data)
         resp = one_hot(labels, num_classes=self.n_components).float()
         self._m_step(data, resp)
 
     def _e_step(self, data: torch.Tensor) -> torch.Tensor:
-        """Perform the E-step to estimate the responsibilities of the gaussians.
+        """Perform E-step to compute responsibilities and log-likelihood.
 
         Args:
-            data (Tensor): Data to fit the model to. Tensor of shape (n_samples, n_features).
+            data (torch.Tensor): Input data.
+                Shape: ``(n_samples, n_features)``.
 
         Returns:
-            Tensor: log probability of the data given the gaussians.
-            Tensor: Tensor of shape (n_samples, n_components) containing the responsibilities.
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing:
+                - Mean log-likelihood of the data
+                - Responsibilities for each component.
+                  Shape: ``(n_samples, n_components)``
         """
         weighted_log_prob = self._estimate_weighted_log_prob(data)
         log_prob_norm = torch.logsumexp(weighted_log_prob, axis=1)
-        log_resp = weighted_log_prob - torch.logsumexp(weighted_log_prob, dim=1, keepdim=True)
+        log_resp = weighted_log_prob - torch.logsumexp(
+            weighted_log_prob,
+            dim=1,
+            keepdim=True,
+        )
         return torch.mean(log_prob_norm), torch.exp(log_resp)
 
     def _m_step(self, data: torch.Tensor, resp: torch.Tensor) -> None:
-        """Perform the M-step to update the parameters of the gaussians.
+        """Perform M-step to update GMM parameters.
 
         Args:
-            data (Tensor): Data to fit the model to. Tensor of shape (n_samples, n_features).
-            resp (Tensor): Tensor of shape (n_samples, n_components) containing the responsibilities.
+            data (torch.Tensor): Input data.
+                Shape: ``(n_samples, n_features)``.
+            resp (torch.Tensor): Responsibilities from E-step.
+                Shape: ``(n_samples, n_components)``.
         """
         cluster_counts = resp.sum(axis=0)  # number of points in each cluster
         self.weights = resp.mean(axis=0)  # new weights
@@ -130,22 +149,37 @@ def _m_step(self, data: torch.Tensor, resp: torch.Tensor) -> None:
 
         diff = data.unsqueeze(0) - self.means.unsqueeze(1)
         weighted_diff = diff * resp.T.unsqueeze(-1)
-        covariances = torch.bmm(weighted_diff.transpose(-2, -1), diff) / cluster_counts.view(-1, 1, 1)
+        covariances = torch.bmm(
+            weighted_diff.transpose(-2, -1),
+            diff,
+        ) / cluster_counts.view(-1, 1, 1)
         # Add a small constant for numerical stability
-        self.covariances = covariances + torch.eye(data.shape[1], device=data.device) * 1e-6  # new covariances
+        self.covariances = (
+            covariances
+            + torch.eye(
+                data.shape[1],
+                device=data.device,
+            )
+            * 1e-6
+        )
 
     def _estimate_weighted_log_prob(self, data: torch.Tensor) -> torch.Tensor:
-        """Estimate the log probability of the data given the gaussian parameters.
+        """Estimate weighted log probabilities for each component.
 
         Args:
-            data (Tensor): Data to fit the model to. Tensor of shape (n_samples, n_features).
+            data (torch.Tensor): Input data.
+                Shape: ``(n_samples, n_features)``.
 
         Returns:
-            Tensor: Tensor of shape (n_samples, n_components) containing the log-probabilities of each sample.
+            torch.Tensor: Weighted log probabilities.
+                Shape: ``(n_samples, n_components)``.
         """
         log_prob = torch.stack(
             [
-                MultivariateNormal(self.means[comp], self.covariances[comp]).log_prob(data)
+                MultivariateNormal(
+                    self.means[comp],
+                    self.covariances[comp],
+                ).log_prob(data)
                 for comp in range(self.n_components)
             ],
             dim=1,
@@ -153,24 +187,28 @@ def _estimate_weighted_log_prob(self, data: torch.Tensor) -> torch.Tensor:
         return log_prob + torch.log(self.weights)
 
     def score_samples(self, data: torch.Tensor) -> torch.Tensor:
-        """Assign a likelihood score to each sample in the data.
+        """Compute per-sample likelihood scores.
 
         Args:
-            data (Tensor): Samples to assign scores to. Tensor of shape (n_samples, n_features).
+            data (torch.Tensor): Input samples to score.
+                Shape: ``(n_samples, n_features)``.
 
         Returns:
-            Tensor: Tensor of shape (n_samples,) containing the log-likelihood score of each sample.
+            torch.Tensor: Log-likelihood scores.
+                Shape: ``(n_samples,)``.
         """
         return torch.logsumexp(self._estimate_weighted_log_prob(data), dim=1)
 
     def predict(self, data: torch.Tensor) -> torch.Tensor:
-        """Predict the cluster labels of the data.
+        """Predict cluster assignments for the input data.
 
         Args:
-            data (Tensor): Samples to assign to clusters. Tensor of shape (n_samples, n_features).
+            data (torch.Tensor): Input samples.
+                Shape: ``(n_samples, n_features)``.
 
         Returns:
-            Tensor: Tensor of shape (n_samples,) containing the predicted cluster label of each sample.
+            torch.Tensor: Predicted cluster labels.
+                Shape: ``(n_samples,)``.
         """
         _, resp = self._e_step(data)
         return torch.argmax(resp, axis=1)
diff --git a/src/anomalib/models/components/cluster/kmeans.py b/src/anomalib/models/components/cluster/kmeans.py
index 908a3e3fae..b8f5f05c90 100644
--- a/src/anomalib/models/components/cluster/kmeans.py
+++ b/src/anomalib/models/components/cluster/kmeans.py
@@ -1,4 +1,23 @@
-"""KMeans clustering algorithm implementation using PyTorch."""
+"""PyTorch implementation of K-means clustering algorithm.
+
+This module provides a PyTorch-based implementation of the K-means clustering
+algorithm for partitioning data into ``k`` distinct clusters.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.cluster import KMeans
+    >>> # Create synthetic data
+    >>> data = torch.tensor([
+    ...     [1.0, 2.0], [1.5, 1.8], [1.2, 2.2],  # Cluster 1
+    ...     [4.0, 4.0], [4.2, 4.1], [3.8, 4.2],  # Cluster 2
+    ... ])
+    >>> # Initialize and fit KMeans
+    >>> kmeans = KMeans(n_clusters=2)
+    >>> labels, centers = kmeans.fit(data)
+    >>> # Predict cluster for new points
+    >>> new_points = torch.tensor([[1.1, 2.1], [4.0, 4.1]])
+    >>> predictions = kmeans.predict(new_points)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -7,11 +26,27 @@
 
 
 class KMeans:
-    """Initialize the KMeans object.
+    """K-means clustering algorithm implementation.
 
     Args:
-        n_clusters (int): The number of clusters to create.
-        max_iter (int, optional)): The maximum number of iterations to run the algorithm. Defaults to 10.
+        n_clusters (int): Number of clusters to partition the data into.
+        max_iter (int, optional): Maximum number of iterations for the clustering
+            algorithm. Defaults to 10.
+
+    Attributes:
+        cluster_centers_ (torch.Tensor): Coordinates of cluster centers after
+            fitting. Shape: ``(n_clusters, n_features)``.
+        labels_ (torch.Tensor): Cluster labels for the training data after
+            fitting. Shape: ``(n_samples,)``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.components.cluster import KMeans
+        >>> kmeans = KMeans(n_clusters=3)
+        >>> data = torch.randn(100, 5)  # 100 samples, 5 features
+        >>> labels, centers = kmeans.fit(data)
+        >>> print(f"Cluster assignments shape: {labels.shape}")
+        >>> print(f"Cluster centers shape: {centers.shape}")
     """
 
     def __init__(self, n_clusters: int, max_iter: int = 10) -> None:
@@ -22,15 +57,26 @@ def fit(self, inputs: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
         """Fit the K-means algorithm to the input data.
 
         Args:
-            inputs (torch.Tensor): Input data of shape (batch_size, n_features).
+            inputs (torch.Tensor): Input data to cluster.
+                Shape: ``(n_samples, n_features)``.
 
         Returns:
-            tuple: A tuple containing the labels of the input data with respect to the identified clusters
-            and the cluster centers themselves. The labels have a shape of (batch_size,) and the
-            cluster centers have a shape of (n_clusters, n_features).
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing:
+                - labels: Cluster assignments for each input point.
+                  Shape: ``(n_samples,)``
+                - cluster_centers: Coordinates of the cluster centers.
+                  Shape: ``(n_clusters, n_features)``
 
         Raises:
-            ValueError: If the number of clusters is less than or equal to 0.
+            ValueError: If ``n_clusters`` is less than or equal to 0.
+
+        Example:
+            >>> kmeans = KMeans(n_clusters=2)
+            >>> data = torch.tensor([[1.0, 2.0], [4.0, 5.0], [1.2, 2.1]])
+            >>> labels, centers = kmeans.fit(data)
+            >>> print(f"Number of points in each cluster: {
+            ...     [(labels == i).sum().item() for i in range(2)]
+            ... }")
         """
         batch_size, _ = inputs.shape
 
@@ -46,25 +92,36 @@ def fit(self, inputs: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
             # Assign each data point to the closest centroid
             self.labels_ = torch.argmin(distances, dim=1)
 
-            # Update the centroids to be the mean of the data points assigned to them
+            # Update the centroids to be the mean of the data points assigned
             for j in range(self.n_clusters):
                 mask = self.labels_ == j
                 if mask.any():
                     self.cluster_centers_[j] = inputs[mask].mean(dim=0)
-        # this line returns labels and centoids of the results
+
         return self.labels_, self.cluster_centers_
 
     def predict(self, inputs: torch.Tensor) -> torch.Tensor:
-        """Predict the labels of input data based on the fitted model.
+        """Predict cluster labels for input data.
 
         Args:
-            inputs (torch.Tensor): Input data of shape (batch_size, n_features).
+            inputs (torch.Tensor): Input data to assign to clusters.
+                Shape: ``(n_samples, n_features)``.
 
         Returns:
-            torch.Tensor: The predicted labels of the input data with respect to the identified clusters.
+            torch.Tensor: Predicted cluster labels.
+                Shape: ``(n_samples,)``.
 
         Raises:
-            AttributeError: If the KMeans object has not been fitted to input data.
+            AttributeError: If called before fitting the model.
+
+        Example:
+            >>> kmeans = KMeans(n_clusters=2)
+            >>> # First fit the model
+            >>> train_data = torch.tensor([[1.0, 2.0], [4.0, 5.0]])
+            >>> kmeans.fit(train_data)
+            >>> # Then predict on new data
+            >>> new_data = torch.tensor([[1.1, 2.1], [3.9, 4.8]])
+            >>> predictions = kmeans.predict(new_data)
         """
         distances = torch.cdist(inputs, self.cluster_centers_)
         return torch.argmin(distances, dim=1)
diff --git a/src/anomalib/models/components/dimensionality_reduction/__init__.py b/src/anomalib/models/components/dimensionality_reduction/__init__.py
index d69c691bf0..62260edda8 100644
--- a/src/anomalib/models/components/dimensionality_reduction/__init__.py
+++ b/src/anomalib/models/components/dimensionality_reduction/__init__.py
@@ -1,6 +1,27 @@
-"""Algorithms for decomposition and dimensionality reduction."""
+"""Dimensionality reduction and decomposition algorithms for feature processing.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides implementations of dimensionality reduction techniques used
+in anomaly detection models.
+
+Classes:
+    PCA: Principal Component Analysis for linear dimensionality reduction.
+    SparseRandomProjection: Random projection using sparse random matrices.
+
+Example:
+    >>> from anomalib.models.components.dimensionality_reduction import PCA
+    >>> # Create and fit PCA
+    >>> pca = PCA(n_components=10)
+    >>> features = torch.randn(100, 50)  # 100 samples, 50 features
+    >>> reduced_features = pca.fit_transform(features)
+    >>> # Use SparseRandomProjection
+    >>> from anomalib.models.components.dimensionality_reduction import (
+    ...     SparseRandomProjection
+    ... )
+    >>> projector = SparseRandomProjection(n_components=20)
+    >>> projected_features = projector.fit_transform(features)
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .pca import PCA
diff --git a/src/anomalib/models/components/dimensionality_reduction/pca.py b/src/anomalib/models/components/dimensionality_reduction/pca.py
index 3e9bd4bb65..55fa679243 100644
--- a/src/anomalib/models/components/dimensionality_reduction/pca.py
+++ b/src/anomalib/models/components/dimensionality_reduction/pca.py
@@ -1,4 +1,20 @@
-"""Principle Component Analysis (PCA) with PyTorch."""
+"""Principal Component Analysis (PCA) implementation using PyTorch.
+
+This module provides a PyTorch-based implementation of Principal Component Analysis
+for dimensionality reduction.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components import PCA
+    >>> # Create sample data
+    >>> data = torch.randn(100, 10)  # 100 samples, 10 features
+    >>> # Initialize PCA with 3 components
+    >>> pca = PCA(n_components=3)
+    >>> # Fit and transform the data
+    >>> transformed_data = pca.fit_transform(data)
+    >>> print(transformed_data.shape)
+    torch.Size([100, 3])
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -9,31 +25,34 @@
 
 
 class PCA(DynamicBufferMixin):
-    """Principle Component Analysis (PCA).
+    """Principal Component Analysis (PCA) for dimensionality reduction.
 
     Args:
-        n_components (float): Number of components. Can be either integer number of components
-          or a ratio between 0-1.
+        n_components (int | float): Number of components to keep. If float between
+            0 and 1, represents the variance ratio to preserve. If int, represents
+            the exact number of components to keep.
+
+    Attributes:
+        singular_vectors (torch.Tensor): Right singular vectors from SVD.
+        singular_values (torch.Tensor): Singular values from SVD.
+        mean (torch.Tensor): Mean of the training data.
+        num_components (torch.Tensor): Number of components kept.
 
     Example:
         >>> import torch
         >>> from anomalib.models.components import PCA
-
-        Create a PCA model with 2 components:
-
-        >>> pca = PCA(n_components=2)
-
-        Create a random embedding and fit a PCA model.
-
-        >>> embedding = torch.rand(1000, 5).cuda()
-        >>> pca = PCA(n_components=2)
-        >>> pca.fit(embedding)
-
-        Apply transformation:
-
-        >>> transformed = pca.transform(embedding)
-        >>> transformed.shape
-        torch.Size([1000, 2])
+        >>> # Create sample data
+        >>> data = torch.randn(100, 10)  # 100 samples, 10 features
+        >>> # Initialize with fixed number of components
+        >>> pca = PCA(n_components=3)
+        >>> pca.fit(data)
+        >>> # Transform new data
+        >>> transformed = pca.transform(data)
+        >>> print(transformed.shape)
+        torch.Size([100, 3])
+        >>> # Initialize with variance ratio
+        >>> pca = PCA(n_components=0.95)  # Keep 95% of variance
+        >>> pca.fit(data)
     """
 
     def __init__(self, n_components: int | float) -> None:
@@ -50,18 +69,21 @@ def __init__(self, n_components: int | float) -> None:
         self.num_components: torch.Tensor
 
     def fit(self, dataset: torch.Tensor) -> None:
-        """Fits the PCA model to the dataset.
+        """Fit the PCA model to the dataset.
 
         Args:
-          dataset (torch.Tensor): Input dataset to fit the model.
+            dataset (torch.Tensor): Input dataset of shape ``(n_samples,
+                n_features)``.
 
         Example:
-            >>> pca.fit(embedding)
-            >>> pca.singular_vectors
-            tensor([9.6053, 9.2763], device='cuda:0')
-
-            >>> pca.mean
-            tensor([0.4859, 0.4959, 0.4906, 0.5010, 0.5042], device='cuda:0')
+            >>> data = torch.randn(100, 10)
+            >>> pca = PCA(n_components=3)
+            >>> pca.fit(data)
+            >>> # Access fitted attributes
+            >>> print(pca.singular_vectors.shape)
+            torch.Size([10, 3])
+            >>> print(pca.mean.shape)
+            torch.Size([10])
         """
         mean = dataset.mean(dim=0)
         dataset -= mean
@@ -81,19 +103,22 @@ def fit(self, dataset: torch.Tensor) -> None:
         self.mean = mean
 
     def fit_transform(self, dataset: torch.Tensor) -> torch.Tensor:
-        """Fit and transform PCA to dataset.
+        """Fit the model and transform the input dataset.
 
         Args:
-            dataset (torch.Tensor): Dataset to which the PCA if fit and transformed
+            dataset (torch.Tensor): Input dataset of shape ``(n_samples,
+                n_features)``.
 
         Returns:
-            Transformed dataset
+            torch.Tensor: Transformed dataset of shape ``(n_samples,
+                n_components)``.
 
         Example:
-            >>> pca.fit_transform(embedding)
-            >>> transformed_embedding = pca.fit_transform(embedding)
-            >>> transformed_embedding.shape
-            torch.Size([1000, 2])
+            >>> data = torch.randn(100, 10)
+            >>> pca = PCA(n_components=3)
+            >>> transformed = pca.fit_transform(data)
+            >>> print(transformed.shape)
+            torch.Size([100, 3])
         """
         mean = dataset.mean(dim=0)
         dataset -= mean
@@ -107,54 +132,66 @@ def fit_transform(self, dataset: torch.Tensor) -> torch.Tensor:
         return torch.matmul(dataset, self.singular_vectors)
 
     def transform(self, features: torch.Tensor) -> torch.Tensor:
-        """Transform the features based on singular vectors calculated earlier.
+        """Transform features using the fitted PCA model.
 
         Args:
-            features (torch.Tensor): Input features
+            features (torch.Tensor): Input features of shape ``(n_samples,
+                n_features)``.
 
         Returns:
-            Transformed features
+            torch.Tensor: Transformed features of shape ``(n_samples,
+                n_components)``.
 
         Example:
-            >>> pca.transform(embedding)
-            >>> transformed_embedding = pca.transform(embedding)
-
-            >>> embedding.shape
-            torch.Size([1000, 5])
-            #
-            >>> transformed_embedding.shape
-            torch.Size([1000, 2])
+            >>> data = torch.randn(100, 10)
+            >>> pca = PCA(n_components=3)
+            >>> pca.fit(data)
+            >>> new_data = torch.randn(50, 10)
+            >>> transformed = pca.transform(new_data)
+            >>> print(transformed.shape)
+            torch.Size([50, 3])
         """
         features -= self.mean
         return torch.matmul(features, self.singular_vectors)
 
     def inverse_transform(self, features: torch.Tensor) -> torch.Tensor:
-        """Inverses the transformed features.
+        """Inverse transform features back to original space.
 
         Args:
-            features (torch.Tensor): Transformed features
+            features (torch.Tensor): Transformed features of shape ``(n_samples,
+                n_components)``.
 
         Returns:
-            Inverse features
+            torch.Tensor: Reconstructed features of shape ``(n_samples,
+                n_features)``.
 
         Example:
-            >>> inverse_embedding = pca.inverse_transform(transformed_embedding)
-            >>> inverse_embedding.shape
-            torch.Size([1000, 5])
+            >>> data = torch.randn(100, 10)
+            >>> pca = PCA(n_components=3)
+            >>> transformed = pca.fit_transform(data)
+            >>> reconstructed = pca.inverse_transform(transformed)
+            >>> print(reconstructed.shape)
+            torch.Size([100, 10])
         """
         return torch.matmul(features, self.singular_vectors.transpose(-2, -1))
 
     def forward(self, features: torch.Tensor) -> torch.Tensor:
-        """Transform the features.
+        """Transform features (alias for transform method).
 
         Args:
-            features (torch.Tensor): Input features
+            features (torch.Tensor): Input features of shape ``(n_samples,
+                n_features)``.
 
         Returns:
-            Transformed features
+            torch.Tensor: Transformed features of shape ``(n_samples,
+                n_components)``.
 
         Example:
-            >>> pca(embedding).shape
-            torch.Size([1000, 2])
+            >>> data = torch.randn(100, 10)
+            >>> pca = PCA(n_components=3)
+            >>> pca.fit(data)
+            >>> transformed = pca(data)  # Using forward
+            >>> print(transformed.shape)
+            torch.Size([100, 3])
         """
         return self.transform(features)
diff --git a/src/anomalib/models/components/dimensionality_reduction/random_projection.py b/src/anomalib/models/components/dimensionality_reduction/random_projection.py
index cfa6ecad30..083103273a 100644
--- a/src/anomalib/models/components/dimensionality_reduction/random_projection.py
+++ b/src/anomalib/models/components/dimensionality_reduction/random_projection.py
@@ -1,6 +1,18 @@
 """Random Sparse Projector.
 
-Sparse Random Projection using PyTorch Operations
+This module provides a PyTorch implementation of Sparse Random Projection for
+dimensionality reduction.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components import SparseRandomProjection
+    >>> # Create sample data
+    >>> data = torch.randn(100, 50)  # 100 samples, 50 features
+    >>> # Initialize projector
+    >>> projector = SparseRandomProjection(eps=0.1)
+    >>> # Fit and transform the data
+    >>> projected_data = projector.fit_transform(data)
+    >>> print(projected_data.shape)
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -12,40 +24,43 @@
 
 
 class NotFittedError(ValueError, AttributeError):
-    """Raise Exception if estimator is used before fitting."""
+    """Exception raised when model is used before fitting."""
 
 
 class SparseRandomProjection:
     """Sparse Random Projection using PyTorch operations.
 
+    This class implements sparse random projection for dimensionality reduction
+    using PyTorch. The implementation is based on the paper by Li et al. [1]_.
+
     Args:
         eps (float, optional): Minimum distortion rate parameter for calculating
-            Johnson-Lindenstrauss minimum dimensions.
-            Defaults to ``0.1``.
-        random_state (int | None, optional): Uses the seed to set the random
-            state for sample_without_replacement function.
-            Defaults to ``None``.
-
-    Example:
-        To fit and transform the embedding tensor, use the following code:
-
-        .. code-block:: python
-
-            import torch
-            from anomalib.models.components import SparseRandomProjection
-
-            sparse_embedding = torch.rand(1000, 5).cuda()
-            model = SparseRandomProjection(eps=0.1)
-
-        Fit the model and transform the embedding tensor:
-
-        .. code-block:: python
+            Johnson-Lindenstrauss minimum dimensions. Defaults to ``0.1``.
+        random_state (int | None, optional): Seed for random number generation.
+            Used for reproducible results. Defaults to ``None``.
 
-            model.fit(sparse_embedding)
-            projected_embedding = model.transform(sparse_embedding)
+    Attributes:
+        n_components (int): Number of components in the projected space.
+        sparse_random_matrix (torch.Tensor): Random projection matrix.
+        eps (float): Minimum distortion rate.
+        random_state (int | None): Random seed.
 
-            print(projected_embedding.shape)
-            # Output: torch.Size([1000, 5920])
+    Example:
+        >>> import torch
+        >>> from anomalib.models.components import SparseRandomProjection
+        >>> # Create sample data
+        >>> data = torch.randn(100, 50)  # 100 samples, 50 features
+        >>> # Initialize and fit projector
+        >>> projector = SparseRandomProjection(eps=0.1)
+        >>> projector.fit(data)
+        >>> # Transform data
+        >>> projected = projector.transform(data)
+        >>> print(projected.shape)
+
+    References:
+        .. [1] P. Li, T. Hastie and K. Church, "Very Sparse Random Projections,"
+           KDD '06, 2006.
+           https://web.stanford.edu/~hastie/Papers/Ping/KDD06_rp.pdf
     """
 
     def __init__(self, eps: float = 0.1, random_state: int | None = None) -> None:
@@ -55,15 +70,20 @@ def __init__(self, eps: float = 0.1, random_state: int | None = None) -> None:
         self.random_state = random_state
 
     def _sparse_random_matrix(self, n_features: int) -> torch.Tensor:
-        """Random sparse matrix. Based on https://web.stanford.edu/~hastie/Papers/Ping/KDD06_rp.pdf.
+        """Generate a sparse random matrix for projection.
+
+        Implements the sparse random matrix generation described in [1]_.
 
         Args:
-            n_features (int): Dimentionality of the original source space
+            n_features (int): Dimensionality of the original source space.
 
         Returns:
-            Tensor: Sparse matrix of shape (n_components, n_features).
-                The generated Gaussian random matrix is in CSR (compressed sparse row)
-                format.
+            torch.Tensor: Sparse matrix of shape ``(n_components, n_features)``.
+                The matrix is stored in dense format for GPU compatibility.
+
+        References:
+            .. [1] P. Li, T. Hastie and K. Church, "Very Sparse Random
+               Projections," KDD '06, 2006.
         """
         # Density 'auto'. Factorize density
         density = 1 / np.sqrt(n_features)
@@ -100,28 +120,40 @@ def _sparse_random_matrix(self, n_features: int) -> torch.Tensor:
 
     @staticmethod
     def _johnson_lindenstrauss_min_dim(n_samples: int, eps: float = 0.1) -> int | np.integer:
-        """Find a 'safe' number of components to randomly project to.
+        """Find a 'safe' number of components for random projection.
 
-        Ref eqn 2.1 https://cseweb.ucsd.edu/~dasgupta/papers/jl.pdf
+        Implements the Johnson-Lindenstrauss lemma to determine the minimum number
+        of components needed to approximately preserve distances.
 
         Args:
-            n_samples (int): Number of samples used to compute safe components
-            eps (float, optional): Minimum distortion rate. Defaults to 0.1.
+            n_samples (int): Number of samples in the dataset.
+            eps (float, optional): Minimum distortion rate. Defaults to ``0.1``.
+
+        Returns:
+            int: Minimum number of components required.
+
+        References:
+            .. [1] Dasgupta, S. and Gupta, A., "An elementary proof of a theorem
+               of Johnson and Lindenstrauss," Random Struct. Algor., 22: 60-65,
+               2003.
         """
         denominator = (eps**2 / 2) - (eps**3 / 3)
         return (4 * np.log(n_samples) / denominator).astype(np.int64)
 
     def fit(self, embedding: torch.Tensor) -> "SparseRandomProjection":
-        """Generate sparse matrix from the embedding tensor.
+        """Fit the random projection matrix to the data.
 
         Args:
-            embedding (torch.Tensor): embedding tensor for generating embedding
+            embedding (torch.Tensor): Input tensor of shape
+                ``(n_samples, n_features)``.
 
         Returns:
-            (SparseRandomProjection): Return self to be used as
+            SparseRandomProjection: The fitted projector.
 
-            >>> model = SparseRandomProjection()
-            >>> model = model.fit()
+        Example:
+            >>> projector = SparseRandomProjection()
+            >>> data = torch.randn(100, 50)
+            >>> projector = projector.fit(data)
         """
         n_samples, n_features = embedding.shape
         device = embedding.device
@@ -137,20 +169,25 @@ def fit(self, embedding: torch.Tensor) -> "SparseRandomProjection":
         return self
 
     def transform(self, embedding: torch.Tensor) -> torch.Tensor:
-        """Project the data by using matrix product with the random matrix.
+        """Project the data using the random projection matrix.
 
         Args:
-            embedding (torch.Tensor): Embedding of shape (n_samples, n_features)
-                The input data to project into a smaller dimensional space
+            embedding (torch.Tensor): Input tensor of shape
+                ``(n_samples, n_features)``.
 
         Returns:
-            projected_embedding (torch.Tensor): Sparse matrix of shape
-                (n_samples, n_components) Projected array.
+            torch.Tensor: Projected tensor of shape
+                ``(n_samples, n_components)``.
+
+        Raises:
+            NotFittedError: If transform is called before fitting.
 
         Example:
-            >>> projected_embedding = model.transform(embedding)
-            >>> projected_embedding.shape
-            torch.Size([1000, 5920])
+            >>> projector = SparseRandomProjection()
+            >>> data = torch.randn(100, 50)
+            >>> projector.fit(data)
+            >>> projected = projector.transform(data)
+            >>> print(projected.shape)
         """
         if self.sparse_random_matrix is None:
             msg = "`fit()` has not been called on SparseRandomProjection yet."
diff --git a/src/anomalib/models/components/feature_extractors/__init__.py b/src/anomalib/models/components/feature_extractors/__init__.py
index 5092056967..be57c40936 100644
--- a/src/anomalib/models/components/feature_extractors/__init__.py
+++ b/src/anomalib/models/components/feature_extractors/__init__.py
@@ -1,4 +1,28 @@
-"""Feature extractors."""
+"""Feature extractors for deep learning models.
+
+This module provides feature extraction utilities and classes for extracting
+features from images using various backbone architectures.
+
+Classes:
+    TimmFeatureExtractor: Feature extractor using timm models.
+    TorchFXFeatureExtractor: Feature extractor using TorchFX for graph capture.
+    BackboneParams: Configuration parameters for backbone models.
+
+Functions:
+    dryrun_find_featuremap_dims: Utility to find feature map dimensions.
+
+Example:
+    >>> from anomalib.models.components.feature_extractors import (
+    ...     TimmFeatureExtractor
+    ... )
+    >>> # Create feature extractor
+    >>> feature_extractor = TimmFeatureExtractor(
+    ...     backbone="resnet18",
+    ...     layers=['layer1', 'layer2']
+    ... )
+    >>> # Extract features
+    >>> features = feature_extractor(images)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/components/feature_extractors/timm.py b/src/anomalib/models/components/feature_extractors/timm.py
index ae81dfb2c4..adb1d41153 100644
--- a/src/anomalib/models/components/feature_extractors/timm.py
+++ b/src/anomalib/models/components/feature_extractors/timm.py
@@ -1,6 +1,24 @@
-"""Feature Extractor.
-
-This script extracts features from a CNN network
+"""Feature extractor using timm models.
+
+This module provides a feature extractor implementation that leverages the timm
+library to extract intermediate features from various CNN architectures.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.feature_extractors import (
+    ...     TimmFeatureExtractor
+    ... )
+    >>> # Initialize feature extractor
+    >>> extractor = TimmFeatureExtractor(
+    ...     backbone="resnet18",
+    ...     layers=["layer1", "layer2", "layer3"]
+    ... )
+    >>> # Extract features from input
+    >>> inputs = torch.randn(32, 3, 256, 256)
+    >>> features = extractor(inputs)
+    >>> # Access features by layer name
+    >>> print(features["layer1"].shape)
+    torch.Size([32, 64, 64, 64])
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -17,31 +35,44 @@
 
 
 class TimmFeatureExtractor(nn.Module):
-    """Extract features from a CNN.
+    """Extract intermediate features from timm models.
 
     Args:
-        backbone (nn.Module): The backbone to which the feature extraction hooks are attached.
-        layers (Iterable[str]): List of layer names of the backbone to which the hooks are attached.
-        pre_trained (bool): Whether to use a pre-trained backbone. Defaults to True.
-        requires_grad (bool): Whether to require gradients for the backbone. Defaults to False.
-            Models like ``stfpm`` use the feature extractor model as a trainable network. In such cases gradient
-            computation is required.
+        backbone (str): Name of the timm model architecture to use as backbone.
+            Can include custom weights URI in format ``name__AT__uri``.
+        layers (Sequence[str]): Names of layers from which to extract features.
+        pre_trained (bool, optional): Whether to use pre-trained weights.
+            Defaults to ``True``.
+        requires_grad (bool, optional): Whether to compute gradients for the
+            backbone. Required for training models like STFPM. Defaults to
+            ``False``.
+
+    Attributes:
+        backbone (str): Name of the backbone model.
+        layers (list[str]): Layer names for feature extraction.
+        idx (list[int]): Indices mapping layer names to model outputs.
+        requires_grad (bool): Whether gradients are computed.
+        feature_extractor (nn.Module): The underlying timm model.
+        out_dims (list[int]): Output dimensions for each extracted layer.
 
     Example:
-        .. code-block:: python
-
-            import torch
-            from anomalib.models.components.feature_extractors import TimmFeatureExtractor
-
-            model = TimmFeatureExtractor(model="resnet18", layers=['layer1', 'layer2', 'layer3'])
-            input = torch.rand((32, 3, 256, 256))
-            features = model(input)
-
-            print([layer for layer in features.keys()])
-            # Output: ['layer1', 'layer2', 'layer3']
-
-            print([feature.shape for feature in features.values()]()
-            # Output: [torch.Size([32, 64, 64, 64]), torch.Size([32, 128, 32, 32]), torch.Size([32, 256, 16, 16])]
+        >>> import torch
+        >>> from anomalib.models.components.feature_extractors import (
+        ...     TimmFeatureExtractor
+        ... )
+        >>> # Create extractor
+        >>> model = TimmFeatureExtractor(
+        ...     backbone="resnet18",
+        ...     layers=["layer1", "layer2"]
+        ... )
+        >>> # Extract features
+        >>> inputs = torch.randn(1, 3, 224, 224)
+        >>> features = model(inputs)
+        >>> # Print shapes
+        >>> for name, feat in features.items():
+        ...     print(f"{name}: {feat.shape}")
+        layer1: torch.Size([1, 64, 56, 56])
+        layer2: torch.Size([1, 128, 28, 28])
     """
 
     def __init__(
@@ -78,10 +109,14 @@ def __init__(
         self._features = {layer: torch.empty(0) for layer in self.layers}
 
     def _map_layer_to_idx(self) -> list[int]:
-        """Map set of layer names to indices of model.
+        """Map layer names to their indices in the model's output.
 
         Returns:
-            list[int]: Feature map extracted from the CNN.
+            list[int]: Indices corresponding to the requested layer names.
+
+        Note:
+            If a requested layer is not found in the model, it is removed from
+            ``self.layers`` and a warning is logged.
         """
         idx = []
         model = timm.create_model(
@@ -90,7 +125,8 @@ def _map_layer_to_idx(self) -> list[int]:
             features_only=True,
             exportable=True,
         )
-        # model.feature_info.info returns list of dicts containing info, inside which "module" contains layer name
+        # model.feature_info.info returns list of dicts containing info,
+        # inside which "module" contains layer name
         layer_names = [info["module"] for info in model.feature_info.info]
         for layer in self.layers:
             try:
@@ -104,21 +140,29 @@ def _map_layer_to_idx(self) -> list[int]:
         return idx
 
     def forward(self, inputs: torch.Tensor) -> dict[str, torch.Tensor]:
-        """Forward-pass input tensor into the CNN.
+        """Extract features from the input tensor.
 
         Args:
-            inputs (torch.Tensor): Input tensor
+            inputs (torch.Tensor): Input tensor of shape
+                ``(batch_size, channels, height, width)``.
 
         Returns:
-            Feature map extracted from the CNN
+            dict[str, torch.Tensor]: Dictionary mapping layer names to their
+            feature tensors.
 
         Example:
-            .. code-block:: python
-
-                model = TimmFeatureExtractor(model="resnet50", layers=['layer3'])
-                input = torch.rand((32, 3, 256, 256))
-                features = model.forward(input)
-
+            >>> import torch
+            >>> from anomalib.models.components.feature_extractors import (
+            ...     TimmFeatureExtractor
+            ... )
+            >>> model = TimmFeatureExtractor(
+            ...     backbone="resnet18",
+            ...     layers=["layer1"]
+            ... )
+            >>> inputs = torch.randn(1, 3, 224, 224)
+            >>> features = model(inputs)
+            >>> features["layer1"].shape
+            torch.Size([1, 64, 56, 56])
         """
         if self.requires_grad:
             features = dict(zip(self.layers, self.feature_extractor(inputs), strict=True))
diff --git a/src/anomalib/models/components/feature_extractors/torchfx.py b/src/anomalib/models/components/feature_extractors/torchfx.py
index 600f2a961d..355d611d10 100644
--- a/src/anomalib/models/components/feature_extractors/torchfx.py
+++ b/src/anomalib/models/components/feature_extractors/torchfx.py
@@ -1,4 +1,52 @@
-"""Feature Extractor based on TorchFX."""
+"""Feature Extractor based on TorchFX.
+
+This module provides a feature extractor implementation that leverages TorchFX to
+extract intermediate features from CNN architectures.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.feature_extractors import (
+    ...     TorchFXFeatureExtractor
+    ... )
+    >>> # Initialize with torchvision model
+    >>> from torchvision.models.efficientnet import EfficientNet_B5_Weights
+    >>> extractor = TorchFXFeatureExtractor(
+    ...     backbone="efficientnet_b5",
+    ...     return_nodes=["features.6.8"],
+    ...     weights=EfficientNet_B5_Weights.DEFAULT
+    ... )
+    >>> # Extract features
+    >>> inputs = torch.rand((32, 3, 256, 256))
+    >>> features = extractor(inputs)
+    >>> print([layer for layer in features.keys()])
+    ['features.6.8']
+    >>> print([feature.shape for feature in features.values()])
+    [torch.Size([32, 304, 8, 8])]
+
+    With custom models:
+    >>> # Initialize with custom model
+    >>> extractor = TorchFXFeatureExtractor(
+    ...     "path.to.CustomModel",
+    ...     ["linear_relu_stack.3"],
+    ...     weights="path/to/weights.pth"
+    ... )
+    >>> inputs = torch.randn(1, 1, 28, 28)
+    >>> features = extractor(inputs)
+    >>> print([layer for layer in features.keys()])
+    ['linear_relu_stack.3']
+
+    With model instances:
+    >>> # Initialize with model instance
+    >>> from timm import create_model
+    >>> model = create_model("resnet18", pretrained=True)
+    >>> extractor = TorchFXFeatureExtractor(model, ["layer1"])
+    >>> inputs = torch.rand((32, 3, 256, 256))
+    >>> features = extractor(inputs)
+    >>> print([layer for layer in features.keys()])
+    ['layer1']
+    >>> print([feature.shape for feature in features.values()])
+    [torch.Size([32, 64, 64, 64])]
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,91 +64,64 @@
 
 @dataclass
 class BackboneParams:
-    """Used for serializing the backbone."""
+    """Used for serializing the backbone.
+
+    Args:
+        class_path (str | type[nn.Module]): Path to the backbone class or the
+            class itself.
+        init_args (dict): Dictionary of initialization arguments for the backbone.
+            Defaults to empty dict.
+    """
 
     class_path: str | type[nn.Module]
     init_args: dict = field(default_factory=dict)
 
 
 class TorchFXFeatureExtractor(nn.Module):
-    """Extract features from a CNN.
+    """Extract features from a CNN using TorchFX.
 
     Args:
-        backbone (str | BackboneParams | dict | nn.Module): The backbone to which the feature extraction hooks are
-            attached. If the name is provided, the model is loaded from torchvision. Otherwise, the model class can be
-            provided and it will try to load the weights from the provided weights file. Last, an instance of nn.Module
-            can also be passed directly.
-        return_nodes (Iterable[str]): List of layer names of the backbone to which the hooks are attached.
-            You can find the names of these nodes by using ``get_graph_node_names`` function.
-        weights (str | WeightsEnum | None): Weights enum to use for the model. Torchvision models require
-            ``WeightsEnum``. These enums are defined in ``torchvision.models.``. You can pass the weights
-            path for custom models.
-        requires_grad (bool): Models like ``stfpm`` use the feature extractor for training. In such cases we should
-            set ``requires_grad`` to ``True``. Default is ``False``.
-        tracer_kwargs (dict | None): a dictionary of keyword arguments for NodePathTracer (which passes them onto
-            it's parent class torch.fx.Tracer). Can be used to allow not tracing through a list of problematic
-            modules, by passing a list of `leaf_modules` as one of the `tracer_kwargs`.
+        backbone (str | BackboneParams | dict | nn.Module): The backbone to which
+            the feature extraction hooks are attached. If a string name is
+            provided, the model is loaded from torchvision. Otherwise, the model
+            class can be provided and it will try to load the weights from the
+            provided weights file. Last, an instance of nn.Module can also be
+            passed directly.
+        return_nodes (list[str]): List of layer names of the backbone to which
+            the hooks are attached. You can find the names of these nodes by
+            using ``get_graph_node_names`` function.
+        weights (str | WeightsEnum | None): Weights enum to use for the model.
+            Torchvision models require ``WeightsEnum``. These enums are defined
+            in ``torchvision.models.``. You can pass the weights path for
+            custom models. Defaults to ``None``.
+        requires_grad (bool): Models like ``stfpm`` use the feature extractor for
+            training. In such cases we should set ``requires_grad`` to ``True``.
+            Defaults to ``False``.
+        tracer_kwargs (dict | None): Dictionary of keyword arguments for
+            NodePathTracer (which passes them onto it's parent class
+            torch.fx.Tracer). Can be used to allow not tracing through a list of
+            problematic modules, by passing a list of ``leaf_modules`` as one of
+            the ``tracer_kwargs``. Defaults to ``None``.
+
+    Attributes:
+        feature_extractor (GraphModule): The TorchFX feature extractor module.
 
     Example:
-        With torchvision models:
-
-        .. code-block:: python
-
-            import torch
-            from anomalib.models.components.feature_extractors import TorchFXFeatureExtractor
-            from torchvision.models.efficientnet import EfficientNet_B5_Weights
-
-            feature_extractor = TorchFXFeatureExtractor(
-                backbone="efficientnet_b5",
-                return_nodes=["features.6.8"],
-                weights=EfficientNet_B5_Weights.DEFAULT
-            )
-
-            input = torch.rand((32, 3, 256, 256))
-            features = feature_extractor(input)
-
-            print([layer for layer in features.keys()])
-            # Output: ["features.6.8"]
-
-            print([feature.shape for feature in features.values()])
-            # Output: [torch.Size([32, 304, 8, 8])]
-
-        With custom models:
-
-        .. code-block:: python
-
-            import torch
-            from anomalib.models.components.feature_extractors import TorchFXFeatureExtractor
-
-            feature_extractor = TorchFXFeatureExtractor(
-                "path.to.CustomModel", ["linear_relu_stack.3"], weights="path/to/weights.pth"
-            )
-
-            input = torch.randn(1, 1, 28, 28)
-            features = feature_extractor(input)
-
-            print([layer for layer in features.keys()])
-            # Output: ["linear_relu_stack.3"]
-
-        with model instances:
-
-        .. code-block:: python
-
-            import torch
-            from anomalib.models.components.feature_extractors import TorchFXFeatureExtractor
-            from timm import create_model
-
-            model = create_model("resnet18", pretrained=True)
-            feature_extractor = TorchFXFeatureExtractor(model, ["layer1"])
-
-            input = torch.rand((32, 3, 256, 256))
-            features = feature_extractor(input)
-
-            print([layer for layer in features.keys()])
-            # Output: ["layer1"]
-
-            print([feature.shape for feature in features.values()])
-            # Output: [torch.Size([32, 64, 64, 64])]
+        >>> import torch
+        >>> from anomalib.models.components.feature_extractors import (
+        ...     TorchFXFeatureExtractor
+        ... )
+        >>> # Initialize with torchvision model
+        >>> extractor = TorchFXFeatureExtractor(
+        ...     backbone="resnet18",
+        ...     return_nodes=["layer1", "layer2"]
+        ... )
+        >>> # Extract features
+        >>> inputs = torch.randn(1, 3, 224, 224)
+        >>> features = extractor(inputs)
+        >>> # Access features by layer name
+        >>> print(features["layer1"].shape)
+        torch.Size([1, 64, 56, 56])
     """
 
     def __init__(
@@ -136,26 +157,25 @@ def initialize_feature_extractor(
         requires_grad: bool = False,
         tracer_kwargs: dict | None = None,
     ) -> GraphModule:
-        """Extract features from a CNN.
+        """Initialize the feature extractor.
 
         Args:
-            backbone (BackboneParams | nn.Module): The backbone to which the feature extraction hooks are attached.
-                If the name is provided for BackboneParams, the model is loaded from torchvision. Otherwise, the model
-                class can be provided and it will try to load the weights from the provided weights file. Last, an
-                instance of the model can be provided as well, which will be used as-is.
-            return_nodes (Iterable[str]): List of layer names of the backbone to which the hooks are attached.
-                You can find the names of these nodes by using ``get_graph_node_names`` function.
-            weights (str | WeightsEnum | None): Weights enum to use for the model. Torchvision models require
-                ``WeightsEnum``. These enums are defined in ``torchvision.models.``. You can pass the weights
-                path for custom models.
-            requires_grad (bool): Models like ``stfpm`` use the feature extractor for training. In such cases we should
-                set ``requires_grad`` to ``True``. Default is ``False``.
-            tracer_kwargs (dict | None): a dictionary of keyword arguments for NodePathTracer (which passes them onto
-                it's parent class torch.fx.Tracer). Can be used to allow not tracing through a list of problematic
-                modules, by passing a list of `leaf_modules` as one of the `tracer_kwargs`.
+            backbone (BackboneParams | nn.Module): The backbone to which the
+                feature extraction hooks are attached.
+            return_nodes (list[str]): List of layer names to extract features
+                from.
+            weights (str | WeightsEnum | None): Model weights specification.
+                Defaults to ``None``.
+            requires_grad (bool): Whether to compute gradients. Defaults to
+                ``False``.
+            tracer_kwargs (dict | None): Additional arguments for the tracer.
+                Defaults to ``None``.
 
         Returns:
-            Feature Extractor based on TorchFX.
+            GraphModule: Initialized feature extractor.
+
+        Raises:
+            TypeError: If weights format is invalid.
         """
         if isinstance(backbone, nn.Module):
             backbone_model = backbone
@@ -167,7 +187,10 @@ class can be provided and it will try to load the weights from the provided weig
             backbone_model = backbone_class(**backbone.init_args)
 
         if isinstance(weights, WeightsEnum):  # torchvision models
-            feature_extractor = create_feature_extractor(model=backbone_model, return_nodes=return_nodes)
+            feature_extractor = create_feature_extractor(
+                model=backbone_model,
+                return_nodes=return_nodes,
+            )
         elif weights is not None:
             if not isinstance(weights, str):
                 msg = "Weights should point to a path"
@@ -178,7 +201,11 @@ class can be provided and it will try to load the weights from the provided weig
                 model_weights = model_weights["state_dict"]
             backbone_model.load_state_dict(model_weights)
 
-        feature_extractor = create_feature_extractor(backbone_model, return_nodes, tracer_kwargs=tracer_kwargs)
+        feature_extractor = create_feature_extractor(
+            backbone_model,
+            return_nodes,
+            tracer_kwargs=tracer_kwargs,
+        )
 
         if not requires_grad:
             feature_extractor.eval()
@@ -191,26 +218,30 @@ class can be provided and it will try to load the weights from the provided weig
     def _get_backbone_class(backbone: str) -> Callable[..., nn.Module]:
         """Get the backbone class from the provided path.
 
-        If only the model name is provided, it will try to load the model from torchvision.
-
-        Example:
-            >>> from anomalib.models.components.feature_extractors import TorchFXFeatureExtractor
-            >>> TorchFXFeatureExtractor._get_backbone_class("efficientnet_b5")
-             torchvision.models.efficientnet.EfficientNet>
-
-            >>> TorchFXFeatureExtractor._get_backbone_class("path.to.CustomModel")
-            
+        If only the model name is provided, it will try to load the model from
+        torchvision.
 
         Args:
             backbone (str): Path to the backbone class.
 
         Returns:
-            Backbone class.
+            Callable[..., nn.Module]: Backbone class.
+
+        Raises:
+            ModuleNotFoundError: If backbone cannot be found.
+
+        Example:
+            >>> from anomalib.models.components.feature_extractors import (
+            ...     TorchFXFeatureExtractor
+            ... )
+            >>> # Get torchvision model
+            >>> cls = TorchFXFeatureExtractor._get_backbone_class(
+            ...     "efficientnet_b5"
+            ... )
+            >>> # Get custom model
+            >>> cls = TorchFXFeatureExtractor._get_backbone_class(
+            ...     "path.to.CustomModel"
+            ... )
         """
         try:
             if len(backbone.split(".")) > 1:
@@ -222,12 +253,18 @@ def _get_backbone_class(backbone: str) -> Callable[..., nn.Module]:
                 backbone_class = getattr(models, backbone)
         except ModuleNotFoundError as exception:
             msg = f"Backbone {backbone} not found in torchvision.models nor in {backbone} module."
-            raise ModuleNotFoundError(
-                msg,
-            ) from exception
+            raise ModuleNotFoundError(msg) from exception
 
         return backbone_class
 
     def forward(self, inputs: torch.Tensor) -> dict[str, torch.Tensor]:
-        """Extract features from the input."""
+        """Extract features from the input.
+
+        Args:
+            inputs (torch.Tensor): Input tensor.
+
+        Returns:
+            dict[str, torch.Tensor]: Dictionary mapping layer names to their
+                feature tensors.
+        """
         return self.feature_extractor(inputs)
diff --git a/src/anomalib/models/components/feature_extractors/utils.py b/src/anomalib/models/components/feature_extractors/utils.py
index 71e50f7361..e1d56c3265 100644
--- a/src/anomalib/models/components/feature_extractors/utils.py
+++ b/src/anomalib/models/components/feature_extractors/utils.py
@@ -1,4 +1,30 @@
-"""Utility functions to manipulate feature extractors."""
+"""Utility functions to manipulate feature extractors.
+
+This module provides utility functions for working with feature extractors,
+including functions to analyze feature map dimensions.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.feature_extractors import (
+    ...     TimmFeatureExtractor,
+    ...     dryrun_find_featuremap_dims
+    ... )
+    >>> # Create feature extractor
+    >>> extractor = TimmFeatureExtractor(
+    ...     backbone="resnet18",
+    ...     layers=["layer1", "layer2"]
+    ... )
+    >>> # Get feature dimensions
+    >>> dims = dryrun_find_featuremap_dims(
+    ...     extractor,
+    ...     input_size=(256, 256),
+    ...     layers=["layer1", "layer2"]
+    ... )
+    >>> print(dims["layer1"]["num_features"])  # Number of channels
+    64
+    >>> print(dims["layer1"]["resolution"])  # Feature map height, width
+    (64, 64)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -14,16 +40,42 @@ def dryrun_find_featuremap_dims(
     input_size: tuple[int, int],
     layers: list[str],
 ) -> dict[str, dict[str, int | tuple[int, int]]]:
-    """Dry run an empty image of `input_size` size to get the featuremap tensors' dimensions (num_features, resolution).
+    """Get feature map dimensions by running an empty tensor through the model.
+
+    Performs a forward pass with an empty tensor to determine the output
+    dimensions of specified feature maps.
+
+    Args:
+        feature_extractor: Feature extraction model, either a ``TimmFeatureExtractor``
+            or ``GraphModule``.
+        input_size: Tuple of ``(height, width)`` specifying input image dimensions.
+        layers: List of layer names from which to extract features.
 
     Returns:
-        tuple[int, int]: maping of `layer -> dimensions dict`
-            Each `dimension dict` has two keys: `num_features` (int) and `resolution`(tuple[int, int]).
+        Dictionary mapping layer names to dimension information. For each layer,
+        returns a dictionary with:
+            - ``num_features``: Number of feature channels (int)
+            - ``resolution``: Spatial dimensions as ``(height, width)`` tuple
+
+    Example:
+        >>> extractor = TimmFeatureExtractor("resnet18", layers=["layer1"])
+        >>> dims = dryrun_find_featuremap_dims(
+        ...     extractor,
+        ...     input_size=(256, 256),
+        ...     layers=["layer1"]
+        ... )
+        >>> print(dims["layer1"]["num_features"])  # channels
+        64
+        >>> print(dims["layer1"]["resolution"])  # (height, width)
+        (64, 64)
     """
     device = next(feature_extractor.parameters()).device
     dryrun_input = torch.empty(1, 3, *input_size).to(device)
     dryrun_features = feature_extractor(dryrun_input)
     return {
-        layer: {"num_features": dryrun_features[layer].shape[1], "resolution": dryrun_features[layer].shape[2:]}
+        layer: {
+            "num_features": dryrun_features[layer].shape[1],
+            "resolution": dryrun_features[layer].shape[2:],
+        }
         for layer in layers
     }
diff --git a/src/anomalib/models/components/filters/__init__.py b/src/anomalib/models/components/filters/__init__.py
index 340daa47f2..c632383437 100644
--- a/src/anomalib/models/components/filters/__init__.py
+++ b/src/anomalib/models/components/filters/__init__.py
@@ -1,4 +1,20 @@
-"""Implements filters used by models."""
+"""Filters used by anomaly detection models.
+
+This module provides filter implementations that can be used for image
+preprocessing and feature enhancement in anomaly detection models.
+
+Classes:
+    GaussianBlur2d: 2D Gaussian blur filter implementation.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.filters import GaussianBlur2d
+    >>> # Create a Gaussian blur filter
+    >>> blur = GaussianBlur2d(kernel_size=3, sigma=1.0)
+    >>> # Apply blur to input tensor
+    >>> input_tensor = torch.randn(1, 3, 256, 256)
+    >>> blurred = blur(input_tensor)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/components/filters/blur.py b/src/anomalib/models/components/filters/blur.py
index 986214707d..cfe1640e04 100644
--- a/src/anomalib/models/components/filters/blur.py
+++ b/src/anomalib/models/components/filters/blur.py
@@ -1,4 +1,17 @@
-"""Gaussian blurring via pytorch."""
+"""Gaussian blurring implementation using PyTorch.
+
+This module provides a 2D Gaussian blur filter implementation that pre-computes
+the Gaussian kernel during initialization for efficiency.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.filters import GaussianBlur2d
+    >>> # Create a Gaussian blur filter
+    >>> blur = GaussianBlur2d(sigma=1.0, channels=3)
+    >>> # Apply blur to input tensor
+    >>> input_tensor = torch.randn(1, 3, 256, 256)
+    >>> blurred = blur(input_tensor)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -14,21 +27,53 @@
 def compute_kernel_size(sigma_val: float) -> int:
     """Compute kernel size from sigma value.
 
+    The kernel size is calculated as 2 * (4 * sigma + 0.5) + 1 to ensure it
+    captures the significant part of the Gaussian distribution.
+
     Args:
-        sigma_val (float): Sigma value.
+        sigma_val (float): Standard deviation value for the Gaussian kernel.
 
     Returns:
-        int: Kernel size.
+        int: Computed kernel size (always odd).
+
+    Example:
+        >>> compute_kernel_size(1.0)
+        9
+        >>> compute_kernel_size(2.0)
+        17
     """
     return 2 * int(4.0 * sigma_val + 0.5) + 1
 
 
 class GaussianBlur2d(nn.Module):
-    """Compute GaussianBlur in 2d.
+    """2D Gaussian blur filter with pre-computed kernel.
+
+    Unlike some implementations, this class pre-computes the Gaussian kernel
+    during initialization rather than computing it during the forward pass.
+    This approach is more efficient but requires specifying the number of
+    input channels upfront.
 
-    Makes use of kornia functions, but most notably the kernel is not computed
-    during the forward pass, and does not depend on the input size. As a caveat,
-    the number of channels that are expected have to be provided during initialization.
+    Args:
+        sigma (float | tuple[float, float]): Standard deviation(s) for the
+            Gaussian kernel. If a single float is provided, it's used for both
+            dimensions.
+        channels (int): Number of input channels. Defaults to 1.
+        kernel_size (int | tuple[int, int] | None): Size of the Gaussian
+            kernel. If ``None``, computed from sigma. Defaults to ``None``.
+        normalize (bool): Whether to normalize the kernel so its elements sum
+            to 1. Defaults to ``True``.
+        border_type (str): Padding mode for border handling. Options are
+            'reflect', 'replicate', etc. Defaults to "reflect".
+        padding (str): Padding strategy. Either 'same' or 'valid'.
+            Defaults to "same".
+
+    Example:
+        >>> import torch
+        >>> blur = GaussianBlur2d(sigma=1.0, channels=3)
+        >>> x = torch.randn(1, 3, 64, 64)
+        >>> output = blur(x)
+        >>> output.shape
+        torch.Size([1, 3, 64, 64])
     """
 
     def __init__(
@@ -40,17 +85,6 @@ def __init__(
         border_type: str = "reflect",
         padding: str = "same",
     ) -> None:
-        """Initialize model, setup kernel etc..
-
-        Args:
-            sigma (float | tuple[float, float]): standard deviation to use for constructing the Gaussian kernel.
-            channels (int): channels of the input. Defaults to 1.
-            kernel_size (int | tuple[int, int] | None): size of the Gaussian kernel to use. Defaults to None.
-            normalize (bool, optional): Whether to normalize the kernel or not (i.e. all elements sum to 1).
-                Defaults to True.
-            border_type (str, optional): Border type to use for padding of the input. Defaults to "reflect".
-            padding (str, optional): Type of padding to apply. Defaults to "same".
-        """
         super().__init__()
         sigma = sigma if isinstance(sigma, tuple) else (sigma, sigma)
         self.channels = channels
@@ -74,13 +108,22 @@ def __init__(
         self.padding_shape = _compute_padding([self.height, self.width])
 
     def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
-        """Blur the input with the computed Gaussian.
+        """Apply Gaussian blur to input tensor.
 
         Args:
-            input_tensor (torch.Tensor): Input tensor to be blurred.
+            input_tensor (torch.Tensor): Input tensor of shape
+                ``(B, C, H, W)``.
 
         Returns:
-            Tensor: Blurred output tensor.
+            torch.Tensor: Blurred output tensor. If padding is 'same',
+                output shape matches input. If 'valid', output is smaller.
+
+        Example:
+            >>> blur = GaussianBlur2d(sigma=1.0, channels=1)
+            >>> x = torch.ones(1, 1, 5, 5)
+            >>> output = blur(x)
+            >>> output.shape
+            torch.Size([1, 1, 5, 5])
         """
         batch, channel, height, width = input_tensor.size()
 
diff --git a/src/anomalib/models/components/flow/__init__.py b/src/anomalib/models/components/flow/__init__.py
index dca2e7b9e6..f343c8dd38 100644
--- a/src/anomalib/models/components/flow/__init__.py
+++ b/src/anomalib/models/components/flow/__init__.py
@@ -1,6 +1,23 @@
-"""All In One Block Layer."""
+"""Flow components used in anomaly detection models.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides flow-based components that can be used in anomaly detection
+models. These components help model complex data distributions and transformations.
+
+Classes:
+    AllInOneBlock: A block that combines multiple flow operations into a single
+        transformation.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.flow import AllInOneBlock
+    >>> # Create flow block
+    >>> flow = AllInOneBlock(channels=64)
+    >>> # Apply flow transformation
+    >>> x = torch.randn(1, 64, 32, 32)
+    >>> y, logdet = flow(x)
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .all_in_one_block import AllInOneBlock
diff --git a/src/anomalib/models/components/flow/all_in_one_block.py b/src/anomalib/models/components/flow/all_in_one_block.py
index 6c6713add8..647306a23b 100644
--- a/src/anomalib/models/components/flow/all_in_one_block.py
+++ b/src/anomalib/models/components/flow/all_in_one_block.py
@@ -1,4 +1,74 @@
-"""All In One Block Layer."""
+r"""All In One Block Layer.
+
+This module provides an invertible block that combines multiple flow operations:
+affine coupling, permutation, and global affine transformation.
+
+The block performs the following computation:
+
+.. math::
+
+    y = V R \; \Psi(s_\mathrm{global}) \odot \mathrm{Coupling}
+    \Big(R^{-1} V^{-1} x\Big)+ t_\mathrm{global}
+
+where:
+
+- :math:`V` is an optional learned householder reflection matrix
+- :math:`R` is a permutation matrix
+- :math:`\Psi` is an activation function for global scaling
+- The coupling operation splits input :math:`x` into :math:`x_1, x_2` and outputs
+  :math:`u = \mathrm{concat}(u_1, u_2)` where:
+
+  .. math::
+
+      u_1 &= x_1 \odot \exp \Big( \alpha \; \mathrm{tanh}\big( s(x_2) \big)\Big)
+      + t(x_2) \\
+      u_2 &= x_2
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.flow import AllInOneBlock
+    >>> # Create flow block
+    >>> def subnet_fc(c_in, c_out):
+    ...     return torch.nn.Sequential(
+    ...         torch.nn.Linear(c_in, 128),
+    ...         torch.nn.ReLU(),
+    ...         torch.nn.Linear(128, c_out)
+    ...     )
+    >>> flow = AllInOneBlock(
+    ...     dims_in=[(64,)],
+    ...     subnet_constructor=subnet_fc
+    ... )
+    >>> # Apply flow transformation
+    >>> x = torch.randn(10, 64)
+    >>> y, logdet = flow(x)
+    >>> print(y[0].shape)
+    torch.Size([10, 64])
+
+Args:
+    dims_in (list[tuple[int]]): Dimensions of input tensor(s)
+    dims_c (list[tuple[int]], optional): Dimensions of conditioning tensor(s).
+        Defaults to None.
+    subnet_constructor (Callable, optional): Function that constructs the subnet,
+        called as ``f(channels_in, channels_out)``. Defaults to None.
+    affine_clamping (float, optional): Clamping value for affine coupling.
+        Defaults to 2.0.
+    gin_block (bool, optional): Use GIN coupling from Sorrenson et al, 2019.
+        Defaults to False.
+    global_affine_init (float, optional): Initial value for global affine
+        scaling. Defaults to 1.0.
+    global_affine_type (str, optional): Type of activation for global affine
+        scaling. One of ``'SIGMOID'``, ``'SOFTPLUS'``, ``'EXP'``.
+        Defaults to ``'SOFTPLUS'``.
+    permute_soft (bool, optional): Use soft permutation matrix from SO(N).
+        Defaults to False.
+    learned_householder_permutation (int, optional): Number of learned
+        householder reflections. Defaults to 0.
+    reverse_permutation (bool, optional): Apply inverse permutation before block.
+        Defaults to False.
+
+Raises:
+    ValueError: If ``subnet_constructor`` is None or dimensions are invalid.
+"""
 
 # Copyright (c) https://github.com/vislearn/FrEIA
 # SPDX-License-Identifier: MIT
@@ -20,90 +90,77 @@
 
 
 def _global_scale_sigmoid_activation(input_tensor: torch.Tensor) -> torch.Tensor:
-    """Global scale sigmoid activation.
+    """Apply sigmoid activation for global scaling.
 
     Args:
         input_tensor (torch.Tensor): Input tensor
 
     Returns:
-        Tensor: Sigmoid activation
+        torch.Tensor: Scaled tensor after sigmoid activation
     """
     return 10 * torch.sigmoid(input_tensor - 2.0)
 
 
 def _global_scale_softplus_activation(input_tensor: torch.Tensor) -> torch.Tensor:
-    """Global scale softplus activation.
+    """Apply softplus activation for global scaling.
 
     Args:
         input_tensor (torch.Tensor): Input tensor
 
     Returns:
-        Tensor: Softplus activation
+        torch.Tensor: Scaled tensor after softplus activation
     """
     softplus = nn.Softplus(beta=0.5)
     return 0.1 * softplus(input_tensor)
 
 
 def _global_scale_exp_activation(input_tensor: torch.Tensor) -> torch.Tensor:
-    """Global scale exponential activation.
+    """Apply exponential activation for global scaling.
 
     Args:
         input_tensor (torch.Tensor): Input tensor
 
     Returns:
-        Tensor: Exponential activation
+        torch.Tensor: Scaled tensor after exponential activation
     """
     return torch.exp(input_tensor)
 
 
 class AllInOneBlock(InvertibleModule):
-    r"""Module combining the most common operations in a normalizing flow or similar model.
+    r"""Module combining common operations in normalizing flows.
 
-    It combines affine coupling, permutation, and global affine transformation
-    ('ActNorm'). It can also be used as GIN coupling block, perform learned
-    householder permutations, and use an inverted pre-permutation. The affine
-    transformation includes a soft clamping mechanism, first used in Real-NVP.
-    The block as a whole performs the following computation:
+    This block combines affine coupling, permutation, and global affine
+    transformation ('ActNorm'). It supports:
 
-    .. math::
-
-        y = V R \; \Psi(s_\mathrm{global}) \odot \mathrm{Coupling}\Big(R^{-1} V^{-1} x\Big)+ t_\mathrm{global}
-
-    - The inverse pre-permutation of x (i.e. :math:`R^{-1} V^{-1}`) is optional (see
-      ``reverse_permutation`` below).
-    - The learned householder reflection matrix
-      :math:`V` is also optional all together (see ``learned_householder_permutation``
-      below).
-    - For the coupling, the input is split into :math:`x_1, x_2` along
-      the channel dimension. Then the output of the coupling operation is the
-      two halves :math:`u = \mathrm{concat}(u_1, u_2)`.
-
-      .. math::
-
-          u_1 &= x_1 \odot \exp \Big( \alpha \; \mathrm{tanh}\big( s(x_2) \big)\Big) + t(x_2) \\
-          u_2 &= x_2
-
-      Because :math:`\mathrm{tanh}(s) \in [-1, 1]`, this clamping mechanism prevents
-      exploding values in the exponential. The hyperparameter :math:`\alpha` can be adjusted.
+    - GIN coupling blocks
+    - Learned householder permutations
+    - Inverted pre-permutation
+    - Soft clamping mechanism from Real-NVP
 
     Args:
-        subnet_constructor: class or callable ``f``, called as ``f(channels_in, channels_out)`` and
-            should return a torch.nn.Module. Predicts coupling coefficients :math:`s, t`.
-        affine_clamping: clamp the output of the multiplicative coefficients before
-            exponentiation to +/- ``affine_clamping`` (see :math:`\alpha` above).
-        gin_block: Turn the block into a GIN block from Sorrenson et al, 2019.
-            Makes it so that the coupling operations as a whole is volume preserving.
-        global_affine_init: Initial value for the global affine scaling :math:`s_\mathrm{global}`.
-        global_affine_init: ``'SIGMOID'``, ``'SOFTPLUS'``, or ``'EXP'``. Defines the activation to be used
-            on the beta for the global affine scaling (:math:`\Psi` above).
-        permute_soft: bool, whether to sample the permutation matrix :math:`R` from :math:`SO(N)`,
-            or to use hard permutations instead. Note, ``permute_soft=True`` is very slow
-            when working with >512 dimensions.
-        learned_householder_permutation: Int, if >0, turn on the matrix :math:`V` above, that represents
-            multiple learned householder reflections. Slow if large number.
-            Dubious whether it actually helps network performance.
-        reverse_permutation: Reverse the permutation before the block, as introduced by Putzky
-            et al, 2019. Turns on the :math:`R^{-1} V^{-1}` pre-multiplication above.
+        dims_in (list[tuple[int]]): Dimensions of input tensor(s)
+        dims_c (list[tuple[int]], optional): Dimensions of conditioning
+            tensor(s). Defaults to None.
+        subnet_constructor (Callable, optional): Function that constructs the
+            subnet, called as ``f(channels_in, channels_out)``. Defaults to None.
+        affine_clamping (float, optional): Clamping value for affine coupling.
+            Defaults to 2.0.
+        gin_block (bool, optional): Use GIN coupling from Sorrenson et al, 2019.
+            Defaults to False.
+        global_affine_init (float, optional): Initial value for global affine
+            scaling. Defaults to 1.0.
+        global_affine_type (str, optional): Type of activation for global affine
+            scaling. One of ``'SIGMOID'``, ``'SOFTPLUS'``, ``'EXP'``.
+            Defaults to ``'SOFTPLUS'``.
+        permute_soft (bool, optional): Use soft permutation matrix from SO(N).
+            Defaults to False.
+        learned_householder_permutation (int, optional): Number of learned
+            householder reflections. Defaults to 0.
+        reverse_permutation (bool, optional): Apply inverse permutation before
+            block. Defaults to False.
+
+    Raises:
+        ValueError: If ``subnet_constructor`` is None or dimensions are invalid.
     """
 
     def __init__(
@@ -215,7 +272,11 @@ def __init__(
         self.last_jac = None
 
     def _construct_householder_permutation(self) -> torch.Tensor:
-        """Compute a permutation matrix from the reflection vectors that are learned internally as nn.Parameters."""
+        """Compute permutation matrix from learned reflection vectors.
+
+        Returns:
+            torch.Tensor: Constructed permutation matrix
+        """
         w = self.w_0
         for vk in self.vk_householder:
             w = torch.mm(w, torch.eye(self.in_channels).to(w.device) - 2 * torch.ger(vk, vk) / torch.dot(vk, vk))
@@ -225,16 +286,15 @@ def _construct_householder_permutation(self) -> torch.Tensor:
         return w
 
     def _permute(self, x: torch.Tensor, rev: bool = False) -> tuple[Any, float | torch.Tensor]:
-        """Perform the permutation and scaling after the coupling operation.
-
-        Returns transformed outputs and the LogJacDet of the scaling operation.
+        """Perform permutation and scaling after coupling operation.
 
         Args:
             x (torch.Tensor): Input tensor
             rev (bool, optional): Reverse the permutation. Defaults to False.
 
         Returns:
-            tuple[Any, float | torch.Tensor]: Transformed outputs and the LogJacDet of the scaling operation.
+            tuple[Any, float | torch.Tensor]: Transformed outputs and LogJacDet
+                of scaling
         """
         if self.GIN:
             scale = 1.0
@@ -249,9 +309,16 @@ def _permute(self, x: torch.Tensor, rev: bool = False) -> tuple[Any, float | tor
         return (self.permute_function(x * scale + self.global_offset, self.w_perm), perm_log_jac)
 
     def _pre_permute(self, x: torch.Tensor, rev: bool = False) -> torch.Tensor:
-        """Permute before the coupling block.
+        """Permute before coupling block.
+
+        Only used if ``reverse_permutation`` is True.
+
+        Args:
+            x (torch.Tensor): Input tensor
+            rev (bool, optional): Reverse the permutation. Defaults to False.
 
-        It is only used if reverse_permutation is set.
+        Returns:
+            torch.Tensor: Permuted tensor
         """
         if rev:
             return self.permute_function(x, self.w_perm)
@@ -261,9 +328,13 @@ def _pre_permute(self, x: torch.Tensor, rev: bool = False) -> torch.Tensor:
     def _affine(self, x: torch.Tensor, a: torch.Tensor, rev: bool = False) -> tuple[Any, torch.Tensor]:
         """Perform affine coupling operation.
 
-        Given the passive half, and the pre-activation outputs of the
-        coupling subnetwork, perform the affine coupling operation.
-        Returns both the transformed inputs and the LogJacDet.
+        Args:
+            x (torch.Tensor): Input tensor (passive half)
+            a (torch.Tensor): Coupling network outputs
+            rev (bool, optional): Reverse the operation. Defaults to False.
+
+        Returns:
+            tuple[Any, torch.Tensor]: Transformed tensor and LogJacDet
         """
         # the entire coupling coefficient tensor is scaled down by a
         # factor of ten for stability and easier initialization.
@@ -286,7 +357,18 @@ def forward(
         rev: bool = False,
         jac: bool = True,
     ) -> tuple[tuple[torch.Tensor], torch.Tensor]:
-        """See base class docstring."""
+        """Forward pass through the invertible block.
+
+        Args:
+            x (torch.Tensor): Input tensor
+            c (list, optional): Conditioning tensors. Defaults to None.
+            rev (bool, optional): Reverse the flow. Defaults to False.
+            jac (bool, optional): Compute Jacobian determinant. Defaults to True.
+
+        Returns:
+            tuple[tuple[torch.Tensor], torch.Tensor]: Tuple of (output tensors,
+                LogJacDet)
+        """
         del jac  # Unused argument.
 
         if c is None:
@@ -332,12 +414,12 @@ def forward(
 
     @staticmethod
     def output_dims(input_dims: list[tuple[int]]) -> list[tuple[int]]:
-        """Output dimensions of the layer.
+        """Get output dimensions of the layer.
 
         Args:
-            input_dims (list[tuple[int]]): Input dimensions.
+            input_dims (list[tuple[int]]): Input dimensions
 
         Returns:
-            list[tuple[int]]: Output dimensions.
+            list[tuple[int]]: Output dimensions
         """
         return input_dims
diff --git a/src/anomalib/models/components/layers/__init__.py b/src/anomalib/models/components/layers/__init__.py
index b2937cfe0c..131f2b2258 100644
--- a/src/anomalib/models/components/layers/__init__.py
+++ b/src/anomalib/models/components/layers/__init__.py
@@ -1,6 +1,23 @@
-"""Neural network layers."""
+"""Neural network layers used in anomaly detection models.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides custom neural network layer implementations that can be used
+as building blocks in anomaly detection models.
+
+Classes:
+    SSPCAB: Spatial-Spectral Pixel-Channel Attention Block layer that combines
+        spatial and channel attention mechanisms.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.layers import SSPCAB
+    >>> # Create attention layer
+    >>> attention = SSPCAB(in_channels=64)
+    >>> # Apply attention to input tensor
+    >>> input_tensor = torch.randn(1, 64, 32, 32)
+    >>> output = attention(input_tensor)
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .sspcab import SSPCAB
diff --git a/src/anomalib/models/components/layers/sspcab.py b/src/anomalib/models/components/layers/sspcab.py
index ee8ce4e8b5..95d9acfa68 100644
--- a/src/anomalib/models/components/layers/sspcab.py
+++ b/src/anomalib/models/components/layers/sspcab.py
@@ -1,6 +1,21 @@
-"""SSPCAB: Self-Supervised Predictive Convolutional Attention Block for reconstruction-based models.
-
-Paper https://arxiv.org/abs/2111.09099
+"""SSPCAB: Self-Supervised Predictive Convolutional Attention Block.
+
+This module implements the SSPCAB architecture from the paper:
+"SSPCAB: Self-Supervised Predictive Convolutional Attention Block for
+Reconstruction-Based Anomaly Detection"
+(https://arxiv.org/abs/2111.09099)
+
+The SSPCAB combines masked convolutions with channel attention to learn
+spatial-spectral feature representations for anomaly detection.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.layers import SSPCAB
+    >>> # Create SSPCAB layer
+    >>> sspcab = SSPCAB(in_channels=64)
+    >>> # Apply attention to input tensor
+    >>> x = torch.randn(1, 64, 32, 32)
+    >>> output = sspcab(x)
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -14,9 +29,23 @@
 class AttentionModule(nn.Module):
     """Squeeze and excitation block that acts as the attention module in SSPCAB.
 
+    This module applies channel attention through global average pooling followed
+    by two fully connected layers with non-linearities.
+
     Args:
-        channels (int): Number of input channels.
-        reduction_ratio (int): Reduction ratio of the attention module.
+        in_channels (int): Number of input channels.
+        reduction_ratio (int, optional): Reduction ratio for the intermediate
+            layer. The intermediate layer will have ``in_channels //
+            reduction_ratio`` channels. Defaults to 8.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.components.layers.sspcab import AttentionModule
+        >>> attention = AttentionModule(in_channels=64)
+        >>> x = torch.randn(1, 64, 32, 32)
+        >>> output = attention(x)
+        >>> output.shape
+        torch.Size([1, 64, 32, 32])
     """
 
     def __init__(self, in_channels: int, reduction_ratio: int = 8) -> None:
@@ -27,7 +56,15 @@ def __init__(self, in_channels: int, reduction_ratio: int = 8) -> None:
         self.fc2 = nn.Linear(out_channels, in_channels)
 
     def forward(self, inputs: torch.Tensor) -> torch.Tensor:
-        """Forward pass through the attention module."""
+        """Forward pass through the attention module.
+
+        Args:
+            inputs (torch.Tensor): Input tensor of shape
+                ``(batch_size, channels, height, width)``.
+
+        Returns:
+            torch.Tensor: Attended output tensor of same shape as input.
+        """
         # reduce feature map to 1d vector through global average pooling
         avg_pooled = inputs.mean(dim=(2, 3))
 
@@ -42,30 +79,78 @@ def forward(self, inputs: torch.Tensor) -> torch.Tensor:
 
 
 class SSPCAB(nn.Module):
-    """SSPCAB block.
+    """Self-Supervised Predictive Convolutional Attention Block.
+
+    This module combines masked convolutions with channel attention to capture
+    spatial and channel dependencies in the feature maps.
 
     Args:
         in_channels (int): Number of input channels.
-        kernel_size (int): Size of the receptive fields of the masked convolution kernel.
-        dilation (int): Dilation factor of the masked convolution kernel.
-        reduction_ratio (int): Reduction ratio of the attention module.
+        kernel_size (int, optional): Size of the receptive fields of the masked
+            convolution kernel. Defaults to 1.
+        dilation (int, optional): Dilation factor of the masked convolution
+            kernel. Defaults to 1.
+        reduction_ratio (int, optional): Reduction ratio of the attention module.
+            Defaults to 8.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.components.layers import SSPCAB
+        >>> sspcab = SSPCAB(in_channels=64, kernel_size=3)
+        >>> x = torch.randn(1, 64, 32, 32)
+        >>> output = sspcab(x)
+        >>> output.shape
+        torch.Size([1, 64, 32, 32])
     """
 
-    def __init__(self, in_channels: int, kernel_size: int = 1, dilation: int = 1, reduction_ratio: int = 8) -> None:
+    def __init__(
+        self,
+        in_channels: int,
+        kernel_size: int = 1,
+        dilation: int = 1,
+        reduction_ratio: int = 8,
+    ) -> None:
         super().__init__()
 
         self.pad = kernel_size + dilation
         self.crop = kernel_size + 2 * dilation + 1
 
-        self.masked_conv1 = nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=kernel_size)
-        self.masked_conv2 = nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=kernel_size)
-        self.masked_conv3 = nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=kernel_size)
-        self.masked_conv4 = nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=kernel_size)
-
-        self.attention_module = AttentionModule(in_channels=in_channels, reduction_ratio=reduction_ratio)
+        self.masked_conv1 = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=in_channels,
+            kernel_size=kernel_size,
+        )
+        self.masked_conv2 = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=in_channels,
+            kernel_size=kernel_size,
+        )
+        self.masked_conv3 = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=in_channels,
+            kernel_size=kernel_size,
+        )
+        self.masked_conv4 = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=in_channels,
+            kernel_size=kernel_size,
+        )
+
+        self.attention_module = AttentionModule(
+            in_channels=in_channels,
+            reduction_ratio=reduction_ratio,
+        )
 
     def forward(self, inputs: torch.Tensor) -> torch.Tensor:
-        """Forward pass through the SSPCAB block."""
+        """Forward pass through the SSPCAB block.
+
+        Args:
+            inputs (torch.Tensor): Input tensor of shape
+                ``(batch_size, channels, height, width)``.
+
+        Returns:
+            torch.Tensor: Output tensor of same shape as input.
+        """
         # compute masked convolution
         padded = F.pad(inputs, (self.pad,) * 4)
         masked_out = torch.zeros_like(inputs)
diff --git a/src/anomalib/models/components/sampling/__init__.py b/src/anomalib/models/components/sampling/__init__.py
index 47c842123f..28c3df81c7 100644
--- a/src/anomalib/models/components/sampling/__init__.py
+++ b/src/anomalib/models/components/sampling/__init__.py
@@ -1,6 +1,23 @@
-"""Sampling methods."""
+"""Sampling methods for anomaly detection models.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides sampling techniques used in anomaly detection models to
+select representative samples from datasets.
+
+Classes:
+    KCenterGreedy: K-center greedy sampling algorithm that selects diverse and
+        representative samples.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.sampling import KCenterGreedy
+    >>> # Create sampler
+    >>> sampler = KCenterGreedy()
+    >>> # Sample from feature embeddings
+    >>> features = torch.randn(100, 512)  # 100 samples with 512 dimensions
+    >>> selected_idx = sampler.select_coreset(features, n=10)
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .k_center_greedy import KCenterGreedy
diff --git a/src/anomalib/models/components/sampling/k_center_greedy.py b/src/anomalib/models/components/sampling/k_center_greedy.py
index d7ca314f33..51e29239c7 100644
--- a/src/anomalib/models/components/sampling/k_center_greedy.py
+++ b/src/anomalib/models/components/sampling/k_center_greedy.py
@@ -1,7 +1,9 @@
 """k-Center Greedy Method.
 
 Returns points that minimizes the maximum distance of any point to a center.
-- https://arxiv.org/abs/1708.00489
+
+Reference:
+    - https://arxiv.org/abs/1708.00489
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -15,16 +17,28 @@
 
 
 class KCenterGreedy:
-    """Implements k-center-greedy method.
+    """k-center-greedy method for coreset selection.
+
+    This class implements the k-center-greedy method to select a coreset from an
+    embedding space. The method aims to minimize the maximum distance between any
+    point and its nearest center.
 
     Args:
-        embedding (torch.Tensor): Embedding vector extracted from a CNN
-        sampling_ratio (float): Ratio to choose coreset size from the embedding size.
+        embedding (torch.Tensor): Embedding tensor extracted from a CNN.
+        sampling_ratio (float): Ratio to determine coreset size from embedding size.
+
+    Attributes:
+        embedding (torch.Tensor): Input embedding tensor.
+        coreset_size (int): Size of the coreset to be selected.
+        model (SparseRandomProjection): Dimensionality reduction model.
+        features (torch.Tensor): Transformed features after dimensionality reduction.
+        min_distances (torch.Tensor): Minimum distances to cluster centers.
+        n_observations (int): Number of observations in the embedding.
 
     Example:
-        >>> embedding.shape
-        torch.Size([219520, 1536])
-        >>> sampler = KCenterGreedy(embedding=embedding)
+        >>> import torch
+        >>> embedding = torch.randn(219520, 1536)
+        >>> sampler = KCenterGreedy(embedding=embedding, sampling_ratio=0.001)
         >>> sampled_idxs = sampler.select_coreset_idxs()
         >>> coreset = embedding[sampled_idxs]
         >>> coreset.shape
@@ -41,14 +55,14 @@ def __init__(self, embedding: torch.Tensor, sampling_ratio: float) -> None:
         self.n_observations = self.embedding.shape[0]
 
     def reset_distances(self) -> None:
-        """Reset minimum distances."""
+        """Reset minimum distances to None."""
         self.min_distances = None
 
     def update_distances(self, cluster_centers: list[int]) -> None:
-        """Update min distances given cluster centers.
+        """Update minimum distances given cluster centers.
 
         Args:
-            cluster_centers (list[int]): indices of cluster centers
+            cluster_centers (list[int]): Indices of cluster centers.
         """
         if cluster_centers:
             centers = self.features[cluster_centers]
@@ -61,12 +75,13 @@ def update_distances(self, cluster_centers: list[int]) -> None:
                 self.min_distances = torch.minimum(self.min_distances, distance)
 
     def get_new_idx(self) -> int:
-        """Get index value of a sample.
-
-        Based on minimum distance of the cluster
+        """Get index of the next sample based on maximum minimum distance.
 
         Returns:
-            int: Sample index
+            int: Index of the selected sample.
+
+        Raises:
+            TypeError: If `self.min_distances` is not a torch.Tensor.
         """
         if isinstance(self.min_distances, torch.Tensor):
             idx = int(torch.argmax(self.min_distances).item())
@@ -77,13 +92,18 @@ def get_new_idx(self) -> int:
         return idx
 
     def select_coreset_idxs(self, selected_idxs: list[int] | None = None) -> list[int]:
-        """Greedily form a coreset to minimize the maximum distance of a cluster.
+        """Greedily form a coreset to minimize maximum distance to cluster centers.
 
         Args:
-            selected_idxs: index of samples already selected. Defaults to an empty set.
+            selected_idxs (list[int] | None, optional): Indices of pre-selected
+                samples. Defaults to None.
 
         Returns:
-          indices of samples selected to minimize distance to cluster centers
+            list[int]: Indices of samples selected to minimize distance to cluster
+                centers.
+
+        Raises:
+            ValueError: If a newly selected index is already in `selected_idxs`.
         """
         if selected_idxs is None:
             selected_idxs = []
@@ -113,15 +133,16 @@ def sample_coreset(self, selected_idxs: list[int] | None = None) -> torch.Tensor
         """Select coreset from the embedding.
 
         Args:
-            selected_idxs: index of samples already selected. Defaults to an empty set.
+            selected_idxs (list[int] | None, optional): Indices of pre-selected
+                samples. Defaults to None.
 
         Returns:
-            Tensor: Output coreset
+            torch.Tensor: Selected coreset.
 
         Example:
-            >>> embedding.shape
-            torch.Size([219520, 1536])
-            >>> sampler = KCenterGreedy(...)
+            >>> import torch
+            >>> embedding = torch.randn(219520, 1536)
+            >>> sampler = KCenterGreedy(embedding=embedding, sampling_ratio=0.001)
             >>> coreset = sampler.sample_coreset()
             >>> coreset.shape
             torch.Size([219, 1536])
diff --git a/src/anomalib/models/components/stats/__init__.py b/src/anomalib/models/components/stats/__init__.py
index c65aef1caf..60f5f340fe 100644
--- a/src/anomalib/models/components/stats/__init__.py
+++ b/src/anomalib/models/components/stats/__init__.py
@@ -1,6 +1,26 @@
-"""Statistical functions."""
+"""Statistical functions for anomaly detection models.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides statistical methods used in anomaly detection models for
+density estimation and probability modeling.
+
+Classes:
+    GaussianKDE: Gaussian kernel density estimation for non-parametric density
+        estimation.
+    MultiVariateGaussian: Multivariate Gaussian distribution for parametric
+        density modeling.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.stats import GaussianKDE
+    >>> # Create density estimator
+    >>> kde = GaussianKDE()
+    >>> # Fit and evaluate density
+    >>> features = torch.randn(100, 10)  # 100 samples, 10 dimensions
+    >>> kde.fit(features)
+    >>> density = kde.predict(features)
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .kde import GaussianKDE
diff --git a/src/anomalib/models/components/stats/kde.py b/src/anomalib/models/components/stats/kde.py
index d9bae9ec81..9903277a18 100644
--- a/src/anomalib/models/components/stats/kde.py
+++ b/src/anomalib/models/components/stats/kde.py
@@ -1,4 +1,18 @@
-"""Gaussian Kernel Density Estimation."""
+"""Gaussian Kernel Density Estimation.
+
+This module implements non-parametric density estimation using Gaussian kernels.
+The bandwidth is selected automatically using Scott's rule.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.stats import GaussianKDE
+    >>> # Create density estimator
+    >>> kde = GaussianKDE()
+    >>> # Fit and evaluate density
+    >>> features = torch.randn(100, 10)  # 100 samples, 10 dimensions
+    >>> kde.fit(features)
+    >>> density = kde.predict(features)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,8 +27,25 @@
 class GaussianKDE(DynamicBufferMixin):
     """Gaussian Kernel Density Estimation.
 
+    Estimates probability density using a Gaussian kernel function. The bandwidth
+    is selected automatically using Scott's rule.
+
     Args:
-        dataset (Tensor | None, optional): Dataset on which to fit the KDE model. Defaults to None.
+        dataset (torch.Tensor | None, optional): Dataset on which to fit the KDE
+            model. If provided, the model will be fitted immediately.
+            Defaults to ``None``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.components.stats import GaussianKDE
+        >>> features = torch.randn(100, 10)  # 100 samples, 10 dimensions
+        >>> # Initialize and fit in one step
+        >>> kde = GaussianKDE(dataset=features)
+        >>> # Or fit later
+        >>> kde = GaussianKDE()
+        >>> kde.fit(features)
+        >>> # Get density estimates
+        >>> density = kde(features)
     """
 
     def __init__(self, dataset: torch.Tensor | None = None) -> None:
@@ -32,12 +63,22 @@ def __init__(self, dataset: torch.Tensor | None = None) -> None:
         self.norm = torch.Tensor()
 
     def forward(self, features: torch.Tensor) -> torch.Tensor:
-        """Get the KDE estimates from the feature map.
+        """Compute KDE estimates for the input features.
 
         Args:
-          features (torch.Tensor): Feature map extracted from the CNN
+            features (torch.Tensor): Feature tensor of shape ``(N, D)`` where
+                ``N`` is the number of samples and ``D`` is the dimension.
 
-        Returns: KDE Estimates
+        Returns:
+            torch.Tensor: Density estimates for each input sample, shape ``(N,)``.
+
+        Example:
+            >>> kde = GaussianKDE()
+            >>> features = torch.randn(100, 10)
+            >>> kde.fit(features)
+            >>> estimates = kde(features)
+            >>> estimates.shape
+            torch.Size([100])
         """
         features = torch.matmul(features, self.bw_transform)
 
@@ -50,13 +91,19 @@ def forward(self, features: torch.Tensor) -> torch.Tensor:
         return estimate
 
     def fit(self, dataset: torch.Tensor) -> None:
-        """Fit a KDE model to the input dataset.
+        """Fit the KDE model to the input dataset.
+
+        Computes the bandwidth matrix using Scott's rule and transforms the data
+        accordingly.
 
         Args:
-          dataset (torch.Tensor): Input dataset.
+            dataset (torch.Tensor): Input dataset of shape ``(N, D)`` where ``N``
+                is the number of samples and ``D`` is the dimension.
 
-        Returns:
-            None
+        Example:
+            >>> kde = GaussianKDE()
+            >>> features = torch.randn(100, 10)
+            >>> kde.fit(features)
         """
         num_samples, dimension = dataset.shape
 
@@ -83,10 +130,17 @@ def cov(tensor: torch.Tensor) -> torch.Tensor:
         """Calculate the unbiased covariance matrix.
 
         Args:
-            tensor (torch.Tensor): Input tensor from which covariance matrix is computed.
+            tensor (torch.Tensor): Input tensor of shape ``(D, N)`` where ``D``
+                is the dimension and ``N`` is the number of samples.
 
         Returns:
-            Output covariance matrix.
+            torch.Tensor: Covariance matrix of shape ``(D, D)``.
+
+        Example:
+            >>> x = torch.randn(5, 100)  # 5 dimensions, 100 samples
+            >>> cov_matrix = GaussianKDE.cov(x)
+            >>> cov_matrix.shape
+            torch.Size([5, 5])
         """
         mean = torch.mean(tensor, dim=1)
         tensor -= mean[:, None]
diff --git a/src/anomalib/models/components/stats/multi_variate_gaussian.py b/src/anomalib/models/components/stats/multi_variate_gaussian.py
index b05edfb827..3a3b05faed 100644
--- a/src/anomalib/models/components/stats/multi_variate_gaussian.py
+++ b/src/anomalib/models/components/stats/multi_variate_gaussian.py
@@ -1,4 +1,20 @@
-"""Multi Variate Gaussian Distribution."""
+"""Multi Variate Gaussian Distribution.
+
+This module implements parametric density estimation using a multivariate Gaussian
+distribution. It estimates the mean and covariance matrix from input features.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.components.stats import MultiVariateGaussian
+    >>> # Create distribution estimator
+    >>> mvg = MultiVariateGaussian()
+    >>> # Fit distribution to features
+    >>> features = torch.randn(100, 64, 32, 32)  # B x C x H x W
+    >>> mean, inv_cov = mvg.fit(features)
+    >>> # Access distribution parameters
+    >>> print(mean.shape)      # [64, 1024]
+    >>> print(inv_cov.shape)   # [1024, 64, 64]
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,9 +28,24 @@
 
 
 class MultiVariateGaussian(DynamicBufferMixin, nn.Module):
-    """Multi Variate Gaussian Distribution."""
+    """Multi Variate Gaussian Distribution.
+
+    Estimates a multivariate Gaussian distribution by computing the mean and
+    covariance matrix from input feature embeddings. The distribution parameters
+    are stored as buffers.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.components.stats import MultiVariateGaussian
+        >>> mvg = MultiVariateGaussian()
+        >>> features = torch.randn(100, 64, 32, 32)  # B x C x H x W
+        >>> mean, inv_cov = mvg.fit(features)
+        >>> print(mean.shape)      # [64, 1024]
+        >>> print(inv_cov.shape)   # [1024, 64, 64]
+    """
 
     def __init__(self) -> None:
+        """Initialize empty buffers for mean and inverse covariance."""
         super().__init__()
 
         self.register_buffer("mean", torch.empty(0))
@@ -31,33 +62,27 @@ def _cov(
         ddof: int | None = None,
         aweights: torch.Tensor | None = None,
     ) -> torch.Tensor:
-        """Estimates covariance matrix like numpy.cov.
+        """Estimate covariance matrix similar to numpy.cov.
 
         Args:
-            observations (torch.Tensor): A 1-D or 2-D array containing multiple variables and observations.
-                 Each row of `m` represents a variable, and each column a single
-                 observation of all those variables. Also see `rowvar` below.
-            rowvar (bool): If `rowvar` is True (default), then each row represents a
-                variable, with observations in the columns. Otherwise, the relationship
-                is transposed: each column represents a variable, while the rows
-                contain observations. Defaults to False.
-            bias (bool): Default normalization (False) is by ``(N - 1)``, where ``N`` is the
-                number of observations given (unbiased estimate). If `bias` is True,
-                then normalization is by ``N``. These values can be overridden by using
-                the keyword ``ddof`` in numpy versions >= 1.5. Defaults to False
-            ddof (int | None): If not ``None`` the default value implied by `bias` is overridden.
-                Note that ``ddof=1`` will return the unbiased estimate, even if both
-                `fweights` and `aweights` are specified, and ``ddof=0`` will return
-                the simple average. See the notes for the details. The default value
-                is ``None``.
-            aweights (torch.Tensor): 1-D array of observation vector weights. These relative weights are
-                typically large for observations considered "important" and smaller for
-                observations considered less "important". If ``ddof=0`` the array of
-                weights can be used to assign probabilities to observation vectors. (Default value = None)
-
+            observations: A 1-D or 2-D tensor containing multiple variables and
+                observations. Each row represents a variable, and each column a
+                single observation of all variables if ``rowvar=True``. The
+                relationship is transposed if ``rowvar=False``.
+            rowvar: If ``True``, each row represents a variable. If ``False``,
+                each column represents a variable. Defaults to ``False``.
+            bias: If ``False`` (default), normalize by ``(N-1)`` for unbiased
+                estimate. If ``True``, normalize by ``N``. Can be overridden by
+                ``ddof``.
+            ddof: Delta degrees of freedom. If not ``None``, overrides ``bias``.
+                ``ddof=1`` gives unbiased estimate, ``ddof=0`` gives simple
+                average.
+            aweights: Optional 1-D tensor of observation weights. Larger weights
+                indicate more "important" observations. If ``ddof=0``, weights
+                are treated as observation probabilities.
 
         Returns:
-          The covariance matrix of the variables.
+            Covariance matrix of the variables.
         """
         # ensure at least 2D
         if observations.dim() == 1:
@@ -75,7 +100,7 @@ def _cov(
 
         if weights is not None:
             if not torch.is_tensor(weights):
-                weights = torch.tensor(weights, dtype=torch.float)  # pylint: disable=not-callable
+                weights = torch.tensor(weights, dtype=torch.float)
             weights_sum = torch.sum(weights)
             avg = torch.sum(observations * (weights / weights_sum)[:, None], 0)
         else:
@@ -101,13 +126,20 @@ def _cov(
         return covariance.squeeze()
 
     def forward(self, embedding: torch.Tensor) -> list[torch.Tensor]:
-        """Calculate multivariate Gaussian distribution.
+        """Calculate multivariate Gaussian distribution parameters.
+
+        Computes the mean and inverse covariance matrix from input feature
+        embeddings. A small regularization term (0.01) is added to the diagonal
+        of the covariance matrix for numerical stability.
 
         Args:
-          embedding (torch.Tensor): CNN features whose dimensionality is reduced via either random sampling or PCA.
+            embedding: Input tensor of shape ``(B, C, H, W)`` containing CNN
+                feature embeddings.
 
         Returns:
-          mean and inverse covariance of the multi-variate gaussian distribution that fits the features.
+            List containing:
+                - Mean tensor of shape ``(C, H*W)``
+                - Inverse covariance tensor of shape ``(H*W, C, C)``
         """
         device = embedding.device
 
@@ -125,12 +157,16 @@ def forward(self, embedding: torch.Tensor) -> list[torch.Tensor]:
         return [self.mean, self.inv_covariance]
 
     def fit(self, embedding: torch.Tensor) -> list[torch.Tensor]:
-        """Fit multi-variate gaussian distribution to the input embedding.
+        """Fit multivariate Gaussian distribution to input embeddings.
+
+        Convenience method that calls ``forward()`` to compute distribution
+        parameters.
 
         Args:
-            embedding (torch.Tensor): Embedding vector extracted from CNN.
+            embedding: Input tensor of shape ``(B, C, H, W)`` containing CNN
+                feature embeddings.
 
         Returns:
-            Mean and the covariance of the embedding.
+            List containing the mean and inverse covariance tensors.
         """
         return self.forward(embedding)
diff --git a/src/anomalib/models/image/__init__.py b/src/anomalib/models/image/__init__.py
index c8ce0987b2..388c6002a7 100644
--- a/src/anomalib/models/image/__init__.py
+++ b/src/anomalib/models/image/__init__.py
@@ -1,6 +1,39 @@
-"""Anomalib Image Models."""
+"""Anomalib Image Models.
 
-# Copyright (C) 2023 Intel Corporation
+This module contains implementations of various deep learning models for image-based
+anomaly detection.
+
+Example:
+    >>> from anomalib.models.image import Padim, Patchcore
+    >>> # Initialize a model
+    >>> model = Padim()  # doctest: +SKIP
+    >>> # Train on normal images
+    >>> model.fit(["normal1.jpg", "normal2.jpg"])  # doctest: +SKIP
+    >>> # Get predictions
+    >>> predictions = model.predict("test.jpg")  # doctest: +SKIP
+
+Available Models:
+    - :class:`Cfa`: Contrastive Feature Aggregation
+    - :class:`Cflow`: Conditional Normalizing Flow
+    - :class:`Csflow`: Conditional Split Flow
+    - :class:`Dfkde`: Deep Feature Kernel Density Estimation
+    - :class:`Dfm`: Deep Feature Modeling
+    - :class:`Draem`: Dual Reconstruction by Adversarial Masking
+    - :class:`Dsr`: Deep Spatial Reconstruction
+    - :class:`EfficientAd`: Efficient Anomaly Detection
+    - :class:`Fastflow`: Fast Flow
+    - :class:`Fre`: Feature Reconstruction Error
+    - :class:`Ganomaly`: Generative Adversarial Networks
+    - :class:`Padim`: Patch Distribution Modeling
+    - :class:`Patchcore`: Patch Core
+    - :class:`ReverseDistillation`: Reverse Knowledge Distillation
+    - :class:`Stfpm`: Student-Teacher Feature Pyramid Matching
+    - :class:`Uflow`: Unsupervised Flow
+    - :class:`VlmAd`: Vision Language Model Anomaly Detection
+    - :class:`WinClip`: Zero-/Few-Shot CLIP-based Detection
+"""
+
+# Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .cfa import Cfa
diff --git a/src/anomalib/models/image/cfa/__init__.py b/src/anomalib/models/image/cfa/__init__.py
index def95441cb..962612f974 100644
--- a/src/anomalib/models/image/cfa/__init__.py
+++ b/src/anomalib/models/image/cfa/__init__.py
@@ -1,8 +1,23 @@
-"""Implementatation of the CFA Model.
+"""Implementation of the CFA (Coupled-hypersphere-based Feature Adaptation) model.
 
-CFA: Coupled-hypersphere-based Feature Adaptation for Target-Oriented Anomaly Localization
+This module provides the CFA model for target-oriented anomaly localization. CFA
+learns discriminative features by adapting them to coupled hyperspheres in the
+feature space.
 
-Paper https://arxiv.org/abs/2206.04325
+The model uses a teacher-student architecture where the teacher network extracts
+features from normal samples to guide the student network in learning
+anomaly-sensitive representations.
+
+Paper: https://arxiv.org/abs/2206.04325
+
+Example:
+    >>> from anomalib.models.image import Cfa
+    >>> # Initialize the model
+    >>> model = Cfa()
+    >>> # Train on normal samples
+    >>> model.fit(normal_samples)
+    >>> # Get anomaly predictions
+    >>> predictions = model.predict(test_samples)
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
diff --git a/src/anomalib/models/image/cfa/anomaly_map.py b/src/anomalib/models/image/cfa/anomaly_map.py
index 5c35881c83..8f65c21f9c 100644
--- a/src/anomalib/models/image/cfa/anomaly_map.py
+++ b/src/anomalib/models/image/cfa/anomaly_map.py
@@ -1,4 +1,18 @@
-"""Anomaly Map Generator for the CFA model implementation."""
+"""Anomaly Map Generator for the CFA model implementation.
+
+This module provides functionality to generate anomaly heatmaps from distance
+features computed by the CFA model.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.cfa.anomaly_map import AnomalyMapGenerator
+    >>> # Initialize generator
+    >>> generator = AnomalyMapGenerator(num_nearest_neighbors=3)
+    >>> # Generate anomaly map
+    >>> distance = torch.randn(1, 1024, 1)  # batch x pixels x 1
+    >>> scale = (32, 32)  # height x width
+    >>> anomaly_map = generator(distance=distance, scale=scale)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,7 +26,24 @@
 
 
 class AnomalyMapGenerator(nn.Module):
-    """Generate Anomaly Heatmap."""
+    """Generate anomaly heatmaps from distance features.
+
+    The generator computes anomaly scores based on k-nearest neighbor distances
+    and applies Gaussian smoothing to produce the final heatmap.
+
+    Args:
+        num_nearest_neighbors (int): Number of nearest neighbors to consider
+            when computing anomaly scores.
+        sigma (int, optional): Standard deviation for Gaussian smoothing.
+            Defaults to ``4``.
+
+    Example:
+        >>> import torch
+        >>> generator = AnomalyMapGenerator(num_nearest_neighbors=3)
+        >>> distance = torch.randn(1, 1024, 1)  # batch x pixels x 1
+        >>> scale = (32, 32)  # height x width
+        >>> anomaly_map = generator(distance=distance, scale=scale)
+    """
 
     def __init__(
         self,
@@ -24,16 +55,17 @@ def __init__(
         self.sigma = sigma
 
     def compute_score(self, distance: torch.Tensor, scale: tuple[int, int]) -> torch.Tensor:
-        """Compute score based on the distance.
+        """Compute anomaly scores from distance features.
 
         Args:
-            distance (torch.Tensor): Distance tensor computed using target oriented
-                features.
-            scale (tuple[int, int]): Height and width of the largest feature
-                map.
+            distance (torch.Tensor): Distance tensor of shape
+                ``(batch_size, num_pixels, 1)``.
+            scale (tuple[int, int]): Height and width of the feature map used
+                to reshape the scores.
 
         Returns:
-            Tensor: Score value.
+            torch.Tensor: Anomaly scores of shape
+                ``(batch_size, 1, height, width)``.
         """
         distance = torch.sqrt(distance)
         distance = distance.topk(self.num_nearest_neighbors, largest=False).values  # noqa: PD011
@@ -48,14 +80,17 @@ def compute_anomaly_map(
         score: torch.Tensor,
         image_size: tuple[int, int] | torch.Size | None = None,
     ) -> torch.Tensor:
-        """Compute anomaly map based on the score.
+        """Generate smoothed anomaly map from scores.
 
         Args:
-            score (torch.Tensor): Score tensor.
-            image_size (tuple[int, int] | torch.Size | None, optional): Size of the input image.
+            score (torch.Tensor): Anomaly scores of shape
+                ``(batch_size, 1, height, width)``.
+            image_size (tuple[int, int] | torch.Size | None, optional): Target
+                size for upsampling the anomaly map. Defaults to ``None``.
 
         Returns:
-            Tensor: Anomaly map.
+            torch.Tensor: Smoothed anomaly map of shape
+                ``(batch_size, 1, height, width)``.
         """
         anomaly_map = score.mean(dim=1, keepdim=True)
         if image_size is not None:
@@ -65,16 +100,27 @@ def compute_anomaly_map(
         return gaussian_blur(anomaly_map)  # pylint: disable=not-callable
 
     def forward(self, **kwargs) -> torch.Tensor:
-        """Return anomaly map.
+        """Generate anomaly map from input features.
+
+        The method expects ``distance`` and ``scale`` as required inputs, with
+        optional ``image_size`` for upsampling.
+
+        Args:
+            **kwargs: Keyword arguments containing:
+                - distance (torch.Tensor): Distance features
+                - scale (tuple[int, int]): Feature map scale
+                - image_size (tuple[int, int] | torch.Size, optional):
+                    Target size for upsampling
 
         Raises:
-            ``distance`` and ``scale`` keys are not found.
+            ValueError: If required arguments are missing.
 
         Returns:
-            Tensor: Anomaly heatmap.
+            torch.Tensor: Anomaly heatmap of shape
+                ``(batch_size, 1, height, width)``.
         """
         if not ("distance" in kwargs and "scale" in kwargs):
-            msg = f"Expected keys `distance` and `scale. Found {kwargs.keys()}"
+            msg = f"Expected keys `distance` and `scale`. Found {kwargs.keys()}"
             raise ValueError(msg)
 
         distance: torch.Tensor = kwargs["distance"]
diff --git a/src/anomalib/models/image/cfa/lightning_model.py b/src/anomalib/models/image/cfa/lightning_model.py
index 9eed15b6a7..650a3277d4 100644
--- a/src/anomalib/models/image/cfa/lightning_model.py
+++ b/src/anomalib/models/image/cfa/lightning_model.py
@@ -1,8 +1,11 @@
-"""Lightning Implementatation of the CFA Model.
+"""Lightning Implementation of the CFA Model.
 
-CFA: Coupled-hypersphere-based Feature Adaptation for Target-Oriented Anomaly Localization
+CFA: Coupled-hypersphere-based Feature Adaptation for Target-Oriented Anomaly
+Localization.
 
-Paper https://arxiv.org/abs/2206.04325
+Paper: https://arxiv.org/abs/2206.04325
+
+This implementation uses PyTorch Lightning for training and inference.
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -31,24 +34,35 @@
 
 
 class Cfa(AnomalibModule):
-    """CFA: Coupled-hypersphere-based Feature Adaptation for Target-Oriented Anomaly Localization.
+    """CFA Lightning Module.
+
+    The CFA model performs anomaly detection and localization using coupled
+    hypersphere-based feature adaptation.
 
     Args:
-        backbone (str): Backbone CNN network
+        backbone (str): Name of the backbone CNN network.
             Defaults to ``"wide_resnet50_2"``.
-        gamma_c (int, optional): gamma_c value from the paper.
+        gamma_c (int, optional): Centroid loss weight parameter.
             Defaults to ``1``.
-        gamma_d (int, optional): gamma_d value from the paper.
+        gamma_d (int, optional): Distance loss weight parameter.
             Defaults to ``1``.
-        num_nearest_neighbors (int): Number of nearest neighbors.
+        num_nearest_neighbors (int): Number of nearest neighbors to consider.
             Defaults to ``3``.
-        num_hard_negative_features (int): Number of hard negative features.
+        num_hard_negative_features (int): Number of hard negative features to use.
             Defaults to ``3``.
-        radius (float): Radius of the hypersphere to search the soft boundary.
+        radius (float): Radius of the hypersphere for soft boundary search.
             Defaults to ``1e-5``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor instance or
+            boolean flag.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor instance or
+            boolean flag.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator instance or boolean flag.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer instance or boolean
+            flag.
+            Defaults to ``True``.
     """
 
     def __init__(
@@ -86,19 +100,23 @@ def __init__(
         )
 
     def on_train_start(self) -> None:
-        """Initialize the centroid for the memory bank computation."""
+        """Initialize the centroid for memory bank computation.
+
+        This method is called at the start of training to compute the initial
+        centroid using the training data.
+        """
         self.model.initialize_centroid(data_loader=self.trainer.datamodule.train_dataloader())
 
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the training step for the CFA model.
+        """Perform a training step.
 
         Args:
-            batch (Batch): Batch input.
-            *args: Arguments.
-            **kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and metadata.
+            *args: Additional positional arguments (unused).
+            **kwargs: Additional keyword arguments (unused).
 
         Returns:
-            STEP_OUTPUT: Loss value.
+            STEP_OUTPUT: Dictionary containing the loss value.
         """
         del args, kwargs  # These variables are not used.
 
@@ -107,15 +125,15 @@ def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         return {"loss": loss}
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the validation step for the CFA model.
+        """Perform a validation step.
 
         Args:
-            batch (Batch): Input batch.
-            *args: Arguments.
-            **kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and metadata.
+            *args: Additional positional arguments (unused).
+            **kwargs: Additional keyword arguments (unused).
 
         Returns:
-            dict: Anomaly map computed by the model.
+            STEP_OUTPUT: Batch object updated with model predictions.
         """
         del args, kwargs  # These variables are not used.
 
@@ -124,12 +142,16 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @staticmethod
     def backward(loss: torch.Tensor, *args, **kwargs) -> None:
-        """Perform backward-pass for the CFA model.
+        """Perform backward pass.
 
         Args:
-            loss (torch.Tensor): Loss value.
-            *args: Arguments.
-            **kwargs: Keyword arguments.
+            loss (torch.Tensor): Computed loss value.
+            *args: Additional positional arguments (unused).
+            **kwargs: Additional keyword arguments (unused).
+
+        Note:
+            Uses ``retain_graph=True`` due to computational graph requirements.
+            See CVS-122673 for more details.
         """
         del args, kwargs  # These variables are not used.
 
@@ -139,14 +161,24 @@ def backward(loss: torch.Tensor, *args, **kwargs) -> None:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """CFA specific trainer arguments."""
+        """Get CFA-specific trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary containing trainer configuration:
+                - ``gradient_clip_val``: Set to ``0`` to disable gradient clipping
+                - ``num_sanity_val_steps``: Set to ``0`` to skip validation sanity
+                  checks
+        """
         return {"gradient_clip_val": 0, "num_sanity_val_steps": 0}
 
     def configure_optimizers(self) -> torch.optim.Optimizer:
-        """Configure optimizers for the CFA Model.
+        """Configure the optimizer.
 
         Returns:
-            Optimizer: Adam optimizer for each decoder
+            torch.optim.Optimizer: AdamW optimizer configured with:
+                - Learning rate: ``1e-3``
+                - Weight decay: ``5e-4``
+                - AMSGrad: ``True``
         """
         return torch.optim.AdamW(
             params=self.model.parameters(),
@@ -157,9 +189,9 @@ def configure_optimizers(self) -> torch.optim.Optimizer:
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: Indicates this is a one-class classification model.
         """
         return LearningType.ONE_CLASS
diff --git a/src/anomalib/models/image/cfa/loss.py b/src/anomalib/models/image/cfa/loss.py
index 91b9d270f6..13e67a66d2 100644
--- a/src/anomalib/models/image/cfa/loss.py
+++ b/src/anomalib/models/image/cfa/loss.py
@@ -1,4 +1,23 @@
-"""Loss function for the Cfa Model Implementation."""
+"""Loss function for the CFA (Coupled-hypersphere-based Feature Adaptation) model.
+
+This module implements the loss function used to train the CFA model for anomaly
+detection. The loss consists of two components:
+    1. Attraction loss that pulls normal samples inside a hypersphere
+    2. Repulsion loss that pushes anomalous samples outside the hypersphere
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.cfa.loss import CfaLoss
+    >>> # Initialize loss function
+    >>> loss_fn = CfaLoss(
+    ...     num_nearest_neighbors=3,
+    ...     num_hard_negative_features=3,
+    ...     radius=0.5
+    ... )
+    >>> # Compute loss on distance tensor
+    >>> distance = torch.randn(2, 1024, 1)  # batch x pixels x 1
+    >>> loss = loss_fn(distance)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -8,12 +27,28 @@
 
 
 class CfaLoss(nn.Module):
-    """Cfa Loss.
+    """Loss function for the CFA model.
+
+    The loss encourages normal samples to lie within a hypersphere while pushing
+    anomalous samples outside. It uses k-nearest neighbors to identify the closest
+    samples and hard negative mining to find challenging anomalous examples.
 
     Args:
-        num_nearest_neighbors (int): Number of nearest neighbors.
-        num_hard_negative_features (int): Number of hard negative features.
-        radius (float): Radius of the hypersphere to search the soft boundary.
+        num_nearest_neighbors (int): Number of nearest neighbors to consider for
+            the attraction loss component.
+        num_hard_negative_features (int): Number of hard negative features to use
+            for the repulsion loss component.
+        radius (float): Initial radius of the hypersphere that defines the
+            decision boundary between normal and anomalous samples.
+
+    Example:
+        >>> loss_fn = CfaLoss(
+        ...     num_nearest_neighbors=3,
+        ...     num_hard_negative_features=3,
+        ...     radius=0.5
+        ... )
+        >>> distance = torch.randn(2, 1024, 1)  # batch x pixels x 1
+        >>> loss = loss_fn(distance)
     """
 
     def __init__(self, num_nearest_neighbors: int, num_hard_negative_features: int, radius: float) -> None:
@@ -23,13 +58,22 @@ def __init__(self, num_nearest_neighbors: int, num_hard_negative_features: int,
         self.radius = torch.ones(1, requires_grad=True) * radius
 
     def forward(self, distance: torch.Tensor) -> torch.Tensor:
-        """Compute the CFA loss.
+        """Compute the CFA loss given distance features.
+
+        The loss has two components:
+            1. Attraction loss (`l_att`): Encourages normal samples to lie within
+               the hypersphere by penalizing distances greater than `radius`.
+            2. Repulsion loss (`l_rep`): Pushes anomalous samples outside the
+               hypersphere by penalizing distances less than `radius + margin`.
 
         Args:
-            distance (torch.Tensor): Distance computed using target oriented features.
+            distance (torch.Tensor): Distance tensor of shape
+                ``(batch_size, num_pixels, 1)`` computed using target-oriented
+                features.
 
         Returns:
-            Tensor: CFA loss.
+            torch.Tensor: Scalar loss value combining attraction and repulsion
+                components.
         """
         num_neighbors = self.num_nearest_neighbors + self.num_hard_negative_features
         distance = distance.topk(num_neighbors, largest=False).values  # noqa: PD011
diff --git a/src/anomalib/models/image/cfa/torch_model.py b/src/anomalib/models/image/cfa/torch_model.py
index e36d53050e..799f273a02 100644
--- a/src/anomalib/models/image/cfa/torch_model.py
+++ b/src/anomalib/models/image/cfa/torch_model.py
@@ -1,8 +1,35 @@
-"""Torch Implementatation of the CFA Model.
-
-CFA: Coupled-hypersphere-based Feature Adaptation for Target-Oriented Anomaly Localization
-
-Paper https://arxiv.org/abs/2206.04325
+"""Torch Implementation of the CFA Model.
+
+CFA: Coupled-hypersphere-based Feature Adaptation for Target-Oriented Anomaly
+Localization.
+
+This module provides the PyTorch implementation of the CFA model for anomaly
+detection and localization. The model learns discriminative features by adapting
+them to coupled hyperspheres in the feature space.
+
+The model consists of:
+    - A backbone CNN feature extractor
+    - A descriptor network that generates target-oriented features
+    - A memory bank that stores prototypical normal features
+    - An anomaly map generator for localization
+
+Paper: https://arxiv.org/abs/2206.04325
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.cfa.torch_model import CfaModel
+    >>> # Initialize model
+    >>> model = CfaModel(
+    ...     backbone="resnet18",
+    ...     gamma_c=1,
+    ...     gamma_d=1,
+    ...     num_nearest_neighbors=3,
+    ...     num_hard_negative_features=3,
+    ...     radius=0.5
+    ... )
+    >>> # Forward pass
+    >>> x = torch.randn(32, 3, 256, 256)
+    >>> predictions = model(x)
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -30,18 +57,23 @@
 
 
 def get_return_nodes(backbone: str) -> list[str]:
-    """Get the return nodes for a given backbone.
+    """Get the return nodes for feature extraction from a backbone network.
 
     Args:
-        backbone (str): The name of the backbone. Must be one of
-            {"resnet18", "wide_resnet50_2", "vgg19_bn", "efficientnet_b5"}.
+        backbone (str): Name of the backbone CNN. Must be one of
+            ``{"resnet18", "wide_resnet50_2", "vgg19_bn", "efficientnet_b5"}``.
 
     Raises:
-        NotImplementedError: If the backbone is "efficientnet_b5".
-        ValueError: If the backbone is not one of the supported backbones.
+        NotImplementedError: If ``backbone`` is "efficientnet_b5".
+        ValueError: If ``backbone`` is not one of the supported backbones.
 
     Returns:
-        list[str]: A list of return nodes for the given backbone.
+        list[str]: List of layer names to extract features from.
+
+    Example:
+        >>> nodes = get_return_nodes("resnet18")
+        >>> print(nodes)
+        ['layer1', 'layer2', 'layer3']
     """
     if backbone == "efficientnet_b5":
         msg = "EfficientNet feature extractor has not implemented yet."
@@ -61,18 +93,24 @@ def get_return_nodes(backbone: str) -> list[str]:
 # TODO(samet-akcay): Replace this with the new torchfx feature extractor.
 # CVS-122673
 def get_feature_extractor(backbone: str, return_nodes: list[str]) -> GraphModule:
-    """Get the feature extractor from the backbone CNN.
+    """Create a feature extractor from a backbone CNN.
 
     Args:
-        backbone (str): Backbone CNN network
-        return_nodes (list[str]): A list of return nodes for the given backbone.
+        backbone (str): Name of the backbone CNN network.
+        return_nodes (list[str]): List of layer names to extract features from.
 
     Raises:
-        NotImplementedError: When the backbone is efficientnet_b5
-        ValueError: When the backbone is not supported
+        NotImplementedError: When ``backbone`` is efficientnet_b5.
+        ValueError: When ``backbone`` is not supported.
 
     Returns:
-        GraphModule: Feature extractor.
+        GraphModule: Feature extractor module.
+
+    Example:
+        >>> nodes = ["layer1", "layer2", "layer3"]
+        >>> extractor = get_feature_extractor("resnet18", nodes)
+        >>> x = torch.randn(1, 3, 224, 224)
+        >>> features = extractor(x)
     """
     model = getattr(torchvision.models, backbone)(pretrained=True)
     feature_extractor = create_feature_extractor(model=model, return_nodes=return_nodes)
@@ -84,13 +122,29 @@ def get_feature_extractor(backbone: str, return_nodes: list[str]) -> GraphModule
 class CfaModel(DynamicBufferMixin):
     """Torch implementation of the CFA Model.
 
+    The model learns discriminative features by adapting them to coupled
+    hyperspheres in the feature space. It uses a teacher-student architecture
+    where the teacher network extracts features from normal samples to guide the
+    student network.
+
     Args:
-        backbone (str): Backbone CNN network.
-        gamma_c (int): gamma_c parameter from the paper.
-        gamma_d (int): gamma_d parameter from the paper.
-        num_nearest_neighbors (int): Number of nearest neighbors.
-        num_hard_negative_features (int): Number of hard negative features.
-        radius (float): Radius of the hypersphere to search the soft boundary.
+        backbone (str): Name of the backbone CNN network.
+        gamma_c (int): Weight for centroid loss.
+        gamma_d (int): Weight for distance loss.
+        num_nearest_neighbors (int): Number of nearest neighbors for score
+            computation.
+        num_hard_negative_features (int): Number of hard negative features to use.
+        radius (float): Initial radius of the hypersphere decision boundary.
+
+    Example:
+        >>> model = CfaModel(
+        ...     backbone="resnet18",
+        ...     gamma_c=1,
+        ...     gamma_d=1,
+        ...     num_nearest_neighbors=3,
+        ...     num_hard_negative_features=3,
+        ...     radius=0.5
+        ... )
     """
 
     def __init__(
@@ -124,10 +178,18 @@ def __init__(
         )
 
     def get_scale(self, input_size: tuple[int, int] | torch.Size) -> torch.Size:
-        """Get the scale of the feature map.
+        """Get the scale of the feature maps.
 
         Args:
-            input_size (tuple[int, int]): Input size of the image tensor.
+            input_size (tuple[int, int] | torch.Size): Input image dimensions
+                (height, width).
+
+        Returns:
+            torch.Size: Feature map dimensions.
+
+        Example:
+            >>> model = CfaModel(...)
+            >>> scale = model.get_scale((256, 256))
         """
         feature_map_metadata = dryrun_find_featuremap_dims(
             feature_extractor=self.feature_extractor,
@@ -148,13 +210,20 @@ def get_scale(self, input_size: tuple[int, int] | torch.Size) -> torch.Size:
         return scale
 
     def initialize_centroid(self, data_loader: DataLoader) -> None:
-        """Initialize the Centroid of the Memory Bank.
+        """Initialize the centroid of the memory bank.
 
-        Args:
-            data_loader (DataLoader):  Train Dataloader.
+        Computes the average feature representation of normal samples to
+        initialize the memory bank centroids.
 
-        Returns:
-            Tensor: Memory Bank.
+        Args:
+            data_loader (DataLoader): DataLoader containing normal training
+                samples.
+
+        Example:
+            >>> from torch.utils.data import DataLoader
+            >>> model = CfaModel(...)
+            >>> train_loader = DataLoader(...)
+            >>> model.initialize_centroid(train_loader)
         """
         device = next(self.feature_extractor.parameters()).device
         with torch.no_grad():
@@ -179,14 +248,19 @@ def initialize_centroid(self, data_loader: DataLoader) -> None:
         self.memory_bank = rearrange(self.memory_bank, "h w -> w h")
 
     def compute_distance(self, target_oriented_features: torch.Tensor) -> torch.Tensor:
-        """Compute distance using target oriented features.
+        """Compute distances between features and memory bank centroids.
 
         Args:
-            target_oriented_features (torch.Tensor): Target oriented features computed
-                using the descriptor.
+            target_oriented_features (torch.Tensor): Features from the descriptor
+                network.
 
         Returns:
-            Tensor: Distance tensor.
+            torch.Tensor: Distance tensor.
+
+        Example:
+            >>> model = CfaModel(...)
+            >>> features = torch.randn(32, 256, 32, 32)  # B x C x H x W
+            >>> distances = model.compute_distance(features)
         """
         if target_oriented_features.ndim == 4:
             target_oriented_features = rearrange(target_oriented_features, "b c h w -> b (h w) c")
@@ -197,16 +271,22 @@ def compute_distance(self, target_oriented_features: torch.Tensor) -> torch.Tens
         return features + centers - f_c
 
     def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
-        """Forward pass.
+        """Forward pass through the model.
 
         Args:
-            input_tensor (torch.Tensor): Input tensor.
+            input_tensor (torch.Tensor): Input image tensor.
 
         Raises:
             ValueError: When the memory bank is not initialized.
 
         Returns:
-            Tensor: Loss or anomaly map depending on the train/eval mode.
+            torch.Tensor | InferenceBatch: During training, returns distance
+                tensor. During inference, returns anomaly predictions.
+
+        Example:
+            >>> model = CfaModel(...)
+            >>> x = torch.randn(32, 3, 256, 256)
+            >>> predictions = model(x)
         """
         if self.memory_bank.ndim == 0:
             msg = "Memory bank is not initialized. Run `initialize_centroid` method first."
@@ -233,7 +313,20 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
 
 
 class Descriptor(nn.Module):
-    """Descriptor module."""
+    """Descriptor network that generates target-oriented features.
+
+    Args:
+        gamma_d (int): Weight for distance loss.
+        backbone (str): Name of the backbone CNN network.
+
+    Raises:
+        ValueError: If ``backbone`` is not supported.
+
+    Example:
+        >>> descriptor = Descriptor(gamma_d=1, backbone="resnet18")
+        >>> features = [torch.randn(32, 64, 64, 64)]
+        >>> target_features = descriptor(features)
+    """
 
     def __init__(self, gamma_d: int, backbone: str) -> None:
         super().__init__()
@@ -252,7 +345,20 @@ def __init__(self, gamma_d: int, backbone: str) -> None:
         self.layer = CoordConv2d(in_channels=dim, out_channels=out_channels, kernel_size=1)
 
     def forward(self, features: list[torch.Tensor] | dict[str, torch.Tensor]) -> torch.Tensor:
-        """Forward pass."""
+        """Forward pass through the descriptor network.
+
+        Args:
+            features (list[torch.Tensor] | dict[str, torch.Tensor]): Features
+                from the backbone network.
+
+        Returns:
+            torch.Tensor: Target-oriented features.
+
+        Example:
+            >>> descriptor = Descriptor(gamma_d=1, backbone="resnet18")
+            >>> features = [torch.randn(32, 64, 64, 64)]
+            >>> target_features = descriptor(features)
+        """
         if isinstance(features, dict):
             features = list(features.values())
 
@@ -273,13 +379,36 @@ def forward(self, features: list[torch.Tensor] | dict[str, torch.Tensor]) -> tor
 
 
 class CoordConv2d(nn.Conv2d):
-    """CoordConv layer as in the paper.
+    """CoordConv layer that adds coordinate channels to input features.
+
+    Implementation based on the paper "An Intriguing Failing of Convolutional
+    Neural Networks and the CoordConv Solution".
 
     MIT License
     Copyright (c) 2018 Walsvid
 
-    Link to the paper: https://arxiv.org/abs/1807.03247
-    Link to the PyTorch implementation: https://github.com/walsvid/CoordConv
+    Paper: https://arxiv.org/abs/1807.03247
+    Code: https://github.com/walsvid/CoordConv
+
+    Args:
+        in_channels (int): Number of input channels.
+        out_channels (int): Number of output channels.
+        kernel_size (_size_2_t): Size of the convolution kernel.
+        stride (_size_2_t, optional): Stride of the convolution.
+            Defaults to ``1``.
+        padding (str | _size_2_t, optional): Padding added to input.
+            Defaults to ``0``.
+        dilation (_size_2_t, optional): Dilation of the kernel.
+            Defaults to ``1``.
+        groups (int, optional): Number of blocked connections. Defaults to ``1``.
+        bias (bool, optional): If True, adds learnable bias. Defaults to ``True``.
+        with_r (bool, optional): If True, adds radial coordinate channel.
+            Defaults to ``False``.
+
+    Example:
+        >>> conv = CoordConv2d(64, 128, kernel_size=3)
+        >>> x = torch.randn(32, 64, 32, 32)
+        >>> out = conv(x)
     """
 
     def __init__(
@@ -309,7 +438,7 @@ def __init__(
 
         # Create conv layer on top of add_coords layer.
         self.conv2d = nn.Conv2d(
-            in_channels=in_channels + 2 + int(with_r),  # 2 for rank-2 tensor, 1 for r if with_r
+            in_channels=in_channels + 2 + int(with_r),  # 2 for rank-2, 1 for r
             out_channels=out_channels,
             kernel_size=kernel_size,
             stride=stride,
@@ -319,27 +448,42 @@ def __init__(
             bias=bias,
         )
 
-    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:  # pylint: disable=arguments-renamed
-        """Forward pass.
+    def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
+        """Forward pass through the CoordConv layer.
 
         Args:
             input_tensor (torch.Tensor): Input tensor.
 
         Returns:
-            Tensor: Output tensor after applying the CoordConv layer.
+            torch.Tensor: Output tensor after applying coordinates and
+                convolution.
+
+        Example:
+            >>> conv = CoordConv2d(64, 128, kernel_size=3)
+            >>> x = torch.randn(32, 64, 32, 32)
+            >>> out = conv(x)
         """
         out = self.add_coords(input_tensor)
         return self.conv2d(out)
 
 
 class AddCoords(nn.Module):
-    """Add coords to a tensor.
+    """Module that adds coordinate channels to input tensor.
 
     MIT License
     Copyright (c) 2018 Walsvid
 
-    Link to the paper: https://arxiv.org/abs/1807.03247
-    Link to the PyTorch implementation: https://github.com/walsvid/CoordConv
+    Paper: https://arxiv.org/abs/1807.03247
+    Code: https://github.com/walsvid/CoordConv
+
+    Args:
+        with_r (bool, optional): If True, adds radial coordinate channel.
+            Defaults to ``False``.
+
+    Example:
+        >>> coord_adder = AddCoords()
+        >>> x = torch.randn(32, 64, 32, 32)
+        >>> out = coord_adder(x)  # adds x,y coordinate channels
     """
 
     def __init__(self, with_r: bool = False) -> None:
@@ -347,13 +491,18 @@ def __init__(self, with_r: bool = False) -> None:
         self.with_r = with_r
 
     def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
-        """Forward pass.
+        """Add coordinate channels to input tensor.
 
         Args:
-            input_tensor (torch.Tensor): Input tensor
+            input_tensor (torch.Tensor): Input tensor.
 
         Returns:
-            Tensor: Output tensor with added coordinates.
+            torch.Tensor: Tensor with added coordinate channels.
+
+        Example:
+            >>> coord_adder = AddCoords()
+            >>> x = torch.randn(32, 64, 32, 32)
+            >>> out = coord_adder(x)  # adds x,y coordinate channels
         """
         # NOTE: This is a modified version of the original implementation,
         #   which only supports rank 2 tensors.
diff --git a/src/anomalib/models/image/cflow/__init__.py b/src/anomalib/models/image/cflow/__init__.py
index d6d4bfde71..61fa9838a5 100644
--- a/src/anomalib/models/image/cflow/__init__.py
+++ b/src/anomalib/models/image/cflow/__init__.py
@@ -1,4 +1,26 @@
-"""Real-Time  Unsupervised Anomaly Detection via Conditional Normalizing Flows."""
+"""Real-Time Unsupervised Anomaly Detection via Conditional Normalizing Flows.
+
+This module provides the implementation of CFLOW model for anomaly detection.
+CFLOW uses conditional normalizing flows to model the distribution of normal
+samples in the feature space.
+
+Example:
+    >>> from anomalib.models.image.cflow import Cflow
+    >>> # Initialize the model
+    >>> model = Cflow(
+    ...     backbone="resnet18",
+    ...     flow_steps=8,
+    ...     hidden_ratio=1.0,
+    ...     coupling_blocks=4,
+    ...     clamp_alpha=1.9,
+    ...     permute_soft=False
+    ... )
+    >>> # Forward pass
+    >>> x = torch.randn(32, 3, 256, 256)
+    >>> predictions = model(x)
+
+Paper: https://arxiv.org/abs/2107.12571
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/cflow/anomaly_map.py b/src/anomalib/models/image/cflow/anomaly_map.py
index b212ddcc36..f13b940df8 100644
--- a/src/anomalib/models/image/cflow/anomaly_map.py
+++ b/src/anomalib/models/image/cflow/anomaly_map.py
@@ -1,4 +1,25 @@
-"""Anomaly Map Generator for CFlow model implementation."""
+"""Anomaly Map Generator for CFlow model implementation.
+
+This module provides the anomaly map generation functionality for the CFlow model.
+The generator takes feature distributions from multiple layers and combines them
+into a single anomaly heatmap.
+
+Example:
+    >>> from anomalib.models.image.cflow.anomaly_map import AnomalyMapGenerator
+    >>> import torch
+    >>> # Initialize generator
+    >>> pool_layers = ["layer1", "layer2", "layer3"]
+    >>> generator = AnomalyMapGenerator(pool_layers=pool_layers)
+    >>> # Generate anomaly map
+    >>> distribution = [torch.randn(32, 64) for _ in range(3)]
+    >>> height = [32, 16, 8]
+    >>> width = [32, 16, 8]
+    >>> anomaly_map = generator(
+    ...     distribution=distribution,
+    ...     height=height,
+    ...     width=width
+    ... )
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,7 +33,27 @@
 
 
 class AnomalyMapGenerator(nn.Module):
-    """Generate Anomaly Heatmap."""
+    """Generate anomaly heatmap from layer-wise feature distributions.
+
+    The generator combines likelihood estimations from multiple feature layers into
+    a single anomaly heatmap by upsampling and aggregating the scores.
+
+    Args:
+        pool_layers (Sequence[str]): Names of pooling layers from which to extract
+            features.
+
+    Example:
+        >>> pool_layers = ["layer1", "layer2", "layer3"]
+        >>> generator = AnomalyMapGenerator(pool_layers=pool_layers)
+        >>> distribution = [torch.randn(32, 64) for _ in range(3)]
+        >>> height = [32, 16, 8]
+        >>> width = [32, 16, 8]
+        >>> anomaly_map = generator(
+        ...     distribution=distribution,
+        ...     height=height,
+        ...     width=width
+        ... )
+    """
 
     def __init__(
         self,
@@ -29,17 +70,22 @@ def compute_anomaly_map(
         width: list[int],
         image_size: tuple[int, int] | torch.Size | None,
     ) -> torch.Tensor:
-        """Compute the layer map based on likelihood estimation.
+        """Compute anomaly map from layer-wise likelihood distributions.
+
+        The method normalizes likelihood scores from each layer, upsamples them to
+        a common size, and combines them into a final anomaly map.
 
         Args:
-            distribution (list[torch.Tensor]): List of likelihoods for each layer.
-            height (list[int]): List of heights of the feature maps.
-            width (list[int]): List of widths of the feature maps.
-            image_size (tuple[int, int] | torch.Size | None): Size of the input image.
+            distribution (list[torch.Tensor]): List of likelihood distributions for
+                each layer.
+            height (list[int]): List of feature map heights for each layer.
+            width (list[int]): List of feature map widths for each layer.
+            image_size (tuple[int, int] | torch.Size | None): Target size for the
+                output anomaly map. If None, keeps the original size.
 
         Returns:
-          Final Anomaly Map
-
+            torch.Tensor: Anomaly map tensor where higher values indicate higher
+                likelihood of anomaly.
         """
         layer_maps: list[torch.Tensor] = []
         for layer_idx in range(len(self.pool_layers)):
@@ -65,20 +111,36 @@ def compute_anomaly_map(
         return score_map.max() - score_map
 
     def forward(self, **kwargs: list[torch.Tensor] | list[int] | list[list]) -> torch.Tensor:
-        """Return anomaly_map.
+        """Generate anomaly map from input feature distributions.
 
-        Expects `distribution`, `height` and 'width' keywords to be passed explicitly
+        The method expects keyword arguments containing the feature distributions
+        and corresponding spatial dimensions.
+
+        Args:
+            **kwargs: Keyword arguments containing:
+                - distribution (list[torch.Tensor]): Feature distributions
+                - height (list[int]): Feature map heights
+                - width (list[int]): Feature map widths
+                - image_size (tuple[int, int] | torch.Size | None, optional):
+                    Target output size
 
         Example:
-            >>> anomaly_map_generator = AnomalyMapGenerator(image_size=tuple(hparams.model.input_size),
-            >>>        pool_layers=pool_layers)
-            >>> output = self.anomaly_map_generator(distribution=dist, height=height, width=width)
+            >>> generator = AnomalyMapGenerator(pool_layers=["layer1", "layer2"])
+            >>> distribution = [torch.randn(32, 64) for _ in range(2)]
+            >>> height = [32, 16]
+            >>> width = [32, 16]
+            >>> anomaly_map = generator(
+            ...     distribution=distribution,
+            ...     height=height,
+            ...     width=width
+            ... )
 
         Raises:
-            ValueError: `distribution`, `height` and 'width' keys are not found
+            KeyError: If required arguments `distribution`, `height` or `width`
+                are missing.
 
         Returns:
-            torch.Tensor: anomaly map
+            torch.Tensor: Generated anomaly map.
         """
         if not ("distribution" in kwargs and "height" in kwargs and "width" in kwargs):
             msg = f"Expected keys `distribution`, `height` and `width`. Found {kwargs.keys()}"
diff --git a/src/anomalib/models/image/cflow/lightning_model.py b/src/anomalib/models/image/cflow/lightning_model.py
index 4dd9c25850..34f7937c61 100644
--- a/src/anomalib/models/image/cflow/lightning_model.py
+++ b/src/anomalib/models/image/cflow/lightning_model.py
@@ -1,9 +1,16 @@
-"""Cflow.
+"""CFLOW - Real-Time Unsupervised Anomaly Detection via Conditional Normalizing Flows.
 
-Real-Time Unsupervised Anomaly Detection via Conditional Normalizing Flows.
+This module implements the CFLOW model for anomaly detection. CFLOW uses conditional
+normalizing flows to model the distribution of normal data and detect anomalies in
+real-time.
 
-For more details, see the paper: `Real-Time Unsupervised Anomaly Detection via
-Conditional Normalizing Flows `_.
+The model consists of:
+    - A CNN backbone encoder to extract features
+    - Multiple decoders using normalizing flows to model feature distributions
+    - Positional encoding to capture spatial information
+
+Paper: `Real-Time Unsupervised Anomaly Detection via Conditional Normalizing Flows
+`_
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -34,29 +41,40 @@
 
 
 class Cflow(AnomalibModule):
-    """PL Lightning Module for the CFLOW algorithm.
+    """PyTorch Lightning implementation of the CFLOW model.
+
+    The model uses a pre-trained CNN backbone to extract features, followed by
+    conditional normalizing flow decoders to model the distribution of normal data.
 
     Args:
-        backbone (str, optional): Backbone CNN architecture.
+        backbone (str, optional): Name of the backbone CNN network.
             Defaults to ``"wide_resnet50_2"``.
-        layers (Sequence[str], optional): Layers to extract features from.
-            Defaults to ``("layer2", "layer3", "layer4")``.
-        pre_trained (bool, optional): Whether to use pre-trained weights.
-            Defaults to ``True``.
-        fiber_batch_size (int, optional): Fiber batch size.
-            Defaults to ``64``.
-        decoder (str, optional): Decoder architecture.
+        layers (Sequence[str], optional): List of layer names to extract features
+            from. Defaults to ``("layer2", "layer3", "layer4")``.
+        pre_trained (bool, optional): If True, use pre-trained weights for the
+            backbone. Defaults to ``True``.
+        fiber_batch_size (int, optional): Batch size for processing individual
+            fibers. Defaults to ``64``.
+        decoder (str, optional): Type of normalizing flow decoder to use.
             Defaults to ``"freia-cflow"``.
-        condition_vector (int, optional): Condition vector size.
+        condition_vector (int, optional): Dimension of the condition vector.
             Defaults to ``128``.
-        coupling_blocks (int, optional): Number of coupling blocks.
+        coupling_blocks (int, optional): Number of coupling blocks in the flow.
             Defaults to ``8``.
-        clamp_alpha (float, optional): Clamping value for the alpha parameter.
-            Defaults to ``1.9``.
-        permute_soft (bool, optional): Whether to use soft permutation.
+        clamp_alpha (float, optional): Clamping value for the alpha parameter in
+            flows. Defaults to ``1.9``.
+        permute_soft (bool, optional): If True, use soft permutation in flows.
             Defaults to ``False``.
-        lr (float, optional): Learning rate.
+        lr (float, optional): Learning rate for the optimizer.
             Defaults to ``0.0001``.
+        pre_processor (PreProcessor | bool, optional): Pre-processing module.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processing module.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluation module.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualization module.
+            Defaults to ``True``.
     """
 
     def __init__(
@@ -95,15 +113,18 @@ def __init__(
             permute_soft=permute_soft,
         )
         self.automatic_optimization = False
-        # TODO(ashwinvaidya17): LR should be part of optimizer in config.yaml since  cflow has custom optimizer.
-        # CVS-122670
+        # TODO(ashwinvaidya17): LR should be part of optimizer in config.yaml since  # noqa: TD003
+        # cflow has custom optimizer. CVS-122670
         self.learning_rate = lr
 
     def configure_optimizers(self) -> Optimizer:
         """Configure optimizers for each decoder.
 
+        Creates an Adam optimizer for all decoder parameters with the specified
+        learning rate.
+
         Returns:
-            Optimizer: Adam optimizer for each decoder
+            Optimizer: Adam optimizer instance configured for the decoders.
         """
         decoders_parameters = []
         for decoder_idx in range(len(self.model.pool_layers)):
@@ -115,20 +136,24 @@ def configure_optimizers(self) -> Optimizer:
         )
 
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the training step of CFLOW.
+        """Perform a training step of the CFLOW model.
 
-        For each batch, decoder layers are trained with a dynamic fiber batch size.
-        Training step is performed manually as multiple training steps are involved
-            per batch of input images
+        The training process involves:
+        1. Extract features using the encoder
+        2. Process features in fiber batches
+        3. Apply positional encoding
+        4. Train decoders using normalizing flows
 
         Args:
-            batch (Batch): Input batch
-            *args: Arguments.
-            **kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images
+            *args: Additional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-          Loss value for the batch
+            STEP_OUTPUT: Dictionary containing the average loss for the batch
 
+        Raises:
+            ValueError: If the fiber batch size is too large for the input size
         """
         del args, kwargs  # These variables are not used.
 
@@ -190,21 +215,20 @@ def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         return {"loss": avg_loss}
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the validation step of CFLOW.
+        """Perform a validation step of the CFLOW model.
 
-            Similar to the training step, encoder features
-            are extracted from the CNN for each batch, and anomaly
-            map is computed.
+        The validation process:
+        1. Extracts features using the encoder
+        2. Computes anomaly maps using the trained decoders
+        3. Updates the batch with predictions
 
         Args:
-            batch (Batch): Input batch
-            *args: Arguments.
-            **kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images
+            *args: Additional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-            Dictionary containing images, anomaly maps, true labels and masks.
-            These are required in `validation_epoch_end` for feature concatenation.
-
+            STEP_OUTPUT: Batch updated with model predictions
         """
         del args, kwargs  # These variables are not used.
 
@@ -213,14 +237,20 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """C-FLOW specific trainer arguments."""
+        """Get CFLOW-specific trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary containing trainer arguments:
+                - gradient_clip_val: 0
+                - num_sanity_val_steps: 0
+        """
         return {"gradient_clip_val": 0, "num_sanity_val_steps": 0}
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type of the model.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: ONE_CLASS learning type
         """
         return LearningType.ONE_CLASS
diff --git a/src/anomalib/models/image/cflow/torch_model.py b/src/anomalib/models/image/cflow/torch_model.py
index dcfdcfa7fc..f83639d6b4 100644
--- a/src/anomalib/models/image/cflow/torch_model.py
+++ b/src/anomalib/models/image/cflow/torch_model.py
@@ -1,4 +1,32 @@
-"""PyTorch model for CFlow model implementation."""
+"""PyTorch model for the CFLOW anomaly detection model.
+
+This module provides the PyTorch implementation of the CFLOW model for anomaly
+detection. The model uses conditional normalizing flows to model the distribution
+of normal data in the feature space.
+
+The model consists of:
+    - A CNN backbone encoder to extract features
+    - Multiple decoders using normalizing flows to model feature distributions
+    - Positional encoding to capture spatial information
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.cflow.torch_model import CflowModel
+    >>> # Initialize the model
+    >>> model = CflowModel(
+    ...     backbone="resnet18",
+    ...     layers=["layer1", "layer2", "layer3"],
+    ...     fiber_batch_size=64,
+    ...     decoder="freia-cflow",
+    ...     condition_vector=128,
+    ...     coupling_blocks=8,
+    ...     clamp_alpha=1.9,
+    ...     permute_soft=False
+    ... )
+    >>> # Forward pass
+    >>> x = torch.randn(32, 3, 256, 256)
+    >>> predictions = model(x)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -20,22 +48,31 @@ class CflowModel(nn.Module):
     """CFLOW: Conditional Normalizing Flows.
 
     Args:
-        backbone (str): Backbone CNN architecture.
-        layers (Sequence[str]): Layers to extract features from.
-        pre_trained (bool): Whether to use pre-trained weights.
-            Defaults to ``True``.
-        fiber_batch_size (int): Fiber batch size.
-            Defaults to ``64``.
-        decoder (str): Decoder architecture.
+        backbone (str): Name of the backbone CNN network to use as feature
+            extractor.
+        layers (Sequence[str]): Names of layers from which to extract features.
+        pre_trained (bool, optional): Whether to use pre-trained weights for the
+            backbone. Defaults to ``True``.
+        fiber_batch_size (int, optional): Batch size for processing feature
+            fibers. Defaults to ``64``.
+        decoder (str, optional): Type of decoder architecture to use.
             Defaults to ``"freia-cflow"``.
-        condition_vector (int): Condition vector size.
-            Defaults to ``128``.
-        coupling_blocks (int): Number of coupling blocks.
-            Defaults to ``8``.
-        clamp_alpha (float): Clamping value for the alpha parameter.
-            Defaults to ``1.9``.
-        permute_soft (bool): Whether to use soft permutation.
-            Defaults to ``False``.
+        condition_vector (int, optional): Size of the condition vector for the
+            normalizing flows. Defaults to ``128``.
+        coupling_blocks (int, optional): Number of coupling blocks in the
+            normalizing flows. Defaults to ``8``.
+        clamp_alpha (float, optional): Clamping value for the alpha parameter in
+            the flows. Defaults to ``1.9``.
+        permute_soft (bool, optional): Whether to use soft permutation in the
+            flows. Defaults to ``False``.
+
+    Example:
+        >>> model = CflowModel(
+        ...     backbone="resnet18",
+        ...     layers=["layer1", "layer2", "layer3"]
+        ... )
+        >>> x = torch.randn(32, 3, 256, 256)
+        >>> predictions = model(x)
     """
 
     def __init__(
@@ -84,14 +121,25 @@ def __init__(
         self.anomaly_map_generator = AnomalyMapGenerator(pool_layers=self.pool_layers)
 
     def forward(self, images: torch.Tensor) -> InferenceBatch:
-        """Forward-pass images into the network to extract encoder features and compute probability.
+        """Forward pass through the model.
+
+        The method extracts features using the encoder, processes them through
+        normalizing flows, and generates anomaly predictions.
 
         Args:
-          images: Batch of images.
+            images (torch.Tensor): Input images of shape
+                ``(batch_size, channels, height, width)``.
 
         Returns:
-          Predicted anomaly maps.
-
+            InferenceBatch: Batch containing predicted anomaly scores and maps.
+                The anomaly maps have shape ``(batch_size, 1, height, width)``.
+
+        Example:
+            >>> x = torch.randn(32, 3, 256, 256)
+            >>> model = CflowModel(backbone="resnet18", layers=["layer1"])
+            >>> predictions = model(x)
+            >>> predictions.anomaly_map.shape
+            torch.Size([32, 1, 256, 256])
         """
         self.encoder.eval()
         self.decoders.eval()
diff --git a/src/anomalib/models/image/cflow/utils.py b/src/anomalib/models/image/cflow/utils.py
index 636bfed1c9..a8e653d1a8 100644
--- a/src/anomalib/models/image/cflow/utils.py
+++ b/src/anomalib/models/image/cflow/utils.py
@@ -1,4 +1,12 @@
-"""Helper functions for CFlow implementation."""
+"""Helper functions for CFlow implementation.
+
+This module provides utility functions used by the CFlow model implementation,
+including:
+
+- Log likelihood estimation
+- 2D positional encoding generation
+- Subnet and decoder network creation
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -17,33 +25,50 @@
 
 
 def get_logp(dim_feature_vector: int, p_u: torch.Tensor, logdet_j: torch.Tensor) -> torch.Tensor:
-    """Return the log likelihood estimation.
+    """Calculate the log likelihood estimation.
 
     Args:
-        dim_feature_vector (int): Dimensions of the condition vector
-        p_u (torch.Tensor): Random variable u
-        logdet_j (torch.Tensor): log of determinant of jacobian returned from the invertable decoder
+        dim_feature_vector (int): Dimension of the feature vector
+        p_u (torch.Tensor): Random variable ``u`` sampled from the base distribution
+        logdet_j (torch.Tensor): Log determinant of the Jacobian returned from the
+            invertible decoder
 
     Returns:
-        Tensor: Log probability
+        torch.Tensor: Log probability estimation
+
+    Example:
+        >>> dim = 128
+        >>> p_u = torch.randn(32, dim)
+        >>> logdet_j = torch.zeros(32)
+        >>> logp = get_logp(dim, p_u, logdet_j)
     """
     ln_sqrt_2pi = -np.log(np.sqrt(2 * np.pi))  # ln(sqrt(2*pi))
     return dim_feature_vector * ln_sqrt_2pi - 0.5 * torch.sum(p_u**2, 1) + logdet_j
 
 
 def positional_encoding_2d(condition_vector: int, height: int, width: int) -> torch.Tensor:
-    """Create embedding to store relative position of the feature vector using sine and cosine functions.
+    """Create 2D positional encoding using sine and cosine functions.
+
+    Creates an embedding to store relative position of feature vectors using
+    sinusoidal functions at different frequencies.
 
     Args:
-        condition_vector (int): Length of the condition vector
-        height (int): H of the positions
-        width (int): W of the positions
+        condition_vector (int): Length of the condition vector (must be multiple
+            of 4)
+        height (int): Height of the positions grid
+        width (int): Width of the positions grid
 
     Raises:
-        ValueError: Cannot generate encoding with conditional vector length not as multiple of 4
+        ValueError: If ``condition_vector`` is not a multiple of 4
 
     Returns:
-        Tensor: condition_vector x HEIGHT x WIDTH position matrix
+        torch.Tensor: Position encoding of shape
+            ``(condition_vector, height, width)``
+
+    Example:
+        >>> encoding = positional_encoding_2d(128, 32, 32)
+        >>> encoding.shape
+        torch.Size([128, 32, 32])
     """
     if condition_vector % 4 != 0:
         msg = f"Cannot use sin/cos positional encoding with odd dimension (got dim={condition_vector})"
@@ -70,14 +95,21 @@ def positional_encoding_2d(condition_vector: int, height: int, width: int) -> to
 
 
 def subnet_fc(dims_in: int, dims_out: int) -> nn.Sequential:
-    """Subnetwork which predicts the affine coefficients.
+    """Create a feed-forward subnetwork that predicts affine coefficients.
 
     Args:
-        dims_in (int): input dimensions
-        dims_out (int): output dimensions
+        dims_in (int): Input dimensions
+        dims_out (int): Output dimensions
 
     Returns:
-        nn.Sequential: Feed-forward subnetwork
+        nn.Sequential: Feed-forward subnetwork with ReLU activation
+
+    Example:
+        >>> net = subnet_fc(64, 128)
+        >>> x = torch.randn(32, 64)
+        >>> out = net(x)
+        >>> out.shape
+        torch.Size([32, 128])
     """
     return nn.Sequential(nn.Linear(dims_in, 2 * dims_in), nn.ReLU(), nn.Linear(2 * dims_in, dims_out))
 
@@ -89,19 +121,28 @@ def cflow_head(
     n_features: int,
     permute_soft: bool = False,
 ) -> SequenceINN:
-    """Create invertible decoder network.
+    """Create an invertible decoder network for CFlow.
 
     Args:
-        condition_vector (int): length of the condition vector
-        coupling_blocks (int): number of coupling blocks to build the decoder
-        clamp_alpha (float): clamping value to avoid exploding values
-        n_features (int): number of decoder features
-        permute_soft (bool): Whether to sample the permutation matrix :math:`R` from :math:`SO(N)`,
-            or to use hard permutations instead. Note, ``permute_soft=True`` is very slow
-            when working with >512 dimensions.
+        condition_vector (int): Length of the condition vector
+        coupling_blocks (int): Number of coupling blocks in the decoder
+        clamp_alpha (float): Clamping value to avoid exploding values
+        n_features (int): Number of decoder features
+        permute_soft (bool, optional): Whether to sample the permutation matrix
+            from SO(N) (True) or use hard permutations (False). Note that
+            ``permute_soft=True`` is very slow for >512 dimensions.
+            Defaults to False.
 
     Returns:
-        SequenceINN: decoder network block
+        SequenceINN: Invertible decoder network
+
+    Example:
+        >>> decoder = cflow_head(
+        ...     condition_vector=128,
+        ...     coupling_blocks=4,
+        ...     clamp_alpha=1.9,
+        ...     n_features=256
+        ... )
     """
     coder = SequenceINN(n_features)
     logger.info("CNF coder: %d", n_features)
diff --git a/src/anomalib/models/image/csflow/__init__.py b/src/anomalib/models/image/csflow/__init__.py
index f53d606823..3f516195c8 100644
--- a/src/anomalib/models/image/csflow/__init__.py
+++ b/src/anomalib/models/image/csflow/__init__.py
@@ -1,4 +1,25 @@
-"""Fully Convolutional Cross-Scale-Flows for Image-based Defect Detection."""
+"""Implementation of the CS-Flow model for anomaly detection.
+
+The CS-Flow model, short for Cross-Scale-Flows, is a fully convolutional approach
+for image-based defect detection. It leverages normalizing flows across multiple
+scales of the input image to model the distribution of normal (non-defective)
+samples.
+
+The model architecture consists of:
+    - A feature extraction backbone
+    - Multiple normalizing flow blocks operating at different scales
+    - Cross-scale connections to capture multi-scale dependencies
+
+Example:
+    >>> from anomalib.models.image.csflow import Csflow
+    >>> model = Csflow()
+
+Reference:
+    Gudovskiy, Denis, et al. "Cflow-ad: Real-time unsupervised anomaly detection
+    with localization via conditional normalizing flows."
+    Proceedings of the IEEE/CVF Winter Conference on Applications of Computer
+    Vision. 2022.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/csflow/anomaly_map.py b/src/anomalib/models/image/csflow/anomaly_map.py
index 8a80f3cdfb..800ee21bb3 100644
--- a/src/anomalib/models/image/csflow/anomaly_map.py
+++ b/src/anomalib/models/image/csflow/anomaly_map.py
@@ -1,4 +1,22 @@
-"""Anomaly Map Generator for CS-Flow model."""
+"""Anomaly Map Generator for CS-Flow model.
+
+This module provides functionality to generate anomaly maps from the CS-Flow model's
+outputs. The generator can operate in two modes:
+
+1. ``ALL`` - Combines anomaly scores from all scales (default)
+2. ``MAX`` - Uses only the largest scale as mentioned in the paper
+
+The anomaly maps are generated by computing the mean of squared z-scores across
+channels and upsampling to the input dimensions.
+
+Example:
+    >>> import torch
+    >>> generator = AnomalyMapGenerator(input_dims=(3, 256, 256))
+    >>> z_dist = [torch.randn(2, 64, 32, 32) for _ in range(3)]
+    >>> anomaly_map = generator(z_dist)
+    >>> anomaly_map.shape
+    torch.Size([2, 1, 256, 256])
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -11,19 +29,31 @@
 
 
 class AnomalyMapMode(str, Enum):
-    """Generate anomaly map from all the scales or the max."""
+    """Mode for generating anomaly maps.
+
+    The mode determines how the anomaly scores from different scales are combined:
+
+    - ``ALL``: Combines scores from all scales by multiplication
+    - ``MAX``: Uses only the score from the largest scale
+    """
 
     ALL = "all"
     MAX = "max"
 
 
 class AnomalyMapGenerator(nn.Module):
-    """Anomaly Map Generator for CS-Flow model.
+    """Generate anomaly maps from CS-Flow model outputs.
 
     Args:
-        input_dims (tuple[int, int, int]): Input dimensions.
-        mode (AnomalyMapMode): Anomaly map mode.
+        input_dims (tuple[int, int, int]): Input dimensions in the format
+            ``(channels, height, width)``.
+        mode (AnomalyMapMode, optional): Mode for generating anomaly maps.
             Defaults to ``AnomalyMapMode.ALL``.
+
+    Example:
+        >>> generator = AnomalyMapGenerator((3, 256, 256))
+        >>> z_dist = [torch.randn(1, 64, 32, 32) for _ in range(3)]
+        >>> anomaly_map = generator(z_dist)
     """
 
     def __init__(self, input_dims: tuple[int, int, int], mode: AnomalyMapMode = AnomalyMapMode.ALL) -> None:
@@ -32,17 +62,23 @@ def __init__(self, input_dims: tuple[int, int, int], mode: AnomalyMapMode = Anom
         self.input_dims = input_dims
 
     def forward(self, inputs: torch.Tensor) -> torch.Tensor:
-        """Get anomaly maps by taking mean of the z-distributions across channels.
-
-        By default it computes anomaly maps for all the scales as it gave better performance on initial tests.
-        Use ``AnomalyMapMode.MAX`` for the largest scale as mentioned in the paper.
+        """Generate anomaly maps from z-distributions.
 
         Args:
-            inputs (torch.Tensor): z-distributions for the three scales.
-            mode (AnomalyMapMode): Anomaly map mode.
+            inputs (torch.Tensor): List of z-distributions from different scales,
+                where each element has shape ``(batch_size, channels, height,
+                width)``.
 
         Returns:
-            Tensor: Anomaly maps.
+            torch.Tensor: Anomaly maps with shape ``(batch_size, 1, height,
+                width)``, where height and width match the input dimensions.
+
+        Example:
+            >>> z_dist = [torch.randn(2, 64, 32, 32) for _ in range(3)]
+            >>> generator = AnomalyMapGenerator((3, 256, 256))
+            >>> maps = generator(z_dist)
+            >>> maps.shape
+            torch.Size([2, 1, 256, 256])
         """
         anomaly_map: torch.Tensor
         if self.mode == AnomalyMapMode.ALL:
diff --git a/src/anomalib/models/image/csflow/lightning_model.py b/src/anomalib/models/image/csflow/lightning_model.py
index 8e9994631a..c1e7f47951 100644
--- a/src/anomalib/models/image/csflow/lightning_model.py
+++ b/src/anomalib/models/image/csflow/lightning_model.py
@@ -1,6 +1,10 @@
 """Fully Convolutional Cross-Scale-Flows for Image-based Defect Detection.
 
-https://arxiv.org/pdf/2110.02855.pdf
+Paper: https://arxiv.org/pdf/2110.02855.pdf
+
+This module provides the CS-Flow model implementation for anomaly detection.
+CS-Flow uses normalizing flows across multiple scales to model the distribution
+of normal images and detect anomalies.
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -29,17 +33,41 @@
 
 
 class Csflow(AnomalibModule):
-    """Fully Convolutional Cross-Scale-Flows for Image-based Defect Detection.
+    """CS-Flow Lightning Model for anomaly detection.
+
+    CS-Flow uses normalizing flows across multiple scales to model the distribution
+    of normal images. During inference, it assigns anomaly scores based on the
+    likelihood of test samples under the learned distribution.
 
     Args:
-        n_coupling_blocks (int): Number of coupling blocks in the model.
+        n_coupling_blocks (int, optional): Number of coupling blocks in the model.
             Defaults to ``4``.
-        cross_conv_hidden_channels (int): Number of hidden channels in the cross convolution.
-            Defaults to ``1024``.
-        clamp (int): Clamp value for glow layer.
-            Defaults to ``3``.
-        num_channels (int): Number of channels in the model.
-            Defaults to ``3``.
+        cross_conv_hidden_channels (int, optional): Number of hidden channels in
+            the cross convolution layer. Defaults to ``1024``.
+        clamp (int, optional): Clamping value for the affine coupling layers in
+            the Glow model. Defaults to ``3``.
+        num_channels (int, optional): Number of input image channels.
+            Defaults to ``3`` for RGB images.
+        pre_processor (PreProcessor | bool, optional): Preprocessing module or
+            flag to enable default preprocessing. Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processing module or
+            flag to enable default post-processing. Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluation module or flag to
+            enable default evaluation. Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualization module or flag to
+            enable default visualization. Defaults to ``True``.
+
+    Raises:
+        ValueError: If ``input_size`` is not provided during initialization.
+
+    Example:
+        >>> from anomalib.models.image.csflow import Csflow
+        >>> model = Csflow(
+        ...     n_coupling_blocks=4,
+        ...     cross_conv_hidden_channels=1024,
+        ...     clamp=3,
+        ...     num_channels=3
+        ... )
     """
 
     def __init__(
@@ -79,15 +107,22 @@ def __init__(
         self.loss = CsFlowLoss()
 
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the training step of CS-Flow.
+        """Perform a training step of CS-Flow model.
 
         Args:
-            batch (Batch): Input batch
-            args: Arguments.
-            kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and targets
+            *args: Additional positional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-            Loss value
+            STEP_OUTPUT: Dictionary containing the loss value
+
+        Example:
+            >>> batch = Batch(image=torch.randn(32, 3, 256, 256))
+            >>> model = Csflow()
+            >>> output = model.training_step(batch)
+            >>> output["loss"]
+            tensor(...)
         """
         del args, kwargs  # These variables are not used.
 
@@ -97,15 +132,21 @@ def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         return {"loss": loss}
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the validation step for CS Flow.
+        """Perform a validation step of CS-Flow model.
 
         Args:
-            batch (Batch): Input batch
-            args: Arguments.
-            kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and targets
+            *args: Additional positional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-            dict[str, torch.Tensor]: Dictionary containing the anomaly map, scores, etc.
+            STEP_OUTPUT: Dictionary containing predictions including anomaly maps
+                and scores
+
+        Example:
+            >>> batch = Batch(image=torch.randn(32, 3, 256, 256))
+            >>> model = Csflow()
+            >>> predictions = model.validation_step(batch)
         """
         del args, kwargs  # These variables are not used.
 
@@ -114,14 +155,26 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """CS-Flow-specific trainer arguments."""
+        """Get CS-Flow-specific trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary containing trainer arguments:
+                - gradient_clip_val: Maximum gradient norm for clipping
+                - num_sanity_val_steps: Number of validation steps to run before
+                  training
+        """
         return {"gradient_clip_val": 1, "num_sanity_val_steps": 0}
 
     def configure_optimizers(self) -> torch.optim.Optimizer:
-        """Configure optimizers.
+        """Configure the Adam optimizer for CS-Flow.
 
         Returns:
-            Optimizer: Adam optimizer
+            torch.optim.Optimizer: Configured Adam optimizer with specific
+                hyperparameters
+
+        Example:
+            >>> model = Csflow()
+            >>> optimizer = model.configure_optimizers()
         """
         return torch.optim.Adam(
             self.parameters(),
@@ -133,9 +186,9 @@ def configure_optimizers(self) -> torch.optim.Optimizer:
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type of the model.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: The learning type, which is ONE_CLASS for CS-Flow
         """
         return LearningType.ONE_CLASS
diff --git a/src/anomalib/models/image/csflow/loss.py b/src/anomalib/models/image/csflow/loss.py
index 2e5d1da8ff..a5156567f1 100644
--- a/src/anomalib/models/image/csflow/loss.py
+++ b/src/anomalib/models/image/csflow/loss.py
@@ -1,4 +1,18 @@
-"""Loss function for the CS-Flow Model Implementation."""
+"""Loss function for the CS-Flow Model Implementation.
+
+This module implements the loss function used in the CS-Flow model for anomaly
+detection. The loss combines the squared L2 norm of the latent space
+representations with the log-determinant of the Jacobian from the normalizing
+flows.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.csflow.loss import CsFlowLoss
+    >>> criterion = CsFlowLoss()
+    >>> z_dist = [torch.randn(2, 64, 32, 32) for _ in range(3)]
+    >>> jacobians = torch.randn(2)
+    >>> loss = criterion(z_dist, jacobians)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -8,18 +22,31 @@
 
 
 class CsFlowLoss(nn.Module):
-    """Loss function for the CS-Flow Model Implementation."""
+    """Loss function for the CS-Flow model.
+
+    The loss is computed as the mean of the squared L2 norm of the latent space
+    representations minus the log-determinant of the Jacobian, normalized by the
+    dimensionality of the latent space.
+    """
 
     @staticmethod
-    def forward(z_dist: torch.Tensor, jacobians: torch.Tensor) -> torch.Tensor:
-        """Compute the loss CS-Flow.
+    def forward(z_dist: list[torch.Tensor], jacobians: torch.Tensor) -> torch.Tensor:
+        """Compute the CS-Flow loss.
 
         Args:
-            z_dist (torch.Tensor): Latent space image mappings from NF.
-            jacobians (torch.Tensor): Jacobians of the distribution
+            z_dist (list[torch.Tensor]): List of latent space tensors from each
+                scale of the normalizing flow. Each tensor has shape
+                ``(batch_size, channels, height, width)``.
+            jacobians (torch.Tensor): Log-determinant of the Jacobian matrices
+                from the normalizing flows. Shape: ``(batch_size,)``.
 
         Returns:
-            Loss value
+            torch.Tensor: Scalar loss value averaged over the batch.
+
+        Example:
+            >>> z_dist = [torch.randn(2, 64, 32, 32) for _ in range(3)]
+            >>> jacobians = torch.randn(2)
+            >>> loss = CsFlowLoss.forward(z_dist, jacobians)
         """
-        z_dist = torch.cat([z_dist[i].reshape(z_dist[i].shape[0], -1) for i in range(len(z_dist))], dim=1)
-        return torch.mean(0.5 * torch.sum(z_dist**2, dim=(1,)) - jacobians) / z_dist.shape[1]
+        concatenated = torch.cat([z_dist[i].reshape(z_dist[i].shape[0], -1) for i in range(len(z_dist))], dim=1)
+        return torch.mean(0.5 * torch.sum(concatenated**2, dim=(1,)) - jacobians) / concatenated.shape[1]
diff --git a/src/anomalib/models/image/csflow/torch_model.py b/src/anomalib/models/image/csflow/torch_model.py
index a4703d9b4c..fd067450e3 100644
--- a/src/anomalib/models/image/csflow/torch_model.py
+++ b/src/anomalib/models/image/csflow/torch_model.py
@@ -1,5 +1,14 @@
-"""PyTorch model for CS-Flow implementation."""
+"""PyTorch model for CS-Flow implementation.
 
+This module contains the PyTorch implementation of CS-Flow model for anomaly detection.
+The model uses cross-scale coupling layers to learn the distribution of normal images
+and detect anomalies based on the likelihood of test images under this distribution.
+
+The implementation is based on the paper:
+    CS-Flow: Learning Cross-Scale Semantic Flow for Unsupervised Anomaly Detection
+    Marco Rudolph, Tom Wehrbein, Bodo Rosenhahn, Bastian Wandt
+    https://arxiv.org/abs/2110.02855
+"""
 
 # Original Code
 # Copyright (c) 2021 marco-rudolph
@@ -27,21 +36,34 @@
 
 
 class CrossConvolutions(nn.Module):
-    """Cross convolution for the three scales.
+    """Cross convolution module for processing features at three scales.
+
+    This module applies convolutions across three different scales of features,
+    with connections between scales via up/downsampling operations.
 
     Args:
         in_channels (int): Number of input channels.
-        channels (int): Number of output channels in the hidden convolution and the upscaling layers.
-        channels_hidden (int, optional): Number of input channels in the hidden convolution layers.
+        channels (int): Number of output channels in convolution layers.
+        channels_hidden (int, optional): Number of channels in hidden layers.
             Defaults to ``512``.
-        kernel_size (int, optional): Kernel size of the convolution layers.
+        kernel_size (int, optional): Size of convolution kernels.
             Defaults to ``3``.
-        leaky_slope (float, optional): Slope of the leaky ReLU activation.
+        leaky_slope (float, optional): Negative slope for leaky ReLU.
             Defaults to ``0.1``.
         batch_norm (bool, optional): Whether to use batch normalization.
             Defaults to ``False``.
-        use_gamma (bool, optional): Whether to use gamma parameters for the cross convolutions.
+        use_gamma (bool, optional): Whether to use learnable gamma parameters.
             Defaults to ``True``.
+
+    Example:
+        >>> cross_conv = CrossConvolutions(64, 128)
+        >>> scale0 = torch.randn(1, 64, 32, 32)
+        >>> scale1 = torch.randn(1, 64, 16, 16)
+        >>> scale2 = torch.randn(1, 64, 8, 8)
+        >>> out0, out1, out2 = cross_conv(scale0, scale1, scale2)
+        >>> out0.shape, out1.shape, out2.shape
+        (torch.Size([1, 128, 32, 32]), torch.Size([1, 128, 16, 16]),
+         torch.Size([1, 128, 8, 8]))
     """
 
     def __init__(
@@ -161,14 +183,21 @@ def __init__(
         self.leaky_relu = nn.LeakyReLU(self.leaky_slope)
 
     def forward(self, scale0: int, scale1: int, scale2: int) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Apply the cross convolution to the three scales.
+        """Apply cross-scale convolutions to input features.
 
-        This block is represented in figure 4 of the paper.
+        Processes features at three scales with cross-connections between scales via
+        up/downsampling operations. This implements the architecture shown in Figure 4
+        of the CS-Flow paper.
+
+        Args:
+            scale0 (torch.Tensor): Features at original scale.
+            scale1 (torch.Tensor): Features at 1/2 scale.
+            scale2 (torch.Tensor): Features at 1/4 scale.
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor, torch.Tensor]: Tensors indicating scale and transform parameters
-                as a single tensor for each scale. The scale parameters are the first part across channel dimension
-                and the transform parameters are the second.
+            tuple[torch.Tensor, torch.Tensor, torch.Tensor]: Processed features at three
+                scales. Each tensor contains scale and transform parameters concatenated
+                along the channel dimension.
         """
         # Increase the number of channels to hidden channel length via convolutions and apply leaky ReLU.
         out0 = self.conv_scale0_0(scale0)
@@ -206,11 +235,23 @@ def forward(self, scale0: int, scale1: int, scale2: int) -> tuple[torch.Tensor,
 
 
 class ParallelPermute(InvertibleModule):
-    """Permutes input vector in a random but fixed way.
+    """Permutes input vectors in a random but fixed way.
+
+    This module applies a fixed random permutation to the channels of each input
+    tensor. The permutation is deterministic for a given seed.
 
     Args:
-        dim (list[tuple[int]]): Dimension of the input vector.
-        seed (float | None=None): Seed for the random permutation.
+        dims_in (list[tuple[int]]): List of input tensor dimensions.
+        seed (int | None, optional): Random seed for permutation.
+            Defaults to ``None``.
+
+    Example:
+        >>> permute = ParallelPermute([(3, 32, 32), (3, 16, 16)], seed=42)
+        >>> x1 = torch.randn(1, 3, 32, 32)
+        >>> x2 = torch.randn(1, 3, 16, 16)
+        >>> y1, y2 = permute([x1, x2])[0]
+        >>> y1.shape, y2.shape
+        (torch.Size([1, 3, 32, 32]), torch.Size([1, 3, 16, 16]))
     """
 
     def __init__(self, dims_in: list[tuple[int]], seed: int | None = None) -> None:
@@ -229,13 +270,13 @@ def __init__(self, dims_in: list[tuple[int]], seed: int | None = None) -> None:
             self.perm_inv.append(perm_inv)
 
     def get_random_perm(self, index: int) -> tuple[torch.Tensor, torch.Tensor]:
-        """Return a random permutation of the channels for each input.
+        """Generate random permutation and its inverse for given input index.
 
         Args:
-            index (int): index of the input
+            index (int): Index of input tensor.
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor]: permutation and inverse permutation
+            tuple[torch.Tensor, torch.Tensor]: Permutation and inverse permutation tensors.
         """
         perm = np.random.default_rng(self.seed).permutation(self.in_channels[index])
         perm_inv = np.zeros_like(perm)
@@ -253,17 +294,17 @@ def forward(
         rev: bool = False,
         jac: bool = True,
     ) -> tuple[list[torch.Tensor], float]:
-        """Apply the permutation to the input.
+        """Apply permutation or inverse permutation to inputs.
 
         Args:
-            input_tensor: list of input tensors
-            rev: if True, applies the inverse permutation
+            input_tensor (list[torch.Tensor]): List of input tensors.
+            rev (bool, optional): If ``True``, applies inverse permutation.
                 Defaults to ``False``.
-            jac: (unused) if True, computes the log determinant of the Jacobian
+            jac (bool, optional): Unused. Required for interface compatibility.
                 Defaults to ``True``.
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor]: output tensor and log determinant of the Jacobian
+            tuple[list[torch.Tensor], float]: Permuted tensors and log determinant (0).
         """
         del jac  # Unused argument.
 
@@ -274,18 +315,39 @@ def forward(
 
     @staticmethod
     def output_dims(input_dims: list[tuple[int]]) -> list[tuple[int]]:
-        """Return the output dimensions of the module."""
+        """Return output dimensions of the module.
+
+        Args:
+            input_dims (list[tuple[int]]): List of input dimensions.
+
+        Returns:
+            list[tuple[int]]: List of output dimensions (same as input).
+        """
         return input_dims
 
 
 class ParallelGlowCouplingLayer(InvertibleModule):
-    """Coupling block that follows the GLOW design but is applied to all the scales in parallel.
+    """Coupling block following GLOW design applied to multiple scales in parallel.
+
+    This module implements an invertible coupling layer that processes multiple scales
+    simultaneously, following the GLOW architecture design.
 
     Args:
-        dims_in (list[tuple[int]]): list of dimensions of the input tensors
-        subnet_args (dict): arguments of the subnet
-        clamp (float): clamp value for the output of the subnet
+        dims_in (list[tuple[int]]): List of input tensor dimensions.
+        subnet_args (dict): Arguments for subnet construction.
+        clamp (float, optional): Clamp value for outputs.
             Defaults to ``5.0``.
+
+    Example:
+        >>> coupling = ParallelGlowCouplingLayer(
+        ...     [(6, 32, 32), (6, 16, 16)],
+        ...     {"channels_hidden": 64}
+        ... )
+        >>> x1 = torch.randn(1, 6, 32, 32)
+        >>> x2 = torch.randn(1, 6, 16, 16)
+        >>> y1, y2 = coupling([x1, x2])[0]
+        >>> y1.shape, y2.shape
+        (torch.Size([1, 6, 32, 32]), torch.Size([1, 6, 16, 16]))
     """
 
     def __init__(self, dims_in: list[tuple[int]], subnet_args: dict, clamp: float = 5.0) -> None:
@@ -305,13 +367,27 @@ def __init__(self, dims_in: list[tuple[int]], subnet_args: dict, clamp: float =
         self.cross_convolution2 = CrossConvolutions(self.split_len2, self.split_len1 * 2, **subnet_args)
 
     def exp(self, input_tensor: torch.Tensor) -> torch.Tensor:
-        """Exponentiates the input and, optionally, clamps it to avoid numerical issues."""
+        """Exponentiates input with optional clamping.
+
+        Args:
+            input_tensor (torch.Tensor): Input tensor.
+
+        Returns:
+            torch.Tensor: Exponentiated tensor, optionally clamped.
+        """
         if self.clamp > 0:
             return torch.exp(self.log_e(input_tensor))
         return torch.exp(input_tensor)
 
     def log_e(self, input_tensor: torch.Tensor) -> torch.Tensor:
-        """Return log of input. And optionally clamped to avoid numerical issues."""
+        """Compute log with optional clamping.
+
+        Args:
+            input_tensor (torch.Tensor): Input tensor.
+
+        Returns:
+            torch.Tensor: Log of input, optionally clamped.
+        """
         if self.clamp > 0:
             return self.clamp * 0.636 * torch.atan(input_tensor / self.clamp)
         return input_tensor
@@ -322,7 +398,19 @@ def forward(
         rev: bool = False,
         jac: bool = True,
     ) -> tuple[list[torch.Tensor], torch.Tensor]:
-        """Apply GLOW coupling for the three scales."""
+        """Apply GLOW coupling transformation to inputs at multiple scales.
+
+        Args:
+            input_tensor (list[torch.Tensor]): List of input tensors at different scales.
+            rev (bool, optional): If ``True``, applies inverse transformation.
+                Defaults to ``False``.
+            jac (bool, optional): Unused. Required for interface compatibility.
+                Defaults to ``True``.
+
+        Returns:
+            tuple[list[torch.Tensor], torch.Tensor]: Transformed tensors and log
+                determinant of Jacobian.
+        """
         del jac  # Unused argument.
 
         # Even channel split. The two splits are used by cross-scale convolution to compute scale and transform
@@ -406,18 +494,40 @@ def forward(
 
     @staticmethod
     def output_dims(input_dims: list[tuple[int]]) -> list[tuple[int]]:
-        """Output dimensions of the module."""
+        """Return output dimensions of the module.
+
+        Args:
+            input_dims (list[tuple[int]]): List of input dimensions.
+
+        Returns:
+            list[tuple[int]]: List of output dimensions (same as input).
+        """
         return input_dims
 
 
 class CrossScaleFlow(nn.Module):
     """Cross scale coupling layer.
 
+    This module implements the cross-scale flow architecture that couples features
+    across multiple scales.
+
     Args:
-        input_dims (tuple[int, int, int]): Input dimensions of the module.
-        n_coupling_blocks (int): Number of coupling blocks.
-        clamp (float): Clamp value for the inputs.
-        corss_conv_hidden_channels (int): Number of hidden channels in the cross convolution.
+        input_dims (tuple[int, int, int]): Input dimensions (C, H, W).
+        n_coupling_blocks (int): Number of coupling blocks to use.
+        clamp (float): Clamping value for coupling layers.
+        cross_conv_hidden_channels (int): Hidden channels in cross convolutions.
+
+    Example:
+        >>> flow = CrossScaleFlow((3, 256, 256), 4, 3.0, 64)
+        >>> x = [
+        ...     torch.randn(1, 304, 8, 8),
+        ...     torch.randn(1, 304, 4, 4),
+        ...     torch.randn(1, 304, 2, 2)
+        ... ]
+        >>> z, jac = flow(x)
+        >>> [zi.shape for zi in z]
+        [torch.Size([1, 304, 8, 8]), torch.Size([1, 304, 4, 4]),
+         torch.Size([1, 304, 2, 2])]
     """
 
     def __init__(
@@ -436,6 +546,11 @@ def __init__(
         self.graph = self._create_graph()
 
     def _create_graph(self) -> GraphINN:
+        """Create the invertible neural network graph.
+
+        Returns:
+            GraphINN: Constructed invertible neural network.
+        """
         nodes: list[Node] = []
         # 304 is the number of features extracted from EfficientNet-B5 feature extractor
         input_nodes = [
@@ -481,25 +596,35 @@ def _create_graph(self) -> GraphINN:
         return GraphINN(nodes)
 
     def forward(self, inputs: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        """Forward pass.
+        """Forward pass through the flow model.
 
         Args:
             inputs (torch.Tensor): Input tensor.
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor]: Output tensor and log determinant of Jacobian.
+            tuple[torch.Tensor, torch.Tensor]: Output tensor and log determinant
+                of Jacobian.
         """
         return self.graph(inputs)
 
 
 class MultiScaleFeatureExtractor(nn.Module):
-    """Multi-scale feature extractor.
+    """Multi-scale feature extractor using EfficientNet-B5.
 
-    Uses 36th layer of EfficientNet-B5 to extract features.
+    This module extracts features at multiple scales using the 36th layer of
+    EfficientNet-B5.
 
     Args:
-        n_scales (int): Number of scales for input image.
-        input_size (tuple[int, int]): Size of input image.
+        n_scales (int): Number of scales to extract features at.
+        input_size (tuple[int, int]): Input image size (H, W).
+
+    Example:
+        >>> extractor = MultiScaleFeatureExtractor(3, (256, 256))
+        >>> x = torch.randn(1, 3, 256, 256)
+        >>> features = extractor(x)
+        >>> [f.shape for f in features]
+        [torch.Size([1, 304, 8, 8]), torch.Size([1, 304, 4, 4]),
+         torch.Size([1, 304, 2, 2])]
     """
 
     def __init__(self, n_scales: int, input_size: tuple[int, int]) -> None:
@@ -514,13 +639,13 @@ def __init__(self, n_scales: int, input_size: tuple[int, int]) -> None:
         )
 
     def forward(self, input_tensor: torch.Tensor) -> list[torch.Tensor]:
-        """Extract features at three scales.
+        """Extract features at multiple scales.
 
         Args:
             input_tensor (torch.Tensor): Input images.
 
         Returns:
-            list[torch.Tensor]: List of tensors containing features at three scales.
+            list[torch.Tensor]: List of feature tensors at different scales.
         """
         output = []
         for scale in range(self.n_scales):
@@ -539,17 +664,27 @@ def forward(self, input_tensor: torch.Tensor) -> list[torch.Tensor]:
 
 
 class CsFlowModel(nn.Module):
-    """CS Flow Module.
+    """CS-Flow model for anomaly detection.
+
+    This module implements the complete CS-Flow model that learns the distribution
+    of normal images using cross-scale coupling layers.
 
     Args:
-        input_size (tuple[int, int]): Input image size.
-        cross_conv_hidden_channels (int): Number of hidden channels in the cross convolution.
-        n_coupling_blocks (int): Number of coupling blocks.
+        input_size (tuple[int, int]): Input image size (H, W).
+        cross_conv_hidden_channels (int): Hidden channels in cross convolutions.
+        n_coupling_blocks (int, optional): Number of coupling blocks.
             Defaults to ``4``.
-        clamp (float): Clamp value for the coupling blocks.
+        clamp (int, optional): Clamping value for coupling layers.
             Defaults to ``3``.
-        num_channels (int): Number of channels in the input image.
+        num_channels (int, optional): Number of input image channels.
             Defaults to ``3``.
+
+    Example:
+        >>> model = CsFlowModel((256, 256), 64)
+        >>> x = torch.randn(1, 3, 256, 256)
+        >>> output = model(x)
+        >>> isinstance(output, InferenceBatch)
+        True
     """
 
     def __init__(
diff --git a/src/anomalib/models/image/dfkde/__init__.py b/src/anomalib/models/image/dfkde/__init__.py
index 9930fcea71..948b252887 100644
--- a/src/anomalib/models/image/dfkde/__init__.py
+++ b/src/anomalib/models/image/dfkde/__init__.py
@@ -1,4 +1,24 @@
-"""Deep Feature Kernel Density Estimation model."""
+"""Deep Feature Kernel Density Estimation (DFKDE) model for anomaly detection.
+
+The DFKDE model extracts deep features from images using a pre-trained CNN backbone
+and fits a kernel density estimation on these features to model the distribution
+of normal samples. During inference, samples with low likelihood under this
+distribution are flagged as anomalous.
+
+Example:
+    >>> from anomalib.models.image import Dfkde
+    >>> model = Dfkde()
+
+The model can be used with any of the supported datasets and task modes in
+anomalib.
+
+Notes:
+    The model implementation is available in the ``lightning_model`` module.
+
+See Also:
+    :class:`anomalib.models.image.dfkde.lightning_model.Dfkde`:
+        Lightning implementation of the DFKDE model.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/dfkde/lightning_model.py b/src/anomalib/models/image/dfkde/lightning_model.py
index 666fb5507d..a437d9a244 100644
--- a/src/anomalib/models/image/dfkde/lightning_model.py
+++ b/src/anomalib/models/image/dfkde/lightning_model.py
@@ -1,4 +1,27 @@
-"""DFKDE: Deep Feature Kernel Density Estimation."""
+"""DFKDE: Deep Feature Kernel Density Estimation.
+
+This module provides a PyTorch Lightning implementation of the DFKDE model for
+anomaly detection. The model extracts deep features from images using a
+pre-trained CNN backbone and fits a kernel density estimation on these features
+to model the distribution of normal samples.
+
+Example:
+    >>> from anomalib.models.image import Dfkde
+    >>> model = Dfkde(
+    ...     backbone="resnet18",
+    ...     layers=("layer4",),
+    ...     pre_trained=True
+    ... )
+
+Notes:
+    The model uses a pre-trained backbone to extract features and fits a KDE
+    classifier on the embeddings during training. No gradient updates are
+    performed on the backbone.
+
+See Also:
+    :class:`anomalib.models.image.dfkde.torch_model.DfkdeModel`:
+        PyTorch implementation of the DFKDE model.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -25,21 +48,40 @@
 
 
 class Dfkde(MemoryBankMixin, AnomalibModule):
-    """DFKDE: Deep Feature Kernel Density Estimation.
+    """DFKDE Lightning Module.
 
     Args:
-        backbone (str): Pre-trained model backbone.
+        backbone (str): Name of the backbone CNN to use for feature extraction.
             Defaults to ``"resnet18"``.
-        layers (Sequence[str], optional): Layers to extract features from.
+        layers (Sequence[str]): Layers from which to extract features.
             Defaults to ``("layer4",)``.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
+        pre_trained (bool): Whether to use pre-trained weights.
             Defaults to ``True``.
-        n_pca_components (int, optional): Number of PCA components.
-            Defaults to ``16``.
-        feature_scaling_method (FeatureScalingMethod, optional): Feature scaling method.
+        n_pca_components (int): Number of principal components for dimensionality
+            reduction. Defaults to ``16``.
+        feature_scaling_method (FeatureScalingMethod): Method to scale features.
             Defaults to ``FeatureScalingMethod.SCALE``.
-        max_training_points (int, optional): Number of training points to fit the KDE model.
-            Defaults to ``40000``.
+        max_training_points (int): Maximum number of points to use for KDE
+            fitting. Defaults to ``40000``.
+        pre_processor (PreProcessor | bool): Pre-processor object or flag.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool): Post-processor object or flag.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool): Evaluator object or flag.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool): Visualizer object or flag.
+            Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models.image import Dfkde
+        >>> from anomalib.models.components.classification import (
+        ...     FeatureScalingMethod
+        ... )
+        >>> model = Dfkde(
+        ...     backbone="resnet18",
+        ...     layers=("layer4",),
+        ...     feature_scaling_method=FeatureScalingMethod.SCALE
+        ... )
     """
 
     def __init__(
@@ -79,15 +121,15 @@ def configure_optimizers() -> None:  # pylint: disable=arguments-differ
         return
 
     def training_step(self, batch: Batch, *args, **kwargs) -> None:
-        """Perform the training step of DFKDE. For each batch, features are extracted from the CNN.
+        """Extract features from the CNN for each training batch.
 
         Args:
-            batch (batch: Batch): Batch containing image filename, image, label and mask
-            args: Arguments.
-            kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and metadata.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
 
         Returns:
-          Deep CNN features.
+            torch.Tensor: Dummy tensor for Lightning compatibility.
         """
         del args, kwargs  # These variables are not used.
 
@@ -98,24 +140,22 @@ def training_step(self, batch: Batch, *args, **kwargs) -> None:
         return torch.tensor(0.0, requires_grad=True, device=self.device)
 
     def fit(self) -> None:
-        """Fit a KDE Model to the embedding collected from the training set."""
+        """Fit KDE model to collected embeddings from the training set."""
         embeddings = torch.vstack(self.embeddings)
 
         logger.info("Fitting a KDE model to the embedding collected from the training set.")
         self.model.classifier.fit(embeddings)
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the validation step of DFKDE.
-
-        Similar to the training step, features are extracted from the CNN for each batch.
+        """Perform validation by computing anomaly scores.
 
         Args:
-            batch (Batch): Input batch
-            args: Arguments.
-            kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and metadata.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
 
         Returns:
-            Dictionary containing probability, prediction and ground truth values.
+            STEP_OUTPUT: Dictionary containing predictions and batch info.
         """
         del args, kwargs  # These variables are not used.
 
@@ -124,21 +164,29 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """Return DFKDE-specific trainer arguments."""
+        """Get DFKDE-specific trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary of trainer arguments.
+        """
         return {"gradient_clip_val": 0, "max_epochs": 1, "num_sanity_val_steps": 0}
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: Learning type of the model (ONE_CLASS).
         """
         return LearningType.ONE_CLASS
 
     @staticmethod
     def configure_evaluator() -> Evaluator:
-        """Default evaluator for DFKE."""
+        """Configure the default evaluator for DFKDE.
+
+        Returns:
+            Evaluator: Evaluator object with image-level AUROC and F1 metrics.
+        """
         image_auroc = AUROC(fields=["pred_score", "gt_label"], prefix="image_")
         image_f1score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
         test_metrics = [image_auroc, image_f1score]
diff --git a/src/anomalib/models/image/dfkde/torch_model.py b/src/anomalib/models/image/dfkde/torch_model.py
index 4dc5fd58fe..deca22aedd 100644
--- a/src/anomalib/models/image/dfkde/torch_model.py
+++ b/src/anomalib/models/image/dfkde/torch_model.py
@@ -1,4 +1,27 @@
-"""Normality model of DFKDE."""
+"""PyTorch model for Deep Feature Kernel Density Estimation (DFKDE).
+
+This module provides a PyTorch implementation of the DFKDE model for anomaly
+detection. The model extracts deep features from images using a pre-trained CNN
+backbone and fits a kernel density estimation on these features to model the
+distribution of normal samples.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.dfkde.torch_model import DfkdeModel
+    >>> model = DfkdeModel(
+    ...     backbone="resnet18",
+    ...     layers=["layer4"],
+    ...     pre_trained=True
+    ... )
+    >>> batch = torch.randn(32, 3, 224, 224)
+    >>> features = model(batch)  # Returns features during training
+    >>> predictions = model(batch)  # Returns scores during inference
+
+Notes:
+    The model uses a pre-trained backbone to extract features and fits a KDE
+    classifier on the embeddings during training. No gradient updates are
+    performed on the backbone.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -18,19 +41,34 @@
 
 
 class DfkdeModel(nn.Module):
-    """Normality Model for the DFKDE algorithm.
+    """Deep Feature Kernel Density Estimation model for anomaly detection.
+
+    The model extracts deep features from images using a pre-trained CNN backbone
+    and fits a kernel density estimation on these features to model the
+    distribution of normal samples.
 
     Args:
-        backbone (str): Pre-trained model backbone.
-        layers (Sequence[str]): Layers to extract features from.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
+        backbone (str): Name of the pre-trained model backbone from timm.
+        layers (Sequence[str]): Names of layers to extract features from.
+        pre_trained (bool, optional): Whether to use pre-trained backbone weights.
             Defaults to ``True``.
-        n_pca_components (int, optional): Number of PCA components.
-            Defaults to ``16``.
-        feature_scaling_method (FeatureScalingMethod, optional): Feature scaling method.
-            Defaults to ``FeatureScalingMethod.SCALE``.
-        max_training_points (int, optional): Number of training points to fit the KDE model.
-            Defaults to ``40000``.
+        n_pca_components (int, optional): Number of components for PCA dimension
+            reduction. Defaults to ``16``.
+        feature_scaling_method (FeatureScalingMethod, optional): Method used to
+            scale features before KDE. Defaults to
+            ``FeatureScalingMethod.SCALE``.
+        max_training_points (int, optional): Maximum number of points used to fit
+            the KDE model. Defaults to ``40000``.
+
+    Example:
+        >>> import torch
+        >>> model = DfkdeModel(
+        ...     backbone="resnet18",
+        ...     layers=["layer4"],
+        ...     pre_trained=True
+        ... )
+        >>> batch = torch.randn(32, 3, 224, 224)
+        >>> features = model(batch)
     """
 
     def __init__(
@@ -53,13 +91,21 @@ def __init__(
         )
 
     def get_features(self, batch: torch.Tensor) -> torch.Tensor:
-        """Extract features from the pretrained network.
+        """Extract features from the pre-trained backbone network.
 
         Args:
-            batch (torch.Tensor): Image batch.
+            batch (torch.Tensor): Batch of input images with shape
+                ``(N, C, H, W)``.
 
         Returns:
-            Tensor: torch.Tensor containing extracted features.
+            torch.Tensor: Concatenated features from specified layers, flattened
+                to shape ``(N, D)`` where ``D`` is the total feature dimension.
+
+        Example:
+            >>> batch = torch.randn(32, 3, 224, 224)
+            >>> features = model.get_features(batch)
+            >>> features.shape
+            torch.Size([32, 512])  # Depends on backbone and layers
         """
         self.feature_extractor.eval()
         layer_outputs = self.feature_extractor(batch)
@@ -70,13 +116,27 @@ def get_features(self, batch: torch.Tensor) -> torch.Tensor:
         return torch.cat(list(layer_outputs.values())).detach()
 
     def forward(self, batch: torch.Tensor) -> torch.Tensor | InferenceBatch:
-        """Prediction by normality model.
+        """Extract features during training or compute anomaly scores during inference.
 
         Args:
-            batch (torch.Tensor): Input images.
+            batch (torch.Tensor): Batch of input images with shape
+                ``(N, C, H, W)``.
 
         Returns:
-            Tensor: Predictions
+            torch.Tensor | InferenceBatch: During training, returns extracted
+                features as a tensor. During inference, returns an
+                ``InferenceBatch`` containing anomaly scores.
+
+        Example:
+            >>> batch = torch.randn(32, 3, 224, 224)
+            >>> # Training mode
+            >>> model.train()
+            >>> features = model(batch)
+            >>> # Inference mode
+            >>> model.eval()
+            >>> predictions = model(batch)
+            >>> predictions.pred_score.shape
+            torch.Size([32])
         """
         # 1. apply feature extraction
         features = self.get_features(batch)
diff --git a/src/anomalib/models/image/dfm/__init__.py b/src/anomalib/models/image/dfm/__init__.py
index c003420afc..2aba3c62d4 100644
--- a/src/anomalib/models/image/dfm/__init__.py
+++ b/src/anomalib/models/image/dfm/__init__.py
@@ -1,4 +1,24 @@
-"""Deep Feature Extraction (DFM) model."""
+"""Deep Feature Matching (DFM) model for anomaly detection.
+
+The DFM model extracts deep features from images using a pre-trained CNN backbone
+and matches these features against a memory bank of normal samples to detect
+anomalies. During inference, samples with high feature matching distances are
+flagged as anomalous.
+
+Example:
+    >>> from anomalib.models.image import Dfm
+    >>> model = Dfm()
+
+The model can be used with any of the supported datasets and task modes in
+anomalib.
+
+Notes:
+    The model implementation is available in the ``lightning_model`` module.
+
+See Also:
+    :class:`anomalib.models.image.dfm.lightning_model.Dfm`:
+        Lightning implementation of the DFM model.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/dfm/lightning_model.py b/src/anomalib/models/image/dfm/lightning_model.py
index 1bdad50e1e..f380dab428 100644
--- a/src/anomalib/models/image/dfm/lightning_model.py
+++ b/src/anomalib/models/image/dfm/lightning_model.py
@@ -1,6 +1,28 @@
-"""DFM: Deep Feature Modeling.
-
-https://arxiv.org/abs/1909.11786
+"""Deep Feature Modeling (DFM) for anomaly detection.
+
+This module provides a PyTorch Lightning implementation of the DFM model for
+anomaly detection. The model extracts deep features from images using a
+pre-trained CNN backbone and fits a Gaussian model on these features to detect
+anomalies.
+
+Paper: https://arxiv.org/abs/1909.11786
+
+Example:
+    >>> from anomalib.models.image import Dfm
+    >>> model = Dfm(
+    ...     backbone="resnet50",
+    ...     layer="layer3",
+    ...     pre_trained=True
+    ... )
+
+Notes:
+    The model uses a pre-trained backbone to extract features and fits a PCA
+    transformation followed by a Gaussian model during training. No gradient
+    updates are performed on the backbone.
+
+See Also:
+    :class:`anomalib.models.image.dfm.torch_model.DFMModel`:
+        PyTorch implementation of the DFM model.
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -26,24 +48,40 @@
 
 
 class Dfm(MemoryBankMixin, AnomalibModule):
-    """DFM: Deep Featured Kernel Density Estimation.
+    """DFM Lightning Module.
 
     Args:
-        backbone (str): Backbone CNN network
+        backbone (str): Name of the backbone CNN network.
             Defaults to ``"resnet50"``.
-        layer (str): Layer to extract features from the backbone CNN
+        layer (str): Name of the layer to extract features from the backbone.
             Defaults to ``"layer3"``.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
+        pre_trained (bool, optional): Whether to use a pre-trained backbone.
             Defaults to ``True``.
-        pooling_kernel_size (int, optional): Kernel size to pool features extracted from the CNN.
+        pooling_kernel_size (int, optional): Kernel size for pooling features.
             Defaults to ``4``.
-        pca_level (float, optional): Ratio from which number of components for PCA are calculated.
+        pca_level (float, optional): Ratio of variance to preserve in PCA.
+            Must be between 0 and 1.
             Defaults to ``0.97``.
-        score_type (str, optional): Scoring type. Options are `fre` and `nll`.
-            Defaults to ``fre``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        score_type (str, optional): Type of anomaly score to compute.
+            Options are ``"fre"`` (feature reconstruction error) or
+            ``"nll"`` (negative log-likelihood).
+            Defaults to ``"fre"``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor to use.
+            If ``True``, uses the default pre-processor.
+            If ``False``, no pre-processing is performed.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor to use.
+            If ``True``, uses the default post-processor.
+            If ``False``, no post-processing is performed.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator to use.
+            If ``True``, uses the default evaluator.
+            If ``False``, no evaluation is performed.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer to use.
+            If ``True``, uses the default visualizer.
+            If ``False``, no visualization is performed.
+            Defaults to ``True``.
     """
 
     def __init__(
@@ -79,21 +117,23 @@ def __init__(
 
     @staticmethod
     def configure_optimizers() -> None:  # pylint: disable=arguments-differ
-        """DFM doesn't require optimization, therefore returns no optimizers."""
+        """Configure optimizers for training.
+
+        Returns:
+            None: DFM doesn't require optimization.
+        """
         return
 
     def training_step(self, batch: Batch, *args, **kwargs) -> None:
-        """Perform the training step of DFM.
-
-        For each batch, features are extracted from the CNN.
+        """Extract features from the input batch during training.
 
         Args:
-            batch (Batch): Input batch
-            args: Arguments.
-            kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images.
+            *args: Additional positional arguments (unused).
+            **kwargs: Additional keyword arguments (unused).
 
         Returns:
-          Deep CNN features.
+            torch.Tensor: Dummy loss tensor for compatibility.
         """
         del args, kwargs  # These variables are not used.
 
@@ -104,7 +144,11 @@ def training_step(self, batch: Batch, *args, **kwargs) -> None:
         return torch.tensor(0.0, requires_grad=True, device=self.device)
 
     def fit(self) -> None:
-        """Fit a PCA transformation and a Gaussian model to dataset."""
+        """Fit the PCA transformation and Gaussian model to the embeddings.
+
+        The method aggregates embeddings collected during training and fits
+        both the PCA transformation and Gaussian model used for scoring.
+        """
         logger.info("Aggregating the embedding extracted from the training set.")
         embeddings = torch.vstack(self.embeddings)
 
@@ -112,17 +156,15 @@ def fit(self) -> None:
         self.model.fit(embeddings)
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the validation step of DFM.
-
-        Similar to the training step, features are extracted from the CNN for each batch.
+        """Compute predictions for the input batch during validation.
 
         Args:
-          batch (Batch): Input batch
-          args: Arguments.
-          kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images.
+            *args: Additional positional arguments (unused).
+            **kwargs: Additional keyword arguments (unused).
 
         Returns:
-          Dictionary containing FRE anomaly scores and anomaly maps.
+            STEP_OUTPUT: Dictionary containing anomaly scores and maps.
         """
         del args, kwargs  # These variables are not used.
 
@@ -131,14 +173,21 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """Return DFM-specific trainer arguments."""
+        """Get DFM-specific trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary of trainer arguments:
+                - ``gradient_clip_val`` (int): Disable gradient clipping
+                - ``max_epochs`` (int): Train for one epoch only
+                - ``num_sanity_val_steps`` (int): Skip validation sanity checks
+        """
         return {"gradient_clip_val": 0, "max_epochs": 1, "num_sanity_val_steps": 0}
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type of the model.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: The model uses one-class learning.
         """
         return LearningType.ONE_CLASS
diff --git a/src/anomalib/models/image/dfm/torch_model.py b/src/anomalib/models/image/dfm/torch_model.py
index 520cbf8196..7ad516e35f 100644
--- a/src/anomalib/models/image/dfm/torch_model.py
+++ b/src/anomalib/models/image/dfm/torch_model.py
@@ -1,4 +1,26 @@
-"""PyTorch model for DFM model implementation."""
+"""PyTorch model for Deep Feature Modeling (DFM).
+
+This module provides a PyTorch implementation of the DFM model for anomaly
+detection. The model extracts deep features from images using a pre-trained CNN
+backbone and fits a Gaussian model on these features to detect anomalies.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.dfm.torch_model import DFMModel
+    >>> model = DFMModel(
+    ...     backbone="resnet18",
+    ...     layer="layer4",
+    ...     pre_trained=True
+    ... )
+    >>> batch = torch.randn(32, 3, 224, 224)
+    >>> features = model(batch)  # Returns features during training
+    >>> predictions = model(batch)  # Returns scores during inference
+
+Notes:
+    The model uses a pre-trained backbone to extract features and fits a PCA
+    transformation followed by a Gaussian model during training. No gradient
+    updates are performed on the backbone.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -14,9 +36,20 @@
 
 
 class SingleClassGaussian(DynamicBufferMixin):
-    """Model Gaussian distribution over a set of points."""
+    """Model Gaussian distribution over a set of points.
+
+    This class fits a single Gaussian distribution to a set of feature vectors
+    and computes likelihood scores for new samples.
+
+    Example:
+        >>> gaussian = SingleClassGaussian()
+        >>> features = torch.randn(128, 100)  # 100 samples of 128 dimensions
+        >>> gaussian.fit(features)
+        >>> scores = gaussian.score_samples(features)
+    """
 
     def __init__(self) -> None:
+        """Initialize Gaussian model with empty buffers."""
         super().__init__()
         self.register_buffer("mean_vec", torch.Tensor())
         self.register_buffer("u_mat", torch.Tensor())
@@ -29,16 +62,14 @@ def __init__(self) -> None:
     def fit(self, dataset: torch.Tensor) -> None:
         """Fit a Gaussian model to dataset X.
 
-        Covariance matrix is not calculated directly using:
-        ``C = X.X^T``
-        Instead, it is represented in terms of the Singular Value Decomposition of X:
-        ``X = U.S.V^T``
-        Hence,
-        ``C = U.S^2.U^T``
-        This simplifies the calculation of the log-likelihood without requiring full matrix inversion.
+        Covariance matrix is not calculated directly using ``C = X.X^T``.
+        Instead, it is represented using SVD of X: ``X = U.S.V^T``.
+        Hence, ``C = U.S^2.U^T``. This simplifies the calculation of the
+        log-likelihood without requiring full matrix inversion.
 
         Args:
-            dataset (torch.Tensor): Input dataset to fit the model.
+            dataset (torch.Tensor): Input dataset to fit the model with shape
+                ``(n_features, n_samples)``.
         """
         num_samples = dataset.shape[1]
         self.mean_vec = torch.mean(dataset, dim=1, device=dataset.device)
@@ -46,43 +77,57 @@ def fit(self, dataset: torch.Tensor) -> None:
         self.u_mat, self.sigma_mat, _ = torch.linalg.svd(data_centered, full_matrices=False)
 
     def score_samples(self, features: torch.Tensor) -> torch.Tensor:
-        """Compute the NLL (negative log likelihood) scores.
+        """Compute the negative log likelihood (NLL) scores.
 
         Args:
-            features (torch.Tensor): semantic features on which density modeling is performed.
+            features (torch.Tensor): Semantic features on which density modeling
+                is performed with shape ``(n_samples, n_features)``.
 
         Returns:
-            nll (torch.Tensor): Torch tensor of scores
+            torch.Tensor: NLL scores for each sample.
         """
         features_transformed = torch.matmul(features - self.mean_vec, self.u_mat / self.sigma_mat)
         return torch.sum(features_transformed * features_transformed, dim=1) + 2 * torch.sum(torch.log(self.sigma_mat))
 
     def forward(self, dataset: torch.Tensor) -> None:
-        """Provide the same functionality as `fit`.
+        """Fit the model to the input dataset.
 
         Transforms the input dataset based on singular values calculated earlier.
 
         Args:
-            dataset (torch.Tensor): Input dataset
+            dataset (torch.Tensor): Input dataset with shape
+                ``(n_features, n_samples)``.
         """
         self.fit(dataset)
 
 
 class DFMModel(nn.Module):
-    """Model for the DFM algorithm.
+    """Deep Feature Modeling (DFM) model for anomaly detection.
+
+    The model extracts deep features from images using a pre-trained CNN backbone
+    and fits a Gaussian model on these features to detect anomalies.
 
     Args:
-        backbone (str): Pre-trained model backbone.
+        backbone (str): Pre-trained model backbone from timm.
         layer (str): Layer from which to extract features.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
+        pre_trained (bool, optional): Whether to use pre-trained backbone.
             Defaults to ``True``.
-        pooling_kernel_size (int, optional): Kernel size to pool features extracted from the CNN.
+        pooling_kernel_size (int, optional): Kernel size to pool features.
             Defaults to ``4``.
-        n_comps (float, optional): Ratio from which number of components for PCA are calculated.
+        n_comps (float, optional): Ratio for PCA components calculation.
             Defaults to ``0.97``.
-        score_type (str, optional): Scoring type. Options are `fre` and `nll`.  Anomaly
-            Defaults to ``fre``. Segmentation is supported with `fre` only.
-            If using `nll`, set `task` in config.yaml to classification Defaults to ``classification``.
+        score_type (str, optional): Scoring type - ``fre`` or ``nll``.
+            Defaults to ``fre``. Segmentation supported with ``fre`` only.
+            For ``nll``, set task to classification.
+
+    Example:
+        >>> model = DFMModel(
+        ...     backbone="resnet18",
+        ...     layer="layer4",
+        ...     pre_trained=True
+        ... )
+        >>> input_tensor = torch.randn(32, 3, 224, 224)
+        >>> output = model(input_tensor)
     """
 
     def __init__(
@@ -109,10 +154,11 @@ def __init__(
         ).eval()
 
     def fit(self, dataset: torch.Tensor) -> None:
-        """Fit a pca transformation and a Gaussian model to dataset.
+        """Fit PCA and Gaussian model to dataset.
 
         Args:
-            dataset (torch.Tensor): Input dataset to fit the model.
+            dataset (torch.Tensor): Input dataset with shape
+                ``(n_samples, n_features)``.
         """
         self.pca_model.fit(dataset)
         if self.score_type == "nll":
@@ -120,17 +166,19 @@ def fit(self, dataset: torch.Tensor) -> None:
             self.gaussian_model.fit(features_reduced.T)
 
     def score(self, features: torch.Tensor, feature_shapes: tuple) -> torch.Tensor:
-        """Compute scores.
+        """Compute anomaly scores.
 
         Scores are either PCA-based feature reconstruction error (FRE) scores or
-        the Gaussian density-based NLL scores
+        Gaussian density-based NLL scores.
 
         Args:
-            features (torch.Tensor): semantic features on which PCA and density modeling is performed.
-            feature_shapes  (tuple): shape of `features` tensor. Used to generate anomaly map of correct shape.
+            features (torch.Tensor): Features for scoring with shape
+                ``(n_samples, n_features)``.
+            feature_shapes (tuple): Shape of features tensor for anomaly map.
 
         Returns:
-            score (torch.Tensor): numpy array of scores
+            tuple[torch.Tensor, Optional[torch.Tensor]]: Tuple containing
+                (scores, anomaly_maps). Anomaly maps are None for NLL scoring.
         """
         feats_projected = self.pca_model.transform(features)
         if self.score_type == "nll":
@@ -150,10 +198,12 @@ def get_features(self, batch: torch.Tensor) -> torch.Tensor:
         """Extract features from the pretrained network.
 
         Args:
-            batch (torch.Tensor): Image batch.
+            batch (torch.Tensor): Input images with shape
+                ``(batch_size, channels, height, width)``.
 
         Returns:
-            Tensor: torch.Tensor containing extracted features.
+            Union[torch.Tensor, Tuple[torch.Tensor, torch.Size]]: Features during
+                training, or tuple of (features, feature_shapes) during inference.
         """
         self.feature_extractor.eval()
         features = self.feature_extractor(batch)[self.layer]
@@ -165,13 +215,16 @@ def get_features(self, batch: torch.Tensor) -> torch.Tensor:
         return features if self.training else (features, feature_shapes)
 
     def forward(self, batch: torch.Tensor) -> torch.Tensor | InferenceBatch:
-        """Compute score from input images.
+        """Compute anomaly predictions from input images.
 
         Args:
-            batch (torch.Tensor): Input images
+            batch (torch.Tensor): Input images with shape
+                ``(batch_size, channels, height, width)``.
 
         Returns:
-            Tensor: Scores
+            Union[torch.Tensor, InferenceBatch]: Model predictions. During
+                training returns features tensor. During inference returns
+                ``InferenceBatch`` with prediction scores and anomaly maps.
         """
         feature_vector, feature_shapes = self.get_features(batch)
         pred_score, anomaly_map = self.score(feature_vector.view(feature_vector.shape[:2]), feature_shapes)
diff --git a/src/anomalib/models/image/draem/__init__.py b/src/anomalib/models/image/draem/__init__.py
index 4c8b06fa1d..945f5c9016 100644
--- a/src/anomalib/models/image/draem/__init__.py
+++ b/src/anomalib/models/image/draem/__init__.py
@@ -1,4 +1,23 @@
-"""DRAEM model."""
+"""DRAEM (Data-efficient Anomaly Detection and Localization) model.
+
+The DRAEM model uses a dual-branch architecture with a reconstruction branch and
+a segmentation branch to detect and localize anomalies. It is trained using
+synthetic anomalies generated by augmenting normal images.
+
+Example:
+    >>> from anomalib.models.image import Draem
+    >>> model = Draem()
+
+The model can be used with any of the supported datasets and task modes in
+anomalib.
+
+Notes:
+    The model implementation is available in the ``lightning_model`` module.
+
+See Also:
+    :class:`anomalib.models.image.draem.lightning_model.Draem`:
+        Lightning implementation of the DRAEM model.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/draem/lightning_model.py b/src/anomalib/models/image/draem/lightning_model.py
index 84b143f3f5..98a0568ce2 100644
--- a/src/anomalib/models/image/draem/lightning_model.py
+++ b/src/anomalib/models/image/draem/lightning_model.py
@@ -1,6 +1,13 @@
-"""DRÆM - A discriminatively trained reconstruction embedding for surface anomaly detection.
+"""DRÆM.
+
+A discriminatively trained reconstruction embedding for surface anomaly
+detection.
 
 Paper https://arxiv.org/abs/2108.07610
+
+This module implements the DRÆM model for surface anomaly detection. DRÆM uses a
+discriminatively trained reconstruction embedding approach to detect anomalies by
+comparing input images with their reconstructions.
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -30,19 +37,38 @@
 
 
 class Draem(AnomalibModule):
-    """DRÆM: A discriminatively trained reconstruction embedding for surface anomaly detection.
+    """DRÆM.
+
+    A discriminatively trained reconstruction embedding for
+    surface anomaly detection.
+
+    The model consists of two main components:
+    1. A reconstruction network that learns to reconstruct normal images
+    2. A discriminative network that learns to identify anomalous regions
 
     Args:
-        enable_sspcab (bool): Enable SSPCAB training.
+        enable_sspcab (bool, optional): Enable SSPCAB training.
             Defaults to ``False``.
-        sspcab_lambda (float): SSPCAB loss weight.
+        sspcab_lambda (float, optional): Weight factor for SSPCAB loss.
             Defaults to ``0.1``.
-        anomaly_source_path (str | None): Path to folder that contains the anomaly source images. Random noise will
-            be used if left empty.
-            Defaults to ``None``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
+        anomaly_source_path (str | None, optional): Path to directory containing
+            anomaly source images. If ``None``, random noise is used.
             Defaults to ``None``.
+        beta (float | tuple[float, float], optional): Blend factor for anomaly
+            generation. If tuple, represents range for random sampling.
+            Defaults to ``(0.1, 1.0)``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor instance or
+            flag to use default.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor instance
+            or flag to use default.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator instance or flag to
+            use default.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer instance or flag to
+            use default.
+            Defaults to ``True``.
     """
 
     def __init__(
@@ -75,22 +101,30 @@ def __init__(
             self.sspcab_lambda = sspcab_lambda
 
     def setup_sspcab(self) -> None:
-        """Prepare the model for the SSPCAB training step by adding forward hooks for the SSPCAB layer activations."""
+        """Set up SSPCAB forward hooks.
+
+        Prepares the model for SSPCAB training by adding forward hooks to capture
+        layer activations from specific points in the network.
+        """
 
         def get_activation(name: str) -> Callable:
-            """Retrieve the activations.
+            """Create a hook function to retrieve layer activations.
 
             Args:
-                name (str): Identifier for the retrieved activations.
+                name (str): Identifier for storing the activation in the
+                    activation dictionary.
+
+            Returns:
+                Callable: Hook function that stores layer activations.
             """
 
             def hook(_, __, output: torch.Tensor) -> None:  # noqa: ANN001
-                """Create hook for retrieving the activations.
+                """Store layer activations during forward pass.
 
                 Args:
-                    _: Placeholder for the module input.
-                    __: Placeholder for the module output.
-                    output (torch.Tensor): The output tensor of the module.
+                    _: Unused module argument.
+                    __: Unused input argument.
+                    output (torch.Tensor): Output tensor from the layer.
                 """
                 self.sspcab_activations[name] = output
 
@@ -100,18 +134,20 @@ def hook(_, __, output: torch.Tensor) -> None:  # noqa: ANN001
         self.model.reconstructive_subnetwork.encoder.block5.register_forward_hook(get_activation("output"))
 
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the training step of DRAEM.
+        """Perform training step for DRAEM.
 
-        Feeds the original image and the simulated anomaly
-        image through the network and computes the training loss.
+        The step consists of:
+        1. Generating simulated anomalies
+        2. Computing reconstructions and predictions
+        3. Calculating the loss
 
         Args:
-            batch (Batch): Batch containing image filename, image, label and mask
-            args: Arguments.
-            kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and metadata.
+            args: Additional positional arguments (unused).
+            kwargs: Additional keyword arguments (unused).
 
         Returns:
-            Loss dictionary
+            STEP_OUTPUT: Dictionary containing the training loss.
         """
         del args, kwargs  # These variables are not used.
 
@@ -133,15 +169,17 @@ def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         return {"loss": loss}
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the validation step of DRAEM. The Softmax predictions of the anomalous class are used as anomaly map.
+        """Perform validation step for DRAEM.
+
+        Uses softmax predictions of the anomalous class as anomaly maps.
 
         Args:
-            batch (Batch): Batch of input images
-            args: Arguments.
-            kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and metadata.
+            args: Additional positional arguments (unused).
+            kwargs: Additional keyword arguments (unused).
 
         Returns:
-            Dictionary to which predicted anomaly maps have been added.
+            STEP_OUTPUT: Dictionary containing predictions and metadata.
         """
         del args, kwargs  # These variables are not used.
 
@@ -150,27 +188,49 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """Return DRÆM-specific trainer arguments."""
+        """Get DRÆM-specific trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary containing trainer arguments:
+                - gradient_clip_val: ``0``
+                - num_sanity_val_steps: ``0``
+        """
         return {"gradient_clip_val": 0, "num_sanity_val_steps": 0}
 
     def configure_optimizers(self) -> torch.optim.Optimizer:
-        """Configure the Adam optimizer."""
+        """Configure optimizer and learning rate scheduler.
+
+        Returns:
+            tuple[list[Adam], list[MultiStepLR]]: Tuple containing optimizer and
+                scheduler lists.
+        """
         optimizer = torch.optim.Adam(params=self.model.parameters(), lr=0.0001)
         scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[400, 600], gamma=0.1)
         return [optimizer], [scheduler]
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type of the model.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: The learning type (``LearningType.ONE_CLASS``).
         """
         return LearningType.ONE_CLASS
 
     @staticmethod
     def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
-        """Default transform for DRAEM. Normalization is not needed as the images are scaled to [0, 1] in Dataset."""
+        """Configure default transforms for DRAEM.
+
+        Note:
+            Normalization is not needed as images are scaled to [0, 1] in Dataset.
+
+        Args:
+            image_size (tuple[int, int] | None, optional): Target size for image
+                resizing. Defaults to ``(256, 256)``.
+
+        Returns:
+            Transform: Composed transform including resizing.
+        """
         image_size = image_size or (256, 256)
         return Compose(
             [
diff --git a/src/anomalib/models/image/draem/loss.py b/src/anomalib/models/image/draem/loss.py
index 1cef702e15..2e65d97ecf 100644
--- a/src/anomalib/models/image/draem/loss.py
+++ b/src/anomalib/models/image/draem/loss.py
@@ -1,4 +1,19 @@
-"""Loss function for the DRAEM model implementation."""
+"""Loss function for the DRAEM model implementation.
+
+This module implements the loss function used to train the DRAEM model for anomaly
+detection. The loss combines L2 reconstruction loss, focal loss for anomaly
+segmentation, and structural similarity (SSIM) loss.
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.draem.loss import DraemLoss
+    >>> criterion = DraemLoss()
+    >>> input_image = torch.randn(8, 3, 256, 256)
+    >>> reconstruction = torch.randn(8, 3, 256, 256)
+    >>> anomaly_mask = torch.randint(0, 2, (8, 1, 256, 256))
+    >>> prediction = torch.randn(8, 2, 256, 256)
+    >>> loss = criterion(input_image, reconstruction, anomaly_mask, prediction)
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -11,11 +26,20 @@
 class DraemLoss(nn.Module):
     """Overall loss function of the DRAEM model.
 
-    The total loss consists of the sum of the L2 loss and Focal loss between the reconstructed image and the input
-    image, and the Structural Similarity loss between the predicted and GT anomaly masks.
+    The total loss consists of three components:
+    1. L2 loss between the reconstructed and input images
+    2. Focal loss between predicted and ground truth anomaly masks
+    3. Structural Similarity (SSIM) loss between reconstructed and input images
+
+    The final loss is computed as: ``loss = l2_loss + ssim_loss + focal_loss``
+
+    Example:
+        >>> criterion = DraemLoss()
+        >>> loss = criterion(input_image, reconstruction, anomaly_mask, prediction)
     """
 
     def __init__(self) -> None:
+        """Initialize loss components with default parameters."""
         super().__init__()
 
         self.l2_loss = nn.modules.loss.MSELoss()
@@ -29,7 +53,21 @@ def forward(
         anomaly_mask: torch.Tensor,
         prediction: torch.Tensor,
     ) -> torch.Tensor:
-        """Compute the loss over a batch for the DRAEM model."""
+        """Compute the combined loss over a batch for the DRAEM model.
+
+        Args:
+            input_image: Original input images of shape
+                ``(batch_size, num_channels, height, width)``
+            reconstruction: Reconstructed images from the model of shape
+                ``(batch_size, num_channels, height, width)``
+            anomaly_mask: Ground truth anomaly masks of shape
+                ``(batch_size, 1, height, width)``
+            prediction: Model predictions of shape
+                ``(batch_size, num_classes, height, width)``
+
+        Returns:
+            torch.Tensor: Combined loss value
+        """
         l2_loss_val = self.l2_loss(reconstruction, input_image)
         focal_loss_val = self.focal_loss(prediction, anomaly_mask.squeeze(1).long())
         ssim_loss_val = self.ssim_loss(reconstruction, input_image) * 2
diff --git a/src/anomalib/models/image/draem/torch_model.py b/src/anomalib/models/image/draem/torch_model.py
index 3ce080aca5..5ef1d7eba6 100644
--- a/src/anomalib/models/image/draem/torch_model.py
+++ b/src/anomalib/models/image/draem/torch_model.py
@@ -1,4 +1,10 @@
-"""PyTorch model for the DRAEM model implementation."""
+"""PyTorch model for the DRAEM model implementation.
+
+The DRAEM model consists of two sub-networks:
+1. A reconstructive sub-network that learns to reconstruct input images
+2. A discriminative sub-network that detects anomalies by comparing original and
+   reconstructed images
+"""
 
 # Original Code
 # Copyright (c) 2021 VitjanZ
@@ -17,11 +23,15 @@
 
 
 class DraemModel(nn.Module):
-    """DRAEM PyTorch model consisting of the reconstructive and discriminative sub networks.
+    """DRAEM PyTorch model with reconstructive and discriminative sub-networks.
 
     Args:
-        sspcab (bool): Enable SSPCAB training.
-            Defaults to ``False``.
+        sspcab (bool, optional): Enable SSPCAB training. Defaults to ``False``.
+
+    Example:
+        >>> model = DraemModel(sspcab=True)
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> reconstruction, prediction = model(input_tensor)
     """
 
     def __init__(self, sspcab: bool = False) -> None:
@@ -30,14 +40,27 @@ def __init__(self, sspcab: bool = False) -> None:
         self.discriminative_subnetwork = DiscriminativeSubNetwork(in_channels=6, out_channels=2)
 
     def forward(self, batch: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor] | InferenceBatch:
-        """Compute the reconstruction and anomaly mask from an input image.
+        """Forward pass through both sub-networks.
 
         Args:
-            batch (torch.Tensor): batch of input images
+            batch (torch.Tensor): Input batch of images of shape
+                ``(batch_size, channels, height, width)``
 
         Returns:
-            Predicted confidence values of the anomaly mask. During training the reconstructed input images are
-            returned as well.
+            During training:
+                tuple: Tuple containing:
+                    - Reconstructed images
+                    - Predicted anomaly masks
+            During inference:
+                InferenceBatch: Contains anomaly map and prediction score
+
+        Example:
+            >>> model = DraemModel()
+            >>> batch = torch.randn(32, 3, 256, 256)
+            >>> reconstruction, prediction = model(batch)  # Training mode
+            >>> model.eval()
+            >>> output = model(batch)  # Inference mode
+            >>> assert isinstance(output, InferenceBatch)
         """
         reconstruction = self.reconstructive_subnetwork(batch)
         concatenated_inputs = torch.cat([batch, reconstruction], axis=1)
@@ -51,17 +74,21 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor | tuple[torch.Tensor, tor
 
 
 class ReconstructiveSubNetwork(nn.Module):
-    """Autoencoder model that encodes and reconstructs the input image.
+    """Autoencoder model for image reconstruction.
 
     Args:
-        in_channels (int): Number of input channels.
-            Defaults to ``3``.
-        out_channels (int): Number of output channels.
-            Defaults to ``3``.
-        base_width (int): Base dimensionality of the layers of the autoencoder.
-            Defaults to ``128``.
-        sspcab (bool): Enable SSPCAB training.
-            Defaults to ``False``.
+        in_channels (int, optional): Number of input channels. Defaults to ``3``.
+        out_channels (int, optional): Number of output channels. Defaults to ``3``.
+        base_width (int, optional): Base dimensionality of layers. Defaults to
+            ``128``.
+        sspcab (bool, optional): Enable SSPCAB training. Defaults to ``False``.
+
+    Example:
+        >>> subnet = ReconstructiveSubNetwork(in_channels=3, base_width=64)
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> output = subnet(input_tensor)
+        >>> output.shape
+        torch.Size([32, 3, 256, 256])
     """
 
     def __init__(
@@ -76,28 +103,37 @@ def __init__(
         self.decoder = DecoderReconstructive(base_width, out_channels=out_channels)
 
     def forward(self, batch: torch.Tensor) -> torch.Tensor:
-        """Encode and reconstruct the input images.
+        """Encode and reconstruct input images.
 
         Args:
-            batch (torch.Tensor): Batch of input images
+            batch (torch.Tensor): Batch of input images of shape
+                ``(batch_size, channels, height, width)``
 
         Returns:
-            Batch of reconstructed images.
+            torch.Tensor: Batch of reconstructed images of same shape as input
         """
         encoded = self.encoder(batch)
         return self.decoder(encoded)
 
 
 class DiscriminativeSubNetwork(nn.Module):
-    """Discriminative model that predicts the anomaly mask from the original image and its reconstruction.
+    """Discriminative model for anomaly mask prediction.
+
+    Compares original images with their reconstructions to predict anomaly masks.
 
     Args:
-        in_channels (int): Number of input channels.
-            Defaults to ``3``.
-        out_channels (int): Number of output channels.
-            Defaults to ``3``.
-        base_width (int): Base dimensionality of the layers of the autoencoder.
-            Defaults to ``64``.
+        in_channels (int, optional): Number of input channels. Defaults to ``3``.
+        out_channels (int, optional): Number of output channels. Defaults to ``3``.
+        base_width (int, optional): Base dimensionality of layers. Defaults to
+            ``64``.
+
+    Example:
+        >>> subnet = DiscriminativeSubNetwork(in_channels=6, out_channels=2)
+        >>> # Concatenated original and reconstructed images
+        >>> input_tensor = torch.randn(32, 6, 256, 256)
+        >>> output = subnet(input_tensor)
+        >>> output.shape
+        torch.Size([32, 2, 256, 256])
     """
 
     def __init__(self, in_channels: int = 3, out_channels: int = 3, base_width: int = 64) -> None:
@@ -106,25 +142,32 @@ def __init__(self, in_channels: int = 3, out_channels: int = 3, base_width: int
         self.decoder_segment = DecoderDiscriminative(base_width, out_channels=out_channels)
 
     def forward(self, batch: torch.Tensor) -> torch.Tensor:
-        """Generate the predicted anomaly masks for a batch of input images.
+        """Generate predicted anomaly masks.
 
         Args:
-            batch (torch.Tensor): Batch of inputs consisting of the concatenation of the original images
-             and their reconstructions.
+            batch (torch.Tensor): Concatenated original and reconstructed images of
+                shape ``(batch_size, channels*2, height, width)``
 
         Returns:
-            Activations of the output layer corresponding to the normal and anomalous class scores on the pixel level.
+            torch.Tensor: Pixel-level class scores for normal and anomalous regions
         """
         act1, act2, act3, act4, act5, act6 = self.encoder_segment(batch)
         return self.decoder_segment(act1, act2, act3, act4, act5, act6)
 
 
 class EncoderDiscriminative(nn.Module):
-    """Encoder part of the discriminator network.
+    """Encoder component of the discriminator network.
 
     Args:
-        in_channels (int): Number of input channels.
-        base_width (int): Base dimensionality of the layers of the autoencoder.
+        in_channels (int): Number of input channels
+        base_width (int): Base dimensionality of the layers
+
+    Example:
+        >>> encoder = EncoderDiscriminative(in_channels=6, base_width=64)
+        >>> input_tensor = torch.randn(32, 6, 256, 256)
+        >>> outputs = encoder(input_tensor)
+        >>> len(outputs)  # Returns 6 activation maps
+        6
     """
 
     def __init__(self, in_channels: int, base_width: int) -> None:
@@ -188,14 +231,14 @@ def forward(
         self,
         batch: torch.Tensor,
     ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Convert the inputs to the salient space by running them through the encoder network.
+        """Convert inputs to salient space through encoder network.
 
         Args:
-            batch (torch.Tensor): Batch of inputs consisting of the concatenation of the original images
-             and their reconstructions.
+            batch (torch.Tensor): Input batch of concatenated original and
+                reconstructed images
 
         Returns:
-            Computed feature maps for each of the layers in the encoder sub network.
+            tuple: Contains 6 activation tensors from each encoder block
         """
         act1 = self.block1(batch)
         mp1 = self.mp1(act1)
@@ -212,12 +255,19 @@ def forward(
 
 
 class DecoderDiscriminative(nn.Module):
-    """Decoder part of the discriminator network.
+    """Decoder component of the discriminator network.
 
     Args:
-        base_width (int): Base dimensionality of the layers of the autoencoder.
-        out_channels (int): Number of output channels.
-            Defaults to ``1``.
+        base_width (int): Base dimensionality of the layers
+        out_channels (int, optional): Number of output channels. Defaults to ``1``
+
+    Example:
+        >>> decoder = DecoderDiscriminative(base_width=64, out_channels=2)
+        >>> # Create 6 mock activation tensors
+        >>> acts = [torch.randn(32, 64, 256>>i, 256>>i) for i in range(6)]
+        >>> output = decoder(*acts)
+        >>> output.shape
+        torch.Size([32, 2, 256, 256])
     """
 
     def __init__(self, base_width: int, out_channels: int = 1) -> None:
@@ -309,18 +359,18 @@ def forward(
         act5: torch.Tensor,
         act6: torch.Tensor,
     ) -> torch.Tensor:
-        """Compute predicted anomaly class scores from the intermediate outputs of the encoder sub network.
+        """Compute predicted anomaly scores from encoder activations.
 
         Args:
-            act1 (torch.Tensor): Encoder activations of the first block of convolutional layers.
-            act2 (torch.Tensor): Encoder activations of the second block of convolutional layers.
-            act3 (torch.Tensor): Encoder activations of the third block of convolutional layers.
-            act4 (torch.Tensor): Encoder activations of the fourth block of convolutional layers.
-            act5 (torch.Tensor): Encoder activations of the fifth block of convolutional layers.
-            act6 (torch.Tensor): Encoder activations of the sixth block of convolutional layers.
+            act1 (torch.Tensor): First block encoder activations
+            act2 (torch.Tensor): Second block encoder activations
+            act3 (torch.Tensor): Third block encoder activations
+            act4 (torch.Tensor): Fourth block encoder activations
+            act5 (torch.Tensor): Fifth block encoder activations
+            act6 (torch.Tensor): Sixth block encoder activations
 
         Returns:
-            Predicted anomaly class scores per pixel.
+            torch.Tensor: Predicted anomaly scores per pixel
         """
         up_b = self.up_b(act6)
         cat_b = torch.cat((up_b, act5), dim=1)
@@ -346,13 +396,19 @@ def forward(
 
 
 class EncoderReconstructive(nn.Module):
-    """Encoder part of the reconstructive network.
+    """Encoder component of the reconstructive network.
 
     Args:
-        in_channels (int): Number of input channels.
-        base_width (int): Base dimensionality of the layers of the autoencoder.
-        sspcab (bool): Enable SSPCAB training.
-            Defaults to ``False``.
+        in_channels (int): Number of input channels
+        base_width (int): Base dimensionality of the layers
+        sspcab (bool, optional): Enable SSPCAB training. Defaults to ``False``
+
+    Example:
+        >>> encoder = EncoderReconstructive(in_channels=3, base_width=64)
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> output = encoder(input_tensor)
+        >>> output.shape
+        torch.Size([32, 512, 16, 16])
     """
 
     def __init__(self, in_channels: int, base_width: int, sspcab: bool = False) -> None:
@@ -406,13 +462,14 @@ def __init__(self, in_channels: int, base_width: int, sspcab: bool = False) -> N
             )
 
     def forward(self, batch: torch.Tensor) -> torch.Tensor:
-        """Encode a batch of input images to the salient space.
+        """Encode input images to the salient space.
 
         Args:
-            batch (torch.Tensor): Batch of input images.
+            batch (torch.Tensor): Input batch of images of shape
+                ``(batch_size, channels, height, width)``
 
         Returns:
-            Feature maps extracted from the bottleneck layer.
+            torch.Tensor: Feature maps from the bottleneck layer
         """
         act1 = self.block1(batch)
         mp1 = self.mp1(act1)
@@ -426,12 +483,18 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor:
 
 
 class DecoderReconstructive(nn.Module):
-    """Decoder part of the reconstructive network.
+    """Decoder component of the reconstructive network.
 
     Args:
-        base_width (int): Base dimensionality of the layers of the autoencoder.
-        out_channels (int): Number of output channels.
-            Defaults to ``1``.
+        base_width (int): Base dimensionality of the layers
+        out_channels (int, optional): Number of output channels. Defaults to ``1``
+
+    Example:
+        >>> decoder = DecoderReconstructive(base_width=64, out_channels=3)
+        >>> input_tensor = torch.randn(32, 512, 16, 16)
+        >>> output = decoder(input_tensor)
+        >>> output.shape
+        torch.Size([32, 3, 256, 256])
     """
 
     def __init__(self, base_width: int, out_channels: int = 1) -> None:
@@ -501,13 +564,14 @@ def __init__(self, base_width: int, out_channels: int = 1) -> None:
         self.fin_out = nn.Sequential(nn.Conv2d(base_width, out_channels, kernel_size=3, padding=1))
 
     def forward(self, act5: torch.Tensor) -> torch.Tensor:
-        """Reconstruct the image from the activations of the bottleneck layer.
+        """Reconstruct image from bottleneck features.
 
         Args:
-            act5 (torch.Tensor): Activations of the bottleneck layer.
+            act5 (torch.Tensor): Activations from the bottleneck layer of shape
+                ``(batch_size, channels, height, width)``
 
         Returns:
-            Batch of reconstructed images.
+            torch.Tensor: Reconstructed images of same size as original input
         """
         up1 = self.up1(act5)
         db1 = self.db1(up1)
diff --git a/src/anomalib/models/image/dsr/__init__.py b/src/anomalib/models/image/dsr/__init__.py
index 54e53d5d6f..e54bfc7c82 100644
--- a/src/anomalib/models/image/dsr/__init__.py
+++ b/src/anomalib/models/image/dsr/__init__.py
@@ -1,4 +1,23 @@
-"""DSR model."""
+"""Deep Spatial Reconstruction (DSR) model.
+
+DSR is an anomaly detection model that uses a deep autoencoder architecture to
+learn spatial reconstructions of normal images. The model learns to reconstruct
+normal patterns and identifies anomalies based on reconstruction errors.
+
+Example:
+    >>> from anomalib.models.image import Dsr
+    >>> model = Dsr()
+
+The model can be used with any of the supported datasets and task modes in
+anomalib.
+
+Notes:
+    The model implementation is available in the ``lightning_model`` module.
+
+See Also:
+    :class:`anomalib.models.image.dsr.lightning_model.Dsr`:
+        Lightning implementation of the DSR model.
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/dsr/anomaly_generator.py b/src/anomalib/models/image/dsr/anomaly_generator.py
index 2d1d5c4a75..b4c884a9db 100644
--- a/src/anomalib/models/image/dsr/anomaly_generator.py
+++ b/src/anomalib/models/image/dsr/anomaly_generator.py
@@ -1,4 +1,15 @@
-"""Anomaly generator for the DSR model implementation."""
+"""Anomaly generator for the DSR model implementation.
+
+This module implements an anomaly generator that creates synthetic anomalies
+using Perlin noise. The generator is used during the second phase of DSR model
+training to create anomalous samples.
+
+Example:
+    >>> from anomalib.models.image.dsr.anomaly_generator import DsrAnomalyGenerator
+    >>> generator = DsrAnomalyGenerator(p_anomalous=0.5)
+    >>> batch = torch.randn(8, 3, 256, 256)
+    >>> masks = generator.augment_batch(batch)
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -11,14 +22,21 @@
 
 
 class DsrAnomalyGenerator(nn.Module):
-    """Anomaly generator of the DSR model.
+    """Anomaly generator for the DSR model.
 
-    The anomaly is generated using a Perlin noise generator on the two quantized representations of an image.
-    This generator is only used during the second phase of training! The third phase requires generating
-    smudges over the input images.
+    The generator creates synthetic anomalies by applying Perlin noise to images.
+    It is used during the second phase of DSR model training. The third phase
+    uses a different approach with smudge-based anomalies.
 
     Args:
-        p_anomalous (float, optional): Probability to generate an anomalous image.
+        p_anomalous (float, optional): Probability of generating an anomalous
+            image. Defaults to ``0.5``.
+
+    Example:
+        >>> generator = DsrAnomalyGenerator(p_anomalous=0.7)
+        >>> batch = torch.randn(4, 3, 256, 256)
+        >>> masks = generator.augment_batch(batch)
+        >>> assert masks.shape == (4, 1, 256, 256)
     """
 
     def __init__(
@@ -32,14 +50,21 @@ def __init__(
         self.rot = v2.RandomAffine(degrees=(-90, 90))
 
     def generate_anomaly(self, height: int, width: int) -> Tensor:
-        """Generate an anomalous mask.
+        """Generate an anomalous mask using Perlin noise.
 
         Args:
-            height (int): Height of generated mask.
-            width (int): Width of generated mask.
+            height (int): Height of the mask to generate.
+            width (int): Width of the mask to generate.
 
         Returns:
-            Tensor: Generated mask.
+            Tensor: Binary mask of shape ``(1, height, width)`` where ``1``
+                indicates anomalous regions.
+
+        Example:
+            >>> generator = DsrAnomalyGenerator()
+            >>> mask = generator.generate_anomaly(256, 256)
+            >>> assert mask.shape == (1, 256, 256)
+            >>> assert torch.all((mask >= 0) & (mask <= 1))
         """
         min_perlin_scale = 0
         perlin_scale = 6
@@ -59,13 +84,23 @@ def generate_anomaly(self, height: int, width: int) -> Tensor:
         return mask.unsqueeze(0)  # Add channel dimension [1, H, W]
 
     def augment_batch(self, batch: Tensor) -> Tensor:
-        """Generate anomalous augmentations for a batch of input images.
+        """Generate anomalous masks for a batch of images.
 
         Args:
-            batch (Tensor): Batch of input images
+            batch (Tensor): Input batch of images of shape
+                ``(batch_size, channels, height, width)``.
 
         Returns:
-            Tensor: Ground truth masks corresponding to the anomalous perturbations.
+            Tensor: Batch of binary masks of shape
+                ``(batch_size, 1, height, width)`` where ``1`` indicates
+                anomalous regions.
+
+        Example:
+            >>> generator = DsrAnomalyGenerator()
+            >>> batch = torch.randn(8, 3, 256, 256)
+            >>> masks = generator.augment_batch(batch)
+            >>> assert masks.shape == (8, 1, 256, 256)
+            >>> assert torch.all((masks >= 0) & (masks <= 1))
         """
         batch_size, _, height, width = batch.shape
 
diff --git a/src/anomalib/models/image/dsr/lightning_model.py b/src/anomalib/models/image/dsr/lightning_model.py
index dd80e88ba7..86392b76a9 100644
--- a/src/anomalib/models/image/dsr/lightning_model.py
+++ b/src/anomalib/models/image/dsr/lightning_model.py
@@ -1,6 +1,33 @@
 """DSR - A Dual Subspace Re-Projection Network for Surface Anomaly Detection.
 
-Paper https://link.springer.com/chapter/10.1007/978-3-031-19821-2_31
+This module implements the DSR model for surface anomaly detection. DSR uses a dual
+subspace re-projection approach to detect anomalies by comparing input images with
+their reconstructions in two different subspaces.
+
+The model consists of three training phases:
+1. A discrete model pre-training phase (using pre-trained weights)
+2. Training of the main reconstruction and anomaly detection modules
+3. Training of the upsampling module
+
+Paper: https://link.springer.com/chapter/10.1007/978-3-031-19821-2_31
+
+Example:
+    >>> from anomalib.models.image import Dsr
+    >>> model = Dsr(
+    ...     latent_anomaly_strength=0.2,
+    ...     upsampling_train_ratio=0.7
+    ... )
+
+The model can be used with any of the supported datasets and task modes in
+anomalib.
+
+Notes:
+    The model requires pre-trained weights for the discrete model which are
+    downloaded automatically during training.
+
+See Also:
+    :class:`anomalib.models.image.dsr.torch_model.DsrModel`:
+        PyTorch implementation of the DSR model architecture.
 """
 
 # Copyright (C) 2023-2024 Intel Corporation
@@ -33,7 +60,8 @@
 
 WEIGHTS_DOWNLOAD_INFO = DownloadInfo(
     name="vq_model_pretrained_128_4096.pckl",
-    url="https://github.com/openvinotoolkit/anomalib/releases/download/dsr_pretrained_weights/dsr_vq_model_pretrained.zip",
+    url="https://github.com/openvinotoolkit/anomalib/releases/download/"
+    "dsr_pretrained_weights/dsr_vq_model_pretrained.zip",
     hashsum="52fe7504ec8e9df70b4382f287ab26269dcfe000cd7a7e146a52c6f146f34afb",
 )
 
@@ -41,12 +69,33 @@
 class Dsr(AnomalibModule):
     """DSR: A Dual Subspace Re-Projection Network for Surface Anomaly Detection.
 
+    The model uses a dual subspace approach with three training phases:
+    1. Pre-trained discrete model (loaded from weights)
+    2. Training of reconstruction and anomaly detection modules
+    3. Training of the upsampling module for final anomaly map generation
+
     Args:
-        latent_anomaly_strength (float): Strength of the generated anomalies in the latent space. Defaults to 0.2
-        upsampling_train_ratio (float): Ratio of training steps for the upsampling module. Defaults to 0.7
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        latent_anomaly_strength (float, optional): Strength of the generated
+            anomalies in the latent space. Defaults to ``0.2``.
+        upsampling_train_ratio (float, optional): Ratio of training steps for
+            the upsampling module. Defaults to ``0.7``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor instance or
+            flag to use default. Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor instance
+            or flag to use default. Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator instance or flag to
+            use default. Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer instance or flag to
+            use default. Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models.image import Dsr
+        >>> model = Dsr(
+        ...     latent_anomaly_strength=0.2,
+        ...     upsampling_train_ratio=0.7
+        ... )
+        >>> model.trainer_arguments
+        {'num_sanity_val_steps': 0}
     """
 
     def __init__(
@@ -78,7 +127,17 @@ def __init__(
 
     @staticmethod
     def prepare_pretrained_model() -> Path:
-        """Download pre-trained models if they don't exist."""
+        """Download pre-trained models if they don't exist.
+
+        Returns:
+            Path: Path to the downloaded pre-trained model weights.
+
+        Example:
+            >>> model = Dsr()
+            >>> weights_path = model.prepare_pretrained_model()
+            >>> weights_path.name
+            'vq_model_pretrained_128_4096.pckl'
+        """
         pretrained_models_dir = Path("./pre_trained/")
         if not (pretrained_models_dir / "vq_model_pretrained_128_4096.pckl").is_file():
             download_and_extract(pretrained_models_dir, WEIGHTS_DOWNLOAD_INFO)
@@ -92,7 +151,16 @@ def configure_optimizers(
         Does not train the discrete model (phase 1)
 
         Returns:
-            dict[str, torch.optim.Optimizer | torch.optim.lr_scheduler.LRScheduler]: Dictionary of optimizers
+            dict[str, torch.optim.Optimizer | torch.optim.lr_scheduler.LRScheduler]:
+                Dictionary containing optimizers and schedulers.
+
+        Example:
+            >>> model = Dsr()
+            >>> optimizers = model.configure_optimizers()
+            >>> isinstance(optimizers, tuple)
+            True
+            >>> len(optimizers)
+            2
         """
         num_steps = max(
             self.trainer.max_steps // len(self.trainer.datamodule.train_dataloader()),
@@ -126,19 +194,34 @@ def on_train_epoch_start(self) -> None:
     def training_step(self, batch: Batch) -> STEP_OUTPUT:
         """Training Step of DSR.
 
-        Feeds the original image and the simulated anomaly mask during first phase. During
-        second phase, feeds a generated anomalous image to train the upsampling module.
+        During the first phase, feeds the original image and simulated anomaly
+        mask. During second phase, feeds a generated anomalous image to train
+        the upsampling module.
 
         Args:
-            batch (Batch): Batch containing image filename, image, label and mask
+            batch (Batch): Input batch containing image, label and mask
 
         Returns:
-            STEP_OUTPUT: Loss dictionary
+            STEP_OUTPUT: Dictionary containing the loss value
+
+        Example:
+            >>> from anomalib.data import Batch
+            >>> model = Dsr()
+            >>> batch = Batch(
+            ...     image=torch.randn(8, 3, 256, 256),
+            ...     label=torch.zeros(8)
+            ... )
+            >>> output = model.training_step(batch)
+            >>> isinstance(output, dict)
+            True
+            >>> "loss" in output
+            True
         """
         ph1_opt, ph2_opt = self.optimizers()
 
         if self.current_epoch < self.second_phase:
-            # we are not yet training the upsampling module: we are only using the first optimizer
+            # we are not yet training the upsampling module: we are only using
+            # the first optimizer
             input_image = batch.image
             # Create anomaly masks
             anomaly_mask = self.quantized_anomaly_generator.augment_batch(input_image)
@@ -185,12 +268,23 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         The Softmax predictions of the anomalous class are used as anomaly map.
 
         Args:
-            batch (Batch): Batch of input images
-            *args: unused
-            **kwargs: unused
+            batch (Batch): Input batch containing image, label and mask
+            *args: Additional positional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-            STEP_OUTPUT: Dictionary to which predicted anomaly maps have been added.
+            STEP_OUTPUT: Dictionary containing predictions and batch information
+
+        Example:
+            >>> from anomalib.data import Batch
+            >>> model = Dsr()
+            >>> batch = Batch(
+            ...     image=torch.randn(8, 3, 256, 256),
+            ...     label=torch.zeros(8)
+            ... )
+            >>> output = model.validation_step(batch)
+            >>> isinstance(output, Batch)
+            True
         """
         del args, kwargs  # These variables are not used.
 
@@ -199,7 +293,16 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """Required trainer arguments."""
+        """Required trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary of trainer arguments
+
+        Example:
+            >>> model = Dsr()
+            >>> model.trainer_arguments
+            {'num_sanity_val_steps': 0}
+        """
         return {"num_sanity_val_steps": 0}
 
     @property
@@ -208,12 +311,33 @@ def learning_type(self) -> LearningType:
 
         Returns:
             LearningType: Learning type of the model.
+
+        Example:
+            >>> model = Dsr()
+            >>> model.learning_type
+            
         """
         return LearningType.ONE_CLASS
 
     @staticmethod
     def configure_transforms(image_size: tuple[int, int] | None = None) -> Transform:
-        """Default transform for DSR. Normalization is not needed as the images are scaled to [0, 1] in Dataset."""
+        """Configure default transforms for DSR.
+
+        Normalization is not needed as the images are scaled to [0, 1] in Dataset.
+
+        Args:
+            image_size (tuple[int, int] | None, optional): Input image size.
+                Defaults to ``(256, 256)``.
+
+        Returns:
+            Transform: Composed transforms
+
+        Example:
+            >>> model = Dsr()
+            >>> transforms = model.configure_transforms((512, 512))
+            >>> isinstance(transforms, Transform)
+            True
+        """
         image_size = image_size or (256, 256)
         return Compose(
             [
diff --git a/src/anomalib/models/image/dsr/loss.py b/src/anomalib/models/image/dsr/loss.py
index f1020b9d34..07a9a14578 100644
--- a/src/anomalib/models/image/dsr/loss.py
+++ b/src/anomalib/models/image/dsr/loss.py
@@ -1,4 +1,22 @@
-"""Loss function for the DSR model implementation."""
+"""Loss functions for the DSR model implementation.
+
+This module contains the loss functions used in the second and third training
+phases of the DSR model.
+
+Example:
+    >>> from anomalib.models.image.dsr.loss import DsrSecondStageLoss
+    >>> loss_fn = DsrSecondStageLoss()
+    >>> loss = loss_fn(
+    ...     recon_nq_hi=recon_nq_hi,
+    ...     recon_nq_lo=recon_nq_lo,
+    ...     qu_hi=qu_hi,
+    ...     qu_lo=qu_lo,
+    ...     input_image=input_image,
+    ...     gen_img=gen_img,
+    ...     seg=seg,
+    ...     anomaly_mask=anomaly_mask
+    ... )
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -8,13 +26,27 @@
 
 
 class DsrSecondStageLoss(nn.Module):
-    """Overall loss function of the second training phase of the DSR model.
-
-    The total loss consists of:
-        - MSE loss between non-anomalous quantized input image and anomalous subspace-reconstructed
-          non-quantized input (hi and lo)
-        - MSE loss between input image and reconstructed image through object-specific decoder,
-        - Focal loss between computed segmentation mask and ground truth mask.
+    """Loss function for the second training phase of the DSR model.
+
+    The total loss is a combination of:
+        - MSE loss between non-anomalous quantized input image and anomalous
+          subspace-reconstructed non-quantized input (hi and lo features)
+        - MSE loss between input image and reconstructed image through
+          object-specific decoder
+        - Focal loss between computed segmentation mask and ground truth mask
+
+    Example:
+        >>> loss_fn = DsrSecondStageLoss()
+        >>> loss = loss_fn(
+        ...     recon_nq_hi=recon_nq_hi,
+        ...     recon_nq_lo=recon_nq_lo,
+        ...     qu_hi=qu_hi,
+        ...     qu_lo=qu_lo,
+        ...     input_image=input_image,
+        ...     gen_img=gen_img,
+        ...     seg=seg,
+        ...     anomaly_mask=anomaly_mask
+        ... )
     """
 
     def __init__(self) -> None:
@@ -34,20 +66,33 @@ def forward(
         seg: Tensor,
         anomaly_mask: Tensor,
     ) -> Tensor:
-        """Compute the loss over a batch for the DSR model.
+        """Compute the combined loss over a batch.
 
         Args:
             recon_nq_hi (Tensor): Reconstructed non-quantized hi feature
             recon_nq_lo (Tensor): Reconstructed non-quantized lo feature
             qu_hi (Tensor): Non-defective quantized hi feature
             qu_lo (Tensor): Non-defective quantized lo feature
-            input_image (Tensor): Original image
+            input_image (Tensor): Original input image
             gen_img (Tensor): Object-specific decoded image
-            seg (Tensor): Computed anomaly map
-            anomaly_mask (Tensor): Ground truth anomaly map
+            seg (Tensor): Computed anomaly segmentation map
+            anomaly_mask (Tensor): Ground truth anomaly mask
 
         Returns:
-            Tensor: Total loss
+            Tensor: Total combined loss value
+
+        Example:
+            >>> loss_fn = DsrSecondStageLoss()
+            >>> loss = loss_fn(
+            ...     recon_nq_hi=torch.randn(32, 64, 32, 32),
+            ...     recon_nq_lo=torch.randn(32, 64, 32, 32),
+            ...     qu_hi=torch.randn(32, 64, 32, 32),
+            ...     qu_lo=torch.randn(32, 64, 32, 32),
+            ...     input_image=torch.randn(32, 3, 256, 256),
+            ...     gen_img=torch.randn(32, 3, 256, 256),
+            ...     seg=torch.randn(32, 2, 256, 256),
+            ...     anomaly_mask=torch.randint(0, 2, (32, 1, 256, 256))
+            ... )
         """
         l2_loss_hi_val = self.l2_loss(recon_nq_hi, qu_hi)
         l2_loss_lo_val = self.l2_loss(recon_nq_lo, qu_lo)
@@ -57,9 +102,17 @@ def forward(
 
 
 class DsrThirdStageLoss(nn.Module):
-    """Overall loss function of the third training phase of the DSR model.
+    """Loss function for the third training phase of the DSR model.
+
+    The loss consists of a focal loss between the computed segmentation mask
+    and the ground truth mask.
 
-    The loss consists of a focal loss between the computed segmentation mask and the ground truth mask.
+    Example:
+        >>> loss_fn = DsrThirdStageLoss()
+        >>> loss = loss_fn(
+        ...     pred_mask=pred_mask,
+        ...     true_mask=true_mask
+        ... )
     """
 
     def __init__(self) -> None:
@@ -68,13 +121,20 @@ def __init__(self) -> None:
         self.focal_loss = FocalLoss(alpha=1, reduction="mean")
 
     def forward(self, pred_mask: Tensor, true_mask: Tensor) -> Tensor:
-        """Compute the loss over a batch for the DSR model.
+        """Compute the focal loss between predicted and true masks.
 
         Args:
-            pred_mask (Tensor): Computed anomaly map
-            true_mask (Tensor): Ground truth anomaly map
+            pred_mask (Tensor): Computed anomaly segmentation map
+            true_mask (Tensor): Ground truth anomaly mask
 
         Returns:
-            Tensor: Total loss
+            Tensor: Focal loss value
+
+        Example:
+            >>> loss_fn = DsrThirdStageLoss()
+            >>> loss = loss_fn(
+            ...     pred_mask=torch.randn(32, 2, 256, 256),
+            ...     true_mask=torch.randint(0, 2, (32, 1, 256, 256))
+            ... )
         """
         return self.focal_loss(pred_mask, true_mask.squeeze(1).long())
diff --git a/src/anomalib/models/image/dsr/torch_model.py b/src/anomalib/models/image/dsr/torch_model.py
index 4fe036ea5c..a55fb6cd27 100644
--- a/src/anomalib/models/image/dsr/torch_model.py
+++ b/src/anomalib/models/image/dsr/torch_model.py
@@ -1,4 +1,30 @@
-"""PyTorch model for the DSR model implementation."""
+"""PyTorch model for the DSR model implementation.
+
+This module implements the PyTorch model for Deep Spatial Reconstruction (DSR).
+DSR is an anomaly detection model that uses a discrete latent model, image
+reconstruction network, subspace restriction modules, anomaly detection module
+and upsampling module to detect anomalies in images.
+
+The model works by:
+1. Encoding input images into quantized feature maps
+2. Reconstructing images using a general appearance decoder
+3. Detecting anomalies by comparing reconstructed and original images
+
+Example:
+    >>> from anomalib.models.image.dsr.torch_model import DsrModel
+    >>> model = DsrModel()
+    >>> input_tensor = torch.randn(32, 3, 256, 256)
+    >>> output = model(input_tensor)
+    >>> output["anomaly_map"].shape
+    torch.Size([32, 256, 256])
+
+Notes:
+    The model implementation is based on the original DSR paper and code.
+    Original code: https://github.com/VitjanZ/DSR_anomaly_detection
+
+References:
+    - Original paper: https://arxiv.org/abs/2012.12436
+"""
 
 # Original Code
 # Copyright (c) 2022 VitjanZ
@@ -26,12 +52,24 @@ class DsrModel(nn.Module):
     subspace restriction modules, anomaly detection module and upsampling module.
 
     Args:
-        embedding_dim (int): Dimension of codebook embeddings.
-        num_embeddings (int): Number of embeddings.
-        latent_anomaly_strength (float): Strength of the generated anomalies in the latent space.
+        embedding_dim (int): Dimension of codebook embeddings. Defaults to
+            ``128``.
+        num_embeddings (int): Number of embeddings in codebook. Defaults to
+            ``4096``.
+        latent_anomaly_strength (float): Strength of the generated anomalies in
+            latent space. Defaults to ``0.2``.
         num_hiddens (int): Number of output channels in residual layers.
-        num_residual_layers (int): Number of residual layers.
-        num_residual_hiddens (int): Number of intermediate channels.
+            Defaults to ``128``.
+        num_residual_layers (int): Number of residual layers. Defaults to ``2``.
+        num_residual_hiddens (int): Number of intermediate channels in residual
+            layers. Defaults to ``64``.
+
+    Example:
+        >>> model = DsrModel()
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> output = model(input_tensor)
+        >>> output["anomaly_map"].shape
+        torch.Size([32, 256, 256])
     """
 
     def __init__(
@@ -83,7 +121,13 @@ def __init__(
             parameters.requires_grad = False
 
     def load_pretrained_discrete_model_weights(self, ckpt: Path, device: torch.device | str | None = None) -> None:
-        """Load pre-trained model weights."""
+        """Load pre-trained model weights from checkpoint file.
+
+        Args:
+            ckpt (Path): Path to checkpoint file containing model weights.
+            device (torch.device | str | None, optional): Device to load weights
+                to. Defaults to ``None``.
+        """
         self.discrete_latent_model.load_state_dict(torch.load(ckpt, map_location=device))
 
     def forward(
@@ -91,28 +135,47 @@ def forward(
         batch: torch.Tensor,
         anomaly_map_to_generate: torch.Tensor | None = None,
     ) -> dict[str, torch.Tensor] | InferenceBatch:
-        """Compute the anomaly mask from an input image.
+        """Forward pass through the model.
 
         Args:
-            batch (torch.Tensor): Batch of input images.
-            anomaly_map_to_generate (torch.Tensor | None): anomaly map to use to generate quantized defects.
-            If not training phase 2, should be None.
+            batch (torch.Tensor): Input batch of images.
+            anomaly_map_to_generate (torch.Tensor | None, optional): Anomaly map
+                to use for generating quantized defects. Should be ``None`` if
+                not in training phase 2. Defaults to ``None``.
 
         Returns:
-            dict[str, torch.Tensor]:
+            dict[str, torch.Tensor] | InferenceBatch: Output depends on mode:
+
             If testing:
-                - "anomaly_map": Upsampled anomaly map
-                - "pred_score": Image score
+                - ``anomaly_map``: Upsampled anomaly map
+                - ``pred_score``: Image anomaly score
+
             If training phase 2:
-                - "recon_feat_hi": Reconstructed non-quantized hi features of defect (F~_hi)
-                - "recon_feat_lo": Reconstructed non-quantized lo features of defect (F~_lo)
-                - "embedding_bot": Quantized features of non defective img (Q_hi)
-                - "embedding_top": Quantized features of non defective img (Q_lo)
-                - "obj_spec_image": Object-specific-decoded image (I_spc)
-                - "anomaly_map": Predicted segmentation mask (M)
-                - "true_mask": Resized ground-truth anomaly map (M_gt)
+                - ``recon_feat_hi``: Reconstructed non-quantized hi features
+                  (F~_hi)
+                - ``recon_feat_lo``: Reconstructed non-quantized lo features
+                  (F~_lo)
+                - ``embedding_bot``: Quantized features of non defective img
+                  (Q_hi)
+                - ``embedding_top``: Quantized features of non defective img
+                  (Q_lo)
+                - ``obj_spec_image``: Object-specific-decoded image (I_spc)
+                - ``anomaly_map``: Predicted segmentation mask (M)
+                - ``true_mask``: Resized ground-truth anomaly map (M_gt)
+
             If training phase 3:
-                - "anomaly_map": Reconstructed anomaly map
+                - ``anomaly_map``: Reconstructed anomaly map
+
+        Raises:
+            RuntimeError: If ``anomaly_map_to_generate`` is provided when not in
+                training mode.
+
+        Example:
+            >>> model = DsrModel()
+            >>> input_tensor = torch.randn(32, 3, 256, 256)
+            >>> output = model(input_tensor)
+            >>> output["anomaly_map"].shape
+            torch.Size([32, 256, 256])
         """
         # Generate latent embeddings decoded image via general object decoder
         if anomaly_map_to_generate is None:
@@ -127,7 +190,8 @@ def forward(
                 embedder_bot = self.discrete_latent_model.vq_vae_bot
                 embedder_top = self.discrete_latent_model.vq_vae_top
 
-                # Copy embeddings in order to input them to the subspace restriction module
+                # Copy embeddings in order to input them to the subspace
+                # restriction module
                 anomaly_embedding_bot_copy = embd_bot.clone()
                 anomaly_embedding_top_copy = embd_top.clone()
 
@@ -138,7 +202,8 @@ def forward(
                 # Upscale top (lo) embedding
                 up_quantized_recon_t = self.discrete_latent_model.upsample_t(recon_embd_top)
 
-                # Concat embeddings and reconstruct image (object specific decoder)
+                # Concat embeddings and reconstruct image (object specific
+                # decoder)
                 quant_join = torch.cat((up_quantized_recon_t, recon_embd_bot), dim=1)
                 obj_spec_image = self.image_reconstruction_network(quant_join)
 
@@ -181,7 +246,8 @@ def forward(
                 torch.rand(batch.shape[0]) * (1.0 - self.latent_anomaly_strength) + self.latent_anomaly_strength
             ).cuda()
 
-            # Generate image through general object decoder, and defective & non defective quantized feature maps.
+            # Generate image through general object decoder, and defective & non
+            # defective quantized feature maps.
             with torch.no_grad():
                 latent_model_outputs = self.discrete_latent_model(
                     batch,
@@ -196,7 +262,8 @@ def forward(
             embd_top_def = latent_model_outputs["anomaly_embedding_lo"]
             embd_bot_def = latent_model_outputs["anomaly_embedding_hi"]
 
-            # Restore the features to normality with the Subspace restriction modules
+            # Restore the features to normality with the Subspace restriction
+            # modules
             recon_feat_hi, recon_embeddings_hi = self.subspace_restriction_module_hi(
                 embd_bot_def,
                 self.discrete_latent_model.vq_vae_bot,
diff --git a/src/anomalib/models/image/efficient_ad/__init__.py b/src/anomalib/models/image/efficient_ad/__init__.py
index d8b6f5f2b0..295ec61762 100644
--- a/src/anomalib/models/image/efficient_ad/__init__.py
+++ b/src/anomalib/models/image/efficient_ad/__init__.py
@@ -1,6 +1,17 @@
 """EfficientAd: Accurate Visual Anomaly Detection at Millisecond-Level Latencies.
 
-https://arxiv.org/pdf/2303.14535.pdf.
+EfficientAd is a fast and accurate anomaly detection model that achieves
+state-of-the-art performance with millisecond-level inference times. The model
+utilizes a pre-trained EfficientNet backbone and employs a student-teacher
+architecture for anomaly detection.
+
+The implementation is based on the paper:
+    "EfficientAd: Accurate Visual Anomaly Detection at Millisecond-Level Latencies"
+    https://arxiv.org/pdf/2303.14535.pdf
+
+Example:
+    >>> from anomalib.models import EfficientAd
+    >>> model = EfficientAd()
 """
 
 # Copyright (C) 2023-2024 Intel Corporation
diff --git a/src/anomalib/models/image/efficient_ad/lightning_model.py b/src/anomalib/models/image/efficient_ad/lightning_model.py
index aa99d6a439..a75f889ec3 100644
--- a/src/anomalib/models/image/efficient_ad/lightning_model.py
+++ b/src/anomalib/models/image/efficient_ad/lightning_model.py
@@ -1,6 +1,36 @@
 """EfficientAd: Accurate Visual Anomaly Detection at Millisecond-Level Latencies.
 
-https://arxiv.org/pdf/2303.14535.pdf.
+This module implements the EfficientAd model for fast and accurate anomaly
+detection. EfficientAd uses a student-teacher architecture with a pre-trained
+EfficientNet backbone to achieve state-of-the-art performance with
+millisecond-level inference times.
+
+The model consists of:
+    - A pre-trained EfficientNet teacher network
+    - A lightweight student network
+    - Knowledge distillation training
+    - Anomaly detection via feature comparison
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import EfficientAd
+    >>> from anomalib.engine import Engine
+
+    >>> datamodule = MVTec()
+    >>> model = EfficientAd()
+    >>> engine = Engine()
+
+    >>> engine.fit(model, datamodule=datamodule)  # doctest: +SKIP
+    >>> predictions = engine.predict(model, datamodule=datamodule)  # doctest: +SKIP
+
+Paper:
+    "EfficientAd: Accurate Visual Anomaly Detection at
+    Millisecond-Level Latencies"
+    https://arxiv.org/pdf/2303.14535.pdf
+
+See Also:
+    :class:`anomalib.models.image.efficient_ad.torch_model.EfficientAdModel`:
+        PyTorch implementation of the EfficientAd model architecture.
 """
 
 # Copyright (C) 2023-2024 Intel Corporation
@@ -46,25 +76,45 @@
 class EfficientAd(AnomalibModule):
     """PL Lightning Module for the EfficientAd algorithm.
 
+    The EfficientAd model uses a student-teacher architecture with a pretrained
+    EfficientNet backbone for fast and accurate anomaly detection.
+
     Args:
-        imagenet_dir (Path|str): directory path for the Imagenet dataset
-            Defaults to ``./datasets/imagenette``.
-        teacher_out_channels (int): number of convolution output channels
+        imagenet_dir (Path | str): Directory path for the Imagenet dataset.
+            Defaults to ``"./datasets/imagenette"``.
+        teacher_out_channels (int): Number of convolution output channels.
             Defaults to ``384``.
-        model_size (str): size of student and teacher model
+        model_size (EfficientAdModelSize | str): Size of student and teacher model.
             Defaults to ``EfficientAdModelSize.S``.
-        lr (float): learning rate
+        lr (float): Learning rate.
             Defaults to ``0.0001``.
-        weight_decay (float): optimizer weight decay
+        weight_decay (float): Optimizer weight decay.
             Defaults to ``0.00001``.
-        padding (bool): use padding in convoluional layers
+        padding (bool): Use padding in convolutional layers.
             Defaults to ``False``.
-        pad_maps (bool): relevant if padding is set to False. In this case, pad_maps = True pads the
-            output anomaly maps so that their size matches the size in the padding = True case.
+        pad_maps (bool): Relevant if ``padding=False``. If ``True``, pads the output
+            anomaly maps to match size of ``padding=True`` case.
+            Defaults to ``True``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor used to transform
+            input data before passing to model.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor used to process
+            model predictions.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator used to compute metrics.
             Defaults to ``True``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        visualizer (Visualizer | bool, optional): Visualizer used to create
+            visualizations.
+            Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models import EfficientAd
+        >>> model = EfficientAd(
+        ...     imagenet_dir="./datasets/imagenette",
+        ...     model_size="s",
+        ...     lr=1e-4
+        ... )
+
     """
 
     def __init__(
@@ -103,7 +153,11 @@ def __init__(
         self.weight_decay: float = weight_decay
 
     def prepare_pretrained_model(self) -> None:
-        """Prepare the pretrained teacher model."""
+        """Prepare the pretrained teacher model.
+
+        Downloads and loads pretrained weights for the teacher model if not already
+        present.
+        """
         pretrained_models_dir = Path("./pre_trained/")
         if not (pretrained_models_dir / "efficientad_pretrained_weights").is_dir():
             download_and_extract(pretrained_models_dir, WEIGHTS_DOWNLOAD_INFO)
@@ -117,8 +171,11 @@ def prepare_pretrained_model(self) -> None:
     def prepare_imagenette_data(self, image_size: tuple[int, int] | torch.Size) -> None:
         """Prepare ImageNette dataset transformations.
 
+        Sets up data transforms and downloads ImageNette dataset if not present.
+
         Args:
-            image_size (tuple[int, int] | torch.Size): Image size.
+            image_size (tuple[int, int] | torch.Size): Target image size for
+                transforms.
         """
         self.data_transforms_imagenet = Compose(
             [
@@ -137,15 +194,22 @@ def prepare_imagenette_data(self, image_size: tuple[int, int] | torch.Size) -> N
 
     @torch.no_grad()
     def teacher_channel_mean_std(self, dataloader: DataLoader) -> dict[str, torch.Tensor]:
-        """Calculate the mean and std of the teacher models activations.
+        """Calculate channel-wise mean and std of teacher model activations.
 
-        Adapted from https://math.stackexchange.com/a/2148949
+        Computes running mean and standard deviation of teacher model feature maps
+        over the full dataset.
 
         Args:
-            dataloader (DataLoader): Dataloader of the respective dataset.
+            dataloader (DataLoader): Dataloader for the dataset.
 
         Returns:
-            dict[str, torch.Tensor]: Dictionary of channel-wise mean and std
+            dict[str, torch.Tensor]: Dictionary containing:
+                - ``mean``: Channel-wise means of shape ``(1, C, 1, 1)``
+                - ``std``: Channel-wise standard deviations of shape
+                  ``(1, C, 1, 1)``
+
+        Raises:
+            ValueError: If no data is provided (``n`` remains ``None``).
         """
         arrays_defined = False
         n: torch.Tensor | None = None
@@ -178,14 +242,20 @@ def teacher_channel_mean_std(self, dataloader: DataLoader) -> dict[str, torch.Te
 
     @torch.no_grad()
     def map_norm_quantiles(self, dataloader: DataLoader) -> dict[str, torch.Tensor]:
-        """Calculate 90% and 99.5% quantiles of the student(st) and autoencoder(ae).
+        """Calculate quantiles of student and autoencoder feature maps.
+
+        Computes the 90% and 99.5% quantiles of the feature maps from both the
+        student network and autoencoder on normal (good) validation samples.
 
         Args:
-            dataloader (DataLoader): Dataloader of the respective dataset.
+            dataloader (DataLoader): Validation dataloader.
 
         Returns:
-            dict[str, torch.Tensor]: Dictionary of both the 90% and 99.5% quantiles
-            of both the student and autoencoder feature maps.
+            dict[str, torch.Tensor]: Dictionary containing:
+                - ``qa_st``: 90% quantile of student maps
+                - ``qa_ae``: 90% quantile of autoencoder maps
+                - ``qb_st``: 99.5% quantile of student maps
+                - ``qb_ae``: 99.5% quantile of autoencoder maps
         """
         maps_st = []
         maps_ae = []
@@ -202,17 +272,18 @@ def map_norm_quantiles(self, dataloader: DataLoader) -> dict[str, torch.Tensor]:
         return {"qa_st": qa_st, "qa_ae": qa_ae, "qb_st": qb_st, "qb_ae": qb_ae}
 
     def _get_quantiles_of_maps(self, maps: list[torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
-        """Calculate 90% and 99.5% quantiles of the given anomaly maps.
+        """Calculate quantiles of anomaly maps.
 
-        If the total number of elements in the given maps is larger than 16777216
-        the returned quantiles are computed on a random subset of the given
-        elements.
+        Computes the 90% and 99.5% quantiles of the given anomaly maps. If total
+        number of elements exceeds 16777216, uses a random subset.
 
         Args:
             maps (list[torch.Tensor]): List of anomaly maps.
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor]: Two scalars - the 90% and the 99.5% quantile.
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing:
+                - 90% quantile scalar
+                - 99.5% quantile scalar
         """
         maps_flat = reduce_tensor_elems(torch.cat(maps))
         qa = torch.quantile(maps_flat, q=0.9).to(self.device)
@@ -221,13 +292,35 @@ def _get_quantiles_of_maps(self, maps: list[torch.Tensor]) -> tuple[torch.Tensor
 
     @classmethod
     def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
-        """Default transform for EfficientAd. Imagenet normalization applied in forward."""
+        """Configure default pre-processor for EfficientAd.
+
+        Note that ImageNet normalization is applied in the forward pass, not here.
+
+        Args:
+            image_size (tuple[int, int] | None, optional): Target image size.
+                Defaults to ``(256, 256)``.
+
+        Returns:
+            PreProcessor: Configured pre-processor with resize transform.
+        """
         image_size = image_size or (256, 256)
         transform = Compose([Resize(image_size, antialias=True)])
         return PreProcessor(transform=transform)
 
     def configure_optimizers(self) -> torch.optim.Optimizer:
-        """Configure optimizers."""
+        """Configure optimizers for training.
+
+        Sets up Adam optimizer with learning rate scheduler that decays LR by 0.1
+        at 95% of training.
+
+        Returns:
+            dict: Dictionary containing:
+                - ``optimizer``: Adam optimizer
+                - ``lr_scheduler``: StepLR scheduler
+
+        Raises:
+            ValueError: If neither ``max_epochs`` nor ``max_steps`` is defined.
+        """
         optimizer = torch.optim.Adam(
             list(self.model.student.parameters()) + list(self.model.ae.parameters()),
             lr=self.lr,
@@ -256,12 +349,17 @@ def configure_optimizers(self) -> torch.optim.Optimizer:
         return {"optimizer": optimizer, "lr_scheduler": scheduler}
 
     def on_train_start(self) -> None:
-        """Called before the first training epoch.
+        """Set up model before training begins.
+
+        Performs the following steps:
+        1. Validates training parameters (batch size=1, no normalization)
+        2. Sets up pretrained teacher model
+        3. Prepares ImageNette dataset
+        4. Calculates channel statistics
 
-        First check if EfficientAd-specific parameters are set correctly (train_batch_size of 1
-        and no Imagenet normalization in transforms), then sets up the pretrained teacher model,
-        then prepares the imagenette data, and finally calculates or loads
-        the channel-wise mean and std of the training dataset and push to the model.
+        Raises:
+            ValueError: If ``train_batch_size != 1`` or transforms contain
+                normalization.
         """
         if self.trainer.datamodule.train_batch_size != 1:
             msg = "train_batch_size for EfficientAd should be 1."
@@ -282,15 +380,18 @@ def on_train_start(self) -> None:
             self.model.mean_std.update(channel_mean_std)
 
     def training_step(self, batch: Batch, *args, **kwargs) -> dict[str, torch.Tensor]:
-        """Perform the training step for EfficientAd returns the student, autoencoder and combined loss.
+        """Perform training step.
+
+        Computes student, autoencoder and combined losses using both the input
+        batch and a batch from ImageNette.
 
         Args:
-            batch (Batch): Batch containing image filename, image, label and mask
-            args: Additional arguments.
-            kwargs: Additional keyword arguments.
+            batch (Batch): Input batch containing image and labels
+            *args: Additional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-          Loss.
+            dict[str, torch.Tensor]: Dictionary containing total loss
         """
         del args, kwargs  # These variables are not used.
 
@@ -311,20 +412,25 @@ def training_step(self, batch: Batch, *args, **kwargs) -> dict[str, torch.Tensor
         return {"loss": loss}
 
     def on_validation_start(self) -> None:
-        """Calculate the feature map quantiles of the validation dataset and push to the model."""
+        """Calculate feature map statistics before validation.
+
+        Computes quantiles of feature maps on validation set and updates model.
+        """
         map_norm_quantiles = self.map_norm_quantiles(self.trainer.datamodule.val_dataloader())
         self.model.quantiles.update(map_norm_quantiles)
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform the validation step of EfficientAd returns anomaly maps for the input image batch.
+        """Perform validation step.
+
+        Generates anomaly maps for the input batch.
 
         Args:
-          batch (Batch): Input batch
-          args: Additional arguments.
-          kwargs: Additional keyword arguments.
+            batch (Batch): Input batch
+            *args: Additional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-          Dictionary containing anomaly maps.
+            STEP_OUTPUT: Batch with added predictions
         """
         del args, kwargs  # These variables are not used.
 
@@ -333,14 +439,19 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """Return EfficientAD trainer arguments."""
+        """Get trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary with trainer arguments:
+                - ``num_sanity_val_steps``: 0
+        """
         return {"num_sanity_val_steps": 0}
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get model's learning type.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: Always ``LearningType.ONE_CLASS``
         """
         return LearningType.ONE_CLASS
diff --git a/src/anomalib/models/image/efficient_ad/torch_model.py b/src/anomalib/models/image/efficient_ad/torch_model.py
index 74f2a507bb..e053736614 100644
--- a/src/anomalib/models/image/efficient_ad/torch_model.py
+++ b/src/anomalib/models/image/efficient_ad/torch_model.py
@@ -1,4 +1,31 @@
-"""Torch model for student, teacher and autoencoder model in EfficientAd."""
+"""PyTorch implementation of the EfficientAd model architecture.
+
+This module contains the PyTorch implementation of the student, teacher and
+autoencoder networks used in EfficientAd for fast and accurate anomaly detection.
+
+The model consists of:
+    - A pre-trained EfficientNet teacher network
+    - A lightweight student network
+    - Knowledge distillation training
+    - Anomaly detection via feature comparison
+
+Example:
+    >>> from anomalib.models.image.efficient_ad.torch_model import EfficientAdModel
+    >>> model = EfficientAdModel()
+    >>> input_tensor = torch.randn(32, 3, 256, 256)
+    >>> output = model(input_tensor)
+    >>> output["anomaly_map"].shape
+    torch.Size([32, 256, 256])
+
+Paper:
+    "EfficientAd: Accurate Visual Anomaly Detection at
+    Millisecond-Level Latencies"
+    https://arxiv.org/pdf/2303.14535.pdf
+
+See Also:
+    :class:`anomalib.models.image.efficient_ad.lightning_model.EfficientAd`:
+        Lightning implementation of the EfficientAd model.
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -19,13 +46,22 @@
 
 
 def imagenet_norm_batch(x: torch.Tensor) -> torch.Tensor:
-    """Normalize batch of images with ImageNet mean and std.
+    """Normalize batch of images using ImageNet mean and standard deviation.
+
+    This function normalizes a batch of images using the standard ImageNet mean and
+    standard deviation values. The normalization is done channel-wise.
 
     Args:
-        x (torch.Tensor): Input batch.
+        x (torch.Tensor): Input batch tensor of shape ``(N, C, H, W)`` where
+            ``N`` is batch size, ``C`` is number of channels (3 for RGB),
+            ``H`` is height and ``W`` is width.
 
     Returns:
-        torch.Tensor: Normalized batch using the ImageNet mean and std.
+        torch.Tensor: Normalized batch tensor with same shape as input, where each
+            channel is normalized using ImageNet statistics:
+            - Red channel: mean=0.485, std=0.229
+            - Green channel: mean=0.456, std=0.224
+            - Blue channel: mean=0.406, std=0.225
     """
     mean = torch.tensor([0.485, 0.456, 0.406])[None, :, None, None].to(x.device)
     std = torch.tensor([0.229, 0.224, 0.225])[None, :, None, None].to(x.device)
@@ -33,21 +69,32 @@ def imagenet_norm_batch(x: torch.Tensor) -> torch.Tensor:
 
 
 def reduce_tensor_elems(tensor: torch.Tensor, m: int = 2**24) -> torch.Tensor:
-    """Reduce tensor elements.
+    """Reduce the number of elements in a tensor by random sampling.
+
+    This function flattens an n-dimensional tensor and randomly samples at most ``m``
+    elements from it. This is used to handle the limitation of ``torch.quantile``
+    operation which supports a maximum of 2^24 elements.
 
-    This function flatten n-dimensional tensors,  selects m elements from it
-    and returns the selected elements as tensor. It is used to select
-    at most 2**24 for torch.quantile operation, as it is the maximum
-    supported number of elements.
-    https://github.com/pytorch/pytorch/blob/b9f81a483a7879cd3709fd26bcec5f1ee33577e6/aten/src/ATen/native/Sorting.cpp#L291.
+    Reference:
+        https://github.com/pytorch/pytorch/blob/b9f81a483a7879cd3709fd26bcec5f1ee33577e6/aten/src/ATen/native/Sorting.cpp#L291
 
     Args:
-        tensor (torch.Tensor): input tensor from which elements are selected
-        m (int): number of maximum tensor elements.
-            Defaults to ``2**24``
+        tensor (torch.Tensor): Input tensor of any shape from which elements will be
+            sampled.
+        m (int, optional): Maximum number of elements to sample. If the flattened
+            tensor has more elements than ``m``, random sampling is performed.
+            Defaults to ``2**24``.
 
     Returns:
-            Tensor: reduced tensor
+        torch.Tensor: A flattened tensor containing at most ``m`` elements randomly
+            sampled from the input tensor.
+
+    Example:
+        >>> import torch
+        >>> tensor = torch.randn(1000, 1000)  # 1M elements
+        >>> reduced = reduce_tensor_elems(tensor, m=1000)
+        >>> reduced.shape
+        torch.Size([1000])
     """
     tensor = torch.flatten(tensor)
     if len(tensor) > m:
@@ -59,19 +106,53 @@ def reduce_tensor_elems(tensor: torch.Tensor, m: int = 2**24) -> torch.Tensor:
 
 
 class EfficientAdModelSize(str, Enum):
-    """Supported EfficientAd model sizes."""
+    """Supported EfficientAd model sizes.
+
+    The EfficientAd model comes in two sizes:
+        - ``M`` (medium): Uses a larger architecture with more parameters
+        - ``S`` (small): Uses a smaller architecture with fewer parameters
+
+    Example:
+        >>> from anomalib.models.image.efficient_ad.torch_model import (
+        ...     EfficientAdModelSize
+        ... )
+        >>> model_size = EfficientAdModelSize.S
+        >>> model_size
+        'small'
+        >>> model_size = EfficientAdModelSize.M
+        >>> model_size
+        'medium'
+    """
 
     M = "medium"
     S = "small"
 
 
 class SmallPatchDescriptionNetwork(nn.Module):
-    """Patch Description Network small.
+    """Small variant of the Patch Description Network.
+
+    This network processes input images through a series of convolutional and pooling
+    layers to extract patch-level features. It uses a smaller architecture compared
+    to the medium variant.
 
     Args:
-        out_channels (int): number of convolution output channels
-        padding (bool): use padding in convoluional layers
+        out_channels (int): Number of output channels in the final convolution layer.
+        padding (bool, optional): Whether to use padding in convolutional layers.
             Defaults to ``False``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.image.efficient_ad.torch_model import (
+        ...     SmallPatchDescriptionNetwork
+        ... )
+        >>> model = SmallPatchDescriptionNetwork(out_channels=384)
+        >>> input_tensor = torch.randn(32, 3, 64, 64)
+        >>> output = model(input_tensor)
+        >>> output.shape
+        torch.Size([32, 384, 13, 13])
+
+    Note:
+        The network applies ImageNet normalization to the input before processing.
     """
 
     def __init__(self, out_channels: int, padding: bool = False) -> None:
@@ -85,13 +166,15 @@ def __init__(self, out_channels: int, padding: bool = False) -> None:
         self.avgpool2 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1 * pad_mult)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Perform a forward pass through the network.
+        """Forward pass through the network.
 
         Args:
-            x (torch.Tensor): Input batch.
+            x (torch.Tensor): Input tensor of shape ``(N, 3, H, W)``.
 
         Returns:
-            torch.Tensor: Output from the network.
+            torch.Tensor: Output feature maps of shape
+                ``(N, out_channels, H', W')``, where ``H'`` and ``W'`` are
+                determined by the network architecture and padding settings.
         """
         x = imagenet_norm_batch(x)
         x = F.relu(self.conv1(x))
@@ -103,12 +186,31 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
 
 
 class MediumPatchDescriptionNetwork(nn.Module):
-    """Patch Description Network medium.
+    """Medium-sized patch description network.
+
+    This network processes input images through a series of convolutional and
+    pooling layers to extract descriptive features from image patches.
 
     Args:
-        out_channels (int): number of convolution output channels
-        padding (bool): use padding in convoluional layers
+        out_channels (int): Number of output channels in the final convolution
+            layer.
+        padding (bool, optional): Whether to use padding in convolutional layers.
             Defaults to ``False``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.image.efficient_ad.torch_model import (
+        ...     MediumPatchDescriptionNetwork
+        ... )
+        >>> model = MediumPatchDescriptionNetwork(out_channels=384)
+        >>> input_tensor = torch.randn(32, 3, 64, 64)
+        >>> output = model(input_tensor)
+        >>> output.shape
+        torch.Size([32, 384, 13, 13])
+
+    Note:
+        The network applies ImageNet normalization to the input before
+        processing.
     """
 
     def __init__(self, out_channels: int, padding: bool = False) -> None:
@@ -124,13 +226,15 @@ def __init__(self, out_channels: int, padding: bool = False) -> None:
         self.avgpool2 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1 * pad_mult)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Perform a forward pass through the network.
+        """Forward pass through the network.
 
         Args:
-            x (torch.Tensor): Input batch.
+            x (torch.Tensor): Input tensor of shape ``(N, 3, H, W)``.
 
         Returns:
-            torch.Tensor: Output from the network.
+            torch.Tensor: Output feature maps of shape
+                ``(N, out_channels, H', W')``, where ``H'`` and ``W'`` are
+                determined by the network architecture and padding settings.
         """
         x = imagenet_norm_batch(x)
         x = F.relu(self.conv1(x))
@@ -144,7 +248,24 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
 
 
 class Encoder(nn.Module):
-    """Autoencoder Encoder model."""
+    """Encoder module for the autoencoder architecture.
+
+    The encoder consists of 6 convolutional layers that progressively reduce the
+    spatial dimensions while increasing the number of channels.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.image.efficient_ad.torch_model import Encoder
+        >>> model = Encoder()
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> output = model(input_tensor)
+        >>> output.shape
+        torch.Size([32, 64, 1, 1])
+
+    Note:
+        The encoder uses ReLU activation after each convolutional layer except
+        the last one.
+    """
 
     def __init__(self) -> None:
         super().__init__()
@@ -156,13 +277,14 @@ def __init__(self) -> None:
         self.enconv6 = nn.Conv2d(64, 64, kernel_size=8, stride=1, padding=0)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """Perform the forward pass through the network.
+        """Forward pass through the encoder network.
 
         Args:
-            x (torch.Tensor): Input batch.
+            x (torch.Tensor): Input tensor of shape ``(N, 3, H, W)``.
 
         Returns:
-            torch.Tensor: Output from the network.
+            torch.Tensor: Encoded features of shape ``(N, 64, H', W')``, where
+                ``H'`` and ``W'`` are determined by the network architecture.
         """
         x = F.relu(self.enconv1(x))
         x = F.relu(self.enconv2(x))
@@ -173,11 +295,32 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
 
 
 class Decoder(nn.Module):
-    """Autoencoder Decoder model.
+    """Decoder module for the autoencoder architecture.
+
+    The decoder consists of 8 convolutional layers with upsampling that
+    progressively increase spatial dimensions while maintaining or reducing
+    channel dimensions.
 
     Args:
-        out_channels (int): number of convolution output channels
-        padding (int): use padding in convoluional layers
+        out_channels (int): Number of output channels in final conv layer.
+        padding (int): Whether to use padding in convolutional layers.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.image.efficient_ad.torch_model import Decoder
+        >>> model = Decoder(out_channels=384, padding=True)
+        >>> input_tensor = torch.randn(32, 64, 1, 1)
+        >>> image_size = (256, 256)
+        >>> output = model(input_tensor, image_size)
+        >>> output.shape
+        torch.Size([32, 384, 64, 64])
+
+    Note:
+        - Uses ReLU activation and dropout after most convolutional layers
+        - Performs bilinear upsampling between conv layers to increase spatial
+          dimensions
+        - Final output size depends on ``padding`` parameter and input
+          ``image_size``
     """
 
     def __init__(self, out_channels: int, padding: int, *args, **kwargs) -> None:
@@ -203,11 +346,14 @@ def forward(self, x: torch.Tensor, image_size: tuple[int, int] | torch.Size) ->
         """Perform a forward pass through the network.
 
         Args:
-            x (torch.Tensor): Input batch.
-            image_size (tuple): size of input images.
+            x (torch.Tensor): Input tensor of shape ``(N, 64, H, W)``.
+            image_size (tuple[int, int] | torch.Size): Target output size
+                ``(H, W)``.
 
         Returns:
-            torch.Tensor: Output from the network.
+            torch.Tensor: Decoded features of shape
+                ``(N, out_channels, H', W')``, where ``H'`` and ``W'`` are
+                determined by the network architecture and padding settings.
         """
         last_upsample = (
             math.ceil(image_size[0] / 4) if self.padding else math.ceil(image_size[0] / 4) - 8,
@@ -239,9 +385,26 @@ def forward(self, x: torch.Tensor, image_size: tuple[int, int] | torch.Size) ->
 class AutoEncoder(nn.Module):
     """EfficientAd Autoencoder.
 
+    The autoencoder consists of an encoder and decoder network. The encoder extracts features
+    from the input image which are then reconstructed by the decoder.
+
     Args:
-       out_channels (int): number of convolution output channels
-       padding (int): use padding in convoluional layers
+        out_channels (int): Number of convolution output channels in the decoder.
+        padding (int): Whether to use padding in convolutional layers.
+        *args: Variable length argument list passed to parent class.
+        **kwargs: Arbitrary keyword arguments passed to parent class.
+
+    Example:
+        >>> from torch import randn
+        >>> autoencoder = AutoEncoder(out_channels=384, padding=True)
+        >>> input_tensor = randn(32, 3, 256, 256)
+        >>> output = autoencoder(input_tensor, image_size=(256, 256))
+        >>> output.shape
+        torch.Size([32, 384, 256, 256])
+
+    Notes:
+        The input images are normalized using ImageNet statistics before being passed
+        through the encoder.
     """
 
     def __init__(self, out_channels: int, padding: int, *args, **kwargs) -> None:
@@ -250,14 +413,16 @@ def __init__(self, out_channels: int, padding: int, *args, **kwargs) -> None:
         self.decoder = Decoder(out_channels, padding)
 
     def forward(self, x: torch.Tensor, image_size: tuple[int, int] | torch.Size) -> torch.Tensor:
-        """Perform the forward pass through the network.
+        """Forward pass through the autoencoder.
 
         Args:
-            x (torch.Tensor): Input batch.
-            image_size (tuple): size of input images.
+            x (torch.Tensor): Input tensor of shape ``(N, C, H, W)``.
+            image_size (tuple[int, int] | torch.Size): Target output size ``(H, W)``.
 
         Returns:
-            torch.Tensor: Output from the network.
+            torch.Tensor: Reconstructed features of shape ``(N, out_channels, H', W')``,
+                where ``H'`` and ``W'`` are determined by the decoder architecture and
+                padding settings.
         """
         x = imagenet_norm_batch(x)
         x = self.encoder(x)
@@ -267,14 +432,41 @@ def forward(self, x: torch.Tensor, image_size: tuple[int, int] | torch.Size) ->
 class EfficientAdModel(nn.Module):
     """EfficientAd model.
 
+    The EfficientAd model consists of a teacher and student network for anomaly
+    detection. The teacher network is pre-trained and frozen, while the student
+    network is trained to match the teacher's outputs.
+
     Args:
-        teacher_out_channels (int): number of convolution output channels of the pre-trained teacher model
-        model_size (str): size of student and teacher model
-        padding (bool): use padding in convoluional layers
+        teacher_out_channels (int): Number of convolution output channels of the
+            pre-trained teacher model.
+        model_size (EfficientAdModelSize): Size of student and teacher model.
+            Defaults to ``EfficientAdModelSize.S``.
+        padding (bool): Whether to use padding in convolutional layers.
             Defaults to ``False``.
-        pad_maps (bool): relevant if padding is set to False. In this case, pad_maps = True pads the
-            output anomaly maps so that their size matches the size in the padding = True case.
+        pad_maps (bool): Whether to pad output anomaly maps when ``padding=False``
+            to match size of padded case. Only relevant if ``padding=False``.
             Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models.image.efficient_ad.torch_model import (
+        ...     EfficientAdModel,
+        ...     EfficientAdModelSize
+        ... )
+        >>> model = EfficientAdModel(
+        ...     teacher_out_channels=384,
+        ...     model_size=EfficientAdModelSize.S
+        ... )
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> output = model(input_tensor)
+        >>> output.anomaly_map.shape
+        torch.Size([32, 1, 256, 256])
+
+    Notes:
+        The model uses a student-teacher architecture where:
+        - Teacher network is pre-trained and frozen
+        - Student network learns to match teacher outputs
+        - Autoencoder provides additional feature extraction
+        - Anomaly scores are computed from student-teacher differences
     """
 
     def __init__(
@@ -323,25 +515,28 @@ def __init__(
 
     @staticmethod
     def is_set(p_dic: nn.ParameterDict) -> bool:
-        """Check if any of the parameters in the parameter dictionary is set.
+        """Check if any parameters in the dictionary are non-zero.
 
         Args:
-            p_dic (nn.ParameterDict): Parameter dictionary.
+            p_dic (nn.ParameterDict): Parameter dictionary to check.
 
         Returns:
-            bool: Boolean indicating whether any of the parameters in the parameter dictionary is set.
+            bool: ``True`` if any parameter is non-zero, ``False`` otherwise.
         """
         return any(value.sum() != 0 for _, value in p_dic.items())
 
     @staticmethod
     def choose_random_aug_image(image: torch.Tensor) -> torch.Tensor:
-        """Choose a random augmentation function and apply it to the input image.
+        """Apply random augmentation to input image.
+
+        Randomly selects and applies one of: brightness, contrast or saturation
+        adjustment with coefficient sampled from U(0.8, 1.2).
 
         Args:
-            image (torch.Tensor): Input image.
+            image (torch.Tensor): Input image tensor.
 
         Returns:
-            Tensor: Augmented image.
+            torch.Tensor: Augmented image tensor.
         """
         transform_functions = [
             transforms.functional.adjust_brightness,
@@ -359,15 +554,22 @@ def forward(
         batch_imagenet: torch.Tensor | None = None,
         normalize: bool = True,
     ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor] | InferenceBatch:
-        """Perform the forward-pass of the EfficientAd models.
+        """Forward pass through the model.
 
         Args:
-            batch (torch.Tensor): Input images.
-            batch_imagenet (torch.Tensor): ImageNet batch. Defaults to None.
-            normalize (bool): Normalize anomaly maps or not
+            batch (torch.Tensor): Input batch of images.
+            batch_imagenet (torch.Tensor | None): Optional batch of ImageNet
+                images for training. Defaults to ``None``.
+            normalize (bool): Whether to normalize anomaly maps.
+                Defaults to ``True``.
 
         Returns:
-            Tensor: Predictions
+            tuple[torch.Tensor, torch.Tensor, torch.Tensor] | InferenceBatch:
+                If training:
+                    - Loss components (student-teacher, autoencoder,
+                      student-autoencoder)
+                If inference:
+                    - Batch containing anomaly maps and scores
         """
         student_output, distance_st = self.compute_student_teacher_distance(batch)
         if self.training:
@@ -382,12 +584,12 @@ def compute_student_teacher_distance(self, batch: torch.Tensor) -> tuple[torch.T
         """Compute the student-teacher distance vectors.
 
         Args:
-            batch (torch.Tensor): Input images.
-            batch_imagenet (torch.Tensor): ImageNet batch. Defaults to None.
-            normalize (bool): Normalize anomaly maps or not
+            batch (torch.Tensor): Input batch of images.
 
         Returns:
-            Tensor: Predictions
+            tuple[torch.Tensor, torch.Tensor]:
+                - Student network output features
+                - Squared distance between normalized teacher and student features
         """
         with torch.no_grad():
             teacher_output = self.teacher(batch)
@@ -404,7 +606,24 @@ def compute_losses(
         batch_imagenet: torch.Tensor,
         distance_st: torch.Tensor,
     ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Compute the student-teacher loss and the autoencoder loss."""
+        """Compute training losses.
+
+        Computes three loss components:
+        - Student-teacher loss (hard examples + ImageNet penalty)
+        - Autoencoder reconstruction loss
+        - Student-autoencoder consistency loss
+
+        Args:
+            batch (torch.Tensor): Input batch of images.
+            batch_imagenet (torch.Tensor): Batch of ImageNet images.
+            distance_st (torch.Tensor): Student-teacher distances.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+                - Student-teacher loss
+                - Autoencoder loss
+                - Student-autoencoder loss
+        """
         # Student loss
         distance_st = reduce_tensor_elems(distance_st)
         d_hard = torch.quantile(distance_st, 0.999)
@@ -438,7 +657,20 @@ def compute_maps(
         distance_st: torch.Tensor,
         normalize: bool = True,
     ) -> tuple[torch.Tensor, torch.Tensor]:
-        """Compute the anomaly maps."""
+        """Compute anomaly maps from model outputs.
+
+        Args:
+            batch (torch.Tensor): Input batch of images.
+            student_output (torch.Tensor): Student network output features.
+            distance_st (torch.Tensor): Student-teacher distances.
+            normalize (bool): Whether to normalize maps with pre-computed
+                quantiles. Defaults to ``True``.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]:
+                - Student-teacher anomaly map
+                - Student-autoencoder anomaly map
+        """
         image_size = batch.shape[-2:]
         # Eval mode.
         with torch.no_grad():
@@ -463,6 +695,18 @@ def compute_maps(
         return map_st, map_stae
 
     def get_maps(self, batch: torch.Tensor, normalize: bool = False) -> tuple[torch.Tensor, torch.Tensor]:
-        """Standalone function to compute anomaly maps."""
+        """Compute anomaly maps for a batch of images.
+
+        Convenience method that combines distance computation and map generation.
+
+        Args:
+            batch (torch.Tensor): Input batch of images.
+            normalize (bool): Whether to normalize maps. Defaults to ``False``.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]:
+                - Student-teacher anomaly map
+                - Student-autoencoder anomaly map
+        """
         student_output, distance_st = self.compute_student_teacher_distance(batch)
         return self.compute_maps(batch, student_output, distance_st, normalize)
diff --git a/src/anomalib/models/image/fastflow/__init__.py b/src/anomalib/models/image/fastflow/__init__.py
index 7abb420e33..f9221b7ee0 100644
--- a/src/anomalib/models/image/fastflow/__init__.py
+++ b/src/anomalib/models/image/fastflow/__init__.py
@@ -1,4 +1,30 @@
-"""FastFlow Algorithm Implementation."""
+"""FastFlow Algorithm Implementation.
+
+FastFlow is a fast flow-based anomaly detection model that uses normalizing flows
+to model the distribution of features extracted from a pre-trained CNN backbone.
+The model achieves competitive performance while maintaining fast inference times.
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Fastflow
+    >>> from anomalib.engine import Engine
+
+    >>> datamodule = MVTec()
+    >>> model = Fastflow()
+    >>> engine = Engine()
+
+    >>> engine.fit(model, datamodule=datamodule)  # doctest: +SKIP
+    >>> predictions = engine.predict(model, datamodule=datamodule)  # doctest: +SKIP
+
+Paper:
+    Title: FastFlow: Unsupervised Anomaly Detection and Localization via 2D
+           Normalizing Flows
+    URL: https://arxiv.org/abs/2111.07677
+
+See Also:
+    :class:`anomalib.models.image.fastflow.torch_model.FastflowModel`:
+        PyTorch implementation of the FastFlow model architecture.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/fastflow/anomaly_map.py b/src/anomalib/models/image/fastflow/anomaly_map.py
index b0bded15b6..4d195eec56 100644
--- a/src/anomalib/models/image/fastflow/anomaly_map.py
+++ b/src/anomalib/models/image/fastflow/anomaly_map.py
@@ -1,4 +1,15 @@
-"""FastFlow Anomaly Map Generator Implementation."""
+"""FastFlow Anomaly Map Generator Implementation.
+
+This module implements the anomaly map generation for the FastFlow model. The
+generator takes hidden variables from normalizing flow blocks and produces an
+anomaly heatmap by computing flow maps.
+
+Example:
+    >>> from anomalib.models.image.fastflow.anomaly_map import AnomalyMapGenerator
+    >>> generator = AnomalyMapGenerator(input_size=(256, 256))
+    >>> hidden_vars = [torch.randn(1, 64, 32, 32)]  # from NF blocks
+    >>> anomaly_map = generator(hidden_vars)  # returns anomaly heatmap
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,10 +21,26 @@
 
 
 class AnomalyMapGenerator(nn.Module):
-    """Generate Anomaly Heatmap.
+    """Generate anomaly heatmaps from FastFlow hidden variables.
+
+    The generator takes hidden variables from normalizing flow blocks and produces
+    an anomaly heatmap. For each hidden variable tensor, it:
+        1. Computes negative log probability
+        2. Converts to probability via exponential
+        3. Interpolates to input size
+        4. Stacks and averages flow maps to produce final anomaly map
 
     Args:
-        input_size (ListConfig | tuple): Input size.
+        input_size (ListConfig | tuple): Target size for the anomaly map as
+            ``(height, width)``. If ``ListConfig`` is provided, it will be
+            converted to tuple.
+
+    Example:
+        >>> generator = AnomalyMapGenerator(input_size=(256, 256))
+        >>> hidden_vars = [torch.randn(1, 64, 32, 32)]  # from NF blocks
+        >>> anomaly_map = generator(hidden_vars)
+        >>> anomaly_map.shape
+        torch.Size([1, 1, 256, 256])
     """
 
     def __init__(self, input_size: ListConfig | tuple) -> None:
@@ -21,18 +48,26 @@ def __init__(self, input_size: ListConfig | tuple) -> None:
         self.input_size = input_size if isinstance(input_size, tuple) else tuple(input_size)
 
     def forward(self, hidden_variables: list[torch.Tensor]) -> torch.Tensor:
-        """Generate Anomaly Heatmap.
+        """Generate anomaly heatmap from hidden variables.
+
+        This implementation generates the heatmap based on the flow maps computed
+        from the normalizing flow (NF) FastFlow blocks. Each block yields a flow
+        map, which overall is stacked and averaged to produce an anomaly map.
 
-        This implementation generates the heatmap based on the flow maps
-        computed from the normalizing flow (NF) FastFlow blocks. Each block
-        yields a flow map, which overall is stacked and averaged to an anomaly
-        map.
+        The process for each hidden variable is:
+            1. Compute negative log probability as mean of squared values
+            2. Convert to probability via exponential
+            3. Interpolate to input size
+            4. Stack all flow maps and average to get final anomaly map
 
         Args:
-            hidden_variables (list[torch.Tensor]): List of hidden variables from each NF FastFlow block.
+            hidden_variables (list[torch.Tensor]): List of hidden variables from
+                each NF FastFlow block. Each tensor has shape
+                ``(N, C, H, W)``.
 
         Returns:
-            Tensor: Anomaly Map.
+            torch.Tensor: Anomaly heatmap with shape ``(N, 1, H, W)`` where
+                ``H, W`` match the ``input_size``.
         """
         flow_maps: list[torch.Tensor] = []
         for hidden_variable in hidden_variables:
diff --git a/src/anomalib/models/image/fastflow/lightning_model.py b/src/anomalib/models/image/fastflow/lightning_model.py
index 8a98ea9e7a..eb3e7deb45 100644
--- a/src/anomalib/models/image/fastflow/lightning_model.py
+++ b/src/anomalib/models/image/fastflow/lightning_model.py
@@ -1,6 +1,35 @@
 """FastFlow Lightning Model Implementation.
 
-https://arxiv.org/abs/2111.07677
+This module provides a PyTorch Lightning implementation of the FastFlow model for anomaly
+detection. FastFlow is a fast flow-based model that uses normalizing flows to model the
+distribution of features extracted from a pre-trained CNN backbone.
+
+The model achieves competitive performance while maintaining fast inference times by
+leveraging normalizing flows to transform feature distributions into a simpler form that
+can be efficiently modeled.
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Fastflow
+    >>> from anomalib.engine import Engine
+
+    >>> datamodule = MVTec()
+    >>> model = Fastflow()
+    >>> engine = Engine()
+
+    >>> engine.fit(model, datamodule=datamodule)  # doctest: +SKIP
+    >>> predictions = engine.predict(model, datamodule=datamodule)  # doctest: +SKIP
+
+Paper:
+    Title: FastFlow: Unsupervised Anomaly Detection and Localization via 2D
+           Normalizing Flows
+    URL: https://arxiv.org/abs/2111.07677
+
+See Also:
+    :class:`anomalib.models.image.fastflow.torch_model.FastflowModel`:
+        PyTorch implementation of the FastFlow model architecture.
+    :class:`anomalib.models.image.fastflow.loss.FastflowLoss`:
+        Loss function used to train the FastFlow model.
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -27,20 +56,45 @@
 class Fastflow(AnomalibModule):
     """PL Lightning Module for the FastFlow algorithm.
 
+    The FastFlow model uses normalizing flows to transform feature distributions from a
+    pre-trained CNN backbone into a simpler form that can be efficiently modeled for
+    anomaly detection.
+
     Args:
-        backbone (str): Backbone CNN network
-            Defaults to ``resnet18``.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
+        backbone (str): Backbone CNN network architecture. Available options are
+            ``"resnet18"``, ``"wide_resnet50_2"``, etc.
+            Defaults to ``"resnet18"``.
+        pre_trained (bool, optional): Whether to use pre-trained backbone weights.
             Defaults to ``True``.
-        flow_steps (int, optional): Flow steps.
+        flow_steps (int, optional): Number of steps in the normalizing flow.
             Defaults to ``8``.
-        conv3x3_only (bool, optinoal): Use only conv3x3 in fast_flow model.
+        conv3x3_only (bool, optional): Whether to use only 3x3 convolutions in the
+            FastFlow model.
             Defaults to ``False``.
-        hidden_ratio (float, optional): Ratio to calculate hidden var channels.
+        hidden_ratio (float, optional): Ratio used to calculate hidden variable
+            channels.
             Defaults to ``1.0``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor to use for
+            input data.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor to use for
+            model outputs.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator to compute metrics.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer for model outputs.
+            Defaults to ``True``.
+
+    Raises:
+        ValueError: If ``input_size`` is not provided during initialization.
+
+    Example:
+        >>> from anomalib.models import Fastflow
+        >>> model = Fastflow(
+        ...     backbone="resnet18",
+        ...     pre_trained=True,
+        ...     flow_steps=8
+        ... )
     """
 
     def __init__(
diff --git a/src/anomalib/models/image/fastflow/loss.py b/src/anomalib/models/image/fastflow/loss.py
index a47f49df88..b2b36b1619 100644
--- a/src/anomalib/models/image/fastflow/loss.py
+++ b/src/anomalib/models/image/fastflow/loss.py
@@ -1,4 +1,22 @@
-"""Loss function for the FastFlow Model Implementation."""
+"""Loss function for the FastFlow Model Implementation.
+
+This module implements the loss function used to train the FastFlow model. The loss is
+computed based on the hidden variables and Jacobian determinants produced by the
+normalizing flow transformations.
+
+Example:
+    >>> from anomalib.models.image.fastflow.loss import FastflowLoss
+    >>> criterion = FastflowLoss()
+    >>> hidden_vars = [torch.randn(2, 64, 32, 32)]  # from NF blocks
+    >>> jacobians = [torch.randn(2)]  # log det jacobians
+    >>> loss = criterion(hidden_vars, jacobians)
+    >>> loss.shape
+    torch.Size([])
+
+See Also:
+    :class:`anomalib.models.image.fastflow.torch_model.FastflowModel`:
+        PyTorch implementation of the FastFlow model architecture.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -8,18 +26,38 @@
 
 
 class FastflowLoss(nn.Module):
-    """FastFlow Loss."""
+    """FastFlow Loss Module.
+
+    Computes the negative log-likelihood loss used to train the FastFlow model. The loss
+    combines the log-likelihood of the hidden variables with the log determinant of the
+    Jacobian matrices from the normalizing flow transformations.
+    """
 
     @staticmethod
     def forward(hidden_variables: list[torch.Tensor], jacobians: list[torch.Tensor]) -> torch.Tensor:
-        """Calculate the Fastflow loss.
+        """Calculate the FastFlow loss.
+
+        The loss is computed as the negative log-likelihood of the hidden variables
+        transformed by the normalizing flows, taking into account the Jacobian
+        determinants of the transformations.
 
         Args:
-            hidden_variables (list[torch.Tensor]): Hidden variables from the fastflow model. f: X -> Z
-            jacobians (list[torch.Tensor]): Log of the jacobian determinants from the fastflow model.
+            hidden_variables (list[torch.Tensor]): List of hidden variable tensors
+                produced by the normalizing flow transformations. Each tensor has
+                shape ``(N, C, H, W)`` where ``N`` is batch size.
+            jacobians (list[torch.Tensor]): List of log determinants of Jacobian
+                matrices for each normalizing flow transformation. Each tensor has
+                shape ``(N,)`` where ``N`` is batch size.
 
         Returns:
-            Tensor: Fastflow loss computed based on the hidden variables and the log of the Jacobians.
+            torch.Tensor: Scalar loss value combining the negative log-likelihood
+                of hidden variables and Jacobian determinants.
+
+        Example:
+            >>> criterion = FastflowLoss()
+            >>> h_vars = [torch.randn(2, 64, 32, 32)]  # hidden variables
+            >>> jacs = [torch.randn(2)]  # log det jacobians
+            >>> loss = criterion(h_vars, jacs)
         """
         loss = torch.tensor(0.0, device=hidden_variables[0].device)  # pylint: disable=not-callable
         for hidden_variable, jacobian in zip(hidden_variables, jacobians, strict=True):
diff --git a/src/anomalib/models/image/fre/__init__.py b/src/anomalib/models/image/fre/__init__.py
index 7de3b5b399..91646c778f 100755
--- a/src/anomalib/models/image/fre/__init__.py
+++ b/src/anomalib/models/image/fre/__init__.py
@@ -1,4 +1,26 @@
-"""Deep Feature Extraction (DFM) model."""
+"""Feature Reconstruction Error (FRE) Algorithm Implementation.
+
+FRE is an anomaly detection model that uses feature reconstruction error to detect
+anomalies. The model extracts features from a pre-trained CNN backbone and learns
+to reconstruct them using an autoencoder. Anomalies are detected by measuring the
+reconstruction error.
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Fre
+    >>> from anomalib.engine import Engine
+
+    >>> datamodule = MVTec()
+    >>> model = Fre()
+    >>> engine = Engine()
+
+    >>> engine.fit(model, datamodule=datamodule)  # doctest: +SKIP
+    >>> predictions = engine.predict(model, datamodule=datamodule)  # doctest: +SKIP
+
+See Also:
+    :class:`anomalib.models.image.fre.lightning_model.Fre`:
+        PyTorch Lightning implementation of the FRE model.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/fre/lightning_model.py b/src/anomalib/models/image/fre/lightning_model.py
index 953fcd4322..6021f6655a 100755
--- a/src/anomalib/models/image/fre/lightning_model.py
+++ b/src/anomalib/models/image/fre/lightning_model.py
@@ -1,6 +1,30 @@
-"""FRE: Feature-Reconstruction Error.
+"""Feature Reconstruction Error (FRE) Algorithm Implementation.
 
-https://papers.bmvc2023.org/0614.pdf
+FRE is an anomaly detection model that uses feature reconstruction error to detect
+anomalies. The model extracts features from a pre-trained CNN backbone and learns
+to reconstruct them using a tied autoencoder. Anomalies are detected by measuring
+the reconstruction error between the original and reconstructed features.
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Fre
+    >>> from anomalib.engine import Engine
+
+    >>> datamodule = MVTec()
+    >>> model = Fre()
+    >>> engine = Engine()
+
+    >>> engine.fit(model, datamodule=datamodule)  # doctest: +SKIP
+    >>> predictions = engine.predict(model, datamodule=datamodule)  # doctest: +SKIP
+
+Paper:
+    Title: FRE: Feature Reconstruction Error for Unsupervised Anomaly Detection
+           and Segmentation
+    URL: https://papers.bmvc2023.org/0614.pdf
+
+See Also:
+    :class:`anomalib.models.image.fre.torch_model.FREModel`:
+        PyTorch implementation of the FRE model architecture.
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -29,23 +53,51 @@
 class Fre(AnomalibModule):
     """FRE: Feature-reconstruction error using Tied AutoEncoder.
 
+    The FRE model extracts features from a pre-trained CNN backbone and learns to
+    reconstruct them using a tied autoencoder. Anomalies are detected by measuring
+    the reconstruction error between original and reconstructed features.
+
     Args:
-        backbone (str): Backbone CNN network
-            Defaults to ``resnet50``.
-        layer (str): Layer to extract features from the backbone CNN
-            Defaults to ``layer3``.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
+        backbone (str): Backbone CNN network architecture.
+            Defaults to ``"resnet50"``.
+        layer (str): Layer name to extract features from the backbone CNN.
+            Defaults to ``"layer3"``.
+        pre_trained (bool, optional): Whether to use pre-trained backbone weights.
             Defaults to ``True``.
-        pooling_kernel_size (int, optional): Kernel size to pool features extracted from the CNN.
+        pooling_kernel_size (int, optional): Kernel size for pooling features
+            extracted from the CNN.
             Defaults to ``2``.
-        input_dim (int, optional): Dimension of feature at output of layer specified in layer.
+        input_dim (int, optional): Dimension of features at output of specified
+            layer.
             Defaults to ``65536``.
-        latent_dim (int, optional): Reduced size of feature after applying dimensionality reduction
-            via shallow linear autoencoder.
+        latent_dim (int, optional): Reduced feature dimension after applying
+            dimensionality reduction via shallow linear autoencoder.
             Defaults to ``220``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor to transform
+            inputs before passing to model.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor to generate
+            predictions from model outputs.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator to compute metrics.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer to display results.
+            Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models import Fre
+        >>> model = Fre(
+        ...     backbone="resnet50",
+        ...     layer="layer3",
+        ...     pre_trained=True,
+        ...     pooling_kernel_size=2,
+        ...     input_dim=65536,
+        ...     latent_dim=220,
+        ... )
+
+    See Also:
+        :class:`anomalib.models.image.fre.torch_model.FREModel`:
+            PyTorch implementation of the FRE model architecture.
     """
 
     def __init__(
@@ -82,22 +134,24 @@ def configure_optimizers(self) -> torch.optim.Optimizer:
         """Configure optimizers.
 
         Returns:
-            Optimizer: Adam optimizer
+            torch.optim.Optimizer: Adam optimizer for training the model.
         """
         return optim.Adam(params=self.model.fre_model.parameters(), lr=1e-3)
 
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the training step of FRE.
 
-        For each batch, features are extracted from the CNN.
+        For each batch, features are extracted from the CNN backbone and
+        reconstructed using the tied autoencoder. The loss is computed as the MSE
+        between original and reconstructed features.
 
         Args:
-            batch (Batch): Input batch
-            args: Arguments.
-            kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and labels.
+            args: Additional arguments (unused).
+            kwargs: Additional keyword arguments (unused).
 
         Returns:
-          Deep CNN features.
+            STEP_OUTPUT: Dictionary containing the loss value.
         """
         del args, kwargs  # These variables are not used.
         features_in, features_out, _ = self.model.get_features(batch.image)
@@ -108,15 +162,16 @@ def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step of FRE.
 
-        Similar to the training step, features are extracted from the CNN for each batch.
+        Similar to training, features are extracted and reconstructed. The
+        reconstruction error is used to compute anomaly scores and maps.
 
         Args:
-          batch (Batch): Input batch
-          args: Arguments.
-          kwargs: Keyword arguments.
+            batch (Batch): Input batch containing images and labels.
+            args: Additional arguments (unused).
+            kwargs: Additional keyword arguments (unused).
 
         Returns:
-          Dictionary containing FRE anomaly scores and anomaly maps.
+            STEP_OUTPUT: Dictionary containing anomaly scores and maps.
         """
         del args, kwargs  # These variables are not used.
 
@@ -125,7 +180,14 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """Return FRE-specific trainer arguments."""
+        """Return FRE-specific trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary of trainer arguments:
+                - ``gradient_clip_val``: ``0``
+                - ``max_epochs``: ``220``
+                - ``num_sanity_val_steps``: ``0``
+        """
         return {"gradient_clip_val": 0, "max_epochs": 220, "num_sanity_val_steps": 0}
 
     @property
@@ -133,6 +195,6 @@ def learning_type(self) -> LearningType:
         """Return the learning type of the model.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: Learning type of the model (``ONE_CLASS``).
         """
         return LearningType.ONE_CLASS
diff --git a/src/anomalib/models/image/fre/torch_model.py b/src/anomalib/models/image/fre/torch_model.py
index c2eb0c3416..760bae258a 100755
--- a/src/anomalib/models/image/fre/torch_model.py
+++ b/src/anomalib/models/image/fre/torch_model.py
@@ -1,4 +1,35 @@
-"""PyTorch model for FRE model implementation."""
+"""PyTorch model for the Feature Reconstruction Error (FRE) algorithm implementation.
+
+The FRE model extracts features from a pre-trained CNN backbone and learns to
+reconstruct them using a tied autoencoder. Anomalies are detected by measuring
+the reconstruction error between original and reconstructed features.
+
+Example:
+    >>> from anomalib.models.image.fre.torch_model import FREModel
+    >>> model = FREModel(
+    ...     backbone="resnet50",
+    ...     layer="layer3",
+    ...     input_dim=65536,
+    ...     latent_dim=220,
+    ...     pre_trained=True,
+    ...     pooling_kernel_size=4
+    ... )
+    >>> input_tensor = torch.randn(32, 3, 256, 256)
+    >>> output = model(input_tensor)
+    >>> output.pred_score.shape
+    torch.Size([32])
+    >>> output.anomaly_map.shape
+    torch.Size([32, 1, 256, 256])
+
+Paper:
+    Title: FRE: Feature Reconstruction Error for Unsupervised Anomaly Detection
+           and Segmentation
+    URL: https://papers.bmvc2023.org/0614.pdf
+
+See Also:
+    :class:`anomalib.models.image.fre.lightning_model.Fre`:
+        PyTorch Lightning implementation of the FRE model.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,11 +43,21 @@
 
 
 class TiedAE(nn.Module):
-    """Model for the Tied AutoEncoder used for FRE calculation.
+    """Tied Autoencoder used for feature reconstruction error calculation.
+
+    The tied autoencoder uses shared weights between encoder and decoder to reduce
+    the number of parameters while maintaining reconstruction capability.
 
     Args:
-        input_dim (int): Dimension of input to the tied auto-encoder.
-        latent_dim (int): Dimension of the reduced-dimension latent space of the tied auto-encoder.
+        input_dim (int): Dimension of input features to the tied autoencoder.
+        latent_dim (int): Dimension of the reduced latent space representation.
+
+    Example:
+        >>> tied_ae = TiedAE(input_dim=1024, latent_dim=128)
+        >>> features = torch.randn(32, 1024)
+        >>> reconstructed = tied_ae(features)
+        >>> reconstructed.shape
+        torch.Size([32, 1024])
     """
 
     def __init__(self, input_dim: int, latent_dim: int) -> None:
@@ -31,31 +72,59 @@ def __init__(self, input_dim: int, latent_dim: int) -> None:
     def forward(self, features: torch.Tensor) -> torch.Tensor:
         """Run input features through the autoencoder.
 
+        The features are first encoded to a lower dimensional latent space and
+        then decoded back to the original feature space using transposed weights.
+
         Args:
-            features (torch.Tensor): Feature batch.
+            features (torch.Tensor): Input feature batch of shape
+                ``(N, input_dim)``.
 
         Returns:
-            Tensor: torch.Tensor containing reconstructed features.
+            torch.Tensor: Reconstructed features of shape ``(N, input_dim)``.
         """
         encoded = F.linear(features, self.weight, self.encoder_bias)
         return F.linear(encoded, self.weight.t(), self.decoder_bias)
 
 
 class FREModel(nn.Module):
-    """Model for the FRE algorithm.
+    """Feature Reconstruction Error (FRE) model implementation.
+
+    The model extracts features from a pre-trained CNN backbone and learns to
+    reconstruct them using a tied autoencoder. Anomalies are detected by
+    measuring the reconstruction error between original and reconstructed
+    features.
 
     Args:
-        backbone (str): Pre-trained model backbone.
-        layer (str): Layer from which to extract features.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
-            Defaults to ``True``.
-        pooling_kernel_size (int, optional): Kernel size to pool features extracted from the CNN.
-            Defaults to ``4``.
-        input_dim (int, optional): Dimension of feature at output of layer specified in layer.
+        backbone (str): Pre-trained CNN backbone architecture (e.g.
+            ``"resnet18"``, ``"resnet50"``, etc.).
+        layer (str): Layer name from which to extract features (e.g.
+            ``"layer2"``, ``"layer3"``, etc.).
+        input_dim (int, optional): Dimension of features at output of specified
+            layer.
             Defaults to ``65536``.
-        latent_dim (int, optional): Reduced size of feature after applying dimensionality reduction
-            via shallow linear autoencoder.
+        latent_dim (int, optional): Reduced feature dimension after applying
+            dimensionality reduction via shallow linear autoencoder.
             Defaults to ``220``.
+        pre_trained (bool, optional): Whether to use pre-trained backbone
+            weights.
+            Defaults to ``True``.
+        pooling_kernel_size (int, optional): Kernel size for pooling features
+            extracted from the CNN.
+            Defaults to ``4``.
+
+    Example:
+        >>> model = FREModel(
+        ...     backbone="resnet50",
+        ...     layer="layer3",
+        ...     input_dim=65536,
+        ...     latent_dim=220
+        ... )
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> output = model(input_tensor)
+        >>> output.pred_score.shape
+        torch.Size([32])
+        >>> output.anomaly_map.shape
+        torch.Size([32, 1, 256, 256])
     """
 
     def __init__(
@@ -79,13 +148,18 @@ def __init__(
         ).eval()
 
     def get_features(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Extract features from the pretrained network.
+        """Extract and reconstruct features from the pretrained network.
 
         Args:
-            batch (torch.Tensor): Image batch.
+            batch (torch.Tensor): Input image batch of shape
+                ``(N, C, H, W)``.
 
         Returns:
-            Tensor: torch.Tensor containing extracted features.
+            tuple[torch.Tensor, torch.Tensor, torch.Tensor]: Tuple containing:
+                - Original features of shape ``(N, D)``
+                - Reconstructed features of shape ``(N, D)``
+                - Original feature tensor shape ``(N, C, H, W)``
+                where ``D`` is the flattened feature dimension.
         """
         self.feature_extractor.eval()
         features_in = self.feature_extractor(batch)[self.layer]
@@ -98,13 +172,22 @@ def get_features(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor,
         return features_in, features_out, feature_shapes
 
     def forward(self, batch: torch.Tensor) -> InferenceBatch:
-        """Compute score from input images.
+        """Generate anomaly predictions for input images.
+
+        The method:
+        1. Extracts and reconstructs features using the tied autoencoder
+        2. Computes reconstruction error as anomaly scores
+        3. Generates pixel-wise anomaly maps
+        4. Upsamples anomaly maps to input image size
 
         Args:
-            batch (torch.Tensor): Input images
+            batch (torch.Tensor): Input image batch of shape
+                ``(N, C, H, W)``.
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor]: Scores, Anomaly Map
+            InferenceBatch: Batch containing:
+                - Anomaly scores of shape ``(N,)``
+                - Anomaly maps of shape ``(N, 1, H, W)``
         """
         features_in, features_out, feature_shapes = self.get_features(batch)
         fre = torch.square(features_in - features_out).reshape(feature_shapes)
diff --git a/src/anomalib/models/image/ganomaly/__init__.py b/src/anomalib/models/image/ganomaly/__init__.py
index ec872b077d..ea07b478ca 100644
--- a/src/anomalib/models/image/ganomaly/__init__.py
+++ b/src/anomalib/models/image/ganomaly/__init__.py
@@ -1,4 +1,30 @@
-"""GANomaly Model."""
+"""GANomaly Algorithm Implementation.
+
+GANomaly is an anomaly detection model that uses a conditional GAN architecture to
+learn the normal data distribution. The model consists of a generator network that
+learns to reconstruct normal images, and a discriminator that helps ensure the
+reconstructions are realistic.
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Ganomaly
+    >>> from anomalib.engine import Engine
+
+    >>> datamodule = MVTec()
+    >>> model = Ganomaly()
+    >>> engine = Engine()
+
+    >>> engine.fit(model, datamodule=datamodule)  # doctest: +SKIP
+    >>> predictions = engine.predict(model, datamodule=datamodule)  # doctest: +SKIP
+
+Paper:
+    Title: GANomaly: Semi-Supervised Anomaly Detection via Adversarial Training
+    URL: https://arxiv.org/abs/1805.06725
+
+See Also:
+    :class:`anomalib.models.image.ganomaly.lightning_model.Ganomaly`:
+        PyTorch Lightning implementation of the GANomaly model.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/ganomaly/lightning_model.py b/src/anomalib/models/image/ganomaly/lightning_model.py
index 4b48b0b633..4f2421d37b 100644
--- a/src/anomalib/models/image/ganomaly/lightning_model.py
+++ b/src/anomalib/models/image/ganomaly/lightning_model.py
@@ -1,6 +1,33 @@
 """GANomaly: Semi-Supervised Anomaly Detection via Adversarial Training.
 
-https://arxiv.org/abs/1805.06725
+GANomaly is an anomaly detection model that uses a conditional GAN architecture to
+learn the normal data distribution. The model consists of a generator network that
+learns to reconstruct normal images, and a discriminator that helps ensure the
+reconstructions are realistic.
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Ganomaly
+    >>> from anomalib.engine import Engine
+
+    >>> datamodule = MVTec()
+    >>> model = Ganomaly()
+    >>> engine = Engine()
+
+    >>> engine.fit(model, datamodule=datamodule)  # doctest: +SKIP
+    >>> predictions = engine.predict(model, datamodule=datamodule)  # doctest: +SKIP
+
+Paper:
+    Title: GANomaly: Semi-Supervised Anomaly Detection via Adversarial Training
+    URL: https://arxiv.org/abs/1805.06725
+
+See Also:
+    :class:`anomalib.models.image.ganomaly.torch_model.GanomalyModel`:
+        PyTorch implementation of the GANomaly model architecture.
+    :class:`anomalib.models.image.ganomaly.loss.GeneratorLoss`:
+        Loss function for the generator network.
+    :class:`anomalib.models.image.ganomaly.loss.DiscriminatorLoss`:
+        Loss function for the discriminator network.
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -30,32 +57,63 @@
 class Ganomaly(AnomalibModule):
     """PL Lightning Module for the GANomaly Algorithm.
 
+    The GANomaly model consists of a generator and discriminator network. The
+    generator learns to reconstruct normal images while the discriminator helps
+    ensure the reconstructions are realistic. Anomalies are detected by measuring
+    the reconstruction error and latent space differences.
+
     Args:
-        batch_size (int): Batch size.
+        batch_size (int): Number of samples in each batch.
             Defaults to ``32``.
-        n_features (int): Number of features layers in the CNNs.
+        n_features (int): Number of feature channels in CNN layers.
             Defaults to ``64``.
-        latent_vec_size (int): Size of autoencoder latent vector.
+        latent_vec_size (int): Dimension of the latent space vectors.
             Defaults to ``100``.
-        extra_layers (int, optional): Number of extra layers for encoder/decoder.
+        extra_layers (int, optional): Number of extra layers in encoder/decoder.
             Defaults to ``0``.
         add_final_conv_layer (bool, optional): Add convolution layer at the end.
             Defaults to ``True``.
-        wadv (int, optional): Weight for adversarial loss.
+        wadv (int, optional): Weight for adversarial loss component.
             Defaults to ``1``.
-        wcon (int, optional): Image regeneration weight.
+        wcon (int, optional): Weight for image reconstruction loss component.
             Defaults to ``50``.
-        wenc (int, optional): Latent vector encoder weight.
+        wenc (int, optional): Weight for latent vector encoding loss component.
             Defaults to ``1``.
-        lr (float, optional): Learning rate.
+        lr (float, optional): Learning rate for optimizers.
             Defaults to ``0.0002``.
-        beta1 (float, optional): Adam beta1.
+        beta1 (float, optional): Beta1 parameter for Adam optimizers.
             Defaults to ``0.5``.
-        beta2 (float, optional): Adam beta2.
+        beta2 (float, optional): Beta2 parameter for Adam optimizers.
             Defaults to ``0.999``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor to transform
+            inputs before passing to model.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor to generate
+            predictions from model outputs.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator to compute metrics.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer to display results.
+            Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models import Ganomaly
+        >>> model = Ganomaly(
+        ...     batch_size=32,
+        ...     n_features=64,
+        ...     latent_vec_size=100,
+        ...     wadv=1,
+        ...     wcon=50,
+        ...     wenc=1,
+        ... )
+
+    See Also:
+        :class:`anomalib.models.image.ganomaly.torch_model.GanomalyModel`:
+            PyTorch implementation of the GANomaly model architecture.
+        :class:`anomalib.models.image.ganomaly.loss.GeneratorLoss`:
+            Loss function for the generator network.
+        :class:`anomalib.models.image.ganomaly.loss.DiscriminatorLoss`:
+            Loss function for the discriminator network.
     """
 
     def __init__(
diff --git a/src/anomalib/models/image/ganomaly/loss.py b/src/anomalib/models/image/ganomaly/loss.py
index 6262ef1764..fb50ce24b5 100644
--- a/src/anomalib/models/image/ganomaly/loss.py
+++ b/src/anomalib/models/image/ganomaly/loss.py
@@ -1,4 +1,23 @@
-"""Loss function for the GANomaly Model Implementation."""
+"""Loss functions for the GANomaly model implementation.
+
+The GANomaly model uses two loss functions:
+
+1. Generator Loss: Combines adversarial loss, reconstruction loss and encoding loss
+2. Discriminator Loss: Binary cross entropy loss for real/fake image discrimination
+
+Example:
+    >>> from anomalib.models.image.ganomaly.loss import GeneratorLoss
+    >>> generator_loss = GeneratorLoss(wadv=1, wcon=50, wenc=1)
+    >>> loss = generator_loss(latent_i, latent_o, images, fake, pred_real, pred_fake)
+
+    >>> from anomalib.models.image.ganomaly.loss import DiscriminatorLoss
+    >>> discriminator_loss = DiscriminatorLoss()
+    >>> loss = discriminator_loss(pred_real, pred_fake)
+
+See Also:
+    :class:`anomalib.models.image.ganomaly.torch_model.GanomalyModel`:
+        PyTorch implementation of the GANomaly model architecture.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,13 +29,27 @@
 class GeneratorLoss(nn.Module):
     """Generator loss for the GANomaly model.
 
+    Combines three components:
+    1. Adversarial loss: Helps generate realistic images
+    2. Contextual loss: Ensures generated images match input
+    3. Encoding loss: Enforces consistency in latent space
+
     Args:
-        wadv (int, optional): Weight for adversarial loss.
-            Defaults to ``1``.
-        wcon (int, optional): Image regeneration weight.
+        wadv (int, optional): Weight for adversarial loss. Defaults to ``1``.
+        wcon (int, optional): Weight for contextual/reconstruction loss.
             Defaults to ``50``.
-        wenc (int, optional): Latent vector encoder weight.
-            Defaults to ``1``.
+        wenc (int, optional): Weight for encoding/latent loss. Defaults to ``1``.
+
+    Example:
+        >>> generator_loss = GeneratorLoss(wadv=1, wcon=50, wenc=1)
+        >>> loss = generator_loss(
+        ...     latent_i=torch.randn(32, 100),
+        ...     latent_o=torch.randn(32, 100),
+        ...     images=torch.randn(32, 3, 256, 256),
+        ...     fake=torch.randn(32, 3, 256, 256),
+        ...     pred_real=torch.randn(32, 1),
+        ...     pred_fake=torch.randn(32, 1)
+        ... )
     """
 
     def __init__(self, wadv: int = 1, wcon: int = 50, wenc: int = 1) -> None:
@@ -39,18 +72,22 @@ def forward(
         pred_real: torch.Tensor,
         pred_fake: torch.Tensor,
     ) -> torch.Tensor:
-        """Compute the loss for a batch.
+        """Compute the generator loss for a batch.
 
         Args:
-            latent_i (torch.Tensor): Latent features of the first encoder.
-            latent_o (torch.Tensor): Latent features of the second encoder.
-            images (torch.Tensor): Real image that served as input of the generator.
-            fake (torch.Tensor): Generated image.
-            pred_real (torch.Tensor): Discriminator predictions for the real image.
-            pred_fake (torch.Tensor): Discriminator predictions for the fake image.
+            latent_i (torch.Tensor): Latent features from the first encoder.
+            latent_o (torch.Tensor): Latent features from the second encoder.
+            images (torch.Tensor): Real images that served as generator input.
+            fake (torch.Tensor): Generated/fake images.
+            pred_real (torch.Tensor): Discriminator predictions for real images.
+            pred_fake (torch.Tensor): Discriminator predictions for fake images.
 
         Returns:
-            Tensor: The computed generator loss.
+            torch.Tensor: Combined weighted generator loss.
+
+        Example:
+            >>> loss = generator_loss(latent_i, latent_o, images, fake,
+            ...                      pred_real, pred_fake)
         """
         error_enc = self.loss_enc(latent_i, latent_o)
         error_con = self.loss_con(images, fake)
@@ -60,7 +97,18 @@ def forward(
 
 
 class DiscriminatorLoss(nn.Module):
-    """Discriminator loss for the GANomaly model."""
+    """Discriminator loss for the GANomaly model.
+
+    Uses binary cross entropy to train the discriminator to distinguish between
+    real and generated images.
+
+    Example:
+        >>> discriminator_loss = DiscriminatorLoss()
+        >>> loss = discriminator_loss(
+        ...     pred_real=torch.randn(32, 1),
+        ...     pred_fake=torch.randn(32, 1)
+        ... )
+    """
 
     def __init__(self) -> None:
         super().__init__()
@@ -68,14 +116,17 @@ def __init__(self) -> None:
         self.loss_bce = nn.BCELoss()
 
     def forward(self, pred_real: torch.Tensor, pred_fake: torch.Tensor) -> torch.Tensor:
-        """Compute the loss for a predicted batch.
+        """Compute the discriminator loss for predicted batch.
 
         Args:
-            pred_real (torch.Tensor): Discriminator predictions for the real image.
-            pred_fake (torch.Tensor): Discriminator predictions for the fake image.
+            pred_real (torch.Tensor): Discriminator predictions for real images.
+            pred_fake (torch.Tensor): Discriminator predictions for fake images.
 
         Returns:
-            Tensor: The computed discriminator loss.
+            torch.Tensor: Average discriminator loss.
+
+        Example:
+            >>> loss = discriminator_loss(pred_real, pred_fake)
         """
         error_discriminator_real = self.loss_bce(
             pred_real,
diff --git a/src/anomalib/models/image/ganomaly/torch_model.py b/src/anomalib/models/image/ganomaly/torch_model.py
index 3d791c8501..26d4be55ab 100644
--- a/src/anomalib/models/image/ganomaly/torch_model.py
+++ b/src/anomalib/models/image/ganomaly/torch_model.py
@@ -1,11 +1,46 @@
-"""Torch models defining encoder, decoder, Generator and Discriminator.
-
-Code adapted from https://github.com/samet-akcay/ganomaly.
+"""Torch models defining encoder, decoder, generator and discriminator networks.
+
+The GANomaly model consists of several key components:
+
+1. Encoder: Compresses input images into latent vectors
+2. Decoder: Reconstructs images from latent vectors
+3. Generator: Combines encoder-decoder-encoder for image generation
+4. Discriminator: Distinguishes real from generated images
+
+The architecture follows an encoder-decoder-encoder pattern where:
+- First encoder compresses input image to latent space
+- Decoder reconstructs the image from latent vector
+- Second encoder re-encodes reconstructed image
+- Anomaly score is based on difference between latent vectors
+
+Example:
+    >>> from anomalib.models.image.ganomaly.torch_model import GanomalyModel
+    >>> model = GanomalyModel(
+    ...     input_size=(256, 256),
+    ...     num_input_channels=3,
+    ...     n_features=64,
+    ...     latent_vec_size=100,
+    ...     extra_layers=0,
+    ...     add_final_conv_layer=True
+    ... )
+    >>> input_tensor = torch.randn(32, 3, 256, 256)
+    >>> output = model(input_tensor)
+
+Code adapted from:
+    Title: GANomaly - PyTorch Implementation
+    Authors: Samet Akcay
+    URL: https://github.com/samet-akcay/ganomaly
+    License: MIT
+
+See Also:
+    - :class:`anomalib.models.image.ganomaly.lightning_model.Ganomaly`:
+        Lightning implementation of the GANomaly model
+    - :class:`anomalib.models.image.ganomaly.loss.GeneratorLoss`:
+        Loss function for the generator network
+    - :class:`anomalib.models.image.ganomaly.loss.DiscriminatorLoss`:
+        Loss function for the discriminator network
 """
 
-# Copyright (c) 2018-2022 Samet Akcay, Durham University, UK
-# SPDX-License-Identifier: MIT
-#
 # Copyright (C) 2020-2022 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
@@ -21,15 +56,28 @@
 class Encoder(nn.Module):
     """Encoder Network.
 
+    Compresses input images into latent vectors through a series of convolution
+    layers.
+
     Args:
-        input_size (tuple[int, int]): Size of input image
-        latent_vec_size (int): Size of latent vector z
-        num_input_channels (int): Number of input channels in the image
-        n_features (int): Number of features per convolution layer
-        extra_layers (int): Number of extra layers since the network uses only a single encoder layer by default.
+        input_size (tuple[int, int]): Size of input image (height, width)
+        latent_vec_size (int): Size of output latent vector
+        num_input_channels (int): Number of input image channels
+        n_features (int): Number of feature maps in convolution layers
+        extra_layers (int, optional): Number of extra intermediate layers.
             Defaults to ``0``.
-        add_final_conv_layer (bool): Add a final convolution layer in the encoder.
-            Defaults to ``True``.
+        add_final_conv_layer (bool, optional): Whether to add final convolution
+            layer. Defaults to ``True``.
+
+    Example:
+        >>> encoder = Encoder(
+        ...     input_size=(256, 256),
+        ...     latent_vec_size=100,
+        ...     num_input_channels=3,
+        ...     n_features=64
+        ... )
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> latent = encoder(input_tensor)
     """
 
     def __init__(
@@ -88,7 +136,15 @@ def __init__(
             )
 
     def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
-        """Return latent vectors."""
+        """Forward pass through encoder network.
+
+        Args:
+            input_tensor (torch.Tensor): Input tensor of shape
+                ``(batch_size, channels, height, width)``
+
+        Returns:
+            torch.Tensor: Latent vector tensor
+        """
         output = self.input_layers(input_tensor)
         output = self.extra_layers(output)
         output = self.pyramid_features(output)
@@ -101,13 +157,25 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
 class Decoder(nn.Module):
     """Decoder Network.
 
+    Reconstructs images from latent vectors through transposed convolutions.
+
     Args:
-        input_size (tuple[int, int]): Size of input image
-        latent_vec_size (int): Size of latent vector z
-        num_input_channels (int): Number of input channels in the image
-        n_features (int): Number of features per convolution layer
-        extra_layers (int): Number of extra layers since the network uses only a single encoder layer by default.
+        input_size (tuple[int, int]): Size of output image (height, width)
+        latent_vec_size (int): Size of input latent vector
+        num_input_channels (int): Number of output image channels
+        n_features (int): Number of feature maps in convolution layers
+        extra_layers (int, optional): Number of extra intermediate layers.
             Defaults to ``0``.
+
+    Example:
+        >>> decoder = Decoder(
+        ...     input_size=(256, 256),
+        ...     latent_vec_size=100,
+        ...     num_input_channels=3,
+        ...     n_features=64
+        ... )
+        >>> latent = torch.randn(32, 100, 1, 1)
+        >>> reconstruction = decoder(latent)
     """
 
     def __init__(
@@ -195,7 +263,14 @@ def __init__(
         self.final_layers.add_module(f"final-{num_input_channels}-tanh", nn.Tanh())
 
     def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
-        """Return generated image."""
+        """Forward pass through decoder network.
+
+        Args:
+            input_tensor (torch.Tensor): Input latent tensor
+
+        Returns:
+            torch.Tensor: Reconstructed image tensor
+        """
         output = self.latent_input(input_tensor)
         output = self.inverse_pyramid(output)
         output = self.extra_layers(output)
@@ -203,16 +278,25 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:
 
 
 class Discriminator(nn.Module):
-    """Discriminator.
+    """Discriminator Network.
 
-        Made of only one encoder layer which takes x and x_hat to produce a score.
+    Classifies images as real or generated using a modified encoder architecture.
 
     Args:
-        input_size (tuple[int, int]): Input image size.
-        num_input_channels (int): Number of image channels.
-        n_features (int): Number of feature maps in each convolution layer.
-        extra_layers (int, optional): Add extra intermediate layers.
+        input_size (tuple[int, int]): Input image size (height, width)
+        num_input_channels (int): Number of input image channels
+        n_features (int): Number of feature maps in convolution layers
+        extra_layers (int, optional): Number of extra intermediate layers.
             Defaults to ``0``.
+
+    Example:
+        >>> discriminator = Discriminator(
+        ...     input_size=(256, 256),
+        ...     num_input_channels=3,
+        ...     n_features=64
+        ... )
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> prediction, features = discriminator(input_tensor)
     """
 
     def __init__(
@@ -236,7 +320,16 @@ def __init__(
         self.classifier.add_module("Sigmoid", nn.Sigmoid())
 
     def forward(self, input_tensor: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        """Return class of object and features."""
+        """Forward pass through discriminator network.
+
+        Args:
+            input_tensor (torch.Tensor): Input image tensor
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing:
+                - Classification scores (real/fake)
+                - Intermediate features
+        """
         features = self.features(input_tensor)
         classifier = self.classifier(features)
         classifier = classifier.view(-1, 1).squeeze(1)
@@ -244,19 +337,30 @@ def forward(self, input_tensor: torch.Tensor) -> tuple[torch.Tensor, torch.Tenso
 
 
 class Generator(nn.Module):
-    """Generator model.
+    """Generator Network.
 
-    Made of an encoder-decoder-encoder architecture.
+    Combines encoder-decoder-encoder architecture for image generation and
+    reconstruction.
 
     Args:
-        input_size (tuple[int, int]): Size of input data.
-        latent_vec_size (int): Dimension of latent vector produced between the first encoder-decoder.
-        num_input_channels (int): Number of channels in input image.
-        n_features (int): Number of feature maps in each convolution layer.
-        extra_layers (int, optional): Extra intermediate layers in the encoder/decoder.
+        input_size (tuple[int, int]): Input/output image size (height, width)
+        latent_vec_size (int): Size of latent vector between encoder-decoder
+        num_input_channels (int): Number of input/output image channels
+        n_features (int): Number of feature maps in convolution layers
+        extra_layers (int, optional): Number of extra intermediate layers.
             Defaults to ``0``.
-        add_final_conv_layer (bool, optional): Add a final convolution layer in the decoder.
+        add_final_conv_layer (bool, optional): Add final convolution to encoders.
             Defaults to ``True``.
+
+    Example:
+        >>> generator = Generator(
+        ...     input_size=(256, 256),
+        ...     latent_vec_size=100,
+        ...     num_input_channels=3,
+        ...     n_features=64
+        ... )
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> gen_img, latent_i, latent_o = generator(input_tensor)
     """
 
     def __init__(
@@ -288,7 +392,17 @@ def __init__(
         )
 
     def forward(self, input_tensor: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Return generated image and the latent vectors."""
+        """Forward pass through generator network.
+
+        Args:
+            input_tensor (torch.Tensor): Input image tensor
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor, torch.Tensor]: Tuple containing:
+                - Generated image
+                - First encoder's latent vector
+                - Second encoder's latent vector
+        """
         latent_i = self.encoder1(input_tensor)
         gen_image = self.decoder(latent_i)
         latent_o = self.encoder2(gen_image)
@@ -296,17 +410,35 @@ def forward(self, input_tensor: torch.Tensor) -> tuple[torch.Tensor, torch.Tenso
 
 
 class GanomalyModel(nn.Module):
-    """Ganomaly Model.
+    """GANomaly model for anomaly detection.
+
+    Complete model combining Generator and Discriminator networks.
 
     Args:
-        input_size (tuple[int, int]): Input dimension.
-        num_input_channels (int): Number of input channels.
-        n_features (int): Number of features layers in the CNNs.
-        latent_vec_size (int): Size of autoencoder latent vector.
-        extra_layers (int, optional): Number of extra layers for encoder/decoder.
+        input_size (tuple[int, int]): Input image size (height, width)
+        num_input_channels (int): Number of input image channels
+        n_features (int): Number of feature maps in convolution layers
+        latent_vec_size (int): Size of latent vector between encoder-decoder
+        extra_layers (int, optional): Number of extra intermediate layers.
             Defaults to ``0``.
-        add_final_conv_layer (bool, optional): Add convolution layer at the end.
+        add_final_conv_layer (bool, optional): Add final convolution to encoders.
             Defaults to ``True``.
+
+    Example:
+        >>> model = GanomalyModel(
+        ...     input_size=(256, 256),
+        ...     num_input_channels=3,
+        ...     n_features=64,
+        ...     latent_vec_size=100
+        ... )
+        >>> input_tensor = torch.randn(32, 3, 256, 256)
+        >>> output = model(input_tensor)
+
+    References:
+        - Title: GANomaly: Semi-Supervised Anomaly Detection via Adversarial
+                Training
+        - Authors: Samet Akcay, Amir Atapour-Abarghouei, Toby P. Breckon
+        - URL: https://arxiv.org/abs/1805.06725
     """
 
     def __init__(
@@ -341,7 +473,7 @@ def weights_init(module: nn.Module) -> None:
         """Initialize DCGAN weights.
 
         Args:
-            module (nn.Module): [description]
+            module (nn.Module): Neural network module to initialize
         """
         classname = module.__class__.__name__
         if classname.find("Conv") != -1:
@@ -354,13 +486,21 @@ def forward(
         self,
         batch: torch.Tensor,
     ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor] | InferenceBatch:
-        """Get scores for batch.
+        """Forward pass through GANomaly model.
 
         Args:
-            batch (torch.Tensor): Images
+            batch (torch.Tensor): Batch of input images
 
         Returns:
-            Tensor: Regeneration scores.
+            tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor] |
+            InferenceBatch:
+                If training:
+                    - Padded input batch
+                    - Generated images
+                    - First encoder's latent vectors
+                    - Second encoder's latent vectors
+                If inference:
+                    - Batch containing anomaly scores
         """
         padded_batch = pad_nextpow2(batch)
         fake, latent_i, latent_o = self.generator(padded_batch)
diff --git a/src/anomalib/models/image/padim/__init__.py b/src/anomalib/models/image/padim/__init__.py
index 944e8f20c3..3dcbbd1d43 100644
--- a/src/anomalib/models/image/padim/__init__.py
+++ b/src/anomalib/models/image/padim/__init__.py
@@ -1,4 +1,17 @@
-"""PADIM model."""
+"""PaDiM: a Patch Distribution Modeling Framework for Anomaly Detection and Localization.
+
+The PaDiM model is an anomaly detection approach that leverages patch-based
+distribution modeling using pretrained CNN feature embeddings. It models the
+distribution of patch embeddings at each spatial location using multivariate
+Gaussian distributions.
+
+The model uses features extracted from multiple layers of networks like
+``ResNet`` to capture both semantic and low-level visual information. During
+inference, it computes Mahalanobis distances between test patch embeddings and
+their corresponding reference distributions to detect anomalies.
+
+Paper: https://arxiv.org/abs/2011.08785
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/padim/anomaly_map.py b/src/anomalib/models/image/padim/anomaly_map.py
index 054a930664..4807ccf3dd 100644
--- a/src/anomalib/models/image/padim/anomaly_map.py
+++ b/src/anomalib/models/image/padim/anomaly_map.py
@@ -1,4 +1,32 @@
-"""Anomaly Map Generator for the PaDiM model implementation."""
+"""Anomaly Map Generator for the PaDiM model implementation.
+
+This module generates anomaly heatmaps for the PaDiM model by computing Mahalanobis
+distances between test patch embeddings and reference distributions.
+
+The anomaly map generation process involves:
+1. Computing Mahalanobis distances between embeddings and reference statistics
+2. Upsampling the distance map to match input image size
+3. Applying Gaussian smoothing to obtain the final anomaly map
+
+Example:
+    >>> from anomalib.models.image.padim.anomaly_map import AnomalyMapGenerator
+    >>> generator = AnomalyMapGenerator(sigma=4)
+    >>> embedding = torch.randn(32, 1024, 28, 28)
+    >>> mean = torch.randn(1024, 784)  # 784 = 28*28
+    >>> inv_covariance = torch.randn(784, 1024, 1024)
+    >>> anomaly_map = generator(
+    ...     embedding=embedding,
+    ...     mean=mean,
+    ...     inv_covariance=inv_covariance,
+    ...     image_size=(224, 224)
+    ... )
+
+See Also:
+    - :class:`anomalib.models.image.padim.lightning_model.Padim`:
+        Lightning implementation of the PaDiM model
+    - :class:`anomalib.models.components.GaussianBlur2d`:
+        Gaussian blur module used for smoothing anomaly maps
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,10 +41,24 @@
 class AnomalyMapGenerator(nn.Module):
     """Generate Anomaly Heatmap.
 
+    This class implements anomaly map generation for the PaDiM model by computing
+    Mahalanobis distances and applying post-processing steps.
+
     Args:
-        image_size (ListConfig, tuple): Size of the input image. The anomaly map is upsampled to this dimension.
-        sigma (int, optional): Standard deviation for Gaussian Kernel.
-            Defaults to ``4``.
+        sigma (int, optional): Standard deviation for Gaussian smoothing kernel.
+            Higher values produce smoother anomaly maps. Defaults to ``4``.
+
+    Example:
+        >>> generator = AnomalyMapGenerator(sigma=4)
+        >>> embedding = torch.randn(32, 1024, 28, 28)
+        >>> mean = torch.randn(1024, 784)
+        >>> inv_covariance = torch.randn(784, 1024, 1024)
+        >>> anomaly_map = generator.compute_anomaly_map(
+        ...     embedding=embedding,
+        ...     mean=mean,
+        ...     inv_covariance=inv_covariance,
+        ...     image_size=(224, 224)
+        ... )
     """
 
     def __init__(self, sigma: int = 4) -> None:
@@ -26,16 +68,20 @@ def __init__(self, sigma: int = 4) -> None:
 
     @staticmethod
     def compute_distance(embedding: torch.Tensor, stats: list[torch.Tensor]) -> torch.Tensor:
-        """Compute anomaly score to the patch in position(i,j) of a test image.
+        """Compute anomaly score for each patch position using Mahalanobis distance.
 
-        Ref: Equation (2), Section III-C of the paper.
+        Implements Equation (2) from Section III-C of the PaDiM paper to compute
+        the distance between patch embeddings and their reference distributions.
 
         Args:
-            embedding (torch.Tensor): Embedding Vector
-            stats (list[torch.Tensor]): Mean and Covariance Matrix of the multivariate Gaussian distribution
+            embedding (torch.Tensor): Feature embeddings from the CNN backbone,
+                shape ``(batch_size, n_features, height, width)``
+            stats (list[torch.Tensor]): List containing mean and inverse covariance
+                tensors for the multivariate Gaussian distributions
 
         Returns:
-            Anomaly score of a test image via mahalanobis distance.
+            torch.Tensor: Anomaly scores computed via Mahalanobis distance,
+                shape ``(batch_size, 1, height, width)``
         """
         batch, channel, height, width = embedding.shape
         embedding = embedding.reshape(batch, channel, height * width)
@@ -53,11 +99,13 @@ def up_sample(distance: torch.Tensor, image_size: tuple[int, int] | torch.Size)
         """Up sample anomaly score to match the input image size.
 
         Args:
-            distance (torch.Tensor): Anomaly score computed via the mahalanobis distance.
-            image_size (tuple[int, int] | torch.Size): Size to which the anomaly map should be upsampled.
+            distance (torch.Tensor): Anomaly scores, shape
+                ``(batch_size, 1, height, width)``
+            image_size (tuple[int, int] | torch.Size): Target size for upsampling,
+                usually the original input image size
 
         Returns:
-            Resized distance matrix matching the input image size
+            torch.Tensor: Upsampled anomaly scores matching the input image size
         """
         return F.interpolate(
             distance,
@@ -67,13 +115,14 @@ def up_sample(distance: torch.Tensor, image_size: tuple[int, int] | torch.Size)
         )
 
     def smooth_anomaly_map(self, anomaly_map: torch.Tensor) -> torch.Tensor:
-        """Apply gaussian smoothing to the anomaly map.
+        """Apply Gaussian smoothing to the anomaly map.
 
         Args:
-            anomaly_map (torch.Tensor): Anomaly score for the test image(s).
+            anomaly_map (torch.Tensor): Raw anomaly scores,
+                shape ``(batch_size, 1, height, width)``
 
         Returns:
-            Filtered anomaly scores
+            torch.Tensor: Smoothed anomaly scores with reduced noise
         """
         return self.blur(anomaly_map)
 
@@ -84,19 +133,20 @@ def compute_anomaly_map(
         inv_covariance: torch.Tensor,
         image_size: tuple[int, int] | torch.Size | None = None,
     ) -> torch.Tensor:
-        """Compute anomaly score.
+        """Compute anomaly map from feature embeddings and distribution parameters.
 
-        Scores are calculated based on embedding vector, mean and inv_covariance of the multivariate gaussian
-        distribution.
+        This method combines distance computation, upsampling, and smoothing to
+        generate the final anomaly map.
 
         Args:
-            embedding (torch.Tensor): Embedding vector extracted from the test set.
-            mean (torch.Tensor): Mean of the multivariate gaussian distribution
-            inv_covariance (torch.Tensor): Inverse Covariance matrix of the multivariate gaussian distribution.
-            image_size (tuple[int, int] | torch.Size, optional): Size to which the anomaly map should be upsampled.
+            embedding (torch.Tensor): Feature embeddings from the CNN backbone
+            mean (torch.Tensor): Mean of the multivariate Gaussian distribution
+            inv_covariance (torch.Tensor): Inverse covariance matrix
+            image_size (tuple[int, int] | torch.Size | None, optional): Target
+                size for upsampling. If ``None``, no upsampling is performed.
 
         Returns:
-            Output anomaly score.
+            torch.Tensor: Final anomaly map after all processing steps
         """
         score_map = self.compute_distance(
             embedding=embedding,
@@ -107,19 +157,29 @@ def compute_anomaly_map(
         return self.smooth_anomaly_map(score_map)
 
     def forward(self, **kwargs) -> torch.Tensor:
-        """Return anomaly_map.
+        """Generate anomaly map from the provided embeddings and statistics.
 
-        Expects `embedding`, `mean` and `covariance` keywords to be passed explicitly.
+        Expects ``embedding``, ``mean`` and ``inv_covariance`` keywords to be
+        passed explicitly.
 
         Example:
-            >>> anomaly_map_generator = AnomalyMapGenerator(image_size=input_size)
-            >>> output = anomaly_map_generator(embedding=embedding, mean=mean, covariance=covariance)
+            >>> generator = AnomalyMapGenerator(sigma=4)
+            >>> anomaly_map = generator(
+            ...     embedding=embedding,
+            ...     mean=mean,
+            ...     inv_covariance=inv_covariance,
+            ...     image_size=(224, 224)
+            ... )
+
+        Args:
+            **kwargs: Keyword arguments containing ``embedding``, ``mean``,
+                ``inv_covariance`` and optionally ``image_size``
 
         Raises:
-            ValueError: `embedding`. `mean` or `covariance` keys are not found
+            ValueError: If required keys are not found in ``kwargs``
 
         Returns:
-            torch.Tensor: anomaly map
+            torch.Tensor: Generated anomaly map
         """
         if not ("embedding" in kwargs and "mean" in kwargs and "inv_covariance" in kwargs):
             msg = f"Expected keys `embedding`, `mean` and `covariance`. Found {kwargs.keys()}"
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index 78f17861c0..242cd309e7 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -1,6 +1,31 @@
 """PaDiM: a Patch Distribution Modeling Framework for Anomaly Detection and Localization.
 
-Paper https://arxiv.org/abs/2011.08785
+This model implements the PaDiM algorithm for anomaly detection and localization.
+PaDiM models the distribution of patch embeddings at each spatial location using
+multivariate Gaussian distributions.
+
+The model extracts features from multiple layers of pretrained CNN backbones to
+capture both semantic and low-level visual information. During inference, it
+computes Mahalanobis distances between test patch embeddings and their
+corresponding reference distributions.
+
+Paper: https://arxiv.org/abs/2011.08785
+
+Example:
+    >>> from anomalib.models.image.padim import Padim
+    >>> model = Padim(
+    ...     backbone="resnet18",
+    ...     layers=["layer1", "layer2", "layer3"],
+    ...     pre_trained=True
+    ... )
+    >>> model.fit()
+    >>> prediction = model(image)
+
+See Also:
+    - :class:`anomalib.models.image.padim.torch_model.PadimModel`:
+        PyTorch implementation of the PaDiM model architecture
+    - :class:`anomalib.models.image.padim.anomaly_map.AnomalyMapGenerator`:
+        Anomaly map generation for PaDiM using Mahalanobis distance
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -27,21 +52,41 @@
 
 
 class Padim(MemoryBankMixin, AnomalibModule):
-    """PaDiM: a Patch Distribution Modeling Framework for Anomaly Detection and Localization.
+    """PaDiM: a Patch Distribution Modeling Framework for Anomaly Detection.
 
     Args:
-        backbone (str): Backbone CNN network
-            Defaults to ``resnet18``.
-        layers (list[str]): Layers to extract features from the backbone CNN
-            Defaults to ``["layer1", "layer2", "layer3"]``.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
+        backbone (str): Name of the backbone CNN network. Available options are
+            ``resnet18``, ``wide_resnet50_2`` etc. Defaults to ``resnet18``.
+        layers (list[str]): List of layer names to extract features from the
+            backbone CNN. Defaults to ``["layer1", "layer2", "layer3"]``.
+        pre_trained (bool, optional): Use pre-trained backbone weights.
             Defaults to ``True``.
-        n_features (int, optional): Number of features to retain in the dimension reduction step.
-            Default values from the paper are available for: resnet18 (100), wide_resnet50_2 (550).
-            Defaults to ``None``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        n_features (int | None, optional): Number of features to retain after
+            dimension reduction. Default values from paper: ``resnet18=100``,
+            ``wide_resnet50_2=550``. Defaults to ``None``.
+        pre_processor (PreProcessor | bool, optional): Preprocessor to apply on
+            input data. Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post processor to apply
+            on model outputs. Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator for computing metrics.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer for generating
+            result images. Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models.image.padim import Padim
+        >>> model = Padim(
+        ...     backbone="resnet18",
+        ...     layers=["layer1", "layer2", "layer3"],
+        ...     pre_trained=True
+        ... )
+        >>> model.fit()
+        >>> prediction = model(image)
+
+    Note:
+        The model does not require training in the traditional sense. It fits
+        Gaussian distributions to the extracted features during the training
+        phase.
     """
 
     def __init__(
@@ -78,15 +123,17 @@ def configure_optimizers() -> None:
         return
 
     def training_step(self, batch: Batch, *args, **kwargs) -> None:
-        """Perform the training step of PADIM. For each batch, hierarchical features are extracted from the CNN.
+        """Perform the training step of PADIM.
+
+        For each batch, hierarchical features are extracted from the CNN.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Batch containing image filename, image, label and mask
-            args: Additional arguments.
-            kwargs: Additional keyword arguments.
+            batch (Batch): Input batch containing image and metadata
+            args: Additional arguments (unused)
+            kwargs: Additional keyword arguments (unused)
 
         Returns:
-            Hierarchical feature map
+            torch.Tensor: Dummy loss tensor for Lightning compatibility
         """
         del args, kwargs  # These variables are not used.
 
@@ -107,16 +154,17 @@ def fit(self) -> None:
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform a validation step of PADIM.
 
-        Similar to the training step, hierarchical features are extracted from the CNN for each batch.
+        Similar to the training step, hierarchical features are extracted from
+        the CNN for each batch.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Input batch
-            args: Additional arguments.
-            kwargs: Additional keyword arguments.
+            batch (Batch): Input batch containing image and metadata
+            args: Additional arguments (unused)
+            kwargs: Additional keyword arguments (unused)
 
         Returns:
-            Dictionary containing images, features, true labels and masks.
-            These are required in `validation_epoch_end` for feature concatenation.
+            STEP_OUTPUT: Dictionary containing images, features, true labels
+            and masks required for validation
         """
         del args, kwargs  # These variables are not used.
 
@@ -128,7 +176,11 @@ def trainer_arguments(self) -> dict[str, int | float]:
         """Return PADIM trainer arguments.
 
         Since the model does not require training, we limit the max_epochs to 1.
-        Since we need to run training epoch before validation, we also set the sanity steps to 0
+        Since we need to run training epoch before validation, we also set the
+        sanity steps to 0.
+
+        Returns:
+            dict[str, int | float]: Dictionary of trainer arguments
         """
         return {"max_epochs": 1, "val_check_interval": 1.0, "num_sanity_val_steps": 0}
 
@@ -137,11 +189,15 @@ def learning_type(self) -> LearningType:
         """Return the learning type of the model.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: Learning type (ONE_CLASS for PaDiM)
         """
         return LearningType.ONE_CLASS
 
     @staticmethod
     def configure_post_processor() -> OneClassPostProcessor:
-        """Return the default post-processor for PADIM."""
+        """Return the default post-processor for PADIM.
+
+        Returns:
+            OneClassPostProcessor: Default post-processor
+        """
         return OneClassPostProcessor()
diff --git a/src/anomalib/models/image/padim/torch_model.py b/src/anomalib/models/image/padim/torch_model.py
index e537d87ca3..5f8e165a04 100644
--- a/src/anomalib/models/image/padim/torch_model.py
+++ b/src/anomalib/models/image/padim/torch_model.py
@@ -1,4 +1,35 @@
-"""PyTorch model for the PaDiM model implementation."""
+"""PyTorch model for the PaDiM model implementation.
+
+This module implements the PaDiM model architecture using PyTorch. PaDiM models the
+distribution of patch embeddings at each spatial location using multivariate
+Gaussian distributions.
+
+The model extracts features from multiple layers of pretrained CNN backbones to
+capture both semantic and low-level visual information. During inference, it
+computes Mahalanobis distances between test patch embeddings and their
+corresponding reference distributions.
+
+Example:
+    >>> from anomalib.models.image.padim.torch_model import PadimModel
+    >>> model = PadimModel(
+    ...     backbone="resnet18",
+    ...     layers=["layer1", "layer2", "layer3"],
+    ...     pre_trained=True,
+    ...     n_features=100
+    ... )
+    >>> input_tensor = torch.randn(32, 3, 224, 224)
+    >>> output = model(input_tensor)
+
+Paper: https://arxiv.org/abs/2011.08785
+
+See Also:
+    - :class:`anomalib.models.image.padim.lightning_model.Padim`:
+        Lightning implementation of the PaDiM model
+    - :class:`anomalib.models.image.padim.anomaly_map.AnomalyMapGenerator`:
+        Anomaly map generation for PaDiM using Mahalanobis distance
+    - :class:`anomalib.models.components.MultiVariateGaussian`:
+        Multivariate Gaussian distribution modeling
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -33,11 +64,22 @@ def _deduce_dims(
 ) -> tuple[int, int]:
     """Run a dry run to deduce the dimensions of the extracted features.
 
-    Important: `layers` is assumed to be ordered and the first (layers[0])
-                is assumed to be the layer with largest resolution.
+    This function performs a forward pass to determine the dimensions of features
+    extracted from the specified layers of the backbone network.
+
+    Args:
+        feature_extractor (TimmFeatureExtractor): Feature extraction model
+        input_size (tuple[int, int]): Input image dimensions (height, width)
+        layers (list[str]): Names of layers to extract features from
+
+    Important:
+        ``layers`` is assumed to be ordered and the first (``layers[0]``)
+        is assumed to be the layer with largest resolution.
 
     Returns:
-        tuple[int, int]: Dimensions of the extracted features: (n_dims_original, n_patches)
+        tuple[int, int]: Dimensions of extracted features:
+            - n_dims_original: Total number of feature dimensions
+            - n_patches: Number of spatial patches
     """
     dimensions_mapping = dryrun_find_featuremap_dims(feature_extractor, input_size, layers)
 
@@ -56,13 +98,13 @@ class PadimModel(nn.Module):
 
     Args:
         layers (list[str]): Layers used for feature extraction
-        backbone (str, optional): Pre-trained model backbone. Defaults to "resnet18".
-            Defaults to ``resnet18``.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
-            Defaults to ``True``.
-        n_features (int, optional): Number of features to retain in the dimension reduction step.
-            Default values from the paper are available for: resnet18 (100), wide_resnet50_2 (550).
-            Defaults to ``None``.
+        backbone (str, optional): Pre-trained model backbone. Defaults to
+            ``resnet18``.
+        pre_trained (bool, optional): Boolean to check whether to use a
+            pre_trained backbone. Defaults to ``True``.
+        n_features (int, optional): Number of features to retain in the dimension
+            reduction step. Default values from the paper are available for:
+            resnet18 (100), wide_resnet50_2 (550). Defaults to ``None``.
     """
 
     def __init__(
@@ -110,18 +152,19 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
         """Forward-pass image-batch (N, C, H, W) into model to extract features.
 
         Args:
-            input_tensor: Image-batch (N, C, H, W)
+            input_tensor (torch.Tensor): Image batch with shape (N, C, H, W)
 
         Returns:
-            If training, returns the embeddings.
-            If inference, returns the prediction score and the anomaly map.
+            torch.Tensor | InferenceBatch: If training, returns the embeddings.
+                If inference, returns ``InferenceBatch`` containing prediction
+                scores and anomaly maps.
 
         Example:
+            >>> model = PadimModel()
             >>> x = torch.randn(32, 3, 224, 224)
-            >>> features = self.extract_features(input_tensor)
+            >>> features = model.extract_features(x)
             >>> features.keys()
             dict_keys(['layer1', 'layer2', 'layer3'])
-
             >>> [v.shape for v in features.values()]
             [torch.Size([32, 64, 56, 56]),
             torch.Size([32, 128, 28, 28]),
@@ -153,11 +196,17 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
     def generate_embedding(self, features: dict[str, torch.Tensor]) -> torch.Tensor:
         """Generate embedding from hierarchical feature map.
 
+        This method combines features from multiple layers of the backbone network
+        to create a rich embedding that captures both low-level and high-level
+        image features.
+
         Args:
-            features (dict[str, torch.Tensor]): Hierarchical feature map from a CNN (ResNet18 or WideResnet)
+            features (dict[str, torch.Tensor]): Dictionary mapping layer names to
+                their feature tensors extracted from the backbone CNN.
 
         Returns:
-            Embedding vector
+            torch.Tensor: Embedding tensor combining features from all specified
+                layers, with dimensions reduced according to ``n_features``.
         """
         embeddings = features[self.layers[0]]
         for layer in self.layers[1:]:
diff --git a/src/anomalib/models/image/patchcore/__init__.py b/src/anomalib/models/image/patchcore/__init__.py
index 1e69fa8571..1d716b53f0 100644
--- a/src/anomalib/models/image/patchcore/__init__.py
+++ b/src/anomalib/models/image/patchcore/__init__.py
@@ -1,4 +1,26 @@
-"""PatchCore model."""
+"""PatchCore: Towards Total Recall in Industrial Anomaly Detection.
+
+PatchCore is an anomaly detection model that uses a memory bank of patch features
+extracted from a pretrained CNN backbone. It stores representative patch features
+from normal training images and detects anomalies by comparing test image patches
+against this memory bank.
+
+The model uses a nearest neighbor search to find the most similar patches in the
+memory bank and computes anomaly scores based on these distances. It achieves
+high performance while maintaining interpretability through localization maps.
+
+Example:
+    >>> from anomalib.models.image.patchcore import Patchcore
+    >>> model = Patchcore(
+    ...     backbone="wide_resnet50_2",
+    ...     layers=["layer2", "layer3"],
+    ...     coreset_sampling_ratio=0.1
+    ... )
+    >>> model.fit()
+    >>> prediction = model(image)
+
+Paper: https://arxiv.org/abs/2106.08265
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/patchcore/anomaly_map.py b/src/anomalib/models/image/patchcore/anomaly_map.py
index 2c6cf5e69c..c2a9748305 100644
--- a/src/anomalib/models/image/patchcore/anomaly_map.py
+++ b/src/anomalib/models/image/patchcore/anomaly_map.py
@@ -1,4 +1,28 @@
-"""Anomaly Map Generator for the PatchCore model implementation."""
+"""Anomaly Map Generator for the PatchCore model implementation.
+
+This module generates anomaly heatmaps for the PatchCore model by upsampling
+patch-level anomaly scores and applying Gaussian smoothing.
+
+The anomaly map generation process involves:
+1. Taking patch-level anomaly scores as input
+2. Optionally upsampling scores to match input image dimensions
+3. Applying Gaussian blur to smooth the final anomaly map
+
+Example:
+    >>> from anomalib.models.image.patchcore.anomaly_map import AnomalyMapGenerator
+    >>> generator = AnomalyMapGenerator(sigma=4)
+    >>> patch_scores = torch.randn(32, 1, 28, 28)  # (B, 1, H, W)
+    >>> anomaly_map = generator(
+    ...     patch_scores=patch_scores,
+    ...     image_size=(224, 224)
+    ... )
+
+See Also:
+    - :class:`anomalib.models.image.patchcore.lightning_model.Patchcore`:
+        Lightning implementation of the PatchCore model
+    - :class:`anomalib.models.components.GaussianBlur2d`:
+        Gaussian blur module used for smoothing anomaly maps
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,10 +37,17 @@
 class AnomalyMapGenerator(nn.Module):
     """Generate Anomaly Heatmap.
 
+    This class implements anomaly map generation for the PatchCore model by
+    upsampling patch scores and applying Gaussian smoothing.
+
     Args:
-        The anomaly map is upsampled to this dimension.
-        sigma (int, optional): Standard deviation for Gaussian Kernel.
-            Defaults to ``4``.
+        sigma (int, optional): Standard deviation for Gaussian smoothing kernel.
+            Higher values produce smoother anomaly maps. Defaults to ``4``.
+
+    Example:
+        >>> generator = AnomalyMapGenerator(sigma=4)
+        >>> patch_scores = torch.randn(32, 1, 28, 28)
+        >>> anomaly_map = generator(patch_scores)
     """
 
     def __init__(
@@ -32,16 +63,18 @@ def compute_anomaly_map(
         patch_scores: torch.Tensor,
         image_size: tuple[int, int] | torch.Size | None = None,
     ) -> torch.Tensor:
-        """Pixel Level Anomaly Heatmap.
+        """Compute pixel-level anomaly heatmap from patch scores.
 
         Args:
-            patch_scores (torch.Tensor): Patch-level anomaly scores
-            image_size (tuple[int, int] | torch.Size, optional): Size of the input image.
-                The anomaly map is upsampled to this dimension.
-                Defaults to None.
+            patch_scores (torch.Tensor): Patch-level anomaly scores with shape
+                ``(B, 1, H, W)``
+            image_size (tuple[int, int] | torch.Size | None, optional): Target
+                size ``(H, W)`` to upsample anomaly map. If ``None``, keeps
+                original size. Defaults to ``None``.
 
         Returns:
-            Tensor: Map of the pixel-level anomaly scores
+            torch.Tensor: Pixel-level anomaly scores after upsampling and
+                smoothing, with shape ``(B, 1, H, W)``
         """
         if image_size is None:
             anomaly_map = patch_scores
@@ -54,19 +87,25 @@ def forward(
         patch_scores: torch.Tensor,
         image_size: tuple[int, int] | torch.Size | None = None,
     ) -> torch.Tensor:
-        """Return anomaly_map and anomaly_score.
+        """Generate smoothed anomaly map from patch scores.
 
         Args:
-            patch_scores (torch.Tensor): Patch-level anomaly scores
-            image_size (tuple[int, int] | torch.Size, optional): Size of the input image.
-                The anomaly map is upsampled to this dimension.
-                Defaults to None.
+            patch_scores (torch.Tensor): Patch-level anomaly scores with shape
+                ``(B, 1, H, W)``
+            image_size (tuple[int, int] | torch.Size | None, optional): Target
+                size ``(H, W)`` to upsample anomaly map. If ``None``, keeps
+                original size. Defaults to ``None``.
 
         Example:
-            >>> anomaly_map_generator = AnomalyMapGenerator()
-            >>> map = anomaly_map_generator(patch_scores=patch_scores)
+            >>> generator = AnomalyMapGenerator(sigma=4)
+            >>> patch_scores = torch.randn(32, 1, 28, 28)
+            >>> anomaly_map = generator(
+            ...     patch_scores=patch_scores,
+            ...     image_size=(224, 224)
+            ... )
 
         Returns:
-            Tensor: anomaly_map
+            torch.Tensor: Anomaly heatmap after upsampling and smoothing,
+                with shape ``(B, 1, H, W)``
         """
         return self.compute_anomaly_map(patch_scores, image_size)
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index e58185e50e..bd8f9da4f7 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -1,6 +1,31 @@
-"""Towards Total Recall in Industrial Anomaly Detection.
-
-Paper https://arxiv.org/abs/2106.08265.
+"""PatchCore: Towards Total Recall in Industrial Anomaly Detection.
+
+This module implements the PatchCore model for anomaly detection using a memory bank
+of patch features extracted from a pretrained CNN backbone. The model stores
+representative patch features from normal training images and detects anomalies by
+comparing test image patches against this memory bank.
+
+The model uses a nearest neighbor search to find the most similar patches in the
+memory bank and computes anomaly scores based on these distances. It achieves high
+performance while maintaining interpretability through localization maps.
+
+Example:
+    >>> from anomalib.models.image.patchcore import Patchcore
+    >>> model = Patchcore(
+    ...     backbone="wide_resnet50_2",
+    ...     layers=["layer2", "layer3"],
+    ...     coreset_sampling_ratio=0.1
+    ... )
+    >>> model.fit()
+    >>> prediction = model(image)
+
+Paper: https://arxiv.org/abs/2106.08265
+
+See Also:
+    - :class:`anomalib.models.image.patchcore.torch_model.PatchcoreModel`:
+        PyTorch implementation of the PatchCore model architecture
+    - :class:`anomalib.models.image.patchcore.anomaly_map.AnomalyMapGenerator`:
+        Anomaly map generation for PatchCore using nearest neighbor search
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -28,22 +53,57 @@
 
 
 class Patchcore(MemoryBankMixin, AnomalibModule):
-    """PatchcoreLightning Module to train PatchCore algorithm.
+    """PatchCore Lightning Module for anomaly detection.
+
+    This class implements the PatchCore algorithm which uses a memory bank of patch
+    features for anomaly detection. Features are extracted from a pretrained CNN
+    backbone and stored in a memory bank. Anomalies are detected by comparing test
+    image patches with the stored features using nearest neighbor search.
+
+    The model works in two phases:
+    1. Training: Extract and store patch features from normal training images
+    2. Inference: Compare test image patches against stored features to detect
+       anomalies
 
     Args:
-        backbone (str): Backbone CNN network
-            Defaults to ``wide_resnet50_2``.
-        layers (list[str]): Layers to extract features from the backbone CNN
-            Defaults to ``["layer2", "layer3"]``.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
+        backbone (str): Name of the backbone CNN network.
+            Defaults to ``"wide_resnet50_2"``.
+        layers (Sequence[str]): Names of layers to extract features from.
+            Defaults to ``("layer2", "layer3")``.
+        pre_trained (bool, optional): Whether to use pre-trained backbone weights.
             Defaults to ``True``.
-        coreset_sampling_ratio (float, optional): Coreset sampling ratio to subsample embedding.
-            Defaults to ``0.1``.
-        num_neighbors (int, optional): Number of nearest neighbors.
+        coreset_sampling_ratio (float, optional): Ratio for coreset sampling to
+            subsample embeddings. Defaults to ``0.1``.
+        num_neighbors (int, optional): Number of nearest neighbors to use.
             Defaults to ``9``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor instance or
+            bool flag. Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor instance or
+            bool flag. Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator instance or bool flag.
+            Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer instance or bool flag.
+            Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models.image.patchcore import Patchcore
+        >>> model = Patchcore(
+        ...     backbone="wide_resnet50_2",
+        ...     layers=["layer2", "layer3"],
+        ...     coreset_sampling_ratio=0.1
+        ... )
+        >>> model.fit()
+        >>> predictions = model(image)
+
+    Notes:
+        The model requires no optimization/backpropagation as it uses a pretrained
+        backbone and nearest neighbor search.
+
+    See Also:
+        - :class:`anomalib.models.components.AnomalibModule`:
+            Base class for all anomaly detection models
+        - :class:`anomalib.models.components.MemoryBankMixin`:
+            Mixin class for models using feature memory banks
     """
 
     def __init__(
@@ -80,7 +140,29 @@ def configure_pre_processor(
         image_size: tuple[int, int] | None = None,
         center_crop_size: tuple[int, int] | None = None,
     ) -> PreProcessor:
-        """Default transform for Padim."""
+        """Configure the default pre-processor for PatchCore.
+
+        The pre-processor performs the following steps:
+        1. Resize image to specified size
+        2. Center crop to maintain aspect ratio
+        3. Normalize using ImageNet mean and std
+
+        Args:
+            image_size (tuple[int, int] | None, optional): Target size for
+                resizing. Defaults to ``(256, 256)``.
+            center_crop_size (tuple[int, int] | None, optional): Size for center
+                cropping. If ``None``, scales proportionally to ``image_size``.
+                Defaults to ``None``.
+
+        Returns:
+            PreProcessor: Configured pre-processor instance.
+
+        Example:
+            >>> pre_processor = Patchcore.configure_pre_processor(
+            ...     image_size=(256, 256)
+            ... )
+            >>> transformed_image = pre_processor(image)
+        """
         image_size = image_size or (256, 256)
         if center_crop_size is None:
             # scale center crop size proportional to image size
@@ -99,7 +181,7 @@ def configure_optimizers() -> None:
         """Configure optimizers.
 
         Returns:
-            None: Do not set optimizers by returning None.
+            None: PatchCore requires no optimization.
         """
         return
 
@@ -107,12 +189,16 @@ def training_step(self, batch: Batch, *args, **kwargs) -> None:
         """Generate feature embedding of the batch.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Batch containing image filename, image, label and mask
-            args: Additional arguments.
-            kwargs: Additional keyword arguments.
+            batch (Batch): Input batch containing image and metadata
+            *args: Additional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-            dict[str, np.ndarray]: Embedding Vector
+            torch.Tensor: Dummy loss tensor for Lightning compatibility
+
+        Note:
+            The method stores embeddings in ``self.embeddings`` for later use in
+            ``fit()``.
         """
         del args, kwargs  # These variables are not used.
 
@@ -122,7 +208,12 @@ def training_step(self, batch: Batch, *args, **kwargs) -> None:
         return torch.tensor(0.0, requires_grad=True, device=self.device)
 
     def fit(self) -> None:
-        """Apply subsampling to the embedding collected from the training set."""
+        """Apply subsampling to the embedding collected from the training set.
+
+        This method:
+        1. Aggregates embeddings from all training batches
+        2. Applies coreset subsampling to reduce memory requirements
+        """
         logger.info("Aggregating the embedding extracted from the training set.")
         embeddings = torch.vstack(self.embeddings)
 
@@ -130,15 +221,19 @@ def fit(self) -> None:
         self.model.subsample_embedding(embeddings, self.coreset_sampling_ratio)
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Get batch of anomaly maps from input image batch.
+        """Generate predictions for a batch of images.
 
         Args:
-            batch (dict[str, str | torch.Tensor]): Batch containing image filename, image, label and mask
-            args: Additional arguments.
-            kwargs: Additional keyword arguments.
+            batch (Batch): Input batch containing images and metadata
+            *args: Additional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
 
         Returns:
-            dict[str, Any]: Image filenames, test images, GT and predicted label/masks
+            STEP_OUTPUT: Batch with added predictions
+
+        Note:
+            Predictions include anomaly maps and scores computed using nearest
+            neighbor search.
         """
         # These variables are not used.
         del args, kwargs
@@ -150,23 +245,32 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """Return Patchcore trainer arguments."""
+        """Get default trainer arguments for PatchCore.
+
+        Returns:
+            dict[str, Any]: Trainer arguments
+                - ``gradient_clip_val``: ``0`` (no gradient clipping needed)
+                - ``max_epochs``: ``1`` (single pass through training data)
+                - ``num_sanity_val_steps``: ``0`` (skip validation sanity checks)
+        """
         return {"gradient_clip_val": 0, "max_epochs": 1, "num_sanity_val_steps": 0}
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: Always ``LearningType.ONE_CLASS`` as PatchCore only
+                trains on normal samples
         """
         return LearningType.ONE_CLASS
 
     @staticmethod
     def configure_post_processor() -> OneClassPostProcessor:
-        """Return the default post-processor for the model.
+        """Configure the default post-processor.
 
         Returns:
-            OneClassPostProcessor: Post-processor for one-class models.
+            OneClassPostProcessor: Post-processor for one-class models that
+                converts raw scores to anomaly predictions
         """
         return OneClassPostProcessor()
diff --git a/src/anomalib/models/image/patchcore/torch_model.py b/src/anomalib/models/image/patchcore/torch_model.py
index 80133b4bd2..ac74686994 100644
--- a/src/anomalib/models/image/patchcore/torch_model.py
+++ b/src/anomalib/models/image/patchcore/torch_model.py
@@ -1,4 +1,34 @@
-"""PyTorch model for the PatchCore model implementation."""
+"""PyTorch model for the PatchCore model implementation.
+
+This module implements the PatchCore model architecture using PyTorch. PatchCore
+uses a memory bank of patch features extracted from a pretrained CNN backbone to
+detect anomalies.
+
+The model stores representative patch features from normal training images and
+detects anomalies by comparing test image patches against this memory bank using
+nearest neighbor search.
+
+Example:
+    >>> from anomalib.models.image.patchcore.torch_model import PatchcoreModel
+    >>> model = PatchcoreModel(
+    ...     backbone="wide_resnet50_2",
+    ...     layers=["layer2", "layer3"],
+    ...     pre_trained=True,
+    ...     num_neighbors=9
+    ... )
+    >>> input_tensor = torch.randn(32, 3, 224, 224)
+    >>> output = model(input_tensor)
+
+Paper: https://arxiv.org/abs/2106.08265
+
+See Also:
+    - :class:`anomalib.models.image.patchcore.lightning_model.Patchcore`:
+        Lightning implementation of the PatchCore model
+    - :class:`anomalib.models.image.patchcore.anomaly_map.AnomalyMapGenerator`:
+        Anomaly map generation for PatchCore using nearest neighbor search
+    - :class:`anomalib.models.components.KCenterGreedy`:
+        Coreset subsampling using k-center-greedy approach
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -20,16 +50,56 @@
 
 
 class PatchcoreModel(DynamicBufferMixin, nn.Module):
-    """Patchcore Module.
+    """PatchCore PyTorch model for anomaly detection.
+
+    This model implements the PatchCore algorithm which uses a memory bank of patch
+    features for anomaly detection. Features are extracted from a pretrained CNN
+    backbone and stored in a memory bank. Anomalies are detected by comparing test
+    image patches with the stored features using nearest neighbor search.
+
+    The model works in two phases:
+    1. Training: Extract and store patch features from normal training images
+    2. Inference: Compare test image patches against stored features to detect
+       anomalies
 
     Args:
-        layers (list[str]): Layers used for feature extraction
-        backbone (str, optional): Pre-trained model backbone.
-            Defaults to ``resnet18``.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
+        layers (Sequence[str]): Names of layers to extract features from.
+        backbone (str, optional): Name of the backbone CNN network.
+            Defaults to ``"wide_resnet50_2"``.
+        pre_trained (bool, optional): Whether to use pre-trained backbone weights.
             Defaults to ``True``.
-        num_neighbors (int, optional): Number of nearest neighbors.
+        num_neighbors (int, optional): Number of nearest neighbors to use.
             Defaults to ``9``.
+
+    Example:
+        >>> from anomalib.models.image.patchcore.torch_model import PatchcoreModel
+        >>> model = PatchcoreModel(
+        ...     backbone="wide_resnet50_2",
+        ...     layers=["layer2", "layer3"],
+        ...     pre_trained=True,
+        ...     num_neighbors=9
+        ... )
+        >>> input_tensor = torch.randn(32, 3, 224, 224)
+        >>> output = model(input_tensor)
+
+    Attributes:
+        tiler (Tiler | None): Optional tiler for processing large images.
+        feature_extractor (TimmFeatureExtractor): CNN feature extractor.
+        feature_pooler (torch.nn.AvgPool2d): Average pooling layer.
+        anomaly_map_generator (AnomalyMapGenerator): Generates anomaly heatmaps.
+        memory_bank (torch.Tensor): Storage for patch features from training.
+
+    Notes:
+        The model requires no optimization/backpropagation as it uses a pretrained
+        backbone and nearest neighbor search.
+
+    See Also:
+        - :class:`anomalib.models.image.patchcore.lightning_model.Patchcore`:
+            Lightning implementation of the PatchCore model
+        - :class:`anomalib.models.image.patchcore.anomaly_map.AnomalyMapGenerator`:
+            Anomaly map generation for PatchCore
+        - :class:`anomalib.models.components.KCenterGreedy`:
+            Coreset subsampling using k-center-greedy approach
     """
 
     def __init__(
@@ -58,18 +128,29 @@ def __init__(
         self.memory_bank: torch.Tensor
 
     def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
-        """Return Embedding during training, or a tuple of anomaly map and anomaly score during testing.
+        """Process input tensor through the model.
 
-        Steps performed:
-        1. Get features from a CNN.
-        2. Generate embedding based on the features.
-        3. Compute anomaly map in test mode.
+        During training, returns embeddings extracted from the input. During
+        inference, returns anomaly maps and scores computed by comparing input
+        embeddings against the memory bank.
 
         Args:
-            input_tensor (torch.Tensor): Input tensor
+            input_tensor (torch.Tensor): Input images of shape
+                ``(batch_size, channels, height, width)``.
 
         Returns:
-            Tensor | dict[str, torch.Tensor]: Embedding for training, anomaly map and anomaly score for testing.
+            torch.Tensor | InferenceBatch: During training, returns embeddings.
+                During inference, returns ``InferenceBatch`` containing anomaly
+                maps and scores.
+
+        Example:
+            >>> model = PatchcoreModel(layers=["layer1"])
+            >>> input_tensor = torch.randn(32, 3, 224, 224)
+            >>> output = model(input_tensor)
+            >>> if model.training:
+            ...     assert isinstance(output, torch.Tensor)
+            ... else:
+            ...     assert isinstance(output, InferenceBatch)
         """
         output_size = input_tensor.shape[-2:]
         if self.tiler:
@@ -104,14 +185,27 @@ def forward(self, input_tensor: torch.Tensor) -> torch.Tensor | InferenceBatch:
         return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
     def generate_embedding(self, features: dict[str, torch.Tensor]) -> torch.Tensor:
-        """Generate embedding from hierarchical feature map.
+        """Generate embedding by concatenating multi-scale feature maps.
+
+        Combines feature maps from different CNN layers by upsampling them to a
+        common size and concatenating along the channel dimension.
 
         Args:
-            features: Hierarchical feature map from a CNN (ResNet18 or WideResnet)
-            features: dict[str:Tensor]:
+            features (dict[str, torch.Tensor]): Dictionary mapping layer names to
+                feature tensors extracted from the backbone CNN.
 
         Returns:
-            Embedding vector
+            torch.Tensor: Concatenated feature embedding of shape
+                ``(batch_size, num_features, height, width)``.
+
+        Example:
+            >>> features = {
+            ...     "layer1": torch.randn(32, 64, 56, 56),
+            ...     "layer2": torch.randn(32, 128, 28, 28)
+            ... }
+            >>> embedding = model.generate_embedding(features)
+            >>> embedding.shape
+            torch.Size([32, 192, 56, 56])
         """
         embeddings = features[self.layers[0]]
         for layer in self.layers[1:]:
@@ -123,26 +217,43 @@ def generate_embedding(self, features: dict[str, torch.Tensor]) -> torch.Tensor:
 
     @staticmethod
     def reshape_embedding(embedding: torch.Tensor) -> torch.Tensor:
-        """Reshape Embedding.
+        """Reshape embedding tensor for patch-wise processing.
 
-        Reshapes Embedding to the following format:
-            - [Batch, Embedding, Patch, Patch] to [Batch*Patch*Patch, Embedding]
+        Converts a 4D embedding tensor into a 2D matrix where each row represents
+        a patch embedding vector.
 
         Args:
-            embedding (torch.Tensor): Embedding tensor extracted from CNN features.
+            embedding (torch.Tensor): Input embedding tensor of shape
+                ``(batch_size, embedding_dim, height, width)``.
 
         Returns:
-            Tensor: Reshaped embedding tensor.
+            torch.Tensor: Reshaped embedding tensor of shape
+                ``(batch_size * height * width, embedding_dim)``.
+
+        Example:
+            >>> embedding = torch.randn(32, 512, 7, 7)
+            >>> reshaped = PatchcoreModel.reshape_embedding(embedding)
+            >>> reshaped.shape
+            torch.Size([1568, 512])
         """
         embedding_size = embedding.size(1)
         return embedding.permute(0, 2, 3, 1).reshape(-1, embedding_size)
 
     def subsample_embedding(self, embedding: torch.Tensor, sampling_ratio: float) -> None:
-        """Subsample embedding based on coreset sampling and store to memory.
+        """Subsample embeddings using coreset selection.
+
+        Uses k-center-greedy coreset subsampling to select a representative
+        subset of patch embeddings to store in the memory bank.
 
         Args:
-            embedding (np.ndarray): Embedding tensor from the CNN
-            sampling_ratio (float): Coreset sampling ratio
+            embedding (torch.Tensor): Embedding tensor to subsample from.
+            sampling_ratio (float): Fraction of embeddings to keep, in range (0,1].
+
+        Example:
+            >>> embedding = torch.randn(1000, 512)
+            >>> model.subsample_embedding(embedding, sampling_ratio=0.1)
+            >>> model.memory_bank.shape
+            torch.Size([100, 512])
         """
         # Coreset Subsampling
         sampler = KCenterGreedy(embedding=embedding, sampling_ratio=sampling_ratio)
@@ -151,17 +262,30 @@ def subsample_embedding(self, embedding: torch.Tensor, sampling_ratio: float) ->
 
     @staticmethod
     def euclidean_dist(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
-        """Calculate pair-wise distance between row vectors in x and those in y.
+        """Compute pairwise Euclidean distances between two sets of vectors.
 
-        Replaces torch cdist with p=2, as cdist is not properly exported to onnx and openvino format.
-        Resulting matrix is indexed by x vectors in rows and y vectors in columns.
+        Implements an efficient matrix computation of Euclidean distances between
+        all pairs of vectors in ``x`` and ``y`` without using ``torch.cdist()``.
 
         Args:
-            x: input tensor 1
-            y: input tensor 2
+            x (torch.Tensor): First tensor of shape ``(n, d)``.
+            y (torch.Tensor): Second tensor of shape ``(m, d)``.
 
         Returns:
-            Matrix of distances between row vectors in x and y.
+            torch.Tensor: Distance matrix of shape ``(n, m)`` where element
+                ``(i,j)`` is the distance between row ``i`` of ``x`` and row
+                ``j`` of ``y``.
+
+        Example:
+            >>> x = torch.randn(100, 512)
+            >>> y = torch.randn(50, 512)
+            >>> distances = PatchcoreModel.euclidean_dist(x, y)
+            >>> distances.shape
+            torch.Size([100, 50])
+
+        Note:
+            This implementation avoids using ``torch.cdist()`` for better
+            compatibility with ONNX export and OpenVINO conversion.
         """
         x_norm = x.pow(2).sum(dim=-1, keepdim=True)  # |x|
         y_norm = y.pow(2).sum(dim=-1, keepdim=True)  # |y|
@@ -170,15 +294,28 @@ def euclidean_dist(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
         return res.clamp_min_(0).sqrt_()
 
     def nearest_neighbors(self, embedding: torch.Tensor, n_neighbors: int) -> tuple[torch.Tensor, torch.Tensor]:
-        """Nearest Neighbours using brute force method and euclidean norm.
+        """Find nearest neighbors in memory bank for input embeddings.
+
+        Uses brute force search with Euclidean distance to find the closest
+        matches in the memory bank for each input embedding.
 
         Args:
-            embedding (torch.Tensor): Features to compare the distance with the memory bank.
-            n_neighbors (int): Number of neighbors to look at
+            embedding (torch.Tensor): Query embeddings to find neighbors for.
+            n_neighbors (int): Number of nearest neighbors to return.
 
         Returns:
-            Tensor: Patch scores.
-            Tensor: Locations of the nearest neighbor(s).
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing:
+                - Distances to nearest neighbors (shape: ``(n, k)``)
+                - Indices of nearest neighbors (shape: ``(n, k)``)
+                where ``n`` is number of query embeddings and ``k`` is
+                ``n_neighbors``.
+
+        Example:
+            >>> embedding = torch.randn(100, 512)
+            >>> # Assuming memory_bank is already populated
+            >>> scores, locations = model.nearest_neighbors(embedding, n_neighbors=5)
+            >>> scores.shape, locations.shape
+            (torch.Size([100, 5]), torch.Size([100, 5]))
         """
         distances = self.euclidean_dist(embedding, self.memory_bank)
         if n_neighbors == 1:
@@ -194,15 +331,32 @@ def compute_anomaly_score(
         locations: torch.Tensor,
         embedding: torch.Tensor,
     ) -> torch.Tensor:
-        """Compute Image-Level Anomaly Score.
+        """Compute image-level anomaly scores.
+
+        Implements the paper's weighted scoring mechanism that considers both
+        the distance to nearest neighbors and the local neighborhood structure
+        in the memory bank.
 
         Args:
-            patch_scores (torch.Tensor): Patch-level anomaly scores
-            locations: Memory bank locations of the nearest neighbor for each patch location
-            embedding: The feature embeddings that generated the patch scores
+            patch_scores (torch.Tensor): Patch-level anomaly scores.
+            locations (torch.Tensor): Memory bank indices of nearest neighbors.
+            embedding (torch.Tensor): Input embeddings that generated the scores.
 
         Returns:
-            Tensor: Image-level anomaly scores
+            torch.Tensor: Image-level anomaly scores.
+
+        Example:
+            >>> patch_scores = torch.randn(32, 49)  # 7x7 patches
+            >>> locations = torch.randint(0, 1000, (32, 49))
+            >>> embedding = torch.randn(32 * 49, 512)
+            >>> scores = model.compute_anomaly_score(patch_scores, locations,
+            ...                                     embedding)
+            >>> scores.shape
+            torch.Size([32])
+
+        Note:
+            When ``num_neighbors=1``, returns the maximum patch score directly.
+            Otherwise, computes weighted scores using neighborhood information.
         """
         # Don't need to compute weights if num_neighbors is 1
         if self.num_neighbors == 1:
diff --git a/src/anomalib/models/image/reverse_distillation/__init__.py b/src/anomalib/models/image/reverse_distillation/__init__.py
index 7dd60dcb25..616c06c4f8 100644
--- a/src/anomalib/models/image/reverse_distillation/__init__.py
+++ b/src/anomalib/models/image/reverse_distillation/__init__.py
@@ -1,4 +1,27 @@
-"""Reverse Distillation Model."""
+"""Reverse Distillation Model for anomaly detection.
+
+This module implements the Reverse Distillation model for anomaly detection as described in
+the paper "Reverse Distillation: A New Training Strategy for Feature Reconstruction
+Networks in Anomaly Detection" (Deng et al., 2022).
+
+The model consists of:
+- A pre-trained encoder (e.g. ResNet) that extracts multi-scale features
+- A bottleneck layer that compresses features into a compact representation
+- A decoder that reconstructs features back to the original feature space
+- A scoring mechanism based on reconstruction error
+
+Example:
+    >>> from anomalib.models.image import ReverseDistillation
+    >>> model = ReverseDistillation()
+    >>> model.fit(train_dataloader)
+    >>> predictions = model.predict(test_dataloader)
+
+See Also:
+    - :class:`anomalib.models.image.reverse_distillation.lightning_model.ReverseDistillation`:
+        Lightning implementation of the model
+    - :class:`anomalib.models.image.reverse_distillation.torch_model.ReverseDistillationModel`:
+        PyTorch implementation of the model architecture
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/reverse_distillation/anomaly_map.py b/src/anomalib/models/image/reverse_distillation/anomaly_map.py
index 74dc19e1df..8357eb6acd 100644
--- a/src/anomalib/models/image/reverse_distillation/anomaly_map.py
+++ b/src/anomalib/models/image/reverse_distillation/anomaly_map.py
@@ -1,4 +1,26 @@
-"""Compute Anomaly map."""
+"""Anomaly map computation for Reverse Distillation model.
+
+This module implements functionality to generate anomaly heatmaps from the feature
+reconstruction errors of the Reverse Distillation model.
+
+The anomaly maps are generated by:
+1. Computing reconstruction error between original and reconstructed features
+2. Upscaling the error maps to original image size
+3. Optional smoothing via Gaussian blur
+4. Combining multiple scale errors via addition or multiplication
+
+Example:
+    >>> from anomalib.models.image.reverse_distillation.anomaly_map import (
+    ...     AnomalyMapGenerator
+    ... )
+    >>> generator = AnomalyMapGenerator(image_size=(256, 256))
+    >>> features = [torch.randn(1, 64, 32, 32), torch.randn(1, 128, 16, 16)]
+    >>> anomaly_map = generator(features)
+
+See Also:
+    - :class:`AnomalyMapGenerator`: Main class for generating anomaly maps
+    - :class:`AnomalyMapGenerationMode`: Enum defining map generation modes
+"""
 
 # Original Code
 # Copyright (c) 2022 hq-deng
diff --git a/src/anomalib/models/image/reverse_distillation/components/__init__.py b/src/anomalib/models/image/reverse_distillation/components/__init__.py
index b3f4796605..cb5c14afc1 100644
--- a/src/anomalib/models/image/reverse_distillation/components/__init__.py
+++ b/src/anomalib/models/image/reverse_distillation/components/__init__.py
@@ -1,4 +1,28 @@
-"""PyTorch modules for Reverse Distillation."""
+"""PyTorch modules for the Reverse Distillation model implementation.
+
+This module contains the core components used in the Reverse Distillation model
+architecture, including the bottleneck layer and decoder network.
+
+The components work together to learn a compact representation of normal images
+through distillation and reconstruction:
+
+- Bottleneck layer: Compresses features into a lower dimensional space
+- Decoder network: Reconstructs features from the bottleneck representation
+
+Example:
+    >>> from anomalib.models.image.reverse_distillation.components import (
+    ...     get_bottleneck_layer,
+    ...     get_decoder
+    ... )
+    >>> bottleneck = get_bottleneck_layer()
+    >>> decoder = get_decoder()
+
+See Also:
+    - :func:`anomalib.models.image.reverse_distillation.components.bottleneck`:
+        Bottleneck layer implementation
+    - :func:`anomalib.models.image.reverse_distillation.components.de_resnet`:
+        Decoder network implementation
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/reverse_distillation/components/bottleneck.py b/src/anomalib/models/image/reverse_distillation/components/bottleneck.py
index 220fc1d670..a5a5bde542 100644
--- a/src/anomalib/models/image/reverse_distillation/components/bottleneck.py
+++ b/src/anomalib/models/image/reverse_distillation/components/bottleneck.py
@@ -1,4 +1,28 @@
-"""Torch model defining the bottleneck layer."""
+"""PyTorch model defining the bottleneck layer for Reverse Distillation.
+
+This module implements the bottleneck layer used in the Reverse Distillation model
+architecture. The bottleneck layer compresses features into a lower dimensional
+space while preserving important information for anomaly detection.
+
+The module contains:
+- Bottleneck layer implementation using convolutional blocks
+- Helper functions for creating 3x3 and 1x1 convolutions
+- One-Class Bottleneck Embedding (OCBE) module for feature compression
+
+Example:
+    >>> from anomalib.models.image.reverse_distillation.components.bottleneck import (
+    ...     get_bottleneck_layer
+    ... )
+    >>> bottleneck = get_bottleneck_layer()
+    >>> features = torch.randn(32, 512, 28, 28)
+    >>> compressed = bottleneck(features)
+
+See Also:
+    - :class:`anomalib.models.image.reverse_distillation.torch_model.ReverseDistillationModel`:
+        Main model implementation using this bottleneck layer
+    - :class:`anomalib.models.image.reverse_distillation.components.OCBE`:
+        One-Class Bottleneck Embedding module
+"""
 
 # Original Code
 # Copyright (c) 2022 hq-deng
@@ -38,13 +62,51 @@ def conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Conv2d:
 class OCBE(nn.Module):
     """One-Class Bottleneck Embedding module.
 
+    This module implements a bottleneck layer that compresses multi-scale features into a
+    compact representation. It consists of:
+
+    1. Multiple convolutional layers to process features at different scales
+    2. Feature fusion through concatenation
+    3. Final bottleneck compression through residual blocks
+
+    The module takes features from multiple scales of an encoder network and outputs a
+    compressed bottleneck representation.
+
     Args:
-        block (Bottleneck): Expansion value is extracted from this block.
-        layers (int): Numbers of OCE layers to create after multiscale feature fusion.
-        groups (int, optional): Number of blocked connections from input channels to output channels.
-            Defaults to 1.
-        width_per_group (int, optional): Number of layers in each intermediate convolution layer. Defaults to 64.
-        norm_layer (Callable[..., nn.Module] | None, optional): Batch norm layer to use. Defaults to None.
+        block (Bottleneck | BasicBlock): Block type that determines expansion factor.
+            Can be either ``Bottleneck`` or ``BasicBlock``.
+        layers (int): Number of OCE layers to create after multi-scale feature fusion.
+        groups (int, optional): Number of blocked connections from input channels to
+            output channels. Defaults to ``1``.
+        width_per_group (int, optional): Number of channels in each intermediate
+            convolution layer. Defaults to ``64``.
+        norm_layer (Callable[..., nn.Module] | None, optional): Normalization layer to
+            use. If ``None``, uses ``BatchNorm2d``. Defaults to ``None``.
+
+    Example:
+        >>> import torch
+        >>> from torchvision.models.resnet import Bottleneck
+        >>> from anomalib.models.image.reverse_distillation.components import OCBE
+        >>> model = OCBE(block=Bottleneck, layers=3)
+        >>> # Create 3 feature maps of different scales
+        >>> f1 = torch.randn(1, 256, 28, 28)  # First scale
+        >>> f2 = torch.randn(1, 512, 14, 14)  # Second scale
+        >>> f3 = torch.randn(1, 1024, 7, 7)   # Third scale
+        >>> features = [f1, f2, f3]
+        >>> output = model(features)
+        >>> output.shape
+        torch.Size([1, 2048, 4, 4])
+
+    Notes:
+        - The module expects exactly 3 input feature maps at different scales
+        - Features are processed through conv layers before fusion
+        - Final output dimensions depend on the input feature dimensions and stride
+        - Initialization uses Kaiming normal for conv layers and constant for norms
+
+    See Also:
+        - :func:`get_bottleneck_layer`: Factory function to create OCBE instances
+        - :class:`torchvision.models.resnet.Bottleneck`: ResNet bottleneck block
+        - :class:`torchvision.models.resnet.BasicBlock`: ResNet basic block
     """
 
     def __init__(
@@ -136,13 +198,24 @@ def _make_layer(
         return nn.Sequential(*layers)
 
     def forward(self, features: list[torch.Tensor]) -> torch.Tensor:
-        """Forward-pass of Bottleneck layer.
+        """Forward pass of the bottleneck layer.
+
+        Processes multi-scale features through convolution layers, fuses them via
+        concatenation, and applies final bottleneck compression.
 
         Args:
-            features (list[torch.Tensor]): List of features extracted from the encoder.
+            features (list[torch.Tensor]): List of 3 feature tensors from different
+                scales of the encoder network. Expected shapes:
+                - features[0]: ``(B, C1, H1, W1)``
+                - features[1]: ``(B, C2, H2, W2)``
+                - features[2]: ``(B, C3, H3, W3)``
+                where B is batch size, Ci are channel dimensions, and Hi, Wi are
+                spatial dimensions.
 
         Returns:
-            Tensor: Output of the bottleneck layer
+            torch.Tensor: Compressed bottleneck representation with shape
+                ``(B, C_out, H_out, W_out)``, where dimensions depend on the input
+                feature shapes and stride values.
         """
         # Always assumes that features has length of 3
         feature0 = self.relu(self.bn2(self.conv2(self.relu(self.bn1(self.conv1(features[0]))))))
diff --git a/src/anomalib/models/image/reverse_distillation/components/de_resnet.py b/src/anomalib/models/image/reverse_distillation/components/de_resnet.py
index 3bb8886e8b..be4389cccf 100644
--- a/src/anomalib/models/image/reverse_distillation/components/de_resnet.py
+++ b/src/anomalib/models/image/reverse_distillation/components/de_resnet.py
@@ -1,4 +1,28 @@
-"""Torch model defining the decoder."""
+"""PyTorch model defining the decoder network for Reverse Distillation.
+
+This module implements the decoder network used in the Reverse Distillation model
+architecture. The decoder reconstructs features from the bottleneck representation
+back to the original feature space.
+
+The module contains:
+- Decoder block implementations using transposed convolutions
+- Helper functions for creating decoder layers
+- Full decoder network architecture
+
+Example:
+    >>> from anomalib.models.image.reverse_distillation.components.de_resnet import (
+    ...     get_decoder
+    ... )
+    >>> decoder = get_decoder()
+    >>> features = torch.randn(32, 512, 28, 28)
+    >>> reconstructed = decoder(features)
+
+See Also:
+    - :class:`anomalib.models.image.reverse_distillation.torch_model.ReverseDistillationModel`:
+        Main model implementation using this decoder
+    - :class:`anomalib.models.image.reverse_distillation.components.DecoderBasicBlock`:
+        Basic building block for the decoder network
+"""
 
 # Original Code
 # Copyright (c) 2022 hq-deng
@@ -19,20 +43,46 @@
 class DecoderBasicBlock(nn.Module):
     """Basic block for decoder ResNet architecture.
 
+    This module implements a basic decoder block used in the decoder network. It performs
+    upsampling and feature reconstruction through transposed convolutions and skip
+    connections.
+
+    The block consists of:
+    1. Optional upsampling via transposed convolution when ``stride=2``
+    2. Two convolutional layers with batch normalization and ReLU activation
+    3. Skip connection that adds input to output features
+
     Args:
-        inplanes (int): Number of input channels.
-        planes (int): Number of output channels.
-        stride (int, optional): Stride for convolution and de-convolution layers. Defaults to 1.
-        upsample (nn.Module | None, optional): Module used for upsampling output. Defaults to None.
-        groups (int, optional): Number of blocked connections from input channels to output channels.
-            Defaults to 1.
-        base_width (int, optional): Number of layers in each intermediate convolution layer. Defaults to 64.
-        dilation (int, optional): Spacing between kernel elements. Defaults to 1.
-        norm_layer (Callable[..., nn.Module] | None, optional): Batch norm layer to use.Defaults to None.
+        inplanes (int): Number of input channels
+        planes (int): Number of output channels
+        stride (int, optional): Stride for convolution and transposed convolution.
+            When ``stride=2``, upsampling is performed. Defaults to ``1``.
+        upsample (nn.Module | None, optional): Module used for upsampling the
+            identity branch. Defaults to ``None``.
+        groups (int, optional): Number of blocked connections from input to output
+            channels. Must be ``1``. Defaults to ``1``.
+        base_width (int, optional): Width of intermediate conv layers. Must be
+            ``64``. Defaults to ``64``.
+        dilation (int, optional): Dilation rate for convolutions. Must be ``1``.
+            Defaults to ``1``.
+        norm_layer (Callable[..., nn.Module] | None, optional): Normalization layer
+            to use. Defaults to ``None`` which uses ``BatchNorm2d``.
 
     Raises:
-        ValueError: If groups are not equal to 1 and base width is not 64.
-        NotImplementedError: If dilation is greater than 1.
+        ValueError: If ``groups != 1`` or ``base_width != 64``
+        NotImplementedError: If ``dilation > 1``
+
+    Example:
+        >>> block = DecoderBasicBlock(64, 128, stride=2)
+        >>> x = torch.randn(1, 64, 32, 32)
+        >>> output = block(x)  # Shape: (1, 128, 64, 64)
+
+    Notes:
+        - When ``stride=2``, the first conv is replaced with transposed conv for
+          upsampling
+        - The block maintains the same architectural pattern as ResNet's BasicBlock
+          but in reverse
+        - Skip connections help preserve spatial information during reconstruction
     """
 
     expansion: int = 1
@@ -78,7 +128,15 @@ def __init__(
         self.stride = stride
 
     def forward(self, batch: torch.Tensor) -> torch.Tensor:
-        """Forward-pass of de-resnet block."""
+        """Forward pass of the decoder basic block.
+
+        Args:
+            batch (torch.Tensor): Input tensor of shape ``(B, C, H, W)``
+
+        Returns:
+            torch.Tensor: Output tensor of shape ``(B, C', H', W')``, where C' is
+                determined by ``planes`` and H', W' depend on ``stride``
+        """
         identity = batch
 
         out = self.conv1(batch)
@@ -96,18 +154,50 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor:
 
 
 class DecoderBottleneck(nn.Module):
-    """Bottleneck for Decoder.
+    """Bottleneck block for the decoder network.
+
+    This module implements a bottleneck block used in the decoder part of the Reverse
+    Distillation model. It performs upsampling and feature reconstruction through a series of
+    convolutional layers.
+
+    The block consists of three convolution layers:
+    1. 1x1 conv to adjust channels
+    2. 3x3 conv (or transpose conv) for processing
+    3. 1x1 conv to expand channels
 
     Args:
         inplanes (int): Number of input channels.
-        planes (int): Number of output channels.
-        stride (int, optional): Stride for convolution and de-convolution layers. Defaults to 1.
-        upsample (nn.Module | None, optional): Module used for upsampling output. Defaults to None.
-        groups (int, optional): Number of blocked connections from input channels to output channels.
-            Defaults to 1.
-        base_width (int, optional): Number of layers in each intermediate convolution layer. Defaults to 64.
-        dilation (int, optional): Spacing between kernel elements. Defaults to 1.
-        norm_layer (Callable[..., nn.Module] | None, optional): Batch norm layer to use.Defaults to None.
+        planes (int): Number of intermediate channels (will be expanded by ``expansion``).
+        stride (int, optional): Stride for convolution and transpose convolution layers.
+            Defaults to ``1``.
+        upsample (nn.Module | None, optional): Module used for upsampling the residual branch.
+            Defaults to ``None``.
+        groups (int, optional): Number of blocked connections from input to output channels.
+            Defaults to ``1``.
+        base_width (int, optional): Base width for the conv layers.
+            Defaults to ``64``.
+        dilation (int, optional): Dilation rate for conv layers.
+            Defaults to ``1``.
+        norm_layer (Callable[..., nn.Module] | None, optional): Normalization layer to use.
+            Defaults to ``None`` which will use ``nn.BatchNorm2d``.
+
+    Attributes:
+        expansion (int): Channel expansion factor (4 for bottleneck blocks).
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.image.reverse_distillation.components.de_resnet import (
+        ...     DecoderBottleneck
+        ... )
+        >>> layer = DecoderBottleneck(256, 64)
+        >>> x = torch.randn(32, 256, 28, 28)
+        >>> output = layer(x)
+        >>> output.shape
+        torch.Size([32, 256, 28, 28])
+
+    Notes:
+        - When ``stride=2``, the middle conv layer becomes a transpose conv for upsampling
+        - The actual output channels will be ``planes * expansion``
     """
 
     expansion: int = 4
@@ -150,7 +240,15 @@ def __init__(
         self.stride = stride
 
     def forward(self, batch: torch.Tensor) -> torch.Tensor:
-        """Forward-pass of de-resnet bottleneck block."""
+        """Forward pass of the decoder bottleneck block.
+
+        Args:
+            batch (torch.Tensor): Input tensor of shape ``(B, C, H, W)``
+
+        Returns:
+            torch.Tensor: Output tensor of shape ``(B, C', H', W')``, where ``C'`` is
+                ``planes * expansion`` and ``H'``, ``W'`` depend on ``stride``
+        """
         identity = batch
 
         out = self.conv1(batch)
@@ -172,17 +270,55 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor:
 
 
 class ResNet(nn.Module):
-    """ResNet model for decoder.
+    """Decoder ResNet model for feature reconstruction.
+
+    This module implements a decoder version of the ResNet architecture, which
+    reconstructs features from a bottleneck representation back to higher
+    dimensional feature spaces.
+
+    The decoder consists of multiple layers that progressively upsample and
+    reconstruct features through transposed convolutions and skip connections.
 
     Args:
-        block (Type[DecoderBasicBlock | DecoderBottleneck]): Type of block to use in a layer.
-        layers (list[int]): List to specify number for blocks per layer.
-        zero_init_residual (bool, optional): If true, initializes the last batch norm in each layer to zero.
-            Defaults to False.
-        groups (int, optional): Number of blocked connections per layer from input channels to output channels.
-            Defaults to 1.
-        width_per_group (int, optional): Number of layers in each intermediate convolution layer.. Defaults to 64.
-        norm_layer (Callable[..., nn.Module] | None, optional): Batch norm layer to use. Defaults to None.
+        block (Type[DecoderBasicBlock | DecoderBottleneck]): Type of decoder block
+            to use in each layer. Can be either ``DecoderBasicBlock`` or
+            ``DecoderBottleneck``.
+        layers (list[int]): List specifying number of blocks in each decoder
+            layer.
+        zero_init_residual (bool, optional): If ``True``, initializes the last
+            batch norm in each layer to zero. This improves model performance by
+            0.2~0.3% according to https://arxiv.org/abs/1706.02677.
+            Defaults to ``False``.
+        groups (int, optional): Number of blocked connections from input channels
+            to output channels per layer. Defaults to ``1``.
+        width_per_group (int, optional): Number of channels in each intermediate
+            convolution layer. Defaults to ``64``.
+        norm_layer (Callable[..., nn.Module] | None, optional): Normalization
+            layer to use. If ``None``, uses ``BatchNorm2d``. Defaults to ``None``.
+
+    Example:
+        >>> from anomalib.models.image.reverse_distillation.components import (
+        ...     DecoderBasicBlock,
+        ...     ResNet
+        ... )
+        >>> model = ResNet(
+        ...     block=DecoderBasicBlock,
+        ...     layers=[2, 2, 2, 2]
+        ... )
+        >>> x = torch.randn(1, 512, 8, 8)
+        >>> features = model(x)  # Returns list of features at different scales
+
+    Notes:
+        - The decoder reverses the typical ResNet architecture, starting from a
+          bottleneck and expanding to larger feature maps
+        - Features are returned at multiple scales for multi-scale reconstruction
+        - The implementation follows the original ResNet paper but in reverse
+          for decoding
+
+    See Also:
+        - :class:`DecoderBasicBlock`: Basic building block for decoder layers
+        - :class:`DecoderBottleneck`: Bottleneck building block for deeper
+          decoder architectures
     """
 
     def __init__(
@@ -270,7 +406,30 @@ def _make_layer(
         return nn.Sequential(*layers)
 
     def forward(self, batch: torch.Tensor) -> list[torch.Tensor]:
-        """Forward pass for Decoder ResNet. Returns list of features."""
+        """Forward pass through the decoder ResNet.
+
+        Progressively reconstructs features through multiple decoder layers,
+        returning features at different scales.
+
+        Args:
+            batch (torch.Tensor): Input tensor of shape ``(B, C, H, W)`` where:
+                - ``B`` is batch size
+                - ``C`` is number of input channels (512 * block.expansion)
+                - ``H`` and ``W`` are spatial dimensions
+
+        Returns:
+            list[torch.Tensor]: List of feature tensors at different scales:
+                - ``feature_c``: ``(B, 64, H*8, W*8)``
+                - ``feature_b``: ``(B, 128, H*4, W*4)``
+                - ``feature_a``: ``(B, 256, H*2, W*2)``
+
+        Example:
+            >>> model = ResNet(DecoderBasicBlock, [2, 2, 2])
+            >>> x = torch.randn(1, 512, 8, 8)
+            >>> features = model(x)
+            >>> [f.shape for f in features]
+            [(1, 64, 64, 64), (1, 128, 32, 32), (1, 256, 16, 16)]
+        """
         feature_a = self.layer1(batch)  # 512*8*8->256*16*16
         feature_b = self.layer2(feature_a)  # 256*16*16->128*32*32
         feature_c = self.layer3(feature_b)  # 128*32*32->64*64*64
diff --git a/src/anomalib/models/image/reverse_distillation/lightning_model.py b/src/anomalib/models/image/reverse_distillation/lightning_model.py
index 3eb3bf903c..9436549568 100644
--- a/src/anomalib/models/image/reverse_distillation/lightning_model.py
+++ b/src/anomalib/models/image/reverse_distillation/lightning_model.py
@@ -1,6 +1,27 @@
 """Anomaly Detection via Reverse Distillation from One-Class Embedding.
 
-https://arxiv.org/abs/2201.10703v2
+This module implements the Reverse Distillation model for anomaly detection as described in
+`Deng et al. (2022) `_.
+
+The model consists of:
+- A pre-trained encoder (e.g. ResNet) that extracts multi-scale features
+- A bottleneck layer that compresses features into a compact representation
+- A decoder that reconstructs features back to the original feature space
+- A scoring mechanism based on reconstruction error
+
+Example:
+    >>> from anomalib.models.image import ReverseDistillation
+    >>> model = ReverseDistillation(
+    ...     backbone="wide_resnet50_2",
+    ...     layers=["layer1", "layer2", "layer3"]
+    ... )
+    >>> model.fit(train_dataloader)
+    >>> predictions = model.predict(test_dataloader)
+
+See Also:
+    - :class:`ReverseDistillation`: Lightning implementation of the model
+    - :class:`ReverseDistillationModel`: PyTorch implementation of the model
+    - :class:`ReverseDistillationLoss`: Loss function for training
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
diff --git a/src/anomalib/models/image/reverse_distillation/loss.py b/src/anomalib/models/image/reverse_distillation/loss.py
index 3d563238ff..7d6f50d569 100644
--- a/src/anomalib/models/image/reverse_distillation/loss.py
+++ b/src/anomalib/models/image/reverse_distillation/loss.py
@@ -1,4 +1,29 @@
-"""Loss function for Reverse Distillation."""
+"""Loss function for Reverse Distillation model.
+
+This module implements the loss function used to train the Reverse Distillation model
+for anomaly detection. The loss is based on cosine similarity between encoder and
+decoder features.
+
+The loss function:
+1. Takes encoder and decoder feature maps as input
+2. Flattens the spatial dimensions of each feature map
+3. Computes cosine similarity between corresponding encoder-decoder pairs
+4. Averages the similarities across spatial dimensions and feature pairs
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.reverse_distillation.loss import (
+    ...     ReverseDistillationLoss
+    ... )
+    >>> criterion = ReverseDistillationLoss()
+    >>> encoder_features = [torch.randn(2, 64, 32, 32)]
+    >>> decoder_features = [torch.randn(2, 64, 32, 32)]
+    >>> loss = criterion(encoder_features, decoder_features)
+
+See Also:
+    - :class:`ReverseDistillationLoss`: Main loss class implementation
+    - :class:`ReverseDistillation`: Lightning implementation of the full model
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -8,22 +33,49 @@
 
 
 class ReverseDistillationLoss(nn.Module):
-    """Loss function for Reverse Distillation."""
+    """Loss function for Reverse Distillation model.
+
+    This class implements the cosine similarity loss used to train the Reverse
+    Distillation model. The loss measures the dissimilarity between encoder and
+    decoder feature maps.
+
+    The loss computation involves:
+    1. Flattening the spatial dimensions of encoder and decoder feature maps
+    2. Computing cosine similarity between corresponding encoder-decoder pairs
+    3. Subtracting similarities from 1 to get a dissimilarity measure
+    4. Taking mean across spatial dimensions and feature pairs
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.image.reverse_distillation.loss import (
+        ...     ReverseDistillationLoss
+        ... )
+        >>> criterion = ReverseDistillationLoss()
+        >>> encoder_features = [torch.randn(2, 64, 32, 32)]
+        >>> decoder_features = [torch.randn(2, 64, 32, 32)]
+        >>> loss = criterion(encoder_features, decoder_features)
+
+    References:
+        - Official Implementation:
+          https://github.com/hq-deng/RD4AD/blob/main/main.py
+        - Implementation Details:
+          https://github.com/hq-deng/RD4AD/issues/22
+    """
 
     @staticmethod
     def forward(encoder_features: list[torch.Tensor], decoder_features: list[torch.Tensor]) -> torch.Tensor:
-        """Compute cosine similarity loss based on features from encoder and decoder.
-
-        Based on the official code:
-        https://github.com/hq-deng/RD4AD/blob/6554076872c65f8784f6ece8cfb39ce77e1aee12/main.py#L33C25-L33C25
-        Calculates loss from flattened arrays of features, see https://github.com/hq-deng/RD4AD/issues/22
+        """Compute cosine similarity loss between encoder and decoder features.
 
         Args:
-            encoder_features (list[torch.Tensor]): List of features extracted from encoder
-            decoder_features (list[torch.Tensor]): List of features extracted from decoder
+            encoder_features (list[torch.Tensor]): List of feature tensors from the
+                encoder network. Each tensor has shape ``(B, C, H, W)`` where B is
+                batch size, C is channels, H and W are spatial dimensions.
+            decoder_features (list[torch.Tensor]): List of feature tensors from the
+                decoder network. Must match encoder features in length and shapes.
 
         Returns:
-            Tensor: Cosine similarity loss
+            torch.Tensor: Scalar loss value computed as mean of (1 - cosine
+                similarity) across all feature pairs.
         """
         cos_loss = torch.nn.CosineSimilarity()
         loss_sum = 0
diff --git a/src/anomalib/models/image/reverse_distillation/torch_model.py b/src/anomalib/models/image/reverse_distillation/torch_model.py
index b20e19b02f..e6149e8a95 100644
--- a/src/anomalib/models/image/reverse_distillation/torch_model.py
+++ b/src/anomalib/models/image/reverse_distillation/torch_model.py
@@ -1,4 +1,32 @@
-"""PyTorch model for Reverse Distillation."""
+"""PyTorch model implementation for Reverse Distillation.
+
+This module implements the core PyTorch model architecture for the Reverse Distillation
+anomaly detection method as described in `Deng et al. (2022)
+`_.
+
+The model consists of:
+- A pre-trained encoder (e.g. ResNet) that extracts multi-scale features
+- A bottleneck layer that compresses features into a compact representation
+- A decoder that reconstructs features back to the original feature space
+- A scoring mechanism based on reconstruction error
+
+Example:
+    >>> from anomalib.models.image.reverse_distillation.torch_model import (
+    ...     ReverseDistillationModel
+    ... )
+    >>> model = ReverseDistillationModel(
+    ...     backbone="wide_resnet50_2",
+    ...     input_size=(256, 256),
+    ...     layers=["layer1", "layer2", "layer3"],
+    ...     anomaly_map_mode="multiply"
+    ... )
+    >>> features = model(torch.randn(1, 3, 256, 256))
+
+See Also:
+    - :class:`ReverseDistillationModel`: Main PyTorch model implementation
+    - :class:`ReverseDistillationLoss`: Loss function for training
+    - :class:`AnomalyMapGenerator`: Anomaly map generation from features
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -20,18 +48,48 @@
 
 
 class ReverseDistillationModel(nn.Module):
-    """Reverse Distillation Model.
+    """PyTorch implementation of the Reverse Distillation model.
 
-    To reproduce results in the paper, use torchvision model for the encoder:
-        self.encoder = torchvision.models.wide_resnet50_2(pretrained=True)
+    The model consists of an encoder-decoder architecture where the encoder extracts
+    multi-scale features and the decoder reconstructs them back to the original
+    feature space. The reconstruction error is used to detect anomalies.
 
     Args:
-        backbone (str): Name of the backbone used for encoder and decoder.
-        input_size (tuple[int, int]): Size of input image.
-        layers (list[str]): Name of layers from which the features are extracted.
-        anomaly_map_mode (str): Mode used to generate anomaly map. Options are between ``multiply`` and ``add``.
-        pre_trained (bool, optional): Boolean to check whether to use a pre_trained backbone.
-            Defaults to ``True``.
+        backbone (str): Name of the backbone CNN architecture used for encoder and
+            decoder. Supported backbones can be found in timm library.
+        input_size (tuple[int, int]): Size of input images in format ``(H, W)``.
+        layers (Sequence[str]): Names of layers from which to extract features.
+            For example ``["layer1", "layer2", "layer3"]``.
+        anomaly_map_mode (AnomalyMapGenerationMode): Mode used to generate anomaly
+            map. Options are ``"multiply"`` or ``"add"``.
+        pre_trained (bool, optional): Whether to use pre-trained weights for the
+            encoder backbone. Defaults to ``True``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.image.reverse_distillation.torch_model import (
+        ...     ReverseDistillationModel
+        ... )
+        >>> model = ReverseDistillationModel(
+        ...     backbone="wide_resnet50_2",
+        ...     input_size=(256, 256),
+        ...     layers=["layer1", "layer2", "layer3"],
+        ...     anomaly_map_mode="multiply"
+        ... )
+        >>> input_tensor = torch.randn(1, 3, 256, 256)
+        >>> features = model(input_tensor)
+
+    Note:
+        The original paper uses torchvision's pre-trained wide_resnet50_2 as the
+        encoder backbone.
+
+    Attributes:
+        tiler (Tiler | None): Optional tiler for processing large images in patches.
+        encoder (TimmFeatureExtractor): Feature extraction backbone.
+        bottleneck (nn.Module): Bottleneck layer to compress features.
+        decoder (nn.Module): Decoder network to reconstruct features.
+        anomaly_map_generator (AnomalyMapGenerator): Module to generate anomaly
+            maps from features.
     """
 
     def __init__(
@@ -53,17 +111,39 @@ def __init__(
         self.anomaly_map_generator = AnomalyMapGenerator(image_size=input_size, mode=anomaly_map_mode)
 
     def forward(self, images: torch.Tensor) -> tuple[list[torch.Tensor], list[torch.Tensor]] | InferenceBatch:
-        """Forward-pass images to the network.
+        """Forward pass through the model.
 
-        During the training mode the model extracts features from encoder and decoder networks.
-        During evaluation mode, it returns the predicted anomaly map.
+        The behavior differs between training and evaluation modes:
+        - Training: Returns encoder and decoder features for computing loss
+        - Evaluation: Returns anomaly maps and scores
 
         Args:
-            images (torch.Tensor): Batch of images
+            images (torch.Tensor): Input tensor of shape ``(N, C, H, W)`` where
+                ``N`` is batch size, ``C`` is number of channels, ``H`` and ``W``
+                are height and width.
 
         Returns:
-            torch.Tensor | tuple[list[torch.Tensor]] | InferenceBatch: Encoder and decoder features
-                in training mode, else anomaly maps.
+            tuple[list[torch.Tensor], list[torch.Tensor]] | InferenceBatch:
+                - In training mode: Tuple of lists containing encoder and decoder
+                  features
+                - In evaluation mode: ``InferenceBatch`` containing anomaly maps
+                  and scores
+
+        Example:
+            >>> import torch
+            >>> model = ReverseDistillationModel(
+            ...     backbone="wide_resnet50_2",
+            ...     input_size=(256, 256),
+            ...     layers=["layer1", "layer2", "layer3"],
+            ...     anomaly_map_mode="multiply"
+            ... )
+            >>> input_tensor = torch.randn(1, 3, 256, 256)
+            >>> # Training mode
+            >>> model.train()
+            >>> encoder_features, decoder_features = model(input_tensor)
+            >>> # Evaluation mode
+            >>> model.eval()
+            >>> predictions = model(input_tensor)
         """
         self.encoder.eval()
 
diff --git a/src/anomalib/models/image/stfpm/__init__.py b/src/anomalib/models/image/stfpm/__init__.py
index 049695a63e..d6c456acb5 100644
--- a/src/anomalib/models/image/stfpm/__init__.py
+++ b/src/anomalib/models/image/stfpm/__init__.py
@@ -1,4 +1,33 @@
-"""STFPM Model."""
+"""Student-Teacher Feature Pyramid Matching Model for anomaly detection.
+
+This module implements the STFPM model for anomaly detection as described in
+Wang et al., 2021: Student-Teacher Feature Pyramid Matching for Unsupervised
+Anomaly Detection.
+
+The model consists of:
+- A pre-trained teacher network that extracts multi-scale features
+- A student network that learns to match the teacher's feature representations
+- Feature pyramid matching between student and teacher features
+- Anomaly detection based on feature discrepancy
+
+Example:
+    >>> from anomalib.models.image import Stfpm
+    >>> from anomalib.engine import Engine
+    >>> from anomalib.data import MVTec
+
+    >>> datamodule = MVTec()
+    >>> model = Stfpm()
+    >>> engine = Engine(model=model, datamodule=datamodule)
+
+    >>> engine.fit()  # doctest: +SKIP
+    >>> predictions = engine.predict()  # doctest: +SKIP
+
+See Also:
+    - :class:`anomalib.models.image.stfpm.lightning_model.Stfpm`:
+        Lightning implementation of the model
+    - :class:`anomalib.models.image.stfpm.torch_model.StfpmModel`:
+        PyTorch implementation of the model architecture
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/stfpm/anomaly_map.py b/src/anomalib/models/image/stfpm/anomaly_map.py
index 9cd7887fea..afb38eafb8 100644
--- a/src/anomalib/models/image/stfpm/anomaly_map.py
+++ b/src/anomalib/models/image/stfpm/anomaly_map.py
@@ -1,4 +1,30 @@
-"""Anomaly Map Generator for the STFPM model implementation."""
+"""Anomaly map computation for Student-Teacher Feature Pyramid Matching model.
+
+This module implements functionality to generate anomaly heatmaps by comparing
+features between a pre-trained teacher network and a student network that learns
+to match the teacher's representations.
+
+The anomaly maps are generated by:
+1. Computing cosine similarity between teacher and student features
+2. Converting similarity scores to anomaly scores via L2 norm
+3. Upscaling anomaly scores to original image size
+4. Combining multiple layer scores via element-wise multiplication
+
+Example:
+    >>> from anomalib.models.image.stfpm.anomaly_map import AnomalyMapGenerator
+    >>> generator = AnomalyMapGenerator()
+    >>> teacher_features = {"layer1": torch.randn(1, 64, 32, 32)}
+    >>> student_features = {"layer1": torch.randn(1, 64, 32, 32)}
+    >>> anomaly_map = generator.compute_anomaly_map(
+    ...     teacher_features,
+    ...     student_features,
+    ...     image_size=(256, 256)
+    ... )
+
+See Also:
+    - :class:`AnomalyMapGenerator`: Main class for generating anomaly maps
+    - :func:`compute_layer_map`: Function to compute per-layer anomaly scores
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -9,9 +35,36 @@
 
 
 class AnomalyMapGenerator(nn.Module):
-    """Generate Anomaly Heatmap."""
+    """Generate anomaly heatmaps by comparing teacher and student features.
+
+    This class implements functionality to generate anomaly maps by comparing
+    feature representations between a pre-trained teacher network and a student
+    network. The comparison is done via cosine similarity and L2 distance.
+
+    The anomaly map generation process involves:
+    1. Computing cosine similarity between teacher-student feature pairs
+    2. Converting similarity scores to anomaly scores using L2 norm
+    3. Upscaling the scores to original image size
+    4. Combining multiple layer scores via element-wise multiplication
+
+    Example:
+        >>> from anomalib.models.image.stfpm.anomaly_map import AnomalyMapGenerator
+        >>> generator = AnomalyMapGenerator()
+        >>> teacher_features = {"layer1": torch.randn(1, 64, 32, 32)}
+        >>> student_features = {"layer1": torch.randn(1, 64, 32, 32)}
+        >>> anomaly_map = generator.compute_anomaly_map(
+        ...     teacher_features,
+        ...     student_features,
+        ...     image_size=(256, 256)
+        ... )
+
+    See Also:
+        - :func:`compute_layer_map`: Function to compute per-layer anomaly scores
+        - :func:`compute_anomaly_map`: Function to combine layer scores
+    """
 
     def __init__(self) -> None:
+        """Initialize pairwise distance metric."""
         super().__init__()
         self.distance = torch.nn.PairwiseDistance(p=2, keepdim=True)
 
@@ -21,15 +74,24 @@ def compute_layer_map(
         student_features: torch.Tensor,
         image_size: tuple[int, int] | torch.Size,
     ) -> torch.Tensor:
-        """Compute the layer map based on cosine similarity.
+        """Compute anomaly map for a single feature layer.
+
+        The layer map is computed by:
+        1. Normalizing teacher and student features
+        2. Computing L2 distance between normalized features
+        3. Upscaling the distance map to original image size
 
         Args:
-          teacher_features (torch.Tensor): Teacher features
-          student_features (torch.Tensor): Student features
-          image_size (tuple[int, int]): Image size to which the anomaly map should be resized.
+            teacher_features (torch.Tensor): Features from teacher network with
+                shape ``(B, C, H, W)``
+            student_features (torch.Tensor): Features from student network with
+                matching shape
+            image_size (tuple[int, int] | torch.Size): Target size for upscaling
+                in format ``(H, W)``
 
         Returns:
-          Anomaly score based on cosine similarity.
+            torch.Tensor: Anomaly scores for the layer, upscaled to
+                ``image_size``
         """
         norm_teacher_features = F.normalize(teacher_features)
         norm_student_features = F.normalize(student_features)
@@ -43,15 +105,23 @@ def compute_anomaly_map(
         student_features: dict[str, torch.Tensor],
         image_size: tuple[int, int] | torch.Size,
     ) -> torch.Tensor:
-        """Compute the overall anomaly map via element-wise production the interpolated anomaly maps.
+        """Compute overall anomaly map by combining multiple layer maps.
+
+        The final anomaly map is generated by:
+        1. Computing per-layer anomaly maps via :func:`compute_layer_map`
+        2. Combining layer maps through element-wise multiplication
 
         Args:
-          teacher_features (dict[str, torch.Tensor]): Teacher features
-          student_features (dict[str, torch.Tensor]): Student features
-          image_size (tuple[int, int]): Image size to which the anomaly map should be resized.
+            teacher_features (dict[str, torch.Tensor]): Dictionary mapping layer
+                names to teacher feature tensors
+            student_features (dict[str, torch.Tensor]): Dictionary mapping layer
+                names to student feature tensors
+            image_size (tuple[int, int] | torch.Size): Target size for the
+                anomaly map in format ``(H, W)``
 
         Returns:
-          Final anomaly map
+            torch.Tensor: Final anomaly map with shape ``(B, 1, H, W)`` where
+                ``B`` is batch size and ``(H, W)`` matches ``image_size``
         """
         batch_size = next(iter(teacher_features.values())).shape[0]
         anomaly_map = torch.ones(batch_size, 1, image_size[0], image_size[1])
@@ -63,25 +133,30 @@ def compute_anomaly_map(
         return anomaly_map
 
     def forward(self, **kwargs: dict[str, torch.Tensor]) -> torch.Tensor:
-        """Return anomaly map.
+        """Generate anomaly map from teacher and student features.
 
-        Expects `teach_features` and `student_features` keywords to be passed explicitly.
+        Expects the following keys in ``kwargs``:
+        - ``teacher_features``: Dictionary of teacher network features
+        - ``student_features``: Dictionary of student network features
+        - ``image_size``: Target size for the anomaly map
 
         Args:
-            kwargs (dict[str, torch.Tensor]): Keyword arguments
+            kwargs (dict[str, torch.Tensor]): Keyword arguments containing
+                required inputs
 
         Example:
-            >>> anomaly_map_generator = AnomalyMapGenerator(image_size=tuple(hparams.model.input_size))
-            >>> output = self.anomaly_map_generator(
-                    teacher_features=teacher_features,
-                    student_features=student_features
-                )
+            >>> generator = AnomalyMapGenerator()
+            >>> anomaly_map = generator(
+            ...     teacher_features=teacher_features,
+            ...     student_features=student_features,
+            ...     image_size=(256, 256)
+            ... )
 
         Raises:
-            ValueError: `teach_features` and `student_features` keys are not found
+            ValueError: If required keys are missing from ``kwargs``
 
         Returns:
-            torch.Tensor: anomaly map
+            torch.Tensor: Anomaly map with shape ``(B, 1, H, W)``
         """
         if not ("teacher_features" in kwargs and "student_features" in kwargs):
             msg = f"Expected keys `teacher_features` and `student_features. Found {kwargs.keys()}"
diff --git a/src/anomalib/models/image/stfpm/lightning_model.py b/src/anomalib/models/image/stfpm/lightning_model.py
index f3daafe407..dc07f9035e 100644
--- a/src/anomalib/models/image/stfpm/lightning_model.py
+++ b/src/anomalib/models/image/stfpm/lightning_model.py
@@ -1,6 +1,31 @@
-"""STFPM: Student-Teacher Feature Pyramid Matching for Unsupervised Anomaly Detection.
-
-https://arxiv.org/abs/2103.04257
+"""Student-Teacher Feature Pyramid Matching for anomaly detection.
+
+This module implements the STFPM model for anomaly detection as described in
+`Wang et al. (2021) `_.
+
+The model consists of:
+- A pre-trained teacher network that extracts multi-scale features
+- A student network that learns to match the teacher's feature representations
+- Feature pyramid matching between student and teacher features
+- Anomaly detection based on feature discrepancy
+
+Example:
+    >>> from anomalib.models.image import Stfpm
+    >>> from anomalib.engine import Engine
+    >>> from anomalib.data import MVTec
+    >>> datamodule = MVTec()
+    >>> model = Stfpm(
+    ...     backbone="resnet18",
+    ...     layers=["layer1", "layer2", "layer3"]
+    ... )
+    >>> engine = Engine(model=model, datamodule=datamodule)
+    >>> engine.fit()  # doctest: +SKIP
+    >>> predictions = engine.predict()  # doctest: +SKIP
+
+See Also:
+    - :class:`Stfpm`: Lightning implementation of the model
+    - :class:`STFPMModel`: PyTorch implementation of the model architecture
+    - :class:`STFPMLoss`: Loss function for training
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
@@ -30,14 +55,45 @@
 class Stfpm(AnomalibModule):
     """PL Lightning Module for the STFPM algorithm.
 
+    The Student-Teacher Feature Pyramid Matching (STFPM) model consists of a
+    pre-trained teacher network and a student network that learns to match the
+    teacher's feature representations. The model detects anomalies by comparing
+    feature discrepancies between the teacher and student networks.
+
     Args:
-        backbone (str): Backbone CNN network
-            Defaults to ``resnet18``.
-        layers (list[str]): Layers to extract features from the backbone CNN
+        backbone (str): Name of the backbone CNN network used for both teacher
+            and student. Defaults to ``"resnet18"``.
+        layers (list[str]): Names of layers from which to extract features.
             Defaults to ``["layer1", "layer2", "layer3"]``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor to transform
+            input data before passing to model. If ``True``, uses default.
+            Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor to generate
+            predictions from model outputs. If ``True``, uses default.
+            Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator to compute metrics.
+            If ``True``, uses default. Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer to display results.
+            If ``True``, uses default. Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models.image import Stfpm
+        >>> from anomalib.data import MVTec
+        >>> from anomalib.engine import Engine
+        >>> datamodule = MVTec()
+        >>> model = Stfpm(
+        ...     backbone="resnet18",
+        ...     layers=["layer1", "layer2", "layer3"]
+        ... )
+        >>> engine = Engine(model=model, datamodule=datamodule)
+        >>> engine.fit()  # doctest: +SKIP
+        >>> predictions = engine.predict()  # doctest: +SKIP
+
+    See Also:
+        - :class:`anomalib.models.image.stfpm.torch_model.STFPMModel`:
+            PyTorch implementation of the model architecture
+        - :class:`anomalib.models.image.stfpm.loss.STFPMLoss`:
+            Loss function for training
     """
 
     def __init__(
@@ -62,15 +118,15 @@ def __init__(
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform a training step of STFPM.
 
-        For each batch, teacher and student and teacher features are extracted from the CNN.
+        For each batch, teacher and student features are extracted from the CNN.
 
         Args:
-          batch (Batch): Input batch.
-          args: Additional arguments.
-          kwargs: Additional keyword arguments.
+            batch (Batch): Input batch containing images and labels.
+            args: Additional arguments (unused).
+            kwargs: Additional keyword arguments (unused).
 
         Returns:
-          Loss value
+            STEP_OUTPUT: Dictionary containing the loss value.
         """
         del args, kwargs  # These variables are not used.
 
@@ -80,19 +136,19 @@ def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
         return {"loss": loss}
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
-        """Perform a validation Step of STFPM.
+        """Perform a validation step of STFPM.
 
-        Similar to the training step, student/teacher features are extracted from the CNN for each batch, and
-        anomaly map is computed.
+        Similar to training, extracts student/teacher features from CNN and
+        computes anomaly maps.
 
         Args:
-          batch (Batch): Input batch
-          args: Additional arguments
-          kwargs: Additional keyword arguments
+            batch (Batch): Input batch containing images and labels.
+            args: Additional arguments (unused).
+            kwargs: Additional keyword arguments (unused).
 
         Returns:
-          Dictionary containing images, anomaly maps, true labels and masks.
-          These are required in `validation_epoch_end` for feature concatenation.
+            STEP_OUTPUT: Dictionary containing images, anomaly maps, labels and
+                masks for evaluation.
         """
         del args, kwargs  # These variables are not used.
 
@@ -101,14 +157,24 @@ def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """Required trainer arguments."""
+        """Get required trainer arguments for the model.
+
+        Returns:
+            dict[str, Any]: Dictionary of trainer arguments:
+                - ``gradient_clip_val``: Set to 0 to disable gradient clipping
+                - ``num_sanity_val_steps``: Set to 0 to skip validation sanity
+                  checks
+        """
         return {"gradient_clip_val": 0, "num_sanity_val_steps": 0}
 
     def configure_optimizers(self) -> torch.optim.Optimizer:
-        """Configure optimizers.
+        """Configure optimizers for training.
 
         Returns:
-            Optimizer: SGD optimizer
+            torch.optim.Optimizer: SGD optimizer with the following parameters:
+                - Learning rate: 0.4
+                - Momentum: 0.9
+                - Weight decay: 0.001
         """
         return optim.SGD(
             params=self.model.student_model.parameters(),
@@ -120,9 +186,9 @@ def configure_optimizers(self) -> torch.optim.Optimizer:
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type of the model.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: The model uses one-class learning.
         """
         return LearningType.ONE_CLASS
diff --git a/src/anomalib/models/image/stfpm/loss.py b/src/anomalib/models/image/stfpm/loss.py
index 412caf8fdd..3d598def98 100644
--- a/src/anomalib/models/image/stfpm/loss.py
+++ b/src/anomalib/models/image/stfpm/loss.py
@@ -1,4 +1,37 @@
-"""Loss function for the STFPM Model Implementation."""
+"""Loss function for Student-Teacher Feature Pyramid Matching model.
+
+This module implements the loss function used to train the STFPM model for anomaly
+detection as described in `Wang et al. (2021) `_.
+
+The loss function:
+1. Takes feature maps from teacher and student networks as input
+2. Normalizes the features using L2 normalization
+3. Computes MSE loss between normalized features
+4. Scales the loss by spatial dimensions of feature maps
+
+Example:
+    >>> from anomalib.models.components import TimmFeatureExtractor
+    >>> from anomalib.models.image.stfpm.loss import STFPMLoss
+    >>> from torchvision.models import resnet18
+    >>> layers = ["layer1", "layer2", "layer3"]
+    >>> teacher_model = TimmFeatureExtractor(
+    ...     model=resnet18(pretrained=True),
+    ...     layers=layers
+    ... )
+    >>> student_model = TimmFeatureExtractor(
+    ...     model=resnet18(pretrained=False),
+    ...     layers=layers
+    ... )
+    >>> criterion = STFPMLoss()
+    >>> features = torch.randn(4, 3, 256, 256)
+    >>> teacher_features = teacher_model(features)
+    >>> student_features = student_model(features)
+    >>> loss = criterion(student_features, teacher_features)
+
+See Also:
+    - :class:`STFPMLoss`: Main loss class implementation
+    - :class:`Stfpm`: Lightning implementation of the full model
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -9,23 +42,42 @@
 
 
 class STFPMLoss(nn.Module):
-    """Feature Pyramid Loss This class implmenents the feature pyramid loss function proposed in STFPM paper.
+    """Loss function for Student-Teacher Feature Pyramid Matching model.
 
-    Example:
-        >>> from anomalib.models.components.feature_extractors import TimmFeatureExtractor
-        >>> from anomalib.models.stfpm.loss import STFPMLoss
-        >>> from torchvision.models import resnet18
+    This class implements the feature pyramid loss function proposed in the STFPM
+    paper. The loss measures the discrepancy between feature representations from
+    a pre-trained teacher network and a student network that learns to match them.
 
-        >>> layers = ['layer1', 'layer2', 'layer3']
-        >>> teacher_model = TimmFeatureExtractor(model=resnet18(pretrained=True), layers=layers)
-        >>> student_model = TimmFeatureExtractor(model=resnet18(pretrained=False), layers=layers)
-        >>> loss = Loss()
+    The loss computation involves:
+    1. Normalizing teacher and student features using L2 normalization
+    2. Computing MSE loss between normalized features
+    3. Scaling the loss by spatial dimensions of feature maps
+    4. Summing losses across all feature layers
 
-        >>> inp = torch.rand((4, 3, 256, 256))
-        >>> teacher_features = teacher_model(inp)
-        >>> student_features = student_model(inp)
-        >>> loss(student_features, teacher_features)
-            tensor(51.2015, grad_fn=)
+    Example:
+        >>> from anomalib.models.components import TimmFeatureExtractor
+        >>> from anomalib.models.image.stfpm.loss import STFPMLoss
+        >>> from torchvision.models import resnet18
+        >>> layers = ["layer1", "layer2", "layer3"]
+        >>> teacher_model = TimmFeatureExtractor(
+        ...     model=resnet18(pretrained=True),
+        ...     layers=layers
+        ... )
+        >>> student_model = TimmFeatureExtractor(
+        ...     model=resnet18(pretrained=False),
+        ...     layers=layers
+        ... )
+        >>> criterion = STFPMLoss()
+        >>> features = torch.randn(4, 3, 256, 256)
+        >>> teacher_features = teacher_model(features)
+        >>> student_features = student_model(features)
+        >>> loss = criterion(student_features, teacher_features)
+        >>> loss
+        tensor(51.2015, grad_fn=)
+
+    See Also:
+        - :class:`Stfpm`: Lightning implementation of the full model
+        - :class:`STFPMModel`: PyTorch implementation of the model architecture
     """
 
     def __init__(self) -> None:
@@ -33,14 +85,22 @@ def __init__(self) -> None:
         self.mse_loss = nn.MSELoss(reduction="sum")
 
     def compute_layer_loss(self, teacher_feats: torch.Tensor, student_feats: torch.Tensor) -> torch.Tensor:
-        """Compute layer loss based on Equation (1) in Section 3.2 of the paper.
+        """Compute loss between teacher and student features for a single layer.
+
+        This implements the loss computation based on Equation (1) in Section 3.2
+        of the paper. The loss is computed as:
+        1. L2 normalize teacher and student features
+        2. Compute MSE loss between normalized features
+        3. Scale loss by spatial dimensions (height * width)
 
         Args:
-          teacher_feats (torch.Tensor): Teacher features
-          student_feats (torch.Tensor): Student features
+            teacher_feats (torch.Tensor): Features from teacher network with shape
+                ``(B, C, H, W)``
+            student_feats (torch.Tensor): Features from student network with shape
+                ``(B, C, H, W)``
 
         Returns:
-          L2 distance between teacher and student features.
+            torch.Tensor: Scalar loss value for the layer
         """
         height, width = teacher_feats.shape[2:]
 
@@ -53,14 +113,20 @@ def forward(
         teacher_features: dict[str, torch.Tensor],
         student_features: dict[str, torch.Tensor],
     ) -> torch.Tensor:
-        """Compute the overall loss via the weighted average of the layer losses computed by the cosine similarity.
+        """Compute total loss across all feature layers.
+
+        The total loss is computed as the sum of individual layer losses. Each
+        layer loss measures the discrepancy between teacher and student features
+        at that layer.
 
         Args:
-          teacher_features (dict[str, torch.Tensor]): Teacher features
-          student_features (dict[str, torch.Tensor]): Student features
+            teacher_features (dict[str, torch.Tensor]): Dictionary mapping layer
+                names to teacher feature tensors
+            student_features (dict[str, torch.Tensor]): Dictionary mapping layer
+                names to student feature tensors
 
         Returns:
-          Total loss, which is the weighted average of the layer losses.
+            torch.Tensor: Total loss summed across all layers
         """
         layer_losses: list[torch.Tensor] = []
         for layer in teacher_features:
diff --git a/src/anomalib/models/image/stfpm/torch_model.py b/src/anomalib/models/image/stfpm/torch_model.py
index 72638b1531..a4308ecce9 100644
--- a/src/anomalib/models/image/stfpm/torch_model.py
+++ b/src/anomalib/models/image/stfpm/torch_model.py
@@ -1,4 +1,28 @@
-"""PyTorch model for the STFPM model implementation."""
+"""PyTorch model implementation for Student-Teacher Feature Pyramid Matching.
+
+This module implements the core PyTorch model architecture for the STFPM anomaly
+detection method as described in `Wang et al. (2021)
+`_.
+
+The model consists of:
+- A pre-trained teacher network that extracts multi-scale features
+- A student network that learns to match the teacher's feature representations
+- Feature pyramid matching between student and teacher features
+- Anomaly detection based on feature discrepancy
+
+Example:
+    >>> from anomalib.models.image.stfpm.torch_model import STFPMModel
+    >>> model = STFPMModel(
+    ...     backbone="resnet18",
+    ...     layers=["layer1", "layer2", "layer3"]
+    ... )
+    >>> features = model(torch.randn(1, 3, 256, 256))
+
+See Also:
+    - :class:`STFPMModel`: Main PyTorch model implementation
+    - :class:`STFPMLoss`: Loss function for training
+    - :class:`AnomalyMapGenerator`: Anomaly map generation from features
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -19,12 +43,43 @@
 
 
 class STFPMModel(nn.Module):
-    """STFPM: Student-Teacher Feature Pyramid Matching for Unsupervised Anomaly Detection.
+    """PyTorch implementation of the STFPM model.
+
+    The Student-Teacher Feature Pyramid Matching model consists of a pre-trained
+    teacher network and a student network that learns to match the teacher's
+    feature representations. The model detects anomalies by comparing feature
+    discrepancies between the teacher and student networks.
 
     Args:
-        layers (list[str]): Layers used for feature extraction.
-        backbone (str, optional): Pre-trained model backbone.
-            Defaults to ``resnet18``.
+        layers (Sequence[str]): Names of layers from which to extract features.
+            For example ``["layer1", "layer2", "layer3"]``.
+        backbone (str, optional): Name of the backbone CNN architecture used for
+            both teacher and student networks. Supported backbones can be found
+            in timm library. Defaults to ``"resnet18"``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.image.stfpm.torch_model import STFPMModel
+        >>> model = STFPMModel(
+        ...     backbone="resnet18",
+        ...     layers=["layer1", "layer2", "layer3"]
+        ... )
+        >>> input_tensor = torch.randn(1, 3, 256, 256)
+        >>> features = model(input_tensor)
+
+    Note:
+        The teacher model is initialized with pre-trained weights and frozen
+        during training, while the student model is trained from scratch.
+
+    Attributes:
+        tiler (Tiler | None): Optional tiler for processing large images in
+            patches.
+        teacher_model (TimmFeatureExtractor): Pre-trained teacher network for
+            feature extraction.
+        student_model (TimmFeatureExtractor): Student network that learns to
+            match teacher features.
+        anomaly_map_generator (AnomalyMapGenerator): Module to generate anomaly
+            maps from features.
     """
 
     def __init__(
@@ -54,16 +109,36 @@ def forward(
         self,
         images: torch.Tensor,
     ) -> tuple[dict[str, torch.Tensor], dict[str, torch.Tensor]] | InferenceBatch:
-        """Forward-pass images into the network.
+        """Forward pass through teacher and student networks.
 
-        During the training mode the model extracts the features from the teacher and student networks.
-        During the evaluation mode, it returns the predicted anomaly map.
+        The forward pass behavior differs between training and evaluation:
+        - Training: Returns features from both teacher and student networks
+        - Evaluation: Returns anomaly maps generated from feature differences
 
         Args:
-          images (torch.Tensor): Batch of images.
+            images (torch.Tensor): Batch of input images with shape
+                ``(N, C, H, W)``.
 
         Returns:
-          Teacher and student features when in training mode, otherwise the predicted anomaly maps.
+            Training mode:
+                tuple[dict[str, torch.Tensor], dict[str, torch.Tensor]]:
+                    Features from teacher and student networks respectively.
+                    Each dict maps layer names to feature tensors.
+            Evaluation mode:
+                InferenceBatch:
+                    Batch containing anomaly maps and prediction scores.
+
+        Example:
+            >>> import torch
+            >>> from anomalib.models.image.stfpm.torch_model import STFPMModel
+            >>> model = STFPMModel(layers=["layer1", "layer2", "layer3"])
+            >>> input_tensor = torch.randn(1, 3, 256, 256)
+            >>> # Training mode
+            >>> model.train()
+            >>> teacher_feats, student_feats = model(input_tensor)
+            >>> # Evaluation mode
+            >>> model.eval()
+            >>> predictions = model(input_tensor)
         """
         output_size = images.shape[-2:]
         if self.tiler:
diff --git a/src/anomalib/models/image/uflow/__init__.py b/src/anomalib/models/image/uflow/__init__.py
index 653f7835fa..71693e3b69 100644
--- a/src/anomalib/models/image/uflow/__init__.py
+++ b/src/anomalib/models/image/uflow/__init__.py
@@ -1,4 +1,32 @@
-"""U-Flow: A U-shaped Normalizing Flow for Anomaly Detection with Unsupervised Threshold."""
+"""U-Flow: A U-shaped Normalizing Flow for Anomaly Detection with Unsupervised Threshold.
+
+This module implements the U-Flow model for anomaly detection as described in
+Rudolph et al., 2022: U-Flow: A U-shaped Normalizing Flow for Anomaly Detection
+with Unsupervised Threshold.
+
+The model consists of:
+- A U-shaped normalizing flow architecture for density estimation
+- Unsupervised threshold estimation based on the learned density
+- Anomaly detection by comparing likelihoods to the threshold
+
+Example:
+    >>> from anomalib.models.image import Uflow
+    >>> from anomalib.engine import Engine
+    >>> from anomalib.data import MVTec
+
+    >>> datamodule = MVTec()
+    >>> model = Uflow()
+    >>> engine = Engine(model=model, datamodule=datamodule)
+
+    >>> engine.fit()  # doctest: +SKIP
+    >>> predictions = engine.predict()  # doctest: +SKIP
+
+See Also:
+    - :class:`anomalib.models.image.uflow.lightning_model.Uflow`:
+        Lightning implementation of the model
+    - :class:`anomalib.models.image.uflow.torch_model.UflowModel`:
+        PyTorch implementation of the model architecture
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/uflow/anomaly_map.py b/src/anomalib/models/image/uflow/anomaly_map.py
index 697f03321d..4457bd17e5 100644
--- a/src/anomalib/models/image/uflow/anomaly_map.py
+++ b/src/anomalib/models/image/uflow/anomaly_map.py
@@ -1,4 +1,22 @@
-"""UFlow Anomaly Map Generator Implementation."""
+"""Anomaly map computation for U-Flow model.
+
+This module implements functionality to generate anomaly heatmaps from the latent
+variables produced by a U-Flow model. The anomaly maps are generated by:
+
+1. Computing per-scale likelihoods from latent variables
+2. Upscaling likelihoods to original image size
+3. Combining multiple scale likelihoods
+
+Example:
+    >>> from anomalib.models.image.uflow.anomaly_map import AnomalyMapGenerator
+    >>> generator = AnomalyMapGenerator(input_size=(256, 256))
+    >>> latent_vars = [torch.randn(1, 64, 32, 32), torch.randn(1, 128, 16, 16)]
+    >>> anomaly_map = generator(latent_vars)
+
+See Also:
+    - :class:`AnomalyMapGenerator`: Main class for generating anomaly maps
+    - :func:`compute_anomaly_map`: Function to generate anomaly maps from latents
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,27 +34,66 @@
 
 
 class AnomalyMapGenerator(nn.Module):
-    """Generate Anomaly Heatmap and segmentation."""
+    """Generate anomaly heatmaps and segmentation masks from U-Flow latent variables.
+
+    This class implements functionality to generate anomaly maps by analyzing the latent
+    variables produced by a U-Flow model. The anomaly maps can be generated in two ways:
+
+    1. Using likelihood-based scoring (default method):
+        - Computes per-scale likelihoods from latent variables
+        - Upscales likelihoods to original image size
+        - Combines multiple scale likelihoods via averaging
+
+    2. Using NFA-based segmentation (optional method):
+        - Applies binomial testing on local windows
+        - Computes Number of False Alarms (NFA) statistics
+        - Generates binary segmentation masks
+
+    Args:
+        input_size (ListConfig | tuple): Size of input images as ``(height, width)``
+
+    Example:
+        >>> from anomalib.models.image.uflow.anomaly_map import AnomalyMapGenerator
+        >>> generator = AnomalyMapGenerator(input_size=(256, 256))
+        >>> latents = [torch.randn(1, 64, 32, 32), torch.randn(1, 128, 16, 16)]
+        >>> anomaly_map = generator(latents)
+        >>> anomaly_map.shape
+        torch.Size([1, 1, 256, 256])
+
+    See Also:
+        - :func:`compute_anomaly_map`: Main method for likelihood-based maps
+        - :func:`compute_anomaly_mask`: Optional method for NFA-based segmentation
+    """
 
     def __init__(self, input_size: ListConfig | tuple) -> None:
         super().__init__()
         self.input_size = input_size if isinstance(input_size, tuple) else tuple(input_size)
 
     def forward(self, latent_variables: list[Tensor]) -> Tensor:
-        """Return anomaly map."""
+        """Generate anomaly map from latent variables.
+
+        Args:
+            latent_variables (list[Tensor]): List of latent tensors from U-Flow model
+
+        Returns:
+            Tensor: Anomaly heatmap of shape ``(batch_size, 1, height, width)``
+        """
         return self.compute_anomaly_map(latent_variables)
 
     def compute_anomaly_map(self, latent_variables: list[Tensor]) -> Tensor:
-        """Generate a likelihood-based anomaly map, from latent variables.
+        """Generate likelihood-based anomaly map from latent variables.
+
+        The method:
+        1. Computes per-scale likelihoods from latent variables
+        2. Upscales each likelihood map to input image size
+        3. Combines scale likelihoods via averaging
 
         Args:
-            latent_variables: List of latent variables from the UFlow model. Each element is a tensor of shape
-            (N, Cl, Hl, Wl), where N is the batch size, Cl is the number of channels, and Hl and Wl are the height and
-            width of the latent variables, respectively, for each scale l.
+            latent_variables (list[Tensor]): List of latent tensors from U-Flow model,
+                each with shape ``(batch_size, channels, height, width)``
 
         Returns:
-            Final Anomaly Map. Tensor of shape (N, 1, H, W), where N is the batch size, and H and W are the height and
-            width of the input image, respectively.
+            Tensor: Anomaly heatmap of shape ``(batch_size, 1, height, width)``
         """
         likelihoods = []
         for z in latent_variables:
@@ -61,31 +118,29 @@ def compute_anomaly_mask(
         binomial_probability_thr: float = 0.5,
         high_precision: bool = False,
     ) -> torch.Tensor:
-        """This method is not used in the basic functionality of training and testing.
+        """Generate NFA-based anomaly segmentation mask from latent variables.
 
-        It is a bit slow, so we decided to
-        leave it as an option for the user. It is included as it is part of the U-Flow paper, and can be called
-        separately if an unsupervised anomaly segmentation is needed.
+        This optional method implements the Number of False Alarms (NFA) approach from
+        the U-Flow paper. It is slower than the default likelihood method but provides
+        unsupervised binary segmentation.
 
-        Generate an anomaly mask, from latent variables. It is based on the NFA (Number of False Alarms) method, which
-        is a statistical method to detect anomalies. The NFA is computed as the log of the probability of the null
-        hypothesis, which is that all pixels are normal. First, we compute a list of  candidate pixels, with
-        suspiciously high values of z^2, by applying a binomial test to each pixel, looking at a window  around it.
-        Then, to compute the NFA values (actually the log-NFA), we evaluate how probable is that a pixel  belongs to the
-        normal distribution. The null-hypothesis is that under normality assumptions, all candidate pixels are uniformly
-        distributed. Then, the detection is based on the concentration of candidate pixels.
+        The method:
+        1. Applies binomial testing on local windows around each pixel
+        2. Computes NFA statistics based on concentration of candidate pixels
+        3. Generates binary segmentation mask
 
         Args:
-            z (list[torch.Tensor]): List of latent variables from the UFlow model. Each element is a tensor of shape
-                (N, Cl, Hl, Wl), where N is the batch size, Cl is the number of channels, and Hl and Wl are the height
-                and width of the latent variables, respectively, for each scale l.
-            window_size (int): Window size for the binomial test. Defaults to 7.
-            binomial_probability_thr (float): Probability threshold for the binomial test. Defaults to 0.5
-            high_precision (bool): Whether to use high precision for the binomial test. Defaults to False.
+            z (list[torch.Tensor]): List of latent tensors from U-Flow model
+            window_size (int, optional): Size of local window for binomial test.
+                Defaults to ``7``.
+            binomial_probability_thr (float, optional): Probability threshold for
+                binomial test. Defaults to ``0.5``.
+            high_precision (bool, optional): Whether to use high precision NFA
+                computation. Slower but more accurate. Defaults to ``False``.
 
         Returns:
-            Anomaly mask. Tensor of shape (N, 1, H, W), where N is the batch size, and H and W are the height and
-            width of the input image, respectively.
+            torch.Tensor: Binary anomaly mask of shape ``(batch_size, 1, height,
+                width)``
         """
         log_prob_l = [
             self.binomial_test(zi, window_size / (2**scale), binomial_probability_thr, high_precision)
@@ -113,22 +168,27 @@ def binomial_test(
         probability_thr: float,
         high_precision: bool = False,
     ) -> torch.Tensor:
-        """The binomial test applied to validate or reject the null hypothesis that the pixel is normal.
+        """Apply binomial test to validate/reject normality hypothesis.
 
-        The null hypothesis is that the pixel is normal, and the alternative hypothesis is that the pixel is anomalous.
-        The binomial test is applied to a window around the pixel, and the number of pixels in the window that ares
-        anomalous is compared to the number of pixels that are expected to be anomalous under the null hypothesis.
+        For each pixel, tests the null hypothesis that the pixel and its local
+        neighborhood are normal against the alternative that they are anomalous.
+
+        The test:
+        1. Counts anomalous pixels in local window using chi-square threshold
+        2. Compares observed count to expected count under null hypothesis
+        3. Returns log probability of observing such extreme counts
 
         Args:
-            z: Latent variable from the UFlow model. Tensor of shape (N, Cl, Hl, Wl), where N is the batch size, Cl is
-            the number of channels, and Hl and Wl are the height and width of the latent variables, respectively.
-            window_size (int): Window size for the binomial test.
-            probability_thr: Probability threshold for the binomial test.
-            high_precision: Whether to use high precision for the binomial test.
+            z (torch.Tensor): Latent tensor of shape ``(batch_size, channels,
+                height, width)``
+            window_size (int): Size of local window for counting
+            probability_thr (float): Probability threshold for chi-square test
+            high_precision (bool, optional): Whether to use high precision
+                computation. Defaults to ``False``.
 
         Returns:
-            Log of the probability of the null hypothesis.
-
+            torch.Tensor: Log probability tensor of shape ``(batch_size, 1,
+                height, width)``
         """
         tau = st.chi2.ppf(probability_thr, 1)
         half_win = np.max([int(window_size // 2), 1])
diff --git a/src/anomalib/models/image/uflow/feature_extraction.py b/src/anomalib/models/image/uflow/feature_extraction.py
index 50cd2ba5e3..7597411a5b 100644
--- a/src/anomalib/models/image/uflow/feature_extraction.py
+++ b/src/anomalib/models/image/uflow/feature_extraction.py
@@ -1,4 +1,22 @@
-"""Feature Extractor for U-Flow model."""
+"""Feature extraction module for U-Flow model.
+
+This module implements feature extraction functionality for the U-Flow model for
+anomaly detection. It provides:
+
+1. Feature extractors based on different backbone architectures
+2. Utility function to get appropriate feature extractor
+3. Support for multiple scales of feature extraction
+
+Example:
+    >>> from anomalib.models.image.uflow.feature_extraction import get_feature_extractor
+    >>> extractor = get_feature_extractor(backbone="resnet18")
+    >>> features = extractor(torch.randn(1, 3, 256, 256))
+
+See Also:
+    - :func:`get_feature_extractor`: Factory function to get feature extractors
+    - :class:`FeatureExtractor`: Main feature extractor implementation
+    - :class:`MCaitFeatureExtractor`: Alternative feature extractor
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,17 +34,32 @@
 
 
 def get_feature_extractor(backbone: str, input_size: tuple[int, int] = (256, 256)) -> nn.Module:
-    """Get feature extractor. Currently, is restricted to AVAILABLE_EXTRACTORS.
+    """Get feature extractor based on specified backbone architecture.
+
+    This function returns a feature extractor model based on the specified backbone
+    architecture. Currently supported backbones are defined in ``AVAILABLE_EXTRACTORS``.
 
     Args:
-        backbone (str): Backbone name.
-        input_size (tuple[int, int]): Input size.
+        backbone (str): Name of the backbone architecture to use. Must be one of
+            ``["mcait", "resnet18", "wide_resnet50_2"]``.
+        input_size (tuple[int, int], optional): Input image dimensions as
+            ``(height, width)``. Defaults to ``(256, 256)``.
+
+    Returns:
+        nn.Module: Feature extractor model instance.
 
     Raises:
-        ValueError if unknown backbone is provided.
+        ValueError: If ``backbone`` is not one of the supported architectures in
+            ``AVAILABLE_EXTRACTORS``.
 
-    Returns:
-        FeatureExtractorInterface: Feature extractor.
+    Example:
+        >>> from anomalib.models.image.uflow.feature_extraction import get_feature_extractor
+        >>> extractor = get_feature_extractor(backbone="resnet18")
+        >>> features = extractor(torch.randn(1, 3, 256, 256))
+
+    See Also:
+        - :class:`FeatureExtractor`: Main feature extractor implementation
+        - :class:`MCaitFeatureExtractor`: Alternative feature extractor
     """
     if backbone not in AVAILABLE_EXTRACTORS:
         msg = f"Feature extractor must be one of {AVAILABLE_EXTRACTORS}."
@@ -44,11 +77,33 @@ def get_feature_extractor(backbone: str, input_size: tuple[int, int] = (256, 256
 class FeatureExtractor(TimmFeatureExtractor):
     """Feature extractor based on ResNet (or others) backbones.
 
+    This class extends TimmFeatureExtractor to extract and normalize features from
+    common CNN backbones like ResNet. It adds layer normalization to the extracted
+    features.
+
     Args:
-        backbone (str): Backbone of the feature extractor.
-        input_size (tuple[int, int]): Input image size used for computing normalization layers.
-        layers (tuple[str], optional): Layers from which to extract features.
-            Defaults to ("layer1", "layer2", "layer3").
+        backbone (str): Name of the backbone CNN architecture to use for feature
+            extraction (e.g. ``"resnet18"``, ``"wide_resnet50_2"``).
+        input_size (tuple[int, int]): Input image dimensions as ``(height, width)``
+            used for computing normalization layers.
+        layers (tuple[str, ...], optional): Names of layers from which to extract
+            features. Defaults to ``("layer1", "layer2", "layer3")``.
+        **kwargs: Additional keyword arguments (unused).
+
+    Example:
+        >>> import torch
+        >>> extractor = FeatureExtractor(
+        ...     backbone="resnet18",
+        ...     input_size=(256, 256)
+        ... )
+        >>> features = extractor(torch.randn(1, 3, 256, 256))
+
+    Attributes:
+        channels (list[int]): Number of channels in each extracted feature layer.
+        scale_factors (list[int]): Downsampling factor for each feature layer.
+        scales (range): Range object for iterating over feature scales.
+        feature_normalizations (nn.ModuleList): Layer normalization modules for
+            each feature scale.
     """
 
     def __init__(
@@ -76,26 +131,69 @@ def __init__(
             param.requires_grad = False
 
     def forward(self, img: torch.Tensor) -> torch.Tensor:
-        """Normalized features."""
+        """Extract and normalize features from input image.
+
+        Args:
+            img (torch.Tensor): Input image tensor of shape
+                ``(batch_size, channels, height, width)``.
+
+        Returns:
+            torch.Tensor: Normalized features from multiple network layers.
+        """
         features = self.extract_features(img)
         return self.normalize_features(features)
 
     def extract_features(self, img: torch.Tensor) -> torch.Tensor:
-        """Extract features."""
+        """Extract features from input image using backbone network.
+
+        Args:
+            img (torch.Tensor): Input image tensor of shape
+                ``(batch_size, channels, height, width)``.
+
+        Returns:
+            torch.Tensor: Features extracted from multiple network layers.
+        """
         self.feature_extractor.eval()
         return self.feature_extractor(img)
 
     def normalize_features(self, features: Iterable[torch.Tensor]) -> list[torch.Tensor]:
-        """Normalize features."""
+        """Apply layer normalization to extracted features.
+
+        Args:
+            features (Iterable[torch.Tensor]): Features extracted from multiple
+                network layers.
+
+        Returns:
+            list[torch.Tensor]: Normalized features from each layer.
+        """
         return [self.feature_normalizations[i](feature) for i, feature in enumerate(features)]
 
 
 class MCaitFeatureExtractor(nn.Module):
     """Feature extractor based on MCait backbone.
 
-    This is the proposed feature extractor in the paper. It uses two
-    independently trained Cait models, at different scales, with input sizes 448 and 224, respectively.
-    It also includes a normalization layer for each scale.
+    This class implements the feature extractor proposed in the U-Flow paper. It uses two
+    independently trained CaiT models at different scales:
+    - A CaiT-M48 model with input size 448x448
+    - A CaiT-S24 model with input size 224x224
+
+    Each model extracts features at a different scale, and includes normalization layers.
+
+    Example:
+        >>> from anomalib.models.image.uflow.feature_extraction import MCaitFeatureExtractor
+        >>> extractor = MCaitFeatureExtractor()
+        >>> image = torch.randn(1, 3, 448, 448)
+        >>> features = extractor(image)
+        >>> [f.shape for f in features]
+        [torch.Size([1, 768, 28, 28]), torch.Size([1, 384, 14, 14])]
+
+    Attributes:
+        input_size (int): Size of input images (448)
+        extractor1 (nn.Module): CaiT-M48 model for scale 1 (448x448)
+        extractor2 (nn.Module): CaiT-S24 model for scale 2 (224x224)
+        channels (list[int]): Number of channels for each scale [768, 384]
+        scale_factors (list[int]): Downsampling factors for each scale [16, 32]
+        scales (range): Range object for iterating over scales
     """
 
     def __init__(self) -> None:
@@ -112,20 +210,33 @@ def __init__(self) -> None:
         for param in self.extractor2.parameters():
             param.requires_grad = False
 
-    def forward(self, img: torch.Tensor, training: bool = True) -> torch.Tensor:
-        """Return normalized features."""
+    def forward(self, img: torch.Tensor) -> torch.Tensor:
+        """Extract and normalize features from input image.
+
+        Args:
+            img (torch.Tensor): Input image tensor of shape
+                ``(batch_size, channels, height, width)``
+
+        Returns:
+            torch.Tensor: List of normalized feature tensors from each scale
+        """
         features = self.extract_features(img)
-        return self.normalize_features(features, training=training)
+        return self.normalize_features(features)
 
-    def extract_features(self, img: torch.Tensor, **kwargs) -> tuple[torch.Tensor, torch.Tensor]:  # noqa: ARG002 | unused argument
-        """Extract features from ``img`` from the two extractors.
+    def extract_features(self, img: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        """Extract features from input image using both CaiT models.
+
+        The features are extracted at two scales:
+        - Scale 1: Using CaiT-M48 up to block index 40 (448x448 input)
+        - Scale 2: Using CaiT-S24 up to block index 20 (224x224 input)
 
         Args:
-            img (torch.Tensor): Input image
-            kwargs: unused
+            img (torch.Tensor): Input image tensor of shape
+                ``(batch_size, channels, height, width)``
 
         Returns:
-            tuple[torch.Tensor, torch.Tensor]: Features from the two extractors.
+            tuple[torch.Tensor, torch.Tensor]: Features from both extractors with shapes:
+                ``[(B, 768, H/16, W/16), (B, 384, H/32, W/32)]``
         """
         self.extractor1.eval()
         self.extractor2.eval()
@@ -147,15 +258,20 @@ def extract_features(self, img: torch.Tensor, **kwargs) -> tuple[torch.Tensor, t
 
         return (x1, x2)
 
-    def normalize_features(self, features: torch.Tensor, **kwargs) -> torch.Tensor:  # noqa: ARG002 | unused argument
-        """Normalize features.
+    def normalize_features(self, features: torch.Tensor) -> torch.Tensor:
+        """Normalize extracted features from both scales.
+
+        For each scale:
+        1. Apply layer normalization
+        2. Reshape features to spatial format
+        3. Append to list of normalized features
 
         Args:
-            features (torch.Tensor): Features to normalize.
-            **kwargs: unused
+            features (torch.Tensor): Tuple of features from both extractors
 
         Returns:
-            torch.Tensor: Normalized features.
+            torch.Tensor: List of normalized feature tensors with shapes:
+                ``[(B, 768, H/16, W/16), (B, 384, H/32, W/32)]``
         """
         normalized_features = []
         for i, extractor in enumerate([self.extractor1, self.extractor2]):
diff --git a/src/anomalib/models/image/uflow/lightning_model.py b/src/anomalib/models/image/uflow/lightning_model.py
index bfd51195ca..02715837e9 100644
--- a/src/anomalib/models/image/uflow/lightning_model.py
+++ b/src/anomalib/models/image/uflow/lightning_model.py
@@ -1,6 +1,28 @@
 """U-Flow: A U-shaped Normalizing Flow for Anomaly Detection with Unsupervised Threshold.
 
-https://arxiv.org/pdf/2211.12353.pdf
+This module implements the U-Flow model for anomaly detection as described in
+ `_. The model consists
+of:
+
+- A U-shaped normalizing flow architecture for density estimation
+- Multi-scale feature extraction using pre-trained backbones
+- Unsupervised threshold estimation based on the learned density
+- Anomaly detection by comparing likelihoods to the threshold
+
+Example:
+    >>> from anomalib.models.image import Uflow
+    >>> from anomalib.engine import Engine
+    >>> from anomalib.data import MVTec
+    >>> datamodule = MVTec()
+    >>> model = Uflow()
+    >>> engine = Engine(model=model, datamodule=datamodule)
+    >>> engine.fit()  # doctest: +SKIP
+    >>> predictions = engine.predict()  # doctest: +SKIP
+
+See Also:
+    - :class:`UflowModel`: PyTorch implementation of the model architecture
+    - :class:`UFlowLoss`: Loss function for training
+    - :class:`AnomalyMapGenerator`: Anomaly map generation from features
 """
 
 # Copyright (C) 2023-2024 Intel Corporation
@@ -32,14 +54,55 @@
 
 
 class Uflow(AnomalibModule):
-    """Uflow model.
+    """Lightning implementation of the U-Flow model.
+
+    This class implements the U-Flow model for anomaly detection as described in
+    Rudolph et al., 2022. The model consists of:
+
+    - A U-shaped normalizing flow architecture for density estimation
+    - Multi-scale feature extraction using pre-trained backbones
+    - Unsupervised threshold estimation based on the learned density
+    - Anomaly detection by comparing likelihoods to the threshold
 
     Args:
-        backbone (str): Backbone name.
-        flow_steps (int): Number of flow steps.
-        affine_clamp (float): Affine clamp.
-        affine_subnet_channels_ratio (float): Affine subnet channels ratio.
-        permute_soft (bool): Whether to use soft permutation.
+        backbone (str, optional): Name of the backbone feature extractor. Must be
+            one of ``["mcait", "resnet18", "wide_resnet50_2"]``. Defaults to
+            ``"mcait"``.
+        flow_steps (int, optional): Number of normalizing flow steps. Defaults to
+            ``4``.
+        affine_clamp (float, optional): Clamping value for affine coupling
+            layers. Defaults to ``2.0``.
+        affine_subnet_channels_ratio (float, optional): Channel ratio for affine
+            coupling subnet. Defaults to ``1.0``.
+        permute_soft (bool, optional): Whether to use soft permutation. Defaults
+            to ``False``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor for input
+            data. If ``True``, uses default pre-processor. Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor for model
+            outputs. If ``True``, uses default post-processor. Defaults to
+            ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator for model performance.
+            If ``True``, uses default evaluator. Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer for model outputs.
+            If ``True``, uses default visualizer. Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models.image import Uflow
+        >>> from anomalib.engine import Engine
+        >>> from anomalib.data import MVTec
+        >>> datamodule = MVTec()
+        >>> model = Uflow(backbone="resnet18")
+        >>> engine = Engine(model=model, datamodule=datamodule)
+        >>> engine.fit()  # doctest: +SKIP
+        >>> predictions = engine.predict()  # doctest: +SKIP
+
+    Raises:
+        ValueError: If ``input_size`` is not provided during initialization.
+
+    See Also:
+        - :class:`UflowModel`: PyTorch implementation of the model architecture
+        - :class:`UFlowLoss`: Loss function for training
+        - :class:`AnomalyMapGenerator`: Anomaly map generation from features
     """
 
     def __init__(
@@ -54,26 +117,35 @@ def __init__(
         evaluator: Evaluator | bool = True,
         visualizer: Visualizer | bool = True,
     ) -> None:
-        """Uflow model.
+        """Initialize U-Flow model.
 
         Args:
-            backbone (str): Backbone name.
-            flow_steps (int): Number of flow steps.
-            affine_clamp (float): Affine clamp.
-            affine_subnet_channels_ratio (float): Affine subnet channels ratio.
-            permute_soft (bool): Whether to use soft permutation.
-            pre_processor (PreProcessor, optional): Pre-processor for the model.
-                This is used to pre-process the input data before it is passed to the model.
-                Defaults to ``None``.
-            post_processor (PostProcessor, optional): Post-processor for the model.
-                This is used to post-process the output data after it is passed to the model.
-                Defaults to ``None``.
-            evaluator (Evaluator, optional): Evaluator for the model.
-                This is used to evaluate the model.
-                Defaults to ``True``.
-            visualizer (Visualizer, optional): Visualizer for the model.
-                This is used to visualize the model.
+            backbone (str, optional): Name of the backbone feature extractor.
+                Must be one of ``["mcait", "resnet18", "wide_resnet50_2"]``.
+                Defaults to ``"mcait"``.
+            flow_steps (int, optional): Number of normalizing flow steps.
+                Defaults to ``4``.
+            affine_clamp (float, optional): Clamping value for affine coupling
+                layers. Defaults to ``2.0``.
+            affine_subnet_channels_ratio (float, optional): Channel ratio for
+                affine coupling subnet. Defaults to ``1.0``.
+            permute_soft (bool, optional): Whether to use soft permutation.
+                Defaults to ``False``.
+            pre_processor (PreProcessor | bool, optional): Pre-processor for
+                input data. If ``True``, uses default pre-processor. Defaults to
+                ``True``.
+            post_processor (PostProcessor | bool, optional): Post-processor for
+                model outputs. If ``True``, uses default post-processor.
                 Defaults to ``True``.
+            evaluator (Evaluator | bool, optional): Evaluator for model
+                performance. If ``True``, uses default evaluator. Defaults to
+                ``True``.
+            visualizer (Visualizer | bool, optional): Visualizer for model
+                outputs. If ``True``, uses default visualizer. Defaults to
+                ``True``.
+
+        Raises:
+            ValueError: If ``input_size`` is not provided during initialization.
         """
         super().__init__(
             pre_processor=pre_processor,
@@ -103,7 +175,19 @@ def __init__(
 
     @classmethod
     def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
-        """Default pre-processor for UFlow."""
+        """Configure default pre-processor for U-Flow model.
+
+        Args:
+            image_size (tuple[int, int] | None, optional): Input image size.
+                Not used as U-Flow has fixed input size. Defaults to ``None``.
+
+        Returns:
+            PreProcessor: Default pre-processor with resizing and normalization.
+
+        Note:
+            The input image size is fixed to 448x448 for U-Flow regardless of
+            the provided ``image_size``.
+        """
         if image_size is not None:
             logger.warning("Image size is not used in UFlow. The input image size is determined by the model.")
         transform = Compose([
@@ -113,7 +197,13 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
         return PreProcessor(transform=transform)
 
     def configure_optimizers(self) -> tuple[list[LightningOptimizer], list[LRScheduler]]:
-        """Return optimizer and scheduler."""
+        """Configure optimizers and learning rate schedulers.
+
+        Returns:
+            tuple[list[LightningOptimizer], list[LRScheduler]]: Tuple containing:
+                - List of optimizers (Adam with initial lr=1e-3)
+                - List of schedulers (LinearLR reducing to 0.4 over 25000 steps)
+        """
         # Optimizer
         # values used in paper: bottle: 0.0001128999, cable: 0.0016160391, capsule: 0.0012118892, carpet: 0.0012118892,
         # grid: 0.0000362248, hazelnut: 0.0013268899, leather: 0.0006124724, metal_nut: 0.0008148858,
@@ -131,27 +221,49 @@ def configure_optimizers(self) -> tuple[list[LightningOptimizer], list[LRSchedul
         return [optimizer], [scheduler]
 
     def training_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
-        """Training step."""
+        """Perform a training step.
+
+        Args:
+            batch (Batch): Input batch containing images
+            *args: Variable length argument list
+            **kwargs: Arbitrary keyword arguments
+
+        Returns:
+            STEP_OUTPUT: Dictionary containing the loss value
+        """
         z, ljd = self.model(batch.image)
         loss = self.loss(z, ljd)
         self.log_dict({"loss": loss}, on_step=True, on_epoch=False, prog_bar=False, logger=True)
         return {"loss": loss}
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> STEP_OUTPUT:  # noqa: ARG002 | unused arguments
-        """Validation step."""
+        """Perform a validation step.
+
+        Args:
+            batch (Batch): Input batch containing images
+            *args: Variable length argument list
+            **kwargs: Arbitrary keyword arguments
+
+        Returns:
+            STEP_OUTPUT: Batch updated with model predictions
+        """
         predictions = self.model(batch.image)
         return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """Return EfficientAD trainer arguments."""
+        """Get trainer arguments for U-Flow.
+
+        Returns:
+            dict[str, Any]: Dictionary containing trainer arguments
+        """
         return {"num_sanity_val_steps": 0}
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type of the model.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: Learning type (ONE_CLASS for U-Flow)
         """
         return LearningType.ONE_CLASS
diff --git a/src/anomalib/models/image/uflow/loss.py b/src/anomalib/models/image/uflow/loss.py
index 08f2dfbe31..c9d09547f5 100644
--- a/src/anomalib/models/image/uflow/loss.py
+++ b/src/anomalib/models/image/uflow/loss.py
@@ -1,4 +1,23 @@
-"""Loss function for the UFlow Model Implementation."""
+"""Loss function implementation for the U-Flow model.
+
+This module implements the loss function used to train the U-Flow model for anomaly
+detection as described in  `_.
+The loss combines:
+
+- A likelihood term based on the hidden variables
+- A Jacobian determinant term from the normalizing flow
+
+Example:
+    >>> from anomalib.models.image.uflow.loss import UFlowLoss
+    >>> loss_fn = UFlowLoss()
+    >>> hidden_vars = [torch.randn(2, 64, 32, 32)]
+    >>> jacobians = [torch.randn(2)]
+    >>> loss = loss_fn(hidden_vars, jacobians)
+
+See Also:
+    - :class:`UFlowLoss`: Main loss function implementation
+    - :class:`UflowModel`: PyTorch model using this loss
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -8,18 +27,45 @@
 
 
 class UFlowLoss(nn.Module):
-    """UFlow Loss."""
+    """Loss function for training the U-Flow model.
+
+    This class implements the loss function used to train the U-Flow model.
+    The loss combines:
+
+    1. A likelihood term based on the hidden variables (``lpz``)
+    2. A Jacobian determinant term from the normalizing flow
+
+    The total loss is computed as:
+    ``loss = mean(lpz - jacobians)``
+
+    Example:
+        >>> from anomalib.models.image.uflow.loss import UFlowLoss
+        >>> loss_fn = UFlowLoss()
+        >>> hidden_vars = [torch.randn(2, 64, 32, 32)]  # List of hidden variables
+        >>> jacobians = [torch.randn(2)]  # List of log Jacobian determinants
+        >>> loss = loss_fn(hidden_vars, jacobians)
+        >>> loss.shape
+        torch.Size([])
+
+    See Also:
+        - :class:`UflowModel`: PyTorch model using this loss function
+        - :class:`Uflow`: Lightning implementation using this loss
+    """
 
     @staticmethod
     def forward(hidden_variables: list[Tensor], jacobians: list[Tensor]) -> Tensor:
         """Calculate the UFlow loss.
 
         Args:
-            hidden_variables (list[Tensor]): Hidden variables from the fastflow model. f: X -> Z
-            jacobians (list[Tensor]): Log of the jacobian determinants from the fastflow model.
+            hidden_variables (list[Tensor]): List of hidden variable tensors from the
+                normalizing flow transformation f: X -> Z. Each tensor has shape
+                ``(batch_size, channels, height, width)``.
+            jacobians (list[Tensor]): List of log Jacobian determinant tensors from the
+                flow transformation. Each tensor has shape ``(batch_size,)``.
 
         Returns:
-            Tensor: UFlow loss computed based on the hidden variables and the log of the Jacobians.
+            Tensor: Scalar loss value combining the likelihood of hidden variables and
+                the log Jacobian determinants.
         """
         lpz = torch.sum(torch.stack([0.5 * torch.sum(z_i**2, dim=(1, 2, 3)) for z_i in hidden_variables], dim=0))
         return torch.mean(lpz - jacobians)
diff --git a/src/anomalib/models/image/uflow/torch_model.py b/src/anomalib/models/image/uflow/torch_model.py
index 7c376328b9..2612b16356 100644
--- a/src/anomalib/models/image/uflow/torch_model.py
+++ b/src/anomalib/models/image/uflow/torch_model.py
@@ -1,4 +1,19 @@
-"""U-Flow torch model."""
+"""U-Flow PyTorch Implementation.
+
+This module provides the PyTorch implementation of the U-Flow model for anomaly detection.
+U-Flow combines normalizing flows with a U-Net style architecture to learn the distribution
+of normal images and detect anomalies.
+
+The model consists of several key components:
+    - Feature extraction using a pre-trained backbone
+    - Normalizing flow blocks arranged in a U-Net structure
+    - Anomaly map generation for localization
+
+The implementation includes classes for:
+    - Affine coupling subnet construction
+    - Main U-Flow model architecture
+    - Anomaly map generation
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -18,11 +33,28 @@
 class AffineCouplingSubnet:
     """Class for building the Affine Coupling subnet.
 
-    It is passed as an argument to the `AllInOneBlock` module.
+    This class creates a subnet used within the affine coupling layers of the normalizing
+    flow. The subnet is passed as an argument to the ``AllInOneBlock`` module and
+    determines how features are transformed within the coupling layer.
 
     Args:
-        kernel_size (int): Kernel size.
-        subnet_channels_ratio (float): Subnet channels ratio.
+        kernel_size (int): Size of convolutional kernels used in subnet layers.
+        subnet_channels_ratio (float): Ratio determining the number of intermediate
+            channels in the subnet relative to input channels.
+
+    Example:
+        >>> subnet = AffineCouplingSubnet(kernel_size=3, subnet_channels_ratio=1.0)
+        >>> layer = subnet(in_channels=64, out_channels=128)
+        >>> layer
+        Sequential(
+          (0): Conv2d(64, 64, kernel_size=(3, 3), padding=same)
+          (1): ReLU()
+          (2): Conv2d(64, 128, kernel_size=(3, 3), padding=same)
+        )
+
+    See Also:
+        - :class:`AllInOneBlock`: Flow block using this subnet
+        - :class:`UflowModel`: Main model incorporating these subnets
     """
 
     def __init__(self, kernel_size: int, subnet_channels_ratio: float) -> None:
@@ -30,14 +62,21 @@ def __init__(self, kernel_size: int, subnet_channels_ratio: float) -> None:
         self.subnet_channels_ratio = subnet_channels_ratio
 
     def __call__(self, in_channels: int, out_channels: int) -> nn.Sequential:
-        """Return AffineCouplingSubnet network.
+        """Create and return the affine coupling subnet.
+
+        The subnet consists of two convolutional layers with a ReLU activation in
+        between. The intermediate channel dimension is determined by
+        ``subnet_channels_ratio``.
 
         Args:
-            in_channels (int): Input channels.
-            out_channels (int): Output channels.
+            in_channels (int): Number of input channels to the subnet.
+            out_channels (int): Number of output channels from the subnet.
 
         Returns:
-            nn.Sequential: Affine Coupling subnet.
+            nn.Sequential: Sequential container of the subnet layers including:
+                - Conv2d layer mapping input to intermediate channels
+                - ReLU activation
+                - Conv2d layer mapping intermediate to output channels
         """
         mid_channels = int(in_channels * self.subnet_channels_ratio)
         return nn.Sequential(
@@ -48,15 +87,44 @@ def __call__(self, in_channels: int, out_channels: int) -> nn.Sequential:
 
 
 class UflowModel(nn.Module):
-    """U-Flow model.
+    """PyTorch implementation of the U-Flow model architecture.
+
+    This class implements the U-Flow model for anomaly detection.
+    The model consists of:
+
+    - A U-shaped normalizing flow architecture for density estimation
+    - Multi-scale feature extraction using pre-trained backbones
+    - Unsupervised threshold estimation based on the learned density
+    - Anomaly detection by comparing likelihoods to the threshold
 
     Args:
-        input_size (tuple[int, int]): Input image size.
-        flow_steps (int): Number of flow steps.
-        backbone (str): Backbone name.
-        affine_clamp (float): Affine clamp.
-        affine_subnet_channels_ratio (float): Affine subnet channels ratio.
-        permute_soft (bool): Whether to use soft permutation.
+        input_size (tuple[int, int]): Input image dimensions as ``(height, width)``.
+            Defaults to ``(448, 448)``.
+        flow_steps (int): Number of normalizing flow steps in each flow stage.
+            Defaults to ``4``.
+        backbone (str): Name of the backbone feature extractor. Must be one of
+            ``["mcait", "resnet18", "wide_resnet50_2"]``. Defaults to ``"mcait"``.
+        affine_clamp (float): Clamping value for affine coupling layers. Defaults
+            to ``2.0``.
+        affine_subnet_channels_ratio (float): Channel ratio for affine coupling
+            subnet. Defaults to ``1.0``.
+        permute_soft (bool): Whether to use soft permutation. Defaults to
+            ``False``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.image.uflow.torch_model import UflowModel
+        >>> model = UflowModel(
+        ...     input_size=(256, 256),
+        ...     backbone="resnet18"
+        ... )
+        >>> image = torch.randn(1, 3, 256, 256)
+        >>> output = model(image)  # Returns anomaly map during inference
+
+    See Also:
+        - :class:`Uflow`: Lightning implementation using this model
+        - :class:`UFlowLoss`: Loss function for training
+        - :class:`AnomalyMapGenerator`: Anomaly map generation from features
     """
 
     def __init__(
@@ -80,21 +148,28 @@ def __init__(
         self.anomaly_map_generator = AnomalyMapGenerator(input_size)
 
     def build_flow(self, flow_steps: int) -> ff.GraphINN:
-        """Build the flow model.
+        """Build the U-shaped normalizing flow architecture.
+
+        The flow is built in a U-shaped structure, processing features from coarse
+        to fine scales:
 
-        First we start with the input nodes, which have to match the feature extractor output.
-        Then, we build the U-Shaped flow. Starting from the bottom (the coarsest scale), the flow is built as follows:
-            1. Pass the input through a Flow Stage (`build_flow_stage`).
-            2. Split the output of the flow stage into two parts, one that goes directly to the output,
-            3. and the other is up-sampled, and will be concatenated with the output of the next flow stage (next scale)
-            4. Repeat steps 1-3 for the next scale.
-        Finally, we build the Flow graph using the input nodes, the flow stages, and the output nodes.
+        1. Start with input nodes matching feature extractor outputs
+        2. For each scale (coarse to fine):
+            - Pass through flow stage (sequence of coupling layers)
+            - Split output into two parts
+            - Send one part to output
+            - Upsample other part and concatenate with next scale
+        3. Build final flow graph combining all nodes
 
         Args:
-            flow_steps (int): Number of flow steps.
+            flow_steps (int): Number of coupling layers in each flow stage.
 
         Returns:
-            ff.GraphINN: Flow model.
+            ff.GraphINN: Constructed normalizing flow graph.
+
+        See Also:
+            - :meth:`build_flow_stage`: Builds individual flow stages
+            - :class:`AllInOneBlock`: Individual coupling layer blocks
         """
         input_nodes = []
         for channel, s_factor in zip(
@@ -138,17 +213,24 @@ def build_flow(self, flow_steps: int) -> ff.GraphINN:
         return ff.GraphINN(input_nodes + nodes + output_nodes[::-1])
 
     def build_flow_stage(self, in_node: ff.Node, flow_steps: int, condition_node: ff.Node = None) -> list[ff.Node]:
-        """Build a flow stage, which is a sequence of flow steps.
+        """Build a single flow stage consisting of multiple coupling layers.
 
-        Each flow stage is essentially a sequence of `flow_steps` Glow blocks (`AllInOneBlock`).
+        Each flow stage is a sequence of ``flow_steps`` Glow-style coupling blocks
+        (``AllInOneBlock``). The blocks alternate between 3x3 and 1x1 convolutions
+        in their coupling subnets.
 
         Args:
-            in_node (ff.Node): Input node.
-            flow_steps (int): Number of flow steps.
-            condition_node (ff.Node): Condition node.
+            in_node (ff.Node): Input node to the flow stage.
+            flow_steps (int): Number of coupling layers to use.
+            condition_node (ff.Node, optional): Optional conditioning node.
+                Defaults to ``None``.
 
         Returns:
-            List[ff.Node]: List of flow steps.
+            list[ff.Node]: List of constructed coupling layer nodes.
+
+        See Also:
+            - :class:`AllInOneBlock`: Individual coupling layer implementation
+            - :class:`AffineCouplingSubnet`: Subnet used in coupling layers
         """
         flow_size = in_node.output_dims[0][-1]
         nodes = []
@@ -173,7 +255,20 @@ def build_flow_stage(self, in_node: ff.Node, flow_steps: int, condition_node: ff
         return nodes
 
     def forward(self, image: torch.Tensor) -> torch.Tensor | InferenceBatch:
-        """Return anomaly map."""
+        """Process input image through the model.
+
+        During training, returns latent variables and log-Jacobian determinant.
+        During inference, returns anomaly scores and anomaly map.
+
+        Args:
+            image (torch.Tensor): Input image tensor of shape
+                ``(batch_size, channels, height, width)``.
+
+        Returns:
+            torch.Tensor | InferenceBatch: During training, returns tuple of
+                ``(latent_vars, log_jacobian)``. During inference, returns
+                ``InferenceBatch`` with anomaly scores and map.
+        """
         features = self.feature_extractor(image)
         z, ljd = self.encode(features)
 
@@ -185,7 +280,16 @@ def forward(self, image: torch.Tensor) -> torch.Tensor | InferenceBatch:
         return InferenceBatch(pred_score=pred_score, anomaly_map=anomaly_map)
 
     def encode(self, features: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
-        """Return"""
+        """Encode input features to latent space using normalizing flow.
+
+        Args:
+            features (torch.Tensor): Input features from feature extractor.
+
+        Returns:
+            tuple[torch.Tensor, torch.Tensor]: Tuple containing:
+                - Latent variables from flow transformation
+                - Log-Jacobian determinant of the transformation
+        """
         z, ljd = self.flow(features, rev=False)
         if len(self.feature_extractor.scales) == 1:
             z = [z]
diff --git a/src/anomalib/models/image/vlm_ad/__init__.py b/src/anomalib/models/image/vlm_ad/__init__.py
index 46ab8e0fee..f13d6c46d9 100644
--- a/src/anomalib/models/image/vlm_ad/__init__.py
+++ b/src/anomalib/models/image/vlm_ad/__init__.py
@@ -1,4 +1,23 @@
-"""Visual Anomaly Model."""
+"""Vision Language Model (VLM) based Anomaly Detection.
+
+This module implements anomaly detection using Vision Language Models (VLMs) like
+GPT-4V, LLaVA, etc. The models use natural language prompting to detect anomalies
+in images by comparing them with reference normal images.
+
+Example:
+    >>> from anomalib.models.image import VlmAd
+    >>> model = VlmAd(  # doctest: +SKIP
+    ...     backend="chatgpt",
+    ...     model_name="gpt-4-vision-preview"
+    ... )
+    >>> model.fit(["normal1.jpg", "normal2.jpg"])  # doctest: +SKIP
+    >>> prediction = model.predict("test.jpg")  # doctest: +SKIP
+
+See Also:
+    - :class:`VlmAd`: Main model class for VLM-based anomaly detection
+    - :mod:`.backends`: Different VLM backend implementations
+    - :mod:`.utils`: Utility functions for prompting and responses
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/vlm_ad/backends/__init__.py b/src/anomalib/models/image/vlm_ad/backends/__init__.py
index 44009f8f83..6de26ffa24 100644
--- a/src/anomalib/models/image/vlm_ad/backends/__init__.py
+++ b/src/anomalib/models/image/vlm_ad/backends/__init__.py
@@ -1,4 +1,23 @@
-"""VLM backends."""
+"""Vision Language Model (VLM) backends for anomaly detection.
+
+This module provides backend implementations for different Vision Language Models
+(VLMs) that can be used for anomaly detection. The backends include:
+
+- :class:`ChatGPT`: OpenAI's ChatGPT model
+- :class:`Huggingface`: Models from Hugging Face Hub
+- :class:`Ollama`: Open source LLM models via Ollama
+
+Example:
+    >>> from anomalib.models.image.vlm_ad.backends import ChatGPT
+    >>> backend = ChatGPT()  # doctest: +SKIP
+    >>> response = backend.generate(prompt="Describe this image")  # doctest: +SKIP
+
+See Also:
+    - :class:`Backend`: Base class for VLM backends
+    - :class:`ChatGPT`: ChatGPT backend implementation
+    - :class:`Huggingface`: Hugging Face backend implementation
+    - :class:`Ollama`: Ollama backend implementation
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/vlm_ad/backends/base.py b/src/anomalib/models/image/vlm_ad/backends/base.py
index b4aadf9a22..37fb20d0df 100644
--- a/src/anomalib/models/image/vlm_ad/backends/base.py
+++ b/src/anomalib/models/image/vlm_ad/backends/base.py
@@ -1,4 +1,26 @@
-"""Base backend."""
+"""Base backend for Vision Language Models (VLMs).
+
+This module provides the abstract base class for VLM backends used in anomaly detection.
+The backends handle communication with different VLM services and models.
+
+Example:
+    >>> from anomalib.models.image.vlm_ad.backends import Backend
+    >>> class CustomBackend(Backend):
+    ...     def __init__(self, model_name: str) -> None:
+    ...         super().__init__(model_name)
+    ...     def add_reference_images(self, image: str) -> None:
+    ...         pass
+    ...     def predict(self, image: str, prompt: Prompt) -> str:
+    ...         return "normal"
+    ...     @property
+    ...     def num_reference_images(self) -> int:
+    ...         return 0
+
+See Also:
+    - :class:`ChatGPT`: OpenAI's ChatGPT backend implementation
+    - :class:`Huggingface`: Hugging Face models backend implementation
+    - :class:`Ollama`: Ollama models backend implementation
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,21 +32,65 @@
 
 
 class Backend(ABC):
-    """Base backend."""
+    """Abstract base class for Vision Language Model (VLM) backends.
+
+    This class defines the interface that all VLM backends must implement. Backends
+    handle communication with different VLM services and models for anomaly detection.
+
+    Example:
+        >>> from anomalib.models.image.vlm_ad.backends import Backend
+        >>> class CustomBackend(Backend):
+        ...     def __init__(self, model_name: str) -> None:
+        ...         super().__init__(model_name)
+        ...     def add_reference_images(self, image: str) -> None:
+        ...         pass
+        ...     def predict(self, image: str, prompt: Prompt) -> str:
+        ...         return "normal"
+        ...     @property
+        ...     def num_reference_images(self) -> int:
+        ...         return 0
+
+    See Also:
+        - :class:`ChatGPT`: OpenAI's ChatGPT backend implementation
+        - :class:`Huggingface`: Hugging Face models backend implementation
+        - :class:`Ollama`: Ollama models backend implementation
+    """
 
     @abstractmethod
     def __init__(self, model_name: str) -> None:
-        """Initialize the backend."""
+        """Initialize the VLM backend.
+
+        Args:
+            model_name (str): Name or identifier of the VLM model to use
+        """
 
     @abstractmethod
     def add_reference_images(self, image: str | Path) -> None:
-        """Add reference images for k-shot."""
+        """Add reference images for few-shot learning.
+
+        The backend stores these images to use as examples when making predictions.
+
+        Args:
+            image (str | Path): Path to the reference image file
+        """
 
     @abstractmethod
     def predict(self, image: str | Path, prompt: Prompt) -> str:
-        """Predict the anomaly label."""
+        """Predict whether an image contains anomalies.
+
+        Args:
+            image (str | Path): Path to the image file to analyze
+            prompt (Prompt): Prompt template to use for querying the VLM
+
+        Returns:
+            str: Prediction result from the VLM
+        """
 
     @property
     @abstractmethod
     def num_reference_images(self) -> int:
-        """Get the number of reference images."""
+        """Get the number of stored reference images.
+
+        Returns:
+            int: Count of reference images currently stored in the backend
+        """
diff --git a/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py b/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py
index 53648e688a..e81c1a2d63 100644
--- a/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py
+++ b/src/anomalib/models/image/vlm_ad/backends/chat_gpt.py
@@ -1,4 +1,29 @@
-"""ChatGPT backend."""
+"""ChatGPT backend for Vision Language Models (VLMs).
+
+This module implements a backend for using OpenAI's ChatGPT model for vision-language
+tasks in anomaly detection. The backend handles:
+
+- Authentication with OpenAI API
+- Encoding and sending images
+- Prompting the model
+- Processing responses
+
+Example:
+    >>> from anomalib.models.image.vlm_ad.backends import ChatGPT
+    >>> backend = ChatGPT(model_name="gpt-4-vision-preview")  # doctest: +SKIP
+    >>> backend.add_reference_images("normal_image.jpg")  # doctest: +SKIP
+    >>> response = backend.predict("test.jpg", prompt)  # doctest: +SKIP
+
+Args:
+    model_name (str): Name of the ChatGPT model to use (e.g. ``"gpt-4-vision-preview"``)
+    api_key (str | None, optional): OpenAI API key. If not provided, will attempt to
+        load from environment. Defaults to ``None``.
+
+See Also:
+    - :class:`Backend`: Base class for VLM backends
+    - :class:`Huggingface`: Alternative backend using Hugging Face models
+    - :class:`Ollama`: Alternative backend using Ollama models
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -28,7 +53,37 @@
 
 
 class ChatGPT(Backend):
-    """ChatGPT backend."""
+    """OpenAI ChatGPT backend for vision-language anomaly detection.
+
+    This class implements a backend for using OpenAI's ChatGPT models with vision
+    capabilities (e.g. GPT-4V) for anomaly detection. It handles:
+
+    - Authentication with OpenAI API
+    - Image encoding and formatting
+    - Few-shot learning with reference images
+    - Model prompting and response processing
+
+    Args:
+        model_name (str): Name of the ChatGPT model to use (e.g.
+            ``"gpt-4-vision-preview"``)
+        api_key (str | None, optional): OpenAI API key. If not provided, will
+            attempt to load from environment. Defaults to ``None``.
+
+    Example:
+        >>> from anomalib.models.image.vlm_ad.backends import ChatGPT
+        >>> backend = ChatGPT(model_name="gpt-4-vision-preview")  # doctest: +SKIP
+        >>> backend.add_reference_images("normal_image.jpg")  # doctest: +SKIP
+        >>> response = backend.predict("test.jpg", prompt)  # doctest: +SKIP
+
+    Raises:
+        ImportError: If OpenAI package is not installed
+        ValueError: If no API key is provided or found in environment
+
+    See Also:
+        - :class:`Backend`: Base class for VLM backends
+        - :class:`Huggingface`: Alternative backend using Hugging Face models
+        - :class:`Ollama`: Alternative backend using Ollama models
+    """
 
     def __init__(self, model_name: str, api_key: str | None = None) -> None:
         """Initialize the ChatGPT backend."""
@@ -39,7 +94,14 @@ def __init__(self, model_name: str, api_key: str | None = None) -> None:
 
     @property
     def client(self) -> OpenAI:
-        """Get the OpenAI client."""
+        """Get the OpenAI client.
+
+        Returns:
+            OpenAI: Initialized OpenAI client instance
+
+        Raises:
+            ImportError: If OpenAI package is not installed
+        """
         if OpenAI is None:
             msg = "OpenAI is not installed. Please install it to use ChatGPT backend."
             raise ImportError(msg)
@@ -48,16 +110,33 @@ def client(self) -> OpenAI:
         return self._client
 
     def add_reference_images(self, image: str | Path) -> None:
-        """Add reference images for k-shot."""
+        """Add reference images for few-shot learning.
+
+        Args:
+            image (str | Path): Path to the reference image file
+        """
         self._ref_images_encoded.append(self._encode_image_to_url(image))
 
     @property
     def num_reference_images(self) -> int:
-        """Get the number of reference images."""
+        """Get the number of reference images.
+
+        Returns:
+            int: Number of reference images added for few-shot learning
+        """
         return len(self._ref_images_encoded)
 
     def predict(self, image: str | Path, prompt: Prompt) -> str:
-        """Predict the anomaly label."""
+        """Predict whether an image contains anomalies.
+
+        Args:
+            image (str | Path): Path to the image file to analyze
+            prompt (Prompt): Prompt object containing few-shot and prediction
+                prompts
+
+        Returns:
+            str: Model's response indicating if anomalies were detected
+        """
         image_encoded = self._encode_image_to_url(image)
         messages = []
 
@@ -72,7 +151,15 @@ def predict(self, image: str | Path, prompt: Prompt) -> str:
 
     @staticmethod
     def _generate_message(content: str, images: list[str] | None) -> dict:
-        """Generate a message."""
+        """Generate a message for the ChatGPT API.
+
+        Args:
+            content (str): Text content of the message
+            images (list[str] | None): List of base64-encoded image URLs
+
+        Returns:
+            dict: Formatted message dictionary for the API
+        """
         message: dict[str, list[dict] | str] = {"role": "user"}
         if images is not None:
             _content: list[dict[str, str | dict]] = [{"type": "text", "text": content}]
@@ -83,7 +170,14 @@ def _generate_message(content: str, images: list[str] | None) -> dict:
         return message
 
     def _encode_image_to_url(self, image: str | Path) -> str:
-        """Encode the image to base64 and embed in url string."""
+        """Encode an image file to a base64 URL string.
+
+        Args:
+            image (str | Path): Path to the image file
+
+        Returns:
+            str: Base64-encoded image URL string
+        """
         image_path = Path(image)
         extension = image_path.suffix
         base64_encoded = self._encode_image_to_base_64(image_path)
@@ -91,11 +185,35 @@ def _encode_image_to_url(self, image: str | Path) -> str:
 
     @staticmethod
     def _encode_image_to_base_64(image: str | Path) -> str:
-        """Encode the image to base64."""
+        """Encode an image file to base64.
+
+        Args:
+            image (str | Path): Path to the image file
+
+        Returns:
+            str: Base64-encoded image string
+        """
         image = Path(image)
         return base64.b64encode(image.read_bytes()).decode("utf-8")
 
     def _get_api_key(self, api_key: str | None = None) -> str:
+        """Get the OpenAI API key.
+
+        Attempts to get the API key in the following order:
+        1. From the provided argument
+        2. From environment variable ``OPENAI_API_KEY``
+        3. From ``.env`` file
+
+        Args:
+            api_key (str | None, optional): API key provided directly. Defaults to
+                ``None``.
+
+        Returns:
+            str: Valid OpenAI API key
+
+        Raises:
+            ValueError: If no API key is found
+        """
         if api_key is None:
             load_dotenv()
             api_key = os.getenv("OPENAI_API_KEY")
diff --git a/src/anomalib/models/image/vlm_ad/backends/huggingface.py b/src/anomalib/models/image/vlm_ad/backends/huggingface.py
index e8d3c1e84b..9e427b6965 100644
--- a/src/anomalib/models/image/vlm_ad/backends/huggingface.py
+++ b/src/anomalib/models/image/vlm_ad/backends/huggingface.py
@@ -1,4 +1,28 @@
-"""Huggingface backend."""
+"""Hugging Face backend for Vision Language Models (VLMs).
+
+This module implements a backend for using Hugging Face models for vision-language
+tasks in anomaly detection. The backend handles:
+
+- Loading models and processors from Hugging Face Hub
+- Processing images into model inputs
+- Few-shot learning with reference images
+- Model inference and response processing
+
+Example:
+    >>> from anomalib.models.image.vlm_ad.backends import Huggingface
+    >>> backend = Huggingface(model_name="llava-hf/llava-1.5-7b-hf")  # doctest: +SKIP
+    >>> backend.add_reference_images("normal_image.jpg")  # doctest: +SKIP
+    >>> response = backend.predict("test.jpg", prompt)  # doctest: +SKIP
+
+Args:
+    model_name (str): Name of the Hugging Face model to use (e.g.
+        ``"llava-hf/llava-1.5-7b-hf"``)
+
+See Also:
+    - :class:`Backend`: Base class for VLM backends
+    - :class:`ChatGPT`: Alternative backend using OpenAI models
+    - :class:`Ollama`: Alternative backend using Ollama models
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -28,13 +52,46 @@
 
 
 class Huggingface(Backend):
-    """Huggingface backend."""
+    """Hugging Face backend for vision-language anomaly detection.
+
+    This class implements a backend for using Hugging Face vision-language models for
+    anomaly detection. It handles:
+
+    - Loading models and processors from Hugging Face Hub
+    - Processing images into model inputs
+    - Few-shot learning with reference images
+    - Model inference and response processing
+
+    Args:
+        model_name (str): Name of the Hugging Face model to use (e.g.
+            ``"llava-hf/llava-1.5-7b-hf"``)
+
+    Example:
+        >>> from anomalib.models.image.vlm_ad.backends import Huggingface
+        >>> backend = Huggingface(  # doctest: +SKIP
+        ...     model_name="llava-hf/llava-1.5-7b-hf"
+        ... )
+        >>> backend.add_reference_images("normal_image.jpg")  # doctest: +SKIP
+        >>> response = backend.predict("test.jpg", prompt)  # doctest: +SKIP
+
+    Raises:
+        ValueError: If transformers package is not installed
+
+    See Also:
+        - :class:`Backend`: Base class for VLM backends
+        - :class:`ChatGPT`: Alternative backend using OpenAI models
+        - :class:`Ollama`: Alternative backend using Ollama models
+    """
 
     def __init__(
         self,
         model_name: str,
     ) -> None:
-        """Initialize the Huggingface backend."""
+        """Initialize the Huggingface backend.
+
+        Args:
+            model_name (str): Name of the Hugging Face model to use
+        """
         self.model_name: str = model_name
         self._ref_images: list[str] = []
         self._processor: ProcessorMixin | None = None
@@ -42,7 +99,14 @@ def __init__(
 
     @property
     def processor(self) -> "ProcessorMixin":
-        """Get the Huggingface processor."""
+        """Get the Hugging Face processor.
+
+        Returns:
+            ProcessorMixin: Initialized processor for the model
+
+        Raises:
+            ValueError: If transformers package is not installed
+        """
         if self._processor is None:
             if transformers is None:
                 msg = "transformers is not installed."
@@ -52,7 +116,14 @@ def processor(self) -> "ProcessorMixin":
 
     @property
     def model(self) -> "PreTrainedModel":
-        """Get the Huggingface model."""
+        """Get the Hugging Face model.
+
+        Returns:
+            PreTrainedModel: Initialized model instance
+
+        Raises:
+            ValueError: If transformers package is not installed
+        """
         if self._model is None:
             if transformers is None:
                 msg = "transformers is not installed."
@@ -62,7 +133,15 @@ def model(self) -> "PreTrainedModel":
 
     @staticmethod
     def _generate_message(content: str, images: list[str] | None) -> dict:
-        """Generate a message."""
+        """Generate a message for the model.
+
+        Args:
+            content (str): Text content of the message
+            images (list[str] | None): List of image paths to include in message
+
+        Returns:
+            dict: Formatted message dictionary with role and content
+        """
         message: dict[str, str | list[dict]] = {"role": "user"}
         _content: list[dict[str, str]] = [{"type": "text", "text": content}]
         if images is not None:
@@ -71,16 +150,32 @@ def _generate_message(content: str, images: list[str] | None) -> dict:
         return message
 
     def add_reference_images(self, image: str | Path) -> None:
-        """Add reference images for k-shot."""
+        """Add reference images for few-shot learning.
+
+        Args:
+            image (str | Path): Path to the reference image file
+        """
         self._ref_images.append(Image.open(image))
 
     @property
     def num_reference_images(self) -> int:
-        """Get the number of reference images."""
+        """Get the number of reference images.
+
+        Returns:
+            int: Number of reference images added
+        """
         return len(self._ref_images)
 
     def predict(self, image_path: str | Path, prompt: Prompt) -> str:
-        """Predict the anomaly label."""
+        """Predict whether an image contains anomalies.
+
+        Args:
+            image_path (str | Path): Path to the image to analyze
+            prompt (Prompt): Prompt object containing few-shot and prediction prompts
+
+        Returns:
+            str: Model's prediction response
+        """
         image = Image.open(image_path)
         messages: list[dict] = []
 
@@ -93,6 +188,4 @@ def predict(self, image_path: str | Path, prompt: Prompt) -> str:
         images = [*self._ref_images, image]
         inputs = self.processor(images, processed_prompt, return_tensors="pt", padding=True).to(self.model.device)
         outputs = self.model.generate(**inputs, max_new_tokens=100)
-        result = self.processor.decode(outputs[0], skip_special_tokens=True)
-        print(result)
-        return result
+        return self.processor.decode(outputs[0], skip_special_tokens=True)
diff --git a/src/anomalib/models/image/vlm_ad/backends/ollama.py b/src/anomalib/models/image/vlm_ad/backends/ollama.py
index ff680bee3b..4c712cdba8 100644
--- a/src/anomalib/models/image/vlm_ad/backends/ollama.py
+++ b/src/anomalib/models/image/vlm_ad/backends/ollama.py
@@ -1,9 +1,34 @@
-"""Ollama backend.
+"""Ollama backend for Vision Language Models (VLMs).
 
-Assumes that the Ollama service is running in the background.
-See: https://github.com/ollama/ollama
-Ensure that ollama is running. On linux: `ollama serve`
-On Mac and Windows ensure that the ollama service is running by launching from the application list.
+This module implements a backend for using Ollama models for vision-language tasks in
+anomaly detection. The backend handles:
+
+- Communication with local Ollama service
+- Image encoding and formatting
+- Few-shot learning with reference images
+- Model inference and response processing
+
+Example:
+    >>> from anomalib.models.image.vlm_ad.backends import Ollama
+    >>> backend = Ollama(model_name="llava")  # doctest: +SKIP
+    >>> backend.add_reference_images("normal_image.jpg")  # doctest: +SKIP
+    >>> response = backend.predict("test.jpg", prompt)  # doctest: +SKIP
+
+Note:
+    Requires Ollama service to be running in the background:
+
+    - Linux: Run ``ollama serve``
+    - Mac/Windows: Launch Ollama application from applications list
+
+    See `Ollama documentation `_ for setup details.
+
+Args:
+    model_name (str): Name of the Ollama model to use (e.g. ``"llava"``)
+
+See Also:
+    - :class:`Backend`: Base class for VLM backends
+    - :class:`ChatGPT`: Alternative backend using OpenAI models
+    - :class:`Huggingface`: Alternative backend using Hugging Face models
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -28,32 +53,94 @@
 
 
 class Ollama(Backend):
-    """Ollama backend."""
+    """Ollama backend for vision-language anomaly detection.
+
+    This class implements a backend for using Ollama models with vision capabilities
+    for anomaly detection. It handles:
+
+    - Communication with local Ollama service
+    - Image encoding and formatting
+    - Few-shot learning with reference images
+    - Model inference and response processing
+
+    Args:
+        model_name (str): Name of the Ollama model to use (e.g. ``"llava"``)
+
+    Example:
+        >>> from anomalib.models.image.vlm_ad.backends import Ollama
+        >>> backend = Ollama(model_name="llava")  # doctest: +SKIP
+        >>> backend.add_reference_images("normal_image.jpg")  # doctest: +SKIP
+        >>> response = backend.predict("test.jpg", prompt)  # doctest: +SKIP
+
+    Note:
+        Requires Ollama service to be running in the background:
+
+        - Linux: Run ``ollama serve``
+        - Mac/Windows: Launch Ollama application from applications list
+
+    See Also:
+        - :class:`Backend`: Base class for VLM backends
+        - :class:`ChatGPT`: Alternative backend using OpenAI models
+        - :class:`Huggingface`: Alternative backend using Hugging Face models
+    """
 
     def __init__(self, model_name: str) -> None:
-        """Initialize the Ollama backend."""
+        """Initialize the Ollama backend.
+
+        Args:
+            model_name (str): Name of the Ollama model to use
+        """
         self.model_name: str = model_name
         self._ref_images_encoded: list[str] = []
 
     def add_reference_images(self, image: str | Path) -> None:
-        """Encode the image to base64."""
+        """Add and encode reference images for few-shot learning.
+
+        The images are encoded to base64 format for sending to the Ollama service.
+
+        Args:
+            image (str | Path): Path to the reference image file
+        """
         self._ref_images_encoded.append(_encode_image(image))
 
     @property
     def num_reference_images(self) -> int:
-        """Get the number of reference images."""
+        """Get the number of reference images.
+
+        Returns:
+            int: Number of reference images added
+        """
         return len(self._ref_images_encoded)
 
     @staticmethod
     def _generate_message(content: str, images: list[str] | None) -> dict:
-        """Generate a message."""
+        """Generate a message for the Ollama chat API.
+
+        Args:
+            content (str): Text content of the message
+            images (list[str] | None): List of base64 encoded images to include
+
+        Returns:
+            dict: Formatted message dictionary with role, content and optional images
+        """
         message: dict[str, str | list[str]] = {"role": "user", "content": content}
         if images:
             message["images"] = images
         return message
 
     def predict(self, image: str | Path, prompt: Prompt) -> str:
-        """Predict the anomaly label."""
+        """Predict whether an image contains anomalies.
+
+        Args:
+            image (str | Path): Path to the image to analyze
+            prompt (Prompt): Prompt object containing few-shot and prediction prompts
+
+        Returns:
+            str: Model's prediction response
+
+        Raises:
+            ImportError: If Ollama package is not installed
+        """
         if not chat:
             msg = "Ollama is not installed. Please install it using `pip install ollama`."
             raise ImportError(msg)
diff --git a/src/anomalib/models/image/vlm_ad/lightning_model.py b/src/anomalib/models/image/vlm_ad/lightning_model.py
index 7340474f29..92a52a7c75 100644
--- a/src/anomalib/models/image/vlm_ad/lightning_model.py
+++ b/src/anomalib/models/image/vlm_ad/lightning_model.py
@@ -1,4 +1,29 @@
-"""Visual Anomaly Model for Zero/Few-Shot Anomaly Classification."""
+"""Vision Language Model (VLM) based Anomaly Detection.
+
+This module implements anomaly detection using Vision Language Models (VLMs) like
+GPT-4V, LLaVA, etc. The models use natural language prompting to detect anomalies
+in images by comparing them with reference normal images.
+
+The module supports both zero-shot and few-shot learning approaches:
+
+- Zero-shot: No reference images needed
+- Few-shot: Uses ``k`` reference normal images for better context
+
+Example:
+    >>> from anomalib.models.image import VlmAd
+    >>> model = VlmAd(  # doctest: +SKIP
+    ...     model="gpt-4-vision-preview",
+    ...     api_key="YOUR_API_KEY",
+    ...     k_shot=3
+    ... )
+    >>> model.fit(["normal1.jpg", "normal2.jpg"])  # doctest: +SKIP
+    >>> prediction = model.predict("test.jpg")  # doctest: +SKIP
+
+See Also:
+    - :class:`VlmAd`: Main model class for VLM-based anomaly detection
+    - :mod:`.backends`: Different VLM backend implementations
+    - :mod:`.utils`: Utility functions for prompting and responses
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -21,7 +46,41 @@
 
 
 class VlmAd(AnomalibModule):
-    """Visual anomaly model."""
+    """Vision Language Model (VLM) based anomaly detection model.
+
+    This model uses VLMs like GPT-4V, LLaVA, etc. to detect anomalies in images by
+    comparing them with reference normal images through natural language prompting.
+
+    Args:
+        model (ModelName | str): Name of the VLM model to use. Can be one of:
+            - ``ModelName.LLAMA_OLLAMA``
+            - ``ModelName.GPT_4O_MINI``
+            - ``ModelName.VICUNA_7B_HF``
+            - ``ModelName.VICUNA_13B_HF``
+            - ``ModelName.MISTRAL_7B_HF``
+            Defaults to ``ModelName.LLAMA_OLLAMA``.
+        api_key (str | None, optional): API key for models that require
+            authentication. Defaults to None.
+        k_shot (int, optional): Number of reference normal images to use for
+            few-shot learning. If 0, uses zero-shot approach. Defaults to 0.
+
+    Example:
+        >>> from anomalib.models.image import VlmAd
+        >>> # Zero-shot approach
+        >>> model = VlmAd(  # doctest: +SKIP
+        ...     model="gpt-4-vision-preview",
+        ...     api_key="YOUR_API_KEY"
+        ... )
+        >>> # Few-shot approach with 3 reference images
+        >>> model = VlmAd(  # doctest: +SKIP
+        ...     model="gpt-4-vision-preview",
+        ...     api_key="YOUR_API_KEY",
+        ...     k_shot=3
+        ... )
+
+    Raises:
+        ValueError: If an unsupported VLM model is specified.
+    """
 
     def __init__(
         self,
@@ -53,7 +112,12 @@ def _setup(self) -> None:
             self.collect_reference_images(dataloader)
 
     def collect_reference_images(self, dataloader: DataLoader) -> None:
-        """Collect reference images for few-shot inference."""
+        """Collect reference images for few-shot inference.
+
+        Args:
+            dataloader (DataLoader): DataLoader containing normal images for
+                reference.
+        """
         for batch in dataloader:
             for img_path in batch.image_path:
                 self.vlm_backend.add_reference_images(img_path)
@@ -62,7 +126,11 @@ def collect_reference_images(self, dataloader: DataLoader) -> None:
 
     @property
     def prompt(self) -> Prompt:
-        """Get the prompt."""
+        """Get the prompt for VLM interaction.
+
+        Returns:
+            Prompt: Object containing prompts for prediction and few-shot learning.
+        """
         return Prompt(
             predict=(
                 "You are given an image. It is either normal or anomalous."
@@ -78,7 +146,16 @@ def prompt(self) -> Prompt:
         )
 
     def validation_step(self, batch: ImageBatch, *args, **kwargs) -> ImageBatch:
-        """Validation step."""
+        """Perform validation step.
+
+        Args:
+            batch (ImageBatch): Batch of images to validate.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+
+        Returns:
+            ImageBatch: Batch with predictions and explanations added.
+        """
         del args, kwargs  # These variables are not used.
         assert batch.image_path is not None
         responses = [(self.vlm_backend.predict(img_path, self.prompt)) for img_path in batch.image_path]
@@ -88,30 +165,48 @@ def validation_step(self, batch: ImageBatch, *args, **kwargs) -> ImageBatch:
 
     @property
     def learning_type(self) -> LearningType:
-        """The learning type of the model."""
+        """Get the learning type of the model.
+
+        Returns:
+            LearningType: ZERO_SHOT if k_shot=0, else FEW_SHOT.
+        """
         return LearningType.ZERO_SHOT if self.k_shot == 0 else LearningType.FEW_SHOT
 
     @property
     def trainer_arguments(self) -> dict[str, int | float]:
-        """Doesn't need training."""
+        """Get trainer arguments.
+
+        Returns:
+            dict[str, int | float]: Empty dict as no training is needed.
+        """
         return {}
 
     @staticmethod
     def configure_transforms(image_size: tuple[int, int] | None = None) -> None:
-        """This modes does not require any transforms."""
+        """Configure image transforms.
+
+        Args:
+            image_size (tuple[int, int] | None, optional): Ignored as each backend
+                has its own transforms. Defaults to None.
+        """
         if image_size is not None:
             logger.warning("Ignoring image_size argument as each backend has its own transforms.")
 
     @classmethod
     def configure_post_processor(cls) -> PostProcessor | None:
-        """Post processing is not required for this model."""
+        """Configure post processor.
+
+        Returns:
+            PostProcessor | None: None as post processing is not required.
+        """
         return None
 
     @staticmethod
     def configure_evaluator() -> Evaluator:
-        """Default evaluator.
+        """Configure default evaluator.
 
-        Override in subclass for model-specific evaluator behaviour.
+        Returns:
+            Evaluator: Evaluator configured with F1Score metric.
         """
         image_f1score = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
         return Evaluator(test_metrics=image_f1score)
diff --git a/src/anomalib/models/image/vlm_ad/utils.py b/src/anomalib/models/image/vlm_ad/utils.py
index ce9b9067ac..dec6f05327 100644
--- a/src/anomalib/models/image/vlm_ad/utils.py
+++ b/src/anomalib/models/image/vlm_ad/utils.py
@@ -1,4 +1,22 @@
-"""Dataclasses."""
+"""Utility classes and functions for Vision Language Model (VLM) based anomaly detection.
+
+This module provides utility classes for VLM-based anomaly detection:
+
+- :class:`Prompt`: Dataclass for storing few-shot and prediction prompts
+- :class:`ModelName`: Enum of supported VLM models
+
+Example:
+    >>> from anomalib.models.image.vlm_ad.utils import Prompt, ModelName
+    >>> prompt = Prompt(  # doctest: +SKIP
+    ...     few_shot="These are normal examples...",
+    ...     predict="Is this image normal or anomalous?"
+    ... )
+    >>> model_name = ModelName.LLAMA_OLLAMA  # doctest: +SKIP
+
+See Also:
+    - :class:`VlmAd`: Main model class using these utilities
+    - :mod:`.backends`: VLM backend implementations using these utilities
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -9,14 +27,56 @@
 
 @dataclass
 class Prompt:
-    """Prompt."""
+    """Dataclass for storing prompts used in VLM-based anomaly detection.
+
+    This class stores two types of prompts used when querying vision language models:
+
+    - Few-shot prompt: Used to provide context about normal examples
+    - Prediction prompt: Used to query about a specific test image
+
+    Args:
+        few_shot (str): Prompt template for few-shot learning with reference normal
+            images. Used to establish context about what constitutes normal.
+        predict (str): Prompt template for querying about test images. Used to ask
+            the model whether a given image contains anomalies.
+
+    Example:
+        >>> from anomalib.models.image.vlm_ad.utils import Prompt
+        >>> prompt = Prompt(  # doctest: +SKIP
+        ...     few_shot="Here are some examples of normal items...",
+        ...     predict="Is this image normal or does it contain defects?"
+        ... )
+
+    See Also:
+        - :class:`VlmAd`: Main model class using these prompts
+        - :mod:`.backends`: VLM backend implementations using these prompts
+    """
 
     few_shot: str
     predict: str
 
 
 class ModelName(Enum):
-    """List of supported models."""
+    """Enumeration of supported Vision Language Models (VLMs).
+
+    This enum defines the available VLM models that can be used for anomaly detection:
+
+    - ``LLAMA_OLLAMA``: LLaVA model running via Ollama
+    - ``GPT_4O_MINI``: GPT-4O Mini model
+    - ``VICUNA_7B_HF``: LLaVA v1.6 with Vicuna 7B base from Hugging Face
+    - ``VICUNA_13B_HF``: LLaVA v1.6 with Vicuna 13B base from Hugging Face
+    - ``MISTRAL_7B_HF``: LLaVA v1.6 with Mistral 7B base from Hugging Face
+
+    Example:
+        >>> from anomalib.models.image.vlm_ad.utils import ModelName
+        >>> model_name = ModelName.LLAMA_OLLAMA  # doctest: +SKIP
+        >>> model_name.value
+        'llava'
+
+    See Also:
+        - :class:`VlmAd`: Main model class using these model options
+        - :mod:`.backends`: Backend implementations for different models
+    """
 
     LLAMA_OLLAMA = "llava"
     GPT_4O_MINI = "gpt-4o-mini"
diff --git a/src/anomalib/models/image/winclip/__init__.py b/src/anomalib/models/image/winclip/__init__.py
index 8435a3c1aa..86f2b72691 100644
--- a/src/anomalib/models/image/winclip/__init__.py
+++ b/src/anomalib/models/image/winclip/__init__.py
@@ -1,4 +1,18 @@
-"""WinCLIP Model."""
+"""WinCLIP Model for anomaly detection.
+
+This module implements anomaly detection using the WinCLIP model, which leverages
+CLIP embeddings and a sliding window approach to detect anomalies in images.
+
+Example:
+    >>> from anomalib.models.image import WinClip
+    >>> model = WinClip()  # doctest: +SKIP
+    >>> model.fit(["normal1.jpg", "normal2.jpg"])  # doctest: +SKIP
+    >>> prediction = model.predict("test.jpg")  # doctest: +SKIP
+
+See Also:
+    - :class:`WinClip`: Main model class for WinCLIP-based anomaly detection
+    - :class:`WinClipModel`: PyTorch implementation of the WinCLIP model
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index 23a7cf23a1..e078f60e50 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -1,6 +1,28 @@
 """WinCLIP: Zero-/Few-Shot Anomaly Classification and Segmentation.
 
-Paper https://arxiv.org/abs/2303.14814
+This module implements the WinCLIP model for zero-shot and few-shot anomaly
+detection using CLIP embeddings and a sliding window approach.
+
+The model can perform both anomaly classification and segmentation tasks by
+comparing image regions with normal reference examples through CLIP embeddings.
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.engine import Engine
+    >>> from anomalib.models.image import WinClip
+
+    >>> datamodule = MVTec(root="./datasets/MVTec")  # doctest: +SKIP
+    >>> model = WinClip()  # doctest: +SKIP
+
+    >>> Engine.test(model=model, datamodule=datamodule)  # doctest: +SKIP
+
+Paper:
+    WinCLIP: Zero-/Few-Shot Anomaly Classification and Segmentation
+    https://arxiv.org/abs/2303.14814
+
+See Also:
+    - :class:`WinClip`: Main model class for WinCLIP-based anomaly detection
+    - :class:`WinClipModel`: PyTorch implementation of the WinCLIP model
 """
 
 # Copyright (C) 2024 Intel Corporation
@@ -34,18 +56,49 @@
 class WinClip(AnomalibModule):
     """WinCLIP Lightning model.
 
+    This model implements the WinCLIP algorithm for zero-/few-shot anomaly detection using CLIP
+    embeddings and a sliding window approach. The model can perform both anomaly classification
+    and segmentation by comparing image regions with normal reference examples.
+
     Args:
-        class_name (str, optional): The name of the object class used in the prompt ensemble.
-            Defaults to ``None``.
-        k_shot (int): The number of reference images for few-shot inference.
-            Defaults to ``0``.
-        scales (tuple[int], optional): The scales of the sliding windows used for multiscale anomaly detection.
-            Defaults to ``(2, 3)``.
-        few_shot_source (str | Path, optional): Path to a folder of reference images used for few-shot inference.
-            Defaults to ``None``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        class_name (str | None, optional): Name of the object class used in the prompt
+            ensemble. If not provided, will try to infer from the datamodule or use "object"
+            as default. Defaults to ``None``.
+        k_shot (int, optional): Number of reference images to use for few-shot inference.
+            If 0, uses zero-shot approach. Defaults to ``0``.
+        scales (tuple[int], optional): Scales of sliding windows used for multiscale anomaly
+            detection. Defaults to ``(2, 3)``.
+        few_shot_source (str | Path | None, optional): Path to folder containing reference
+            images for few-shot inference. If not provided, reference images are sampled from
+            training data. Defaults to ``None``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor instance or flag to use
+            default. Used to pre-process input data before model inference. Defaults to
+            ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor instance or flag to
+            use default. Used to post-process model predictions. Defaults to ``True``.
+        evaluator (Evaluator | bool, optional): Evaluator instance or flag to use default.
+            Used to compute metrics. Defaults to ``True``.
+        visualizer (Visualizer | bool, optional): Visualizer instance or flag to use default.
+            Used to create visualizations. Defaults to ``True``.
+
+    Example:
+        >>> from anomalib.models.image import WinClip
+        >>> # Zero-shot approach
+        >>> model = WinClip()  # doctest: +SKIP
+        >>> # Few-shot with 5 reference images
+        >>> model = WinClip(k_shot=5)  # doctest: +SKIP
+        >>> # Custom class name
+        >>> model = WinClip(class_name="transistor")  # doctest: +SKIP
+
+    Notes:
+        - The model automatically excludes CLIP backbone parameters from checkpoints to
+          reduce size
+        - Input image size is fixed at 240x240 and cannot be modified
+        - Uses a custom normalization transform specific to CLIP
+
+    See Also:
+        - :class:`WinClipModel`: PyTorch implementation of the core model
+        - :class:`OneClassPostProcessor`: Default post-processor used by WinCLIP
     """
 
     EXCLUDE_FROM_STATE_DICT = frozenset({"model.clip"})
@@ -74,13 +127,15 @@ def __init__(
         self.few_shot_source = Path(few_shot_source) if few_shot_source else None
 
     def _setup(self) -> None:
-        """Setup WinCLIP.
+        """Setup WinCLIP model.
 
-        - Set the class name used in the prompt ensemble.
-        - Collect text embeddings for zero-shot inference.
-        - Collect reference images for few-shot inference.
+        This method:
+        - Sets the class name used in the prompt ensemble
+        - Collects text embeddings for zero-shot inference
+        - Collects reference images for few-shot inference if ``k_shot > 0``
 
-        We need to pass the device because this hook is called before the model is moved to the device.
+        Note:
+            This hook is called before the model is moved to the target device.
         """
         # get class name
         self.class_name = self._get_class_name()
@@ -105,12 +160,15 @@ def _setup(self) -> None:
         self.model.setup(self.class_name, ref_images)
 
     def _get_class_name(self) -> str:
-        """Set the class name used in the prompt ensemble.
+        """Get the class name used in the prompt ensemble.
 
-        - When a class name is provided by the user, it is used.
-        - When the user did not provide a class name, the category name from the datamodule is used, if available.
-        - When the user did not provide a class name and the datamodule does not have a category name, the default
-            class name "object" is used.
+        The class name is determined in the following order:
+        1. Use class name provided in initialization
+        2. Use category name from datamodule if available
+        3. Use default value "object"
+
+        Returns:
+            str: Class name to use in prompts
         """
         if self.class_name is not None:
             logger.info("Using class name from init args: %s", self.class_name)
@@ -124,11 +182,14 @@ class name "object" is used.
     def collect_reference_images(self, dataloader: DataLoader) -> torch.Tensor:
         """Collect reference images for few-shot inference.
 
-        The reference images are collected by iterating the training dataset until the required number of images are
-        collected.
+        Iterates through the training dataset until the required number of reference images
+        (specified by ``k_shot``) are collected.
+
+        Args:
+            dataloader (DataLoader): DataLoader to collect reference images from
 
         Returns:
-            ref_images (Tensor): A tensor containing the reference images.
+            torch.Tensor: Tensor containing the collected reference images
         """
         ref_images = torch.Tensor()
         for batch in dataloader:
@@ -140,34 +201,56 @@ def collect_reference_images(self, dataloader: DataLoader) -> torch.Tensor:
 
     @staticmethod
     def configure_optimizers() -> None:
-        """WinCLIP doesn't require optimization, therefore returns no optimizers."""
+        """Configure optimizers.
+
+        WinCLIP doesn't require optimization, therefore returns no optimizers.
+        """
         return
 
     def validation_step(self, batch: Batch, *args, **kwargs) -> dict:
-        """Validation Step of WinCLIP."""
+        """Validation Step of WinCLIP.
+
+        Args:
+            batch (Batch): Input batch
+            *args: Variable length argument list
+            **kwargs: Arbitrary keyword arguments
+
+        Returns:
+            dict: Dictionary containing the batch updated with predictions
+        """
         del args, kwargs  # These variables are not used.
         predictions = self.model(batch.image)
         return batch.update(**predictions._asdict())
 
     @property
     def trainer_arguments(self) -> dict[str, int | float]:
-        """Set model-specific trainer arguments."""
+        """Get model-specific trainer arguments.
+
+        Returns:
+            dict[str, int | float]: Empty dictionary as WinCLIP needs no special arguments
+        """
         return {}
 
     @property
     def learning_type(self) -> LearningType:
-        """The learning type of the model.
+        """Get the learning type of the model.
 
-        WinCLIP is a zero-/few-shot model, depending on the user configuration. Therefore, the learning type is
-        set to ``LearningType.FEW_SHOT`` when ``k_shot`` is greater than zero and ``LearningType.ZERO_SHOT`` otherwise.
+        Returns:
+            LearningType: ``LearningType.FEW_SHOT`` if ``k_shot > 0``, else
+                ``LearningType.ZERO_SHOT``
         """
         return LearningType.FEW_SHOT if self.k_shot else LearningType.ZERO_SHOT
 
     def state_dict(self, **kwargs) -> OrderedDict[str, Any]:
-        """Return the state dict of the model.
+        """Get the state dict of the model.
+
+        Removes parameters of the frozen backbone to reduce checkpoint size.
 
-        Before returning the state dict, we remove the parameters of the frozen backbone to reduce the size of the
-        checkpoint.
+        Args:
+            **kwargs: Additional arguments to pass to parent's state_dict
+
+        Returns:
+            OrderedDict[str, Any]: State dict with backbone parameters removed
         """
         state_dict = super().state_dict(**kwargs)
         for pattern in self.EXCLUDE_FROM_STATE_DICT:
@@ -179,8 +262,16 @@ def state_dict(self, **kwargs) -> OrderedDict[str, Any]:
     def load_state_dict(self, state_dict: OrderedDict[str, Any], strict: bool = True) -> Any:  # noqa: ANN401
         """Load the state dict of the model.
 
-        Before loading the state dict, we restore the parameters of the frozen backbone to ensure that the model
-        is loaded correctly. We also restore the auxiliary objects like threshold classes and normalization metrics.
+        Restores backbone parameters before loading to ensure correct model initialization.
+
+        Args:
+            state_dict (OrderedDict[str, Any]): State dict to load
+            strict (bool, optional): Whether to strictly enforce that the keys in
+                ``state_dict`` match the keys returned by this module's
+                ``state_dict()`` function. Defaults to ``True``.
+
+        Returns:
+            Any: Return value from parent's load_state_dict
         """
         # restore the parameters of the excluded modules, if any
         full_dict = super().state_dict()
@@ -191,7 +282,15 @@ def load_state_dict(self, state_dict: OrderedDict[str, Any], strict: bool = True
 
     @classmethod
     def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
-        """Configure the default pre-processor used by the model."""
+        """Configure the default pre-processor used by the model.
+
+        Args:
+            image_size (tuple[int, int] | None, optional): Not used as WinCLIP has fixed
+                input size. Defaults to ``None``.
+
+        Returns:
+            PreProcessor: Configured pre-processor with CLIP-specific transforms
+        """
         if image_size is not None:
             logger.warning("Image size is not used in WinCLIP. The input image size is determined by the model.")
 
@@ -203,5 +302,9 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
 
     @staticmethod
     def configure_post_processor() -> OneClassPostProcessor:
-        """Return the default post-processor for WinCLIP."""
+        """Configure the default post-processor for WinCLIP.
+
+        Returns:
+            OneClassPostProcessor: Default post-processor instance
+        """
         return OneClassPostProcessor()
diff --git a/src/anomalib/models/image/winclip/prompting.py b/src/anomalib/models/image/winclip/prompting.py
index f33a63d1f4..2c3d661b28 100644
--- a/src/anomalib/models/image/winclip/prompting.py
+++ b/src/anomalib/models/image/winclip/prompting.py
@@ -1,4 +1,24 @@
-"""Compositional prompt ensemble for WinCLIP."""
+"""Compositional prompt ensemble for WinCLIP.
+
+This module provides prompt templates and utilities for generating prompt ensembles
+used by the WinCLIP model. The prompts are used to query CLIP about normal and
+anomalous states of objects.
+
+The module contains:
+    - Lists of normal and anomalous state descriptors
+    - Templates for constructing image description prompts
+    - Functions to generate prompt ensembles by combining states and templates
+
+Example:
+    >>> from anomalib.models.image.winclip.prompting import create_prompt_ensemble
+    >>> normal, anomalous = create_prompt_ensemble("transistor")  # doctest: +SKIP
+    >>> print(normal[0])  # doctest: +SKIP
+    'a photo of a transistor.'
+
+See Also:
+    - :class:`WinClip`: Main model class using these prompts
+    - :class:`WinClipModel`: PyTorch model implementation
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -46,22 +66,39 @@
 
 
 def create_prompt_ensemble(class_name: str = "object") -> tuple[list[str], list[str]]:
-    """Create prompt ensemble for WinCLIP.
+    """Create prompt ensemble for WinCLIP model.
 
-    All combinations of states and templates are generated for both normal and anomalous prompts.
+    This function generates a comprehensive set of text prompts used by the WinCLIP model for
+    zero-shot anomaly detection. It creates two sets of prompts:
+
+    1. Normal prompts describing non-anomalous objects
+    2. Anomalous prompts describing objects with defects
+
+    The prompts are generated by combining predefined states (e.g., "flawless", "damaged")
+    with templates (e.g., "a photo of a {}") for the given object class.
 
     Args:
-        class_name (str): Name of the object.
+        class_name (str, optional): Name of the object class to use in the prompts.
+            Defaults to ``"object"``.
 
     Returns:
-        tuple[list[str], list[str]]: Tuple containing the normal and anomalous prompts.
+        tuple[list[str], list[str]]: A tuple containing:
+            - List of normal prompts describing non-anomalous objects
+            - List of anomalous prompts describing defective objects
+
+    Example:
+        Generate prompts for the "bottle" class:
 
-    Examples:
         >>> normal_prompts, anomalous_prompts = create_prompt_ensemble("bottle")
-        >>> normal_prompts[:2]
-        ['a cropped photo of the bottle.', 'a close-up photo of a bottle.']
-        >>> anomalous_prompts[:2]
-        ['a cropped photo of the damaged bottle.', 'a close-up photo of a damaged bottle.']
+        >>> print(normal_prompts[0])
+        'a cropped photo of the bottle.'
+        >>> print(anomalous_prompts[0])
+        'a cropped photo of the damaged bottle.'
+
+    See Also:
+        - :data:`NORMAL_STATES`: Predefined states for normal objects
+        - :data:`ANOMALOUS_STATES`: Predefined states for anomalous objects
+        - :data:`TEMPLATES`: Predefined templates for prompt generation
     """
     normal_states = [state.format(class_name) for state in NORMAL_STATES]
     normal_ensemble = [template.format(state) for state in normal_states for template in TEMPLATES]
diff --git a/src/anomalib/models/image/winclip/torch_model.py b/src/anomalib/models/image/winclip/torch_model.py
index 8d2bfc69f9..9847030074 100644
--- a/src/anomalib/models/image/winclip/torch_model.py
+++ b/src/anomalib/models/image/winclip/torch_model.py
@@ -1,4 +1,29 @@
-"""PyTorch model for the WinCLIP implementation."""
+"""PyTorch model implementation of WinCLIP for zero-/few-shot anomaly detection.
+
+This module provides the core PyTorch model implementation of WinCLIP, which uses
+CLIP embeddings and a sliding window approach to detect anomalies in images.
+
+The model can operate in both zero-shot and few-shot modes:
+- Zero-shot: No reference images needed
+- Few-shot: Uses ``k`` reference normal images for better context
+
+Example:
+    >>> from anomalib.models.image.winclip.torch_model import WinClipModel
+    >>> model = WinClipModel()  # doctest: +SKIP
+    >>> # Zero-shot inference
+    >>> prediction = model(image)  # doctest: +SKIP
+    >>> # Few-shot with reference images
+    >>> model = WinClipModel(reference_images=normal_images)  # doctest: +SKIP
+
+Paper:
+    WinCLIP: Zero-/Few-Shot Anomaly Classification and Segmentation
+    https://arxiv.org/abs/2303.14814
+
+See Also:
+    - :class:`WinClip`: Lightning model wrapper
+    - :mod:`.prompting`: Prompt ensemble generation
+    - :mod:`.utils`: Utility functions for scoring and aggregation
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -27,25 +52,42 @@
 class WinClipModel(DynamicBufferMixin, BufferListMixin, nn.Module):
     """PyTorch module that implements the WinClip model for image anomaly detection.
 
+    The model uses CLIP embeddings and a sliding window approach to detect anomalies in
+    images. It can operate in both zero-shot and few-shot modes.
+
     Args:
-        class_name (str, optional): The name of the object class used in the prompt ensemble.
-            Defaults to ``None``.
-        reference_images (torch.Tensor, optional): Tensor of shape ``(K, C, H, W)`` containing the reference images.
-            Defaults to ``None``.
-        scales (tuple[int], optional): The scales of the sliding windows used for multi-scale anomaly detection.
-            Defaults to ``(2, 3)``.
-        apply_transform (bool, optional): Whether to apply the default CLIP transform to the input images.
-            Defaults to ``False``.
+        class_name (str | None, optional): Name of the object class used in prompt
+            ensemble. Defaults to ``None``.
+        reference_images (torch.Tensor | None, optional): Reference images of shape
+            ``(K, C, H, W)``. Defaults to ``None``.
+        scales (tuple[int], optional): Scales of sliding windows for multi-scale
+            detection. Defaults to ``(2, 3)``.
+        apply_transform (bool, optional): Whether to apply default CLIP transform to
+            inputs. Defaults to ``False``.
 
     Attributes:
-        clip (CLIP): The CLIP model used for image and text encoding.
-        grid_size (tuple[int]): The size of the feature map grid.
-        k_shot (int): The number of reference images used for few-shot anomaly detection.
-        scales (tuple[int]): The scales of the sliding windows used for multi-scale anomaly detection.
-        masks (list[torch.Tensor] | None): The masks representing the sliding window locations.
-        _text_embeddings (torch.Tensor | None): The text embeddings for the compositional prompt ensemble.
-        _visual_embeddings (list[torch.Tensor] | None): The multi-scale embeddings for the reference images.
-        _patch_embeddings (torch.Tensor | None): The patch embeddings for the reference images.
+        clip (CLIP): CLIP model for image and text encoding.
+        grid_size (tuple[int]): Size of feature map grid.
+        k_shot (int): Number of reference images for few-shot detection.
+        scales (tuple[int]): Scales of sliding windows.
+        masks (list[torch.Tensor] | None): Masks for sliding window locations.
+        _text_embeddings (torch.Tensor | None): Text embeddings for prompt ensemble.
+        _visual_embeddings (list[torch.Tensor] | None): Multi-scale reference embeddings.
+        _patch_embeddings (torch.Tensor | None): Patch embeddings for reference images.
+
+    Example:
+        >>> from anomalib.models.image.winclip.torch_model import WinClipModel
+        >>> # Zero-shot mode
+        >>> model = WinClipModel(class_name="transistor")  # doctest: +SKIP
+        >>> image = torch.rand(1, 3, 224, 224)  # doctest: +SKIP
+        >>> prediction = model(image)  # doctest: +SKIP
+        >>>
+        >>> # Few-shot mode with reference images
+        >>> ref_images = torch.rand(3, 3, 224, 224)  # doctest: +SKIP
+        >>> model = WinClipModel(  # doctest: +SKIP
+        ...     class_name="transistor",
+        ...     reference_images=ref_images
+        ... )
     """
 
     def __init__(
@@ -80,46 +122,50 @@ def __init__(
         self.setup(class_name, reference_images)
 
     def setup(self, class_name: str | None = None, reference_images: torch.Tensor | None = None) -> None:
-        """Setup WinCLIP.
+        """Setup WinCLIP model with class name and/or reference images.
 
-        WinCLIP's setup stage consists of collecting the text and visual embeddings used during inference. The
-        following steps are performed, depending on the arguments passed to the model:
-        - Collect text embeddings for zero-shot inference.
-        - Collect reference images for few-shot inference.
-        The k_shot attribute is updated based on the number of reference images.
+        The setup stage collects text and visual embeddings used during inference:
+        - Text embeddings for zero-shot inference if ``class_name`` provided
+        - Visual embeddings for few-shot inference if ``reference_images`` provided
+        The ``k_shot`` attribute is updated based on number of reference images.
 
-        The setup method is called internally by the constructor. However, it can also be called manually to update the
-        text and visual embeddings after the model has been initialized.
+        This method is called by constructor but can also be called manually to update
+        embeddings after initialization.
 
         Args:
-            class_name (str): The name of the object class used in the prompt ensemble.
-            reference_images (torch.Tensor): Tensor of shape ``(batch_size, C, H, W)`` containing the reference images.
+            class_name (str | None, optional): Name of object class for prompt ensemble.
+                Defaults to ``None``.
+            reference_images (torch.Tensor | None, optional): Reference images of shape
+                ``(batch_size, C, H, W)``. Defaults to ``None``.
 
         Examples:
-            >>> model = WinClipModel()
-            >>> model.setup("transistor")
-            >>> model.text_embeddings.shape
+            >>> model = WinClipModel()  # doctest: +SKIP
+            >>> model.setup("transistor")  # doctest: +SKIP
+            >>> model.text_embeddings.shape  # doctest: +SKIP
             torch.Size([2, 640])
 
-            >>> ref_images = torch.rand(2, 3, 240, 240)
-            >>> model = WinClipModel()
-            >>> model.setup("transistor", ref_images)
-            >>> model.k_shot
+            >>> ref_images = torch.rand(2, 3, 240, 240)  # doctest: +SKIP
+            >>> model = WinClipModel()  # doctest: +SKIP
+            >>> model.setup("transistor", ref_images)  # doctest: +SKIP
+            >>> model.k_shot  # doctest: +SKIP
             2
-            >>> model.visual_embeddings[0].shape
+            >>> model.visual_embeddings[0].shape  # doctest: +SKIP
             torch.Size([2, 196, 640])
 
-            >>> model = WinClipModel("transistor")
-            >>> model.k_shot
+            >>> model = WinClipModel("transistor")  # doctest: +SKIP
+            >>> model.k_shot  # doctest: +SKIP
             0
-            >>> model.setup(reference_images=ref_images)
-            >>> model.k_shot
+            >>> model.setup(reference_images=ref_images)  # doctest: +SKIP
+            >>> model.k_shot  # doctest: +SKIP
             2
 
-            >>> model = WinClipModel(class_name="transistor", reference_images=ref_images)
-            >>> model.text_embeddings.shape
+            >>> model = WinClipModel(  # doctest: +SKIP
+            ...     class_name="transistor",
+            ...     reference_images=ref_images
+            ... )
+            >>> model.text_embeddings.shape  # doctest: +SKIP
             torch.Size([2, 640])
-            >>> model.visual_embeddings[0].shape
+            >>> model.visual_embeddings[0].shape  # doctest: +SKIP
             torch.Size([2, 196, 640])
         """
         # update class name and text embeddings
@@ -133,29 +179,35 @@ def setup(self, class_name: str | None = None, reference_images: torch.Tensor |
             self._collect_visual_embeddings(self.reference_images)
 
     def encode_image(self, batch: torch.Tensor) -> tuple[torch.Tensor, list[torch.Tensor], torch.Tensor]:
-        """Encode the batch of images to obtain image embeddings, window embeddings, and patch embeddings.
+        """Encode batch of images to get image, window and patch embeddings.
 
-        The image embeddings and patch embeddings are obtained by passing the batch of images through the model. The
-        window embeddings are obtained by masking the feature map and passing it through the transformer. A forward hook
-        is used to retrieve the intermediate feature map and share computation between the image and window embeddings.
+        The image and patch embeddings are obtained by passing images through the model.
+        Window embeddings are obtained by masking feature map and passing through
+        transformer. A forward hook retrieves intermediate feature map to share
+        computation.
 
         Args:
-            batch (torch.Tensor): Batch of input images of shape ``(N, C, H, W)``.
+            batch (torch.Tensor): Input images of shape ``(N, C, H, W)``.
 
         Returns:
-            Tuple[torch.Tensor, List[torch.Tensor], torch.Tensor]: A tuple containing the image embeddings,
-            window embeddings, and patch embeddings respectively.
+            tuple[torch.Tensor, list[torch.Tensor], torch.Tensor]: Tuple containing:
+                - Image embeddings of shape ``(N, D)``
+                - Window embeddings list, each of shape ``(N, W, D)``
+                - Patch embeddings of shape ``(N, P, D)``
+                where ``D`` is embedding dimension, ``W`` is number of windows,
+                and ``P`` is number of patches.
 
         Examples:
-            >>> model = WinClipModel()
-            >>> model.prepare_masks()
-            >>> batch = torch.rand((1, 3, 240, 240))
-            >>> image_embeddings, window_embeddings, patch_embeddings = model.encode_image(batch)
-            >>> image_embeddings.shape
+            >>> model = WinClipModel()  # doctest: +SKIP
+            >>> model.prepare_masks()  # doctest: +SKIP
+            >>> batch = torch.rand((1, 3, 240, 240))  # doctest: +SKIP
+            >>> outputs = model.encode_image(batch)  # doctest: +SKIP
+            >>> image_embeddings, window_embeddings, patch_embeddings = outputs
+            >>> image_embeddings.shape  # doctest: +SKIP
             torch.Size([1, 640])
-            >>> [embedding.shape for embedding in window_embeddings]
+            >>> [emb.shape for emb in window_embeddings]  # doctest: +SKIP
             [torch.Size([1, 196, 640]), torch.Size([1, 169, 640])]
-            >>> patch_embeddings.shape
+            >>> patch_embeddings.shape  # doctest: +SKIP
             torch.Size([1, 225, 896])
         """
         # apply transform if needed
@@ -189,14 +241,16 @@ def hook(_model: Identity, inputs: tuple[torch.Tensor,], _outputs: torch.Tensor)
         )
 
     def _get_window_embeddings(self, feature_map: torch.Tensor, masks: torch.Tensor) -> torch.Tensor:
-        """Computes the embeddings for each window in the feature map using the given masks.
+        """Compute embeddings for each window in feature map using given masks.
 
         Args:
-            feature_map (torch.Tensor): The input feature map of shape ``(n_batches, n_patches, dimensionality)``.
-            masks (torch.Tensor): Masks of shape ``(kernel_size, n_masks)`` representing the sliding window locations.
+            feature_map (torch.Tensor): Input features of shape
+                ``(n_batches, n_patches, dimensionality)``.
+            masks (torch.Tensor): Window location masks of shape
+                ``(kernel_size, n_masks)``.
 
         Returns:
-            torch.Tensor: The embeddings for each sliding window location.
+            torch.Tensor: Embeddings for each sliding window location.
         """
         batch_size = feature_map.shape[0]
         n_masks = masks.shape[1]
@@ -225,13 +279,16 @@ def _get_window_embeddings(self, feature_map: torch.Tensor, masks: torch.Tensor)
 
     @torch.no_grad
     def forward(self, batch: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor] | InferenceBatch:
-        """Forward-pass through the model to obtain image and pixel scores.
+        """Forward pass to get image and pixel anomaly scores.
 
         Args:
-            batch (torch.Tensor): Batch of input images of shape ``(batch_size, C, H, W)``.
+            batch (torch.Tensor): Input images of shape ``(batch_size, C, H, W)``.
 
         Returns:
-            Tuple[torch.Tensor, torch.Tensor]: Tuple containing the image scores and pixel scores.
+            tuple[torch.Tensor, torch.Tensor] | InferenceBatch: Either tuple containing:
+                - Image scores of shape ``(batch_size,)``
+                - Pixel scores of shape ``(batch_size, H, W)``
+                Or ``InferenceBatch`` with same information.
         """
         image_embeddings, window_embeddings, patch_embeddings = self.encode_image(batch)
 
@@ -258,19 +315,20 @@ def _compute_zero_shot_scores(
         image_scores: torch.Tensor,
         window_embeddings: list[torch.Tensor],
     ) -> torch.Tensor:
-        """Compute the multi-scale anomaly score maps based on the text embeddings.
+        """Compute multi-scale anomaly score maps using text embeddings.
 
-        Each window embedding is compared to the text embeddings to obtain a similarity score for each window. Harmonic
-        averaging is then used to aggregate the scores for each window into a single score map for each scale. Finally,
-        the score maps are combined into a single multi-scale score map by aggregating across scales.
+        Each window embedding is compared to text embeddings for similarity scores.
+        Harmonic averaging aggregates window scores into score maps per scale.
+        Score maps are combined into single multi-scale map by cross-scale
+        aggregation.
 
         Args:
-            image_scores (torch.Tensor): Tensor of shape ``(batch_size)`` representing the full image scores.
-            window_embeddings (list[torch.Tensor]): List of tensors of shape ``(batch_size, n_windows, n_features)``
-                representing the embeddings for each sliding window location.
+            image_scores (torch.Tensor): Full image scores of shape ``(batch_size)``.
+            window_embeddings (list[torch.Tensor]): Window embeddings list, each of
+                shape ``(batch_size, n_windows, n_features)``.
 
         Returns:
-            torch.Tensor: Tensor of shape ``(batch_size, H, W)`` representing the 0-shot scores for each patch location.
+            torch.Tensor: Zero-shot scores of shape ``(batch_size, H, W)``.
         """
         # image scores are added to represent the full image scale
         multi_scale_scores = [image_scores.view(-1, 1, 1).repeat(1, self.grid_size[0], self.grid_size[1])]
@@ -286,21 +344,21 @@ def _compute_few_shot_scores(
         patch_embeddings: torch.Tensor,
         window_embeddings: list[torch.Tensor],
     ) -> torch.Tensor:
-        """Compute the multi-scale anomaly score maps based on the reference image embeddings.
+        """Compute multi-scale anomaly score maps using reference embeddings.
 
-        Visual association scores are computed between the extracted embeddings and the reference image embeddings for
-        each scale. The window-level scores are additionally aggregated into a single score map for each scale using
-        harmonic averaging. The final score maps are obtained by averaging across scales.
+        Visual association scores are computed between extracted embeddings and
+        reference embeddings at each scale. Window scores are aggregated into score
+        maps per scale using harmonic averaging. Final maps obtained by averaging
+        across scales.
 
         Args:
             patch_embeddings (torch.Tensor): Full-scale patch embeddings of shape
                 ``(batch_size, n_patches, n_features)``.
-            window_embeddings (list[torch.Tensor]): List of tensors of shape ``(batch_size, n_windows, n_features)``
-                representing the embeddings for each sliding window location.
+            window_embeddings (list[torch.Tensor]): Window embeddings list, each of
+                shape ``(batch_size, n_windows, n_features)``.
 
         Returns:
-            torch.Tensor: Tensor of shape ``(batch_size, H, W)`` representing the few-shot scores for each patch
-                location.
+            torch.Tensor: Few-shot scores of shape ``(batch_size, H, W)``.
         """
         multi_scale_scores = [
             visual_association_score(patch_embeddings, self.patch_embeddings).reshape((-1, *self.grid_size)),
@@ -318,15 +376,14 @@ def _compute_few_shot_scores(
 
     @torch.no_grad
     def _collect_text_embeddings(self, class_name: str) -> None:
-        """Collect text embeddings for the object class using a compositional prompt ensemble.
+        """Collect text embeddings using compositional prompt ensemble.
 
-        First, an ensemble of normal and anomalous prompts is created based on the name of the object class. The
-        prompt ensembles are then tokenized and encoded to obtain prompt embeddings. The prompt embeddings are
-        averaged to obtain a single text embedding for the object class. These final text embeddings are stored in
-        the model to be used during inference.
+        Creates ensemble of normal and anomalous prompts based on class name.
+        Prompts are tokenized and encoded to get embeddings. Embeddings are averaged
+        per class and stored for inference.
 
         Args:
-            class_name (str): The name of the object class used in the prompt ensemble.
+            class_name (str): Object class name for prompt ensemble.
         """
         # get the device, this is to ensure that we move the text embeddings to the same device as the model
         device = next(self.parameters()).device
@@ -347,31 +404,34 @@ def _collect_text_embeddings(self, class_name: str) -> None:
 
     @torch.no_grad
     def _collect_visual_embeddings(self, images: torch.Tensor) -> None:
-        """Collect visual embeddings based on a set of normal reference images.
+        """Collect visual embeddings from normal reference images.
 
         Args:
-            images (torch.Tensor): Tensor of shape ``(K, C, H, W)`` containing the reference images.
+            images (torch.Tensor): Reference images of shape ``(K, C, H, W)``.
         """
         _, self._visual_embeddings, self._patch_embeddings = self.encode_image(images)
 
     def _generate_masks(self) -> list[torch.Tensor]:
-        """Prepare a set of masks that operate as multi-scale sliding windows.
+        """Prepare multi-scale sliding window masks.
 
-        For each of the scales, a set of masks is created that select patches from the feature map. Each mask represents
-        a sliding window location in the pixel domain. The masks are stored in the model to be used during inference.
+        Creates masks for each scale that select patches from feature map. Each mask
+        represents a sliding window location. Masks are stored for inference.
 
         Returns:
-            list[torch.Tensor]: A list of tensors of shape ``(n_patches_per_mask, n_masks)`` representing the sliding
-                window locations for each scale.
+            list[torch.Tensor]: List of masks, each of shape
+            ``(n_patches_per_mask, n_masks)``.
         """
         return [make_masks(self.grid_size, scale, 1) for scale in self.scales]
 
     @property
     def transform(self) -> Compose:
-        """The transform used by the model.
+        """Get model's transform pipeline.
+
+        Retrieves transforms from CLIP backbone and prepends ``ToPILImage`` transform
+        since original transforms expect PIL images.
 
-        To obtain the transforms, we retrieve the transforms from the clip backbone. Since the original transforms are
-        intended for PIL images, we prepend a ToPILImage transform to the list of transforms.
+        Returns:
+            Compose: Transform pipeline for preprocessing images.
         """
         transforms = copy(self._transform.transforms)
         transforms.insert(0, ToPILImage())
@@ -379,7 +439,14 @@ def transform(self) -> Compose:
 
     @property
     def text_embeddings(self) -> torch.Tensor:
-        """The text embeddings used by the model."""
+        """Get model's text embeddings.
+
+        Returns:
+            torch.Tensor: Text embeddings used for zero-shot inference.
+
+        Raises:
+            RuntimeError: If text embeddings not collected via ``setup``.
+        """
         if self._text_embeddings.numel() == 0:
             msg = "Text embeddings have not been collected. Pass a class name to the model using ``setup``."
             raise RuntimeError(msg)
@@ -387,7 +454,14 @@ def text_embeddings(self) -> torch.Tensor:
 
     @property
     def visual_embeddings(self) -> list[torch.Tensor]:
-        """The visual embeddings used by the model."""
+        """Get model's visual embeddings.
+
+        Returns:
+            list[torch.Tensor]: Visual embeddings used for few-shot inference.
+
+        Raises:
+            RuntimeError: If visual embeddings not collected via ``setup``.
+        """
         if self._visual_embeddings[0].numel() == 0:
             msg = "Visual embeddings have not been collected. Pass some reference images to the model using ``setup``."
             raise RuntimeError(msg)
@@ -395,7 +469,14 @@ def visual_embeddings(self) -> list[torch.Tensor]:
 
     @property
     def patch_embeddings(self) -> torch.Tensor:
-        """The patch embeddings used by the model."""
+        """Get model's patch embeddings.
+
+        Returns:
+            torch.Tensor: Patch embeddings used for few-shot inference.
+
+        Raises:
+            RuntimeError: If patch embeddings not collected via ``setup``.
+        """
         if self._patch_embeddings.numel() == 0:
             msg = "Patch embeddings have not been collected. Pass some reference images to the model using ``setup``."
             raise RuntimeError(msg)
diff --git a/src/anomalib/models/image/winclip/utils.py b/src/anomalib/models/image/winclip/utils.py
index 620d04d867..b48928c170 100644
--- a/src/anomalib/models/image/winclip/utils.py
+++ b/src/anomalib/models/image/winclip/utils.py
@@ -1,4 +1,24 @@
-"""WinCLIP utils."""
+"""Utility functions for WinCLIP model.
+
+This module provides utility functions used by the WinCLIP model for anomaly detection:
+
+- :func:`cosine_similarity`: Compute pairwise cosine similarity between tensors
+- :func:`class_scores`: Calculate anomaly scores from CLIP embeddings
+- :func:`harmonic_aggregation`: Aggregate scores using harmonic mean
+- :func:`make_masks`: Generate sliding window masks
+- :func:`visual_association_score`: Compute visual association scores
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.image.winclip.utils import cosine_similarity
+    >>> input1 = torch.randn(100, 128)  # doctest: +SKIP
+    >>> input2 = torch.randn(200, 128)  # doctest: +SKIP
+    >>> similarity = cosine_similarity(input1, input2)  # doctest: +SKIP
+
+See Also:
+    - :class:`WinClip`: Main model class using these utilities
+    - :class:`WinClipModel`: PyTorch model implementation
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,31 +30,56 @@
 def cosine_similarity(input1: torch.Tensor, input2: torch.Tensor) -> torch.Tensor:
     """Compute pairwise cosine similarity matrix between two tensors.
 
-    Computes the cosine similarity between all pairs of vectors in the two tensors.
+    Computes the cosine similarity between all pairs of vectors in the two input tensors.
+    The inputs can be either 2D or 3D tensors. For 2D inputs, an implicit batch
+    dimension of 1 is added.
 
     Args:
-        input1 (torch.Tensor): Input tensor of shape ``(N, D)`` or ``(B, N, D)``.
-        input2 (torch.Tensor): Input tensor of shape ``(M, D)`` or ``(B, M, D)``.
+        input1 (torch.Tensor): First input tensor of shape ``(N, D)`` or ``(B, N, D)``,
+            where:
+            - ``B`` is the optional batch dimension
+            - ``N`` is the number of vectors in first input
+            - ``D`` is the dimension of each vector
+        input2 (torch.Tensor): Second input tensor of shape ``(M, D)`` or ``(B, M, D)``,
+            where:
+            - ``B`` is the optional batch dimension
+            - ``M`` is the number of vectors in second input
+            - ``D`` is the dimension of each vector (must match input1)
 
     Returns:
-        torch.Tensor: Cosine similarity matrix of shape ``(N, M)`` or ``(B, N, M)``.
+        torch.Tensor: Cosine similarity matrix of shape ``(N, M)`` for 2D inputs or
+            ``(B, N, M)`` for 3D inputs, where each element ``[i,j]`` is the cosine
+            similarity between vector ``i`` from ``input1`` and vector ``j`` from
+            ``input2``.
 
     Examples:
+        2D inputs (single batch):
+
         >>> input1 = torch.tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]])
         >>> input2 = torch.tensor([[0.0, 1.0, 0.0], [1.0, 1.0, 0.0]])
         >>> cosine_similarity(input1, input2)
         tensor([[[0.0000, 0.7071],
                  [1.0000, 0.7071]]])
 
-        >>> input1 = torch.randn(100, 128)
-        >>> input2 = torch.randn(200, 128)
-        >>> cosine_similarity(input1, input2).shape
+        Different sized inputs:
+
+        >>> input1 = torch.randn(100, 128)  # 100 vectors of dimension 128
+        >>> input2 = torch.randn(200, 128)  # 200 vectors of dimension 128
+        >>> similarity = cosine_similarity(input1, input2)
+        >>> similarity.shape
         torch.Size([100, 200])
 
-        >>> input1 = torch.randn(10, 100, 128)
-        >>> input2 = torch.randn(10, 200, 128)
-        >>> cosine_similarity(input1, input2).shape
+        3D inputs (batched):
+
+        >>> input1 = torch.randn(10, 100, 128)  # 10 batches of 100 vectors
+        >>> input2 = torch.randn(10, 200, 128)  # 10 batches of 200 vectors
+        >>> similarity = cosine_similarity(input1, input2)
+        >>> similarity.shape
         torch.Size([10, 100, 200])
+
+    Note:
+        The function automatically handles both 2D and 3D inputs by adding a batch
+        dimension to 2D inputs. The vector dimension ``D`` must match between inputs.
     """
     ndim = input1.ndim
     input1 = input1.unsqueeze(0) if input1.ndim == 2 else input1
@@ -54,42 +99,65 @@ def class_scores(
     temperature: float = 1.0,
     target_class: int | None = None,
 ) -> torch.Tensor:
-    """Compute class scores between a set of N image embeddings and a set of M text embeddings.
+    """Compute class scores between image embeddings and text embeddings.
+
+    Computes similarity scores between image and text embeddings by first calculating
+    cosine similarity and then applying temperature scaling and softmax. This follows
+    Equation (1) in the WinCLIP paper.
 
-    Each text embedding represents the embedding of a prompt for a specific class. By computing the cosine similarity
-    between each image embedding and each text embedding, we obtain a similarity matrix of shape (N, M). This matrix is
-    then used to compute the confidence scores for each class by scaling by a temperature parameter and applying the
-    softmax function (Equation (1) in the WinCLIP paper).
+    Each text embedding represents a prompt for a specific class. The similarity matrix
+    is used to compute confidence scores for each class.
 
     Args:
-        image_embeddings (torch.Tensor): Image embedding matrix of shape ``(N, D)`` or ``(B, N, D)``.
-        text_embeddings (torch.Tensor): Text embedding matrix of shape ``(M, D)`` or ``(B, M, D)``.
-        temperature (float): Temperature hyperparameter.
-        target_class (int): Index of the target class. If None, the scores for all classes are returned.
+        image_embeddings (torch.Tensor): Image embeddings with shape ``(N, D)`` or
+            ``(B, N, D)``, where:
+            - ``B`` is optional batch dimension
+            - ``N`` is number of image embeddings
+            - ``D`` is embedding dimension
+        text_embeddings (torch.Tensor): Text embeddings with shape ``(M, D)`` or
+            ``(B, M, D)``, where:
+            - ``B`` is optional batch dimension
+            - ``M`` is number of text embeddings
+            - ``D`` is embedding dimension (must match image embeddings)
+        temperature (float, optional): Temperature scaling parameter. Higher values
+            make distribution more uniform, lower values make it more peaked.
+            Defaults to ``1.0``.
+        target_class (int | None, optional): Index of target class. If provided,
+            returns scores only for that class. Defaults to ``None``.
 
     Returns:
-        torch.Tensor: Similarity score of shape ``(N, M)`` or ``(B, N, M)``.
+        torch.Tensor: Class similarity scores. Shape depends on inputs and
+            ``target_class``:
+            - If no target class: ``(N, M)`` or ``(B, N, M)``
+            - If target class specified: ``(N,)`` or ``(B, N)``
 
     Examples:
+        Basic usage with 2D inputs:
+
         >>> image_embeddings = torch.tensor([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]])
         >>> text_embeddings = torch.tensor([[0.0, 1.0, 0.0], [1.0, 1.0, 0.0]])
         >>> class_scores(image_embeddings, text_embeddings)
         tensor([[0.3302, 0.6698],
                 [0.5727, 0.4273]])
 
-        >>> image_embeddings = torch.randn(100, 128)
-        >>> text_embeddings = torch.randn(200, 128)
+        With different sized inputs:
+
+        >>> image_embeddings = torch.randn(100, 128)  # 100 vectors
+        >>> text_embeddings = torch.randn(200, 128)  # 200 class prompts
         >>> class_scores(image_embeddings, text_embeddings).shape
         torch.Size([100, 200])
 
-        >>> image_embeddings = torch.randn(10, 100, 128)
-        >>> text_embeddings = torch.randn(10, 200, 128)
+        With batched 3D inputs:
+
+        >>> image_embeddings = torch.randn(10, 100, 128)  # 10 batches
+        >>> text_embeddings = torch.randn(10, 200, 128)  # 10 batches
         >>> class_scores(image_embeddings, text_embeddings).shape
         torch.Size([10, 100, 200])
 
-        >>> image_embeddings = torch.randn(10, 100, 128)
-        >>> text_embeddings = torch.randn(10, 200, 128)
-        >>> class_scores(image_embeddings, text_embeddings, target_class=0).shape
+        With target class specified:
+
+        >>> scores = class_scores(image_embeddings, text_embeddings, target_class=0)
+        >>> scores.shape
         torch.Size([10, 100])
     """
     scores = (cosine_similarity(image_embeddings, text_embeddings) / temperature).softmax(dim=-1)
@@ -101,31 +169,37 @@ def class_scores(
 def harmonic_aggregation(window_scores: torch.Tensor, output_size: tuple, masks: torch.Tensor) -> torch.Tensor:
     """Perform harmonic aggregation on window scores.
 
-    Computes a single score for each patch location by aggregating the scores of all windows that cover the patch.
-    Scores are aggregated using the harmonic mean.
+    Computes a single score for each patch location by aggregating the scores of all
+    windows that cover the patch. Scores are aggregated using the harmonic mean.
 
     Args:
-        window_scores (torch.Tensor): Tensor of shape ``(batch_size, n_masks)`` representing the scores for each sliding
-            window location.
-        output_size (tuple): Tuple of integers representing the output size ``(H, W)``.
-        masks (torch.Tensor): Tensor of shape ``(n_patches_per_mask, n_masks)`` representing the masks. Each mask is
-            set of indices indicating which patches are covered by the mask.
+        window_scores (torch.Tensor): Scores for each sliding window location.
+            Shape: ``(batch_size, n_masks)``.
+        output_size (tuple): Output dimensions ``(H, W)``.
+        masks (torch.Tensor): Binary masks indicating which patches are covered by each
+            window. Shape: ``(n_patches_per_mask, n_masks)``.
 
     Returns:
-        torch.Tensor: Tensor of shape ``(batch_size, H, W)```` representing the aggregated scores.
+        torch.Tensor: Aggregated scores. Shape: ``(batch_size, H, W)``.
+
+    Example:
+        Example for a 3x3 patch grid with 4 sliding windows of size 2x2:
 
-    Examples:
-        >>> # example for a 3x3 patch grid with 4 sliding windows of size 2x2
         >>> window_scores = torch.tensor([[1.0, 0.75, 0.5, 0.25]])
         >>> output_size = (3, 3)
         >>> masks = torch.Tensor([[0, 1, 3, 4],
-                                  [1, 2, 4, 5],
-                                  [3, 4, 6, 7],
-                                  [4, 5, 7, 8]])
+        ...                      [1, 2, 4, 5],
+        ...                      [3, 4, 6, 7],
+        ...                      [4, 5, 7, 8]])
         >>> harmonic_aggregation(window_scores, output_size, masks)
         tensor([[[1.0000, 0.8571, 0.7500],
                  [0.6667, 0.4800, 0.3750],
                  [0.5000, 0.3333, 0.2500]]])
+
+    Note:
+        The harmonic mean is used instead of arithmetic mean as it is more sensitive to
+        low scores, making it better suited for anomaly detection where we want to
+        emphasize potential defects.
     """
     batch_size = window_scores.shape[0]
     height, width = output_size
@@ -170,37 +244,57 @@ def visual_association_score(embeddings: torch.Tensor, reference_embeddings: tor
 
 
 def make_masks(grid_size: tuple[int, int], kernel_size: int, stride: int = 1) -> torch.Tensor:
-    """Make a set of masks to select patches from a feature map in a sliding window fashion.
+    """Make masks to select patches from a feature map using sliding windows.
+
+    Creates a set of masks for selecting patches from a feature map in a sliding window
+    fashion. Each column in the returned tensor represents one mask. A mask consists of
+    indices indicating which patches are covered by that sliding window position.
 
-    Each column in the returned tensor represents a mask. Each mask is a set of indices indicating which patches are
-    covered by the mask. The number of masks is equal to the number of sliding windows that fit in the feature map.
+    The number of masks equals the number of possible sliding window positions that fit
+    in the feature map given the kernel size and stride.
 
     Args:
-        grid_size (tuple[int, int]): The shape of the feature map.
-        kernel_size (int): The size of the kernel in number of patches.
-        stride (int): The size of the stride in number of patches.
+        grid_size (tuple[int, int]): Height and width of the feature map grid as
+            ``(H, W)``.
+        kernel_size (int): Size of the sliding window kernel in number of patches.
+        stride (int, optional): Stride of the sliding window in number of patches.
+            Defaults to ``1``.
 
     Returns:
-        torch.Tensor: Set of masks of shape ``(n_patches_per_mask, n_masks)``.
+        torch.Tensor: Set of masks with shape ``(n_patches_per_mask, n_masks)``. Each
+            column represents indices of patches covered by one sliding window position.
+
+    Raises:
+        ValueError: If any dimension of ``grid_size`` is smaller than ``kernel_size``.
 
     Examples:
+        Create masks for a 3x3 grid with kernel size 2 and stride 1:
+
         >>> make_masks((3, 3), 2)
         tensor([[0, 1, 3, 4],
                 [1, 2, 4, 5],
                 [3, 4, 6, 7],
                 [4, 5, 7, 8]], dtype=torch.int32)
 
+        Create masks for a 4x4 grid with kernel size 2 and stride 1:
+
         >>> make_masks((4, 4), 2)
         tensor([[ 0,  1,  2,  4,  5,  6,  8,  9, 10],
                 [ 1,  2,  3,  5,  6,  7,  9, 10, 11],
                 [ 4,  5,  6,  8,  9, 10, 12, 13, 14],
                 [ 5,  6,  7,  9, 10, 11, 13, 14, 15]], dtype=torch.int32)
 
+        Create masks for a 4x4 grid with kernel size 2 and stride 2:
+
         >>> make_masks((4, 4), 2, stride=2)
         tensor([[ 0,  2,  8, 10],
                 [ 1,  3,  9, 11],
                 [ 4,  6, 12, 14],
                 [ 5,  7, 13, 15]], dtype=torch.int32)
+
+    Note:
+        The returned masks can be used with :func:`visual_association_score` to compute
+        scores for sliding window positions.
     """
     if any(dim < kernel_size for dim in grid_size):
         msg = (
diff --git a/src/anomalib/models/video/__init__.py b/src/anomalib/models/video/__init__.py
index ae952f0e30..0de4f1328d 100644
--- a/src/anomalib/models/video/__init__.py
+++ b/src/anomalib/models/video/__init__.py
@@ -1,4 +1,31 @@
-"""Anomalib Video Models."""
+"""Anomalib Video Models.
+
+This module contains implementations of various deep learning models for video-based
+anomaly detection.
+
+Example:
+    >>> from anomalib.models.video import AiVad
+    >>> from anomalib.data import Avenue
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize a model and datamodule
+    >>> datamodule = Avenue(
+    ...     clip_length_in_frames=2,
+    ...     frames_between_clips=1,
+    ...     target_frame=VideoTargetFrame.LAST
+    ... )
+    >>> model = AiVad()
+
+    >>> # Train using the engine
+    >>> engine = Engine()  # doctest: +SKIP
+    >>> engine.fit(model=model, datamodule=datamodule)  # doctest: +SKIP
+
+    >>> # Get predictions
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)  # doctest: +SKIP
+
+Available Models:
+    - :class:`AiVad`: AI-based Video Anomaly Detection
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/video/ai_vad/__init__.py b/src/anomalib/models/video/ai_vad/__init__.py
index 740636009b..4652c299e7 100644
--- a/src/anomalib/models/video/ai_vad/__init__.py
+++ b/src/anomalib/models/video/ai_vad/__init__.py
@@ -1,8 +1,31 @@
-"""Implementatation of the AI-VAD Model.
+"""Implementation of the AI-VAD model.
 
-AI-VAD: Accurate and Interpretable Video Anomaly Detection
+This module provides the implementation of the AI-VAD
+Attribute-based Representations for Accurate and Interpretable Video Anomaly
+Detection.
 
-Paper https://arxiv.org/pdf/2212.00789.pdf
+The model extracts three types of features from video regions:
+    - Velocity features: Histogram of optical flow magnitudes
+    - Pose features: Human keypoint detections using KeypointRCNN
+    - Deep features: CLIP embeddings of region crops
+
+These features are used to model normal behavior patterns and detect anomalies as
+deviations from the learned distributions.
+
+Example:
+    >>> from anomalib.models.video.ai_vad import AiVad
+    >>> # Initialize the model
+    >>> model = AiVad(
+    ...     input_size=(256, 256),
+    ...     use_pose_features=True,
+    ...     use_deep_features=True,
+    ...     use_velocity_features=True
+    ... )
+
+Reference:
+    Tal Reiss, Yedid Hoshen, "AI-VAD: Attribute-based Representations for
+    Accurate and Interpretable Video Anomaly Detection", arXiv:2212.00789, 2022
+    https://arxiv.org/pdf/2212.00789.pdf
 """
 
 # Copyright (C) 2023-2024 Intel Corporation
diff --git a/src/anomalib/models/video/ai_vad/density.py b/src/anomalib/models/video/ai_vad/density.py
index 778e945769..65cef958f9 100644
--- a/src/anomalib/models/video/ai_vad/density.py
+++ b/src/anomalib/models/video/ai_vad/density.py
@@ -1,4 +1,29 @@
-"""Density estimation module for AI-VAD model implementation."""
+"""Density estimation module for AI-VAD model implementation.
+
+This module implements the density estimation stage of the AI-VAD model. It provides
+density estimators for modeling the distribution of extracted features from normal
+video samples.
+
+The module provides the following components:
+    - :class:`BaseDensityEstimator`: Abstract base class for density estimators
+    - :class:`CombinedDensityEstimator`: Main density estimator that combines
+      multiple feature-specific estimators
+
+Example:
+    >>> import torch
+    >>> from anomalib.models.video.ai_vad.density import CombinedDensityEstimator
+    >>> from anomalib.models.video.ai_vad.features import FeatureType
+    >>> estimator = CombinedDensityEstimator()
+    >>> features = {
+    ...     FeatureType.VELOCITY: torch.randn(32, 8),
+    ...     FeatureType.POSE: torch.randn(32, 34),
+    ...     FeatureType.DEEP: torch.randn(32, 512)
+    ... }
+    >>> scores = estimator(features)  # Returns anomaly scores during inference
+
+The density estimators are used to model the distribution of normal behavior and
+detect anomalies as samples with low likelihood under the learned distributions.
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,11 +41,38 @@
 
 
 class BaseDensityEstimator(nn.Module, ABC):
-    """Base density estimator."""
+    """Abstract base class for density estimators.
+
+    This class defines the interface for density estimators used in the AI-VAD model.
+    Subclasses must implement methods for updating the density model with new features,
+    predicting densities for test samples, and fitting the model.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.video.ai_vad.density import BaseDensityEstimator
+        >>> class MyEstimator(BaseDensityEstimator):
+        ...     def update(self, features, group=None):
+        ...         pass
+        ...     def predict(self, features):
+        ...         return torch.rand(features.shape[0])
+        ...     def fit(self):
+        ...         pass
+        >>> estimator = MyEstimator()
+        >>> features = torch.randn(32, 8)
+        >>> scores = estimator(features)  # Forward pass returns predictions
+    """
 
     @abstractmethod
     def update(self, features: dict[FeatureType, torch.Tensor] | torch.Tensor, group: str | None = None) -> None:
-        """Update the density model with a new set of features."""
+        """Update the density model with a new set of features.
+
+        Args:
+            features (dict[FeatureType, torch.Tensor] | torch.Tensor): Input features
+                to update the model. Can be either a dictionary mapping feature types
+                to tensors, or a single tensor.
+            group (str | None, optional): Optional group identifier for grouped
+                density estimation. Defaults to ``None``.
+        """
         raise NotImplementedError
 
     @abstractmethod
@@ -28,19 +80,45 @@ def predict(
         self,
         features: dict[FeatureType, torch.Tensor] | torch.Tensor,
     ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
-        """Predict the density of a set of features."""
+        """Predict the density of a set of features.
+
+        Args:
+            features (dict[FeatureType, torch.Tensor] | torch.Tensor): Input features
+                to compute density for. Can be either a dictionary mapping feature
+                types to tensors, or a single tensor.
+
+        Returns:
+            torch.Tensor | tuple[torch.Tensor, torch.Tensor]: Predicted density
+                scores. May return either a single tensor of scores or a tuple of
+                tensors for more complex estimators.
+        """
         raise NotImplementedError
 
     @abstractmethod
     def fit(self) -> None:
-        """Compose model using collected features."""
+        """Compose model using collected features.
+
+        This method should be called after updating the model with features to fit
+        the density estimator to the collected data.
+        """
         raise NotImplementedError
 
     def forward(
         self,
         features: dict[FeatureType, torch.Tensor] | torch.Tensor,
     ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor] | None:
-        """Update or predict depending on training status."""
+        """Forward pass that either updates or predicts based on training status.
+
+        Args:
+            features (dict[FeatureType, torch.Tensor] | torch.Tensor): Input
+                features. Can be either a dictionary mapping feature types to
+                tensors, or a single tensor.
+
+        Returns:
+            torch.Tensor | tuple[torch.Tensor, torch.Tensor] | None: During
+                training, returns ``None`` after updating. During inference,
+                returns density predictions.
+        """
         if self.training:
             self.update(features)
             return None
@@ -53,18 +131,38 @@ class CombinedDensityEstimator(BaseDensityEstimator):
     Combines density estimators for the different feature types included in the model.
 
     Args:
-        use_pose_features (bool): Flag indicating if pose features should be used.
-            Defaults to ``True``.
-        use_deep_features (bool): Flag indicating if deep features should be used.
-            Defaults to ``True``.
-        use_velocity_features (bool): Flag indicating if velocity features should be used.
-            Defaults to ``False``.
-        n_neighbors_pose (int): Number of neighbors used in KNN density estimation for pose features.
-            Defaults to ``1``.
-        n_neighbors_deep (int): Number of neighbors used in KNN density estimation for deep features.
-            Defaults to ``1``.
-        n_components_velocity (int): Number of components used by GMM density estimation for velocity features.
-            Defaults to ``5``.
+        use_pose_features (bool, optional): Flag indicating if pose features should be
+            used. Defaults to ``True``.
+        use_deep_features (bool, optional): Flag indicating if deep features should be
+            used. Defaults to ``True``.
+        use_velocity_features (bool, optional): Flag indicating if velocity features
+            should be used. Defaults to ``False``.
+        n_neighbors_pose (int, optional): Number of neighbors used in KNN density
+            estimation for pose features. Defaults to ``1``.
+        n_neighbors_deep (int, optional): Number of neighbors used in KNN density
+            estimation for deep features. Defaults to ``1``.
+        n_components_velocity (int, optional): Number of components used by GMM density
+            estimation for velocity features. Defaults to ``5``.
+
+    Raises:
+        ValueError: If none of the feature types (velocity, pose, deep) are enabled.
+
+    Example:
+        >>> from anomalib.models.video.ai_vad.density import CombinedDensityEstimator
+        >>> estimator = CombinedDensityEstimator(
+        ...     use_pose_features=True,
+        ...     use_deep_features=True,
+        ...     use_velocity_features=True,
+        ...     n_neighbors_pose=1,
+        ...     n_neighbors_deep=1,
+        ...     n_components_velocity=5
+        ... )
+        >>> # Update with features from training data
+        >>> estimator.update(features, group="video_001")
+        >>> # Fit the density estimators
+        >>> estimator.fit()
+        >>> # Get predictions for test data
+        >>> region_scores, image_score = estimator.predict(features)
     """
 
     def __init__(
@@ -96,8 +194,12 @@ def update(self, features: dict[FeatureType, torch.Tensor], group: str | None =
         """Update the density estimators for the different feature types.
 
         Args:
-            features (dict[FeatureType, torch.Tensor]): Dictionary containing extracted features for a single frame.
-            group (str): Identifier of the video from which the frame was sampled. Used for grouped density estimation.
+            features (dict[FeatureType, torch.Tensor]): Dictionary containing
+                extracted features for a single frame. Keys are feature types and
+                values are the corresponding feature tensors.
+            group (str | None, optional): Identifier of the video from which the
+                frame was sampled. Used for grouped density estimation. Defaults to
+                ``None``.
         """
         if self.use_velocity_features:
             self.velocity_estimator.update(features[FeatureType.VELOCITY])
@@ -107,7 +209,11 @@ def update(self, features: dict[FeatureType, torch.Tensor], group: str | None =
             self.pose_estimator.update(features[FeatureType.POSE], group=group)
 
     def fit(self) -> None:
-        """Fit the density estimation models on the collected features."""
+        """Fit the density estimation models on the collected features.
+
+        This method should be called after updating with all training features to
+        fit the density estimators to the collected data.
+        """
         if self.use_velocity_features:
             self.velocity_estimator.fit()
         if self.use_deep_features:
@@ -116,14 +222,28 @@ def fit(self) -> None:
             self.pose_estimator.fit()
 
     def predict(self, features: dict[FeatureType, torch.Tensor]) -> tuple[torch.Tensor, torch.Tensor]:
-        """Predict the region- and image-level anomaly scores for an image based on a set of features.
+        """Predict region and image-level anomaly scores.
+
+        Computes anomaly scores for each region in the frame and an overall frame
+        score based on the maximum region score.
 
         Args:
-            features (dict[Tensor]): Dictionary containing extracted features for a single frame.
+            features (dict[FeatureType, torch.Tensor]): Dictionary containing
+                extracted features for a single frame. Keys are feature types and
+                values are the corresponding feature tensors.
 
         Returns:
-            Tensor: Region-level anomaly scores for all regions withing the frame.
-            Tensor: Frame-level anomaly score for the frame.
+            tuple[torch.Tensor, torch.Tensor]: A tuple containing:
+                - Region-level anomaly scores for all regions within the frame
+                - Frame-level anomaly score for the frame
+
+        Example:
+            >>> features = {
+            ...     FeatureType.VELOCITY: velocity_features,
+            ...     FeatureType.DEEP: deep_features,
+            ...     FeatureType.POSE: pose_features
+            ... }
+            >>> region_scores, image_score = estimator.predict(features)
         """
         n_regions = next(iter(features.values())).shape[0]
         device = next(iter(features.values())).device
@@ -147,13 +267,30 @@ def predict(self, features: dict[FeatureType, torch.Tensor]) -> tuple[torch.Tens
 class GroupedKNNEstimator(DynamicBufferMixin, BaseDensityEstimator):
     """Grouped KNN density estimator.
 
-    Keeps track of the group (e.g. video id) from which the features were sampled for normalization purposes.
+    Keeps track of the group (e.g. video id) from which the features were sampled for
+    normalization purposes.
 
     Args:
         n_neighbors (int): Number of neighbors used in KNN search.
+
+    Example:
+        >>> from anomalib.models.video.ai_vad.density import GroupedKNNEstimator
+        >>> import torch
+        >>> estimator = GroupedKNNEstimator(n_neighbors=5)
+        >>> features = torch.randn(32, 512)  # (N, D)
+        >>> estimator.update(features, group="video_1")
+        >>> estimator.fit()
+        >>> scores = estimator.predict(features)
+        >>> scores.shape
+        torch.Size([32])
     """
 
     def __init__(self, n_neighbors: int) -> None:
+        """Initialize the grouped KNN density estimator.
+
+        Args:
+            n_neighbors (int): Number of neighbors used in KNN search.
+        """
         super().__init__()
 
         self.n_neighbors = n_neighbors
@@ -168,8 +305,15 @@ def update(self, features: torch.Tensor, group: str | None = None) -> None:
         """Update the internal feature bank while keeping track of the group.
 
         Args:
-            features (torch.Tensor): Feature vectors extracted from a video frame.
-            group (str): Identifier of the group (video) from which the frame was sampled.
+            features (torch.Tensor): Feature vectors extracted from a video frame of
+                shape ``(N, D)``.
+            group (str | None, optional): Identifier of the group (video) from which
+                the frame was sampled. Defaults to ``None``.
+
+        Example:
+            >>> estimator = GroupedKNNEstimator(n_neighbors=5)
+            >>> features = torch.randn(32, 512)  # (N, D)
+            >>> estimator.update(features, group="video_1")
         """
         group = group or "default"
 
@@ -179,7 +323,17 @@ def update(self, features: torch.Tensor, group: str | None = None) -> None:
             self.feature_collection[group] = [features]
 
     def fit(self) -> None:
-        """Fit the KNN model by stacking the feature vectors and computing the normalization statistics."""
+        """Fit the KNN model by stacking features and computing normalization stats.
+
+        Stacks the collected feature vectors group-wise and computes the normalization
+        statistics. After fitting, the feature collection is deleted to free up memory.
+
+        Example:
+            >>> estimator = GroupedKNNEstimator(n_neighbors=5)
+            >>> features = torch.randn(32, 512)  # (N, D)
+            >>> estimator.update(features, group="video_1")
+            >>> estimator.fit()
+        """
         # stack the collected features group-wise
         feature_collection = {key: torch.vstack(value) for key, value in self.feature_collection.items()}
         # assign memory bank, group index and group names
@@ -202,17 +356,30 @@ def predict(
         """Predict the (normalized) density for a set of features.
 
         Args:
-            features (torch.Tensor): Input features that will be compared to the density model.
-            group (str, optional): Group (video id) from which the features originate. If passed, all features of the
-                same group in the memory bank will be excluded from the density estimation.
+            features (torch.Tensor): Input features of shape ``(N, D)`` that will be
+                compared to the density model.
+            group (str | None, optional): Group (video id) from which the features
+                originate. If passed, all features of the same group in the memory
+                bank will be excluded from the density estimation.
                 Defaults to ``None``.
-            n_neighbors (int): Number of neighbors used in the KNN search.
+            n_neighbors (int, optional): Number of neighbors used in the KNN search.
                 Defaults to ``1``.
-            normalize (bool): Flag indicating if the density should be normalized to min-max stats of the feature bank.
-                Defatuls to ``True``.
+            normalize (bool, optional): Flag indicating if the density should be
+                normalized to min-max stats of the feature bank.
+                Defaults to ``True``.
 
         Returns:
-            Tensor: Mean (normalized) distances of input feature vectors to k nearest neighbors in feature bank.
+            torch.Tensor: Mean (normalized) distances of input feature vectors to k
+                nearest neighbors in feature bank.
+
+        Example:
+            >>> estimator = GroupedKNNEstimator(n_neighbors=5)
+            >>> features = torch.randn(32, 512)  # (N, D)
+            >>> estimator.update(features, group="video_1")
+            >>> estimator.fit()
+            >>> scores = estimator.predict(features, group="video_1")
+            >>> scores.shape
+            torch.Size([32])
         """
         n_neighbors = n_neighbors or self.n_neighbors
 
@@ -234,12 +401,15 @@ def _nearest_neighbors(feature_bank: torch.Tensor, features: torch.Tensor, n_nei
         """Perform the KNN search.
 
         Args:
-            feature_bank (torch.Tensor): Feature bank used for KNN search.
-            features (Ternsor): Input features.
-            n_neighbors (int): Number of neighbors used in KNN search.
+            feature_bank (torch.Tensor): Feature bank of shape ``(M, D)`` used for
+                KNN search.
+            features (torch.Tensor): Input features of shape ``(N, D)``.
+            n_neighbors (int, optional): Number of neighbors used in KNN search.
+                Defaults to ``1``.
 
         Returns:
-            Tensor: Distances between the input features and their K nearest neighbors in the feature bank.
+            torch.Tensor: Distances between the input features and their K nearest
+                neighbors in the feature bank.
         """
         distances = torch.cdist(features, feature_bank, p=2.0)  # euclidean norm
         if n_neighbors == 1:
@@ -250,7 +420,12 @@ def _nearest_neighbors(feature_bank: torch.Tensor, features: torch.Tensor, n_nei
         return distances
 
     def _compute_normalization_statistics(self, grouped_features: dict[str, Tensor]) -> None:
-        """Compute min-max normalization statistics while taking the group into account."""
+        """Compute min-max normalization statistics while taking the group into account.
+
+        Args:
+            grouped_features (dict[str, Tensor]): Dictionary mapping group names to
+                feature tensors.
+        """
         for group, features in grouped_features.items():
             distances = self.predict(features, group, normalize=False)
             self.normalization_statistics.update(distances)
@@ -264,7 +439,7 @@ def _normalize(self, distances: torch.Tensor) -> torch.Tensor:
             distances (torch.Tensor): Distance tensor produced by KNN search.
 
         Returns:
-            Tensor: Normalized distances.
+            torch.Tensor: Normalized distances.
         """
         return (distances - self.normalization_statistics.min) / (
             self.normalization_statistics.max - self.normalization_statistics.min
@@ -274,9 +449,23 @@ def _normalize(self, distances: torch.Tensor) -> torch.Tensor:
 class GMMEstimator(BaseDensityEstimator):
     """Density estimation based on Gaussian Mixture Model.
 
+    Fits a GMM to the training features and uses the negative log-likelihood as an
+    anomaly score during inference.
+
     Args:
-        n_components (int): Number of components used in the GMM.
+        n_components (int, optional): Number of Gaussian components used in the GMM.
             Defaults to ``2``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.video.ai_vad.density import GMMEstimator
+        >>> estimator = GMMEstimator(n_components=2)
+        >>> features = torch.randn(32, 8)  # (N, D)
+        >>> estimator.update(features)
+        >>> estimator.fit()
+        >>> scores = estimator.predict(features)
+        >>> scores.shape
+        torch.Size([32])
     """
 
     def __init__(self, n_components: int = 2) -> None:
@@ -288,27 +477,44 @@ def __init__(self, n_components: int = 2) -> None:
         self.normalization_statistics = MinMax()
 
     def update(self, features: torch.Tensor, group: str | None = None) -> None:
-        """Update the feature bank."""
+        """Update the feature bank with new features.
+
+        Args:
+            features (torch.Tensor): Feature vectors of shape ``(N, D)`` to add to
+                the memory bank.
+            group (str | None, optional): Unused group parameter included for
+                interface compatibility. Defaults to ``None``.
+        """
         del group
         if isinstance(self.memory_bank, list):
             self.memory_bank.append(features)
 
     def fit(self) -> None:
-        """Fit the GMM and compute normalization statistics."""
+        """Fit the GMM and compute normalization statistics.
+
+        Concatenates all features in the memory bank, fits the GMM to the combined
+        features, and computes min-max normalization statistics over the training
+        scores.
+        """
         self.memory_bank = torch.vstack(self.memory_bank)
         self.gmm.fit(self.memory_bank)
         self._compute_normalization_statistics()
 
     def predict(self, features: torch.Tensor, normalize: bool = True) -> torch.Tensor:
-        """Predict the density of a set of feature vectors.
+        """Predict anomaly scores for input features.
+
+        Computes the negative log-likelihood of each feature vector under the
+        fitted GMM. Lower likelihood (higher score) indicates more anomalous
+        samples.
 
         Args:
-            features (torch.Tensor): Input feature vectors.
-            normalize (bool): Flag indicating if the density should be normalized to min-max stats of the feature bank.
-                Defaults to ``True``.
+            features (torch.Tensor): Input feature vectors of shape ``(N, D)``.
+            normalize (bool, optional): Whether to normalize scores using min-max
+                statistics from training. Defaults to ``True``.
 
         Returns:
-            Tensor: Density scores of the input feature vectors.
+            torch.Tensor: Anomaly scores of shape ``(N,)``. Higher values indicate
+                more anomalous samples.
         """
         density = -self.gmm.score_samples(features)
         if normalize:
@@ -316,19 +522,23 @@ def predict(self, features: torch.Tensor, normalize: bool = True) -> torch.Tenso
         return density
 
     def _compute_normalization_statistics(self) -> None:
-        """Compute min-max normalization statistics over the feature bank."""
+        """Compute min-max normalization statistics over the feature bank.
+
+        Computes anomaly scores for all training features and updates the min-max
+        statistics used for score normalization during inference.
+        """
         training_scores = self.predict(self.memory_bank, normalize=False)
         self.normalization_statistics.update(training_scores)
         self.normalization_statistics.compute()
 
     def _normalize(self, density: torch.Tensor) -> torch.Tensor:
-        """Normalize distance predictions.
+        """Normalize anomaly scores using min-max statistics.
 
         Args:
-            density (torch.Tensor): Distance tensor produced by KNN search.
+            density (torch.Tensor): Raw anomaly scores of shape ``(N,)``.
 
         Returns:
-            Tensor: Normalized distances.
+            torch.Tensor: Normalized anomaly scores of shape ``(N,)``.
         """
         return (density - self.normalization_statistics.min) / (
             self.normalization_statistics.max - self.normalization_statistics.min
diff --git a/src/anomalib/models/video/ai_vad/features.py b/src/anomalib/models/video/ai_vad/features.py
index f2107f217c..312946b4ea 100644
--- a/src/anomalib/models/video/ai_vad/features.py
+++ b/src/anomalib/models/video/ai_vad/features.py
@@ -1,4 +1,25 @@
-"""Feature extraction module for AI-VAD model implementation."""
+"""Feature extraction module for AI-VAD model implementation.
+
+This module implements the feature extraction stage of the AI-VAD model. It extracts
+three types of features from video regions:
+
+- Velocity features: Histogram of optical flow magnitudes
+- Pose features: Human keypoint detections using KeypointRCNN
+- Deep features: CLIP embeddings of region crops
+
+Example:
+    >>> from anomalib.models.video.ai_vad.features import FeatureExtractor
+    >>> import torch
+    >>> extractor = FeatureExtractor()
+    >>> frames = torch.randn(32, 2, 3, 256, 256)  # (N, L, C, H, W)
+    >>> flow = torch.randn(32, 2, 256, 256)  # (N, 2, H, W)
+    >>> regions = [{"boxes": torch.randn(5, 4)}] * 32  # List of region dicts
+    >>> features = extractor(frames, flow, regions)
+
+The module provides the following components:
+    - :class:`FeatureType`: Enum of available feature types
+    - :class:`FeatureExtractor`: Main class that handles feature extraction
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,7 +37,26 @@
 
 
 class FeatureType(str, Enum):
-    """Names of the different feature streams used in AI-VAD."""
+    """Names of the different feature streams used in AI-VAD.
+
+    This enum defines the available feature types that can be extracted from video
+    regions in the AI-VAD model.
+
+    Attributes:
+        POSE: Keypoint features extracted using KeypointRCNN model
+        VELOCITY: Histogram features computed from optical flow magnitudes
+        DEEP: Visual embedding features extracted using CLIP model
+
+    Example:
+        >>> from anomalib.models.video.ai_vad.features import FeatureType
+        >>> feature_type = FeatureType.POSE
+        >>> feature_type
+        
+        >>> feature_type == "pose"
+        True
+        >>> feature_type in [FeatureType.POSE, FeatureType.VELOCITY]
+        True
+    """
 
     POSE = "pose"
     VELOCITY = "velocity"
@@ -26,15 +66,31 @@ class FeatureType(str, Enum):
 class FeatureExtractor(nn.Module):
     """Feature extractor for AI-VAD.
 
+    Extracts velocity, pose and deep features from video regions based on the enabled
+    feature types.
+
     Args:
-        n_velocity_bins (int): Number of discrete bins used for velocity histogram features.
-            Defaults to ``8``.
-        use_velocity_features (bool): Flag indicating if velocity features should be used.
-            Defaults to ``True``.
-        use_pose_features (bool): Flag indicating if pose features should be used.
-            Defaults to ``True``.
-        use_deep_features (bool): Flag indicating if deep features should be used.
-            Defaults to ``True``.
+        n_velocity_bins (int, optional): Number of discrete bins used for velocity
+            histogram features. Defaults to ``8``.
+        use_velocity_features (bool, optional): Flag indicating if velocity features
+            should be used. Defaults to ``True``.
+        use_pose_features (bool, optional): Flag indicating if pose features should be
+            used. Defaults to ``True``.
+        use_deep_features (bool, optional): Flag indicating if deep features should be
+            used. Defaults to ``True``.
+
+    Raises:
+        ValueError: If none of the feature types (velocity, pose, deep) are enabled.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.video.ai_vad.features import FeatureExtractor
+        >>> extractor = FeatureExtractor()
+        >>> rgb_batch = torch.randn(32, 3, 256, 256)  # (N, C, H, W)
+        >>> flow_batch = torch.randn(32, 2, 256, 256)  # (N, 2, H, W)
+        >>> regions = [{"boxes": torch.randn(5, 4)}] * 32  # List of region dicts
+        >>> features = extractor(rgb_batch, flow_batch, regions)
+        >>> # Returns list of dicts with keys: velocity, pose, deep
     """
 
     def __init__(
@@ -65,15 +121,31 @@ def forward(
     ) -> list[dict]:
         """Forward pass through the feature extractor.
 
-        Extract any combination of velocity, pose and deep features depending on configuration.
+        Extract any combination of velocity, pose and deep features depending on
+        configuration.
 
         Args:
-            rgb_batch (torch.Tensor): Batch of RGB images of shape (N, 3, H, W)
-            flow_batch (torch.Tensor): Batch of optical flow images of shape (N, 2, H, W)
-            regions (list[dict]): Region information per image in batch.
+            rgb_batch (torch.Tensor): Batch of RGB images of shape ``(N, 3, H, W)``.
+            flow_batch (torch.Tensor): Batch of optical flow images of shape
+                ``(N, 2, H, W)``.
+            regions (list[dict]): Region information per image in batch. Each dict
+                contains bounding boxes of shape ``(M, 4)``.
 
         Returns:
-            list[dict]: Feature dictionary per image in batch.
+            list[dict]: Feature dictionary per image in batch. Each dict contains
+                the enabled feature types as keys with corresponding feature tensors
+                as values.
+
+        Example:
+            >>> import torch
+            >>> from anomalib.models.video.ai_vad.features import FeatureExtractor
+            >>> extractor = FeatureExtractor()
+            >>> rgb_batch = torch.randn(32, 3, 256, 256)  # (N, C, H, W)
+            >>> flow_batch = torch.randn(32, 2, 256, 256)  # (N, 2, H, W)
+            >>> regions = [{"boxes": torch.randn(5, 4)}] * 32  # List of region dicts
+            >>> features = extractor(rgb_batch, flow_batch, regions)
+            >>> features[0].keys()  # Features for first image
+            dict_keys(['velocity', 'pose', 'deep'])
         """
         batch_size = rgb_batch.shape[0]
 
@@ -104,7 +176,21 @@ def forward(
 class DeepExtractor(nn.Module):
     """Deep feature extractor.
 
-    Extracts the deep (appearance) features from the input regions.
+    Extracts deep (appearance) features from input regions using a CLIP vision encoder.
+
+    The extractor uses a pre-trained ViT-B/16 CLIP model to encode image regions into
+    a 512-dimensional feature space. Input regions are resized to 224x224 and
+    normalized using CLIP's default preprocessing.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.video.ai_vad.features import DeepExtractor
+        >>> extractor = DeepExtractor()
+        >>> batch = torch.randn(32, 3, 256, 256)  # (N, C, H, W)
+        >>> boxes = torch.tensor([[0, 10, 20, 50, 60]])  # (M, 5) with batch indices
+        >>> features = extractor(batch, boxes, batch_size=32)
+        >>> features.shape
+        torch.Size([1, 512])
     """
 
     def __init__(self) -> None:
@@ -118,13 +204,16 @@ def forward(self, batch: torch.Tensor, boxes: torch.Tensor, batch_size: int) ->
         """Extract deep features using CLIP encoder.
 
         Args:
-            batch (torch.Tensor): Batch of RGB input images of shape (N, 3, H, W)
-            boxes (torch.Tensor): Bounding box coordinates of shaspe (M, 5).
-                First column indicates batch index of the bbox.
+            batch (torch.Tensor): Batch of RGB input images of shape ``(N, 3, H, W)``
+            boxes (torch.Tensor): Bounding box coordinates of shape ``(M, 5)``. First
+                column indicates batch index of the bbox, remaining columns are
+                coordinates ``[x1, y1, x2, y2]``.
             batch_size (int): Number of images in the batch.
 
         Returns:
-            Tensor: Deep feature tensor of shape (M, 512)
+            torch.Tensor: Deep feature tensor of shape ``(M, 512)``, where ``M`` is
+                the number of input regions and 512 is the CLIP feature dimension.
+                Returns empty tensor if no valid regions.
         """
         rgb_regions = roi_align(batch, boxes, output_size=[224, 224])
 
@@ -138,10 +227,23 @@ def forward(self, batch: torch.Tensor, boxes: torch.Tensor, batch_size: int) ->
 class VelocityExtractor(nn.Module):
     """Velocity feature extractor.
 
-    Extracts histograms of optical flow magnitude and direction.
+    Extracts histograms of optical flow magnitude and direction from video regions.
+    The histograms capture motion patterns by binning flow vectors based on their
+    direction and weighting by magnitude.
 
     Args:
-        n_bins (int): Number of direction bins used for the feature histograms.
+        n_bins (int, optional): Number of direction bins used for the feature
+            histograms. Defaults to ``8``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.video.ai_vad.features import VelocityExtractor
+        >>> extractor = VelocityExtractor(n_bins=8)
+        >>> flows = torch.randn(32, 2, 256, 256)  # (N, 2, H, W)
+        >>> boxes = torch.tensor([[0, 10, 20, 50, 60]])  # (M, 5) with batch indices
+        >>> features = extractor(flows, boxes)
+        >>> features.shape
+        torch.Size([1, 8])
     """
 
     def __init__(self, n_bins: int = 8) -> None:
@@ -150,15 +252,25 @@ def __init__(self, n_bins: int = 8) -> None:
         self.n_bins = n_bins
 
     def forward(self, flows: torch.Tensor, boxes: torch.Tensor) -> torch.Tensor:
-        """Extract velocioty features by filling a histogram.
+        """Extract velocity features by computing flow direction histograms.
+
+        For each region, computes a histogram of optical flow directions weighted by
+        flow magnitudes. The flow vectors are converted from cartesian to polar
+        coordinates, with directions binned into ``n_bins`` equal intervals between
+        ``-π`` and ``π``. The histogram values are normalized by the bin counts.
 
         Args:
-            flows (torch.Tensor): Batch of optical flow images of shape (N, 2, H, W)
-            boxes (torch.Tensor): Bounding box coordinates of shaspe (M, 5).
-                First column indicates batch index of the bbox.
+            flows (torch.Tensor): Batch of optical flow images of shape
+                ``(N, 2, H, W)``, where the second dimension contains x and y flow
+                components.
+            boxes (torch.Tensor): Bounding box coordinates of shape ``(M, 5)``. First
+                column indicates batch index of the bbox, remaining columns are
+                coordinates ``[x1, y1, x2, y2]``.
 
         Returns:
-            Tensor: Velocity feature tensor of shape (M, n_bins)
+            torch.Tensor: Velocity feature tensor of shape ``(M, n_bins)``, where
+                ``M`` is the number of input regions. Returns empty tensor if no
+                valid regions.
         """
         flow_regions = roi_align(flows, boxes, output_size=[224, 224])
 
@@ -189,10 +301,25 @@ def forward(self, flows: torch.Tensor, boxes: torch.Tensor) -> torch.Tensor:
 class PoseExtractor(nn.Module):
     """Pose feature extractor.
 
-    Extracts pose features based on estimated body landmark keypoints.
+    Extracts pose features based on estimated body landmark keypoints using a
+    KeypointRCNN model.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.video.ai_vad.features import PoseExtractor
+        >>> extractor = PoseExtractor()
+        >>> batch = torch.randn(2, 3, 256, 256)  # (N, C, H, W)
+        >>> boxes = torch.tensor([[0, 10, 10, 50, 50], [1, 20, 20, 60, 60]])
+        >>> features = extractor(batch, boxes)
+        >>> # Returns list of pose feature tensors for each image
     """
 
     def __init__(self, *args, **kwargs) -> None:
+        """Initialize the pose feature extractor.
+
+        Loads a pre-trained KeypointRCNN model and extracts its components for
+        feature extraction.
+        """
         super().__init__(*args, **kwargs)
 
         weights = KeypointRCNN_ResNet50_FPN_Weights.DEFAULT
@@ -206,13 +333,17 @@ def __init__(self, *args, **kwargs) -> None:
     def _post_process(keypoint_detections: list[dict]) -> list[torch.Tensor]:
         """Convert keypoint predictions to 1D feature vectors.
 
-        Post-processing consists of flattening and normalizing to bbox coordinates.
+        Post-processing consists of flattening the keypoint coordinates and
+        normalizing them relative to the bounding box coordinates.
 
         Args:
             keypoint_detections (list[dict]): Outputs of the keypoint extractor
+                containing detected keypoints and bounding boxes.
 
         Returns:
-            list[torch.Tensor]: List of pose feature tensors for each image
+            list[torch.Tensor]: List of pose feature tensors for each image, where
+                each tensor has shape ``(N, K*2)`` with ``N`` being the number of
+                detections and ``K`` the number of keypoints.
         """
         poses = []
         for detection in keypoint_detections:
@@ -226,13 +357,23 @@ def _post_process(keypoint_detections: list[dict]) -> list[torch.Tensor]:
     def forward(self, batch: torch.Tensor, boxes: torch.Tensor) -> list[torch.Tensor]:
         """Extract pose features using a human keypoint estimation model.
 
+        The method performs the following steps:
+        1. Transform input images
+        2. Extract backbone features
+        3. Pool ROI features for each box
+        4. Predict keypoint locations
+        5. Post-process predictions
+
         Args:
-            batch (torch.Tensor): Batch of RGB input images of shape (N, 3, H, W)
-            boxes (torch.Tensor): Bounding box coordinates of shaspe (M, 5).
-                First column indicates batch index of the bbox.
+            batch (torch.Tensor): Batch of RGB input images of shape
+                ``(N, 3, H, W)``.
+            boxes (torch.Tensor): Bounding box coordinates of shape ``(M, 5)``.
+                First column indicates batch index of the bbox, remaining columns
+                are coordinates ``[x1, y1, x2, y2]``.
 
         Returns:
-            list[torch.Tensor]: list of pose feature tensors for each image.
+            list[torch.Tensor]: List of pose feature tensors for each image, where
+                each tensor contains normalized keypoint coordinates.
         """
         images, _ = self.transform(batch)
         features = self.backbone(images.tensors)
diff --git a/src/anomalib/models/video/ai_vad/flow.py b/src/anomalib/models/video/ai_vad/flow.py
index 9728a23290..fc1fb2b68e 100644
--- a/src/anomalib/models/video/ai_vad/flow.py
+++ b/src/anomalib/models/video/ai_vad/flow.py
@@ -1,4 +1,23 @@
-"""Optical Flow extraction module for AI-VAD implementation."""
+"""Optical Flow extraction module for AI-VAD implementation.
+
+This module implements the optical flow extraction stage of the AI-VAD model. It uses
+RAFT (Recurrent All-Pairs Field Transforms) to compute dense optical flow between
+consecutive video frames.
+
+Example:
+    >>> from anomalib.models.video.ai_vad.flow import FlowExtractor
+    >>> import torch
+    >>> extractor = FlowExtractor()
+    >>> first_frame = torch.randn(32, 3, 256, 256)  # (N, C, H, W)
+    >>> last_frame = torch.randn(32, 3, 256, 256)  # (N, C, H, W)
+    >>> flow = extractor(first_frame, last_frame)
+    >>> flow.shape
+    torch.Size([32, 2, 256, 256])
+
+The module provides the following components:
+    - :class:`FlowExtractor`: Main class that handles optical flow computation using
+      RAFT model
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/models/video/ai_vad/lightning_model.py b/src/anomalib/models/video/ai_vad/lightning_model.py
index 3afd674673..ebca72a289 100644
--- a/src/anomalib/models/video/ai_vad/lightning_model.py
+++ b/src/anomalib/models/video/ai_vad/lightning_model.py
@@ -1,6 +1,38 @@
-"""Attribute-based Representations for Accurate and Interpretable Video Anomaly Detection.
+"""AI-VAD.
 
-Paper https://arxiv.org/pdf/2212.00789.pdf
+Attribute-based Representations for Accurate and Interpretable Video Anomaly
+Detection.
+
+This module implements the AI-VAD model as described in the paper "AI-VAD:
+Attribute-based Representations for Accurate and Interpretable Video Anomaly
+Detection."
+
+The model extracts regions of interest from video frames using object detection and
+foreground detection, then computes attribute-based representations including
+velocity, pose and deep features for anomaly detection.
+
+Example:
+    >>> from anomalib.models.video import AiVad
+    >>> from anomalib.data import Avenue
+    >>> from anomalib.data.utils import VideoTargetFrame
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and datamodule
+    >>> datamodule = Avenue(
+    ...     clip_length_in_frames=2,
+    ...     frames_between_clips=1,
+    ...     target_frame=VideoTargetFrame.LAST
+    ... )
+    >>> model = AiVad()
+
+    >>> # Train using the engine
+    >>> engine = Engine()
+    >>> engine.fit(model=model, datamodule=datamodule)
+
+Reference:
+    Tal Reiss, Yedid Hoshen. "AI-VAD: Attribute-based Representations for Accurate
+    and Interpretable Video Anomaly Detection." arXiv preprint arXiv:2212.00789
+    (2022). https://arxiv.org/pdf/2212.00789.pdf
 """
 
 # Copyright (C) 2023-2024 Intel Corporation
@@ -26,42 +58,70 @@
 
 
 class AiVad(MemoryBankMixin, AnomalibModule):
-    """AI-VAD: Attribute-based Representations for Accurate and Interpretable Video Anomaly Detection.
+    """AI-VAD: Attribute-based Representations for Video Anomaly Detection.
+
+    This model extracts regions of interest from video frames using object detection and
+    foreground detection, then computes attribute-based representations including
+    velocity, pose and deep features for anomaly detection.
 
     Args:
-        box_score_thresh (float): Confidence threshold for bounding box predictions.
-            Defaults to ``0.7``.
-        persons_only (bool): When enabled, only regions labeled as person are included.
-            Defaults to ``False``.
-        min_bbox_area (int): Minimum bounding box area. Regions with a surface area lower than this value are excluded.
-            Defaults to ``100``.
-        max_bbox_overlap (float): Maximum allowed overlap between bounding boxes.
-            Defaults to ``0.65``.
-        enable_foreground_detections (bool): Add additional foreground detections based on pixel difference between
-            consecutive frames.
+        box_score_thresh (float, optional): Confidence threshold for bounding box
+            predictions. Defaults to ``0.7``.
+        persons_only (bool, optional): When enabled, only regions labeled as person are
+            included. Defaults to ``False``.
+        min_bbox_area (int, optional): Minimum bounding box area. Regions with surface
+            area lower than this value are excluded. Defaults to ``100``.
+        max_bbox_overlap (float, optional): Maximum allowed overlap between bounding
+            boxes. Defaults to ``0.65``.
+        enable_foreground_detections (bool, optional): Add additional foreground
+            detections based on pixel difference between consecutive frames.
             Defaults to ``True``.
-        foreground_kernel_size (int): Gaussian kernel size used in foreground detection.
-            Defaults to ``3``.
-        foreground_binary_threshold (int): Value between 0 and 255 which acts as binary threshold in foreground
-            detection.
-            Defaults to ``18``.
-        n_velocity_bins (int): Number of discrete bins used for velocity histogram features.
-            Defaults to ``1``.
-        use_velocity_features (bool): Flag indicating if velocity features should be used.
-            Defaults to ``True``.
-        use_pose_features (bool): Flag indicating if pose features should be used.
-            Defaults to ``True``.
-        use_deep_features (bool): Flag indicating if deep features should be used.
-            Defaults to ``True``.
-        n_components_velocity (int): Number of components used by GMM density estimation for velocity features.
-            Defaults to ``2``.
-        n_neighbors_pose (int): Number of neighbors used in KNN density estimation for pose features.
-            Defaults to ``1``.
-        n_neighbors_deep (int): Number of neighbors used in KNN density estimation for deep features.
-            Defaults to ``1``.
-        pre_processor (PreProcessor, optional): Pre-processor for the model.
-            This is used to pre-process the input data before it is passed to the model.
-            Defaults to ``None``.
+        foreground_kernel_size (int, optional): Gaussian kernel size used in foreground
+            detection. Defaults to ``3``.
+        foreground_binary_threshold (int, optional): Value between 0 and 255 which acts
+            as binary threshold in foreground detection. Defaults to ``18``.
+        n_velocity_bins (int, optional): Number of discrete bins used for velocity
+            histogram features. Defaults to ``1``.
+        use_velocity_features (bool, optional): Flag indicating if velocity features
+            should be used. Defaults to ``True``.
+        use_pose_features (bool, optional): Flag indicating if pose features should be
+            used. Defaults to ``True``.
+        use_deep_features (bool, optional): Flag indicating if deep features should be
+            used. Defaults to ``True``.
+        n_components_velocity (int, optional): Number of components used by GMM density
+            estimation for velocity features. Defaults to ``2``.
+        n_neighbors_pose (int, optional): Number of neighbors used in KNN density
+            estimation for pose features. Defaults to ``1``.
+        n_neighbors_deep (int, optional): Number of neighbors used in KNN density
+            estimation for deep features. Defaults to ``1``.
+        pre_processor (PreProcessor | bool, optional): Pre-processor instance or bool
+            flag to enable default pre-processor. Defaults to ``True``.
+        post_processor (PostProcessor | bool, optional): Post-processor instance or bool
+            flag to enable default post-processor. Defaults to ``True``.
+        **kwargs: Additional keyword arguments passed to the parent class.
+
+    Example:
+        >>> from anomalib.models.video import AiVad
+        >>> from anomalib.data import Avenue
+        >>> from anomalib.data.utils import VideoTargetFrame
+        >>> from anomalib.engine import Engine
+
+        >>> # Initialize model and datamodule
+        >>> datamodule = Avenue(
+        ...     clip_length_in_frames=2,
+        ...     frames_between_clips=1,
+        ...     target_frame=VideoTargetFrame.LAST
+        ... )
+        >>> model = AiVad()
+
+        >>> # Train using the engine
+        >>> engine = Engine()
+        >>> engine.fit(model=model, datamodule=datamodule)
+
+    Note:
+        The model follows a one-class learning approach and does not require
+        optimization during training. Instead, it builds density estimators based on
+        extracted features from normal samples.
     """
 
     def __init__(
@@ -115,7 +175,7 @@ def training_step(self, batch: VideoBatch) -> None:
         Extract features from the batch of clips and update the density estimators.
 
         Args:
-            batch (Batch): Batch containing image filename, image, label and mask
+            batch (VideoBatch): Batch containing video frames and metadata.
         """
         features_per_batch = self.model(batch.image)
 
@@ -128,7 +188,11 @@ def training_step(self, batch: VideoBatch) -> None:
         return torch.tensor(0.0, requires_grad=True, device=self.device)
 
     def fit(self) -> None:
-        """Fit the density estimators to the extracted features from the training set."""
+        """Fit the density estimators to the extracted features from the training set.
+
+        Raises:
+            ValueError: If no regions were extracted during training.
+        """
         if self.total_detections == 0:
             msg = "No regions were extracted during training."
             raise ValueError(msg)
@@ -137,15 +201,15 @@ def fit(self) -> None:
     def validation_step(self, batch: VideoBatch, *args, **kwargs) -> STEP_OUTPUT:
         """Perform the validation step of AI-VAD.
 
-        Extract boxes and box scores..
+        Extract boxes and box scores from the input batch.
 
         Args:
-            batch (Batch): Input batch
-            *args: Arguments.
-            **kwargs: Keyword arguments.
+            batch (VideoBatch): Input batch containing video frames and metadata.
+            *args: Additional arguments (unused).
+            **kwargs: Additional keyword arguments (unused).
 
         Returns:
-            Batch dictionary with added boxes and box scores.
+            STEP_OUTPUT: Batch dictionary with added predictions and anomaly maps.
         """
         del args, kwargs  # Unused arguments.
 
@@ -154,15 +218,19 @@ def validation_step(self, batch: VideoBatch, *args, **kwargs) -> STEP_OUTPUT:
 
     @property
     def trainer_arguments(self) -> dict[str, Any]:
-        """AI-VAD specific trainer arguments."""
+        """Get AI-VAD specific trainer arguments.
+
+        Returns:
+            dict[str, Any]: Dictionary of trainer arguments.
+        """
         return {"gradient_clip_val": 0, "max_epochs": 1, "num_sanity_val_steps": 0}
 
     @property
     def learning_type(self) -> LearningType:
-        """Return the learning type of the model.
+        """Get the learning type of the model.
 
         Returns:
-            LearningType: Learning type of the model.
+            LearningType: Learning type of the model (ONE_CLASS).
         """
         return LearningType.ONE_CLASS
 
@@ -172,11 +240,22 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
 
         AI-VAD does not need a pre-processor or transforms, as the region- and
         feature-extractors apply their own transforms.
+
+        Args:
+            image_size (tuple[int, int] | None, optional): Image size (unused).
+                Defaults to ``None``.
+
+        Returns:
+            PreProcessor: Empty pre-processor instance.
         """
         del image_size
         return PreProcessor()  # A pre-processor with no transforms.
 
     @staticmethod
     def configure_post_processor() -> PostProcessor:
-        """Return the default post-processor for AI-VAD."""
+        """Configure the post-processor for AI-VAD.
+
+        Returns:
+            PostProcessor: One-class post-processor instance.
+        """
         return OneClassPostProcessor()
diff --git a/src/anomalib/models/video/ai_vad/regions.py b/src/anomalib/models/video/ai_vad/regions.py
index 441af32493..0ca7a4bed4 100644
--- a/src/anomalib/models/video/ai_vad/regions.py
+++ b/src/anomalib/models/video/ai_vad/regions.py
@@ -1,4 +1,20 @@
-"""Regions extraction module of AI-VAD model implementation."""
+"""Regions extraction module of AI-VAD model implementation.
+
+This module implements the region extraction stage of the AI-VAD model. It extracts
+regions of interest from video frames using object detection and foreground
+detection.
+
+Example:
+    >>> from anomalib.models.video.ai_vad.regions import RegionExtractor
+    >>> import torch
+    >>> extractor = RegionExtractor()
+    >>> frames = torch.randn(32, 2, 3, 256, 256)  # (N, L, C, H, W)
+    >>> regions = extractor(frames)
+
+The module provides the following components:
+    - :class:`RegionExtractor`: Main class that handles region extraction using
+      object detection and foreground detection
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -17,23 +33,35 @@
 class RegionExtractor(nn.Module):
     """Region extractor for AI-VAD.
 
+    This class extracts regions of interest from video frames using object detection and
+    foreground detection. It uses a Mask R-CNN model for object detection and can
+    optionally detect foreground regions based on frame differences.
+
     Args:
-        box_score_thresh (float): Confidence threshold for bounding box predictions.
-            Defaults to ``0.8``.
-        persons_only (bool): When enabled, only regions labeled as person are included.
-            Defaults to ``False``.
-        min_bbox_area (int): Minimum bounding box area. Regions with a surface area lower than this value are excluded.
-            Defaults to ``100``.
-        max_bbox_overlap (float): Maximum allowed overlap between bounding boxes.
-            Defaults to ``0.65``.
-        enable_foreground_detections (bool): Add additional foreground detections based on pixel difference between
-            consecutive frames.
+        box_score_thresh (float, optional): Confidence threshold for bounding box
+            predictions. Defaults to ``0.8``.
+        persons_only (bool, optional): When enabled, only regions labeled as person are
+            included. Defaults to ``False``.
+        min_bbox_area (int, optional): Minimum bounding box area. Regions with a surface
+            area lower than this value are excluded. Defaults to ``100``.
+        max_bbox_overlap (float, optional): Maximum allowed overlap between bounding
+            boxes. Defaults to ``0.65``.
+        enable_foreground_detections (bool, optional): Add additional foreground
+            detections based on pixel difference between consecutive frames.
             Defaults to ``True``.
-        foreground_kernel_size (int): Gaussian kernel size used in foreground detection.
-            Defaults to ``3``.
-        foreground_binary_threshold (int): Value between 0 and 255 which acts as binary threshold in foreground
-            detection.
-            Defaults to ``18``.
+        foreground_kernel_size (int, optional): Gaussian kernel size used in foreground
+            detection. Defaults to ``3``.
+        foreground_binary_threshold (int, optional): Value between 0 and 255 which acts
+            as binary threshold in foreground detection. Defaults to ``18``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.models.video.ai_vad.regions import RegionExtractor
+        >>> extractor = RegionExtractor()
+        >>> first_frame = torch.randn(2, 3, 256, 256)  # (N, C, H, W)
+        >>> last_frame = torch.randn(2, 3, 256, 256)  # (N, C, H, W)
+        >>> regions = extractor(first_frame, last_frame)
+        >>> # Returns list of dicts with keys: boxes, labels, scores, masks
     """
 
     def __init__(
@@ -61,13 +89,24 @@ def __init__(
     def forward(self, first_frame: torch.Tensor, last_frame: torch.Tensor) -> list[dict]:
         """Perform forward-pass through region extractor.
 
+        The forward pass consists of:
+        1. Object detection on the last frame using Mask R-CNN
+        2. Optional foreground detection by comparing first and last frames
+        3. Post-processing to filter and refine detections
+
         Args:
-            first_frame (torch.Tensor): Batch of input images of shape (N, C, H, W)
+            first_frame (torch.Tensor): Batch of input images of shape ``(N, C, H, W)``
                 forming the first frames in the clip.
-            last_frame (torch.Tensor): Batch of input images of shape (N, C, H, W) forming the last frame in the clip.
+            last_frame (torch.Tensor): Batch of input images of shape ``(N, C, H, W)``
+                forming the last frame in the clip.
 
         Returns:
-            list[dict]: List of Mask RCNN predictions for each image in the batch.
+            list[dict]: List of Mask R-CNN predictions for each image in the batch. Each
+                dict contains:
+                - boxes (torch.Tensor): Detected bounding boxes
+                - labels (torch.Tensor): Class labels for each detection
+                - scores (torch.Tensor): Confidence scores for each detection
+                - masks (torch.Tensor): Instance segmentation masks
         """
         with torch.no_grad():
             regions = self.backbone(last_frame)
@@ -93,21 +132,30 @@ def _add_foreground_boxes(
     ) -> list[dict[str, torch.Tensor]]:
         """Add any foreground regions that were not detected by the region extractor.
 
-        This method adds regions that likely belong to the foreground of the video scene, but were not detected by the
-        region extractor module. The foreground pixels are determined by taking the pixel difference between two
-        consecutive video frames and applying a binary threshold. The final detections consist of all connected
-        components in the foreground that do not fall in one of the bounding boxes predicted by the region extractor.
+        This method adds regions that likely belong to the foreground of the video
+        scene, but were not detected by the region extractor module. The foreground
+        pixels are determined by taking the pixel difference between two consecutive
+        video frames and applying a binary threshold. The final detections consist of
+        all connected components in the foreground that do not fall in one of the
+        bounding boxes predicted by the region extractor.
 
         Args:
-            regions (list[dict[str, torch.Tensor]]): Region detections for a batch of images, generated by the region
-                extraction module.
-            first_frame (torch.Tensor): video frame at time t-1
-            last_frame (torch.Tensor): Video frame time t
-            kernel_size (int): Kernel size for Gaussian smoothing applied to input frames
-            binary_threshold (int): Binary threshold used in foreground detection, should be in range [0, 255]
+            regions (list[dict[str, torch.Tensor]]): Region detections for a batch of
+                images, generated by the region extraction module.
+            first_frame (torch.Tensor): Video frame at time t-1
+            last_frame (torch.Tensor): Video frame at time t
+            kernel_size (int): Kernel size for Gaussian smoothing applied to input
+                frames
+            binary_threshold (int): Binary threshold used in foreground detection,
+                should be in range ``[0, 255]``
 
         Returns:
-            list[dict[str, torch.Tensor]]: region detections with foreground regions appended
+            list[dict[str, torch.Tensor]]: Region detections with foreground regions
+                appended. Each dict contains:
+                - boxes (torch.Tensor): Updated bounding boxes
+                - labels (torch.Tensor): Updated class labels
+                - scores (torch.Tensor): Updated confidence scores
+                - masks (torch.Tensor): Updated instance masks
         """
         # apply gaussian blur to first and last frame
         first_frame = gaussian_blur(first_frame, [kernel_size, kernel_size])
@@ -157,14 +205,16 @@ def _add_foreground_boxes(
     def post_process_bbox_detections(self, regions: list[dict[str, torch.Tensor]]) -> list[dict[str, torch.Tensor]]:
         """Post-process the region detections.
 
-        The region detections are filtered based on class label, bbox area and overlap with other regions.
+        The region detections are filtered based on class label, bbox area and overlap
+        with other regions.
 
         Args:
-            regions (list[dict[str, torch.Tensor]]): Region detections for a batch of images, generated by the region
-                extraction module.
+            regions (list[dict[str, torch.Tensor]]): Region detections for a batch of
+                images, generated by the region extraction module.
 
         Returns:
-            list[dict[str, torch.Tensor]]: Filtered regions
+            list[dict[str, torch.Tensor]]: Filtered regions containing only valid
+                detections based on the filtering criteria.
         """
         filtered_regions_list = []
         for img_regions in regions:
@@ -175,13 +225,15 @@ def post_process_bbox_detections(self, regions: list[dict[str, torch.Tensor]]) -
         return filtered_regions_list
 
     def _keep_only_persons(self, regions: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]:
-        """Remove all region detections that are not labeled as a person by the region extractor.
+        """Remove all region detections that are not labeled as a person.
 
         Args:
-            regions (dict[str, torch.Tensor]): Region detections for a single image in the batch.
+            regions (dict[str, torch.Tensor]): Region detections for a single image in
+                the batch.
 
         Returns:
-            dict[str, torch.Tensor]: Region detections from which non-person objects have been removed.
+            dict[str, torch.Tensor]: Region detections from which non-person objects
+                have been removed.
         """
         keep = torch.where(regions["labels"] == PERSON_LABEL)
         return self.subsample_regions(regions, keep)
@@ -190,11 +242,14 @@ def _filter_by_area(self, regions: dict[str, torch.Tensor], min_area: int) -> di
         """Remove all regions with a surface area smaller than the specified value.
 
         Args:
-            regions (dict[str, torch.Tensor]): Region detections for a single image in the batch.
-            min_area (int): Minimum bounding box area. Regions with a surface area lower than this value are excluded.
+            regions (dict[str, torch.Tensor]): Region detections for a single image in
+                the batch.
+            min_area (int): Minimum bounding box area. Regions with a surface area
+                lower than this value are excluded.
 
         Returns:
-            dict[str, torch.Tensor]: Region detections from which small regions have been removed.
+            dict[str, torch.Tensor]: Region detections from which small regions have
+                been removed.
         """
         areas = box_area(regions["boxes"])
         keep = torch.where(areas > min_area)
@@ -203,16 +258,20 @@ def _filter_by_area(self, regions: dict[str, torch.Tensor], min_area: int) -> di
     def _delete_overlapping_boxes(self, regions: dict[str, torch.Tensor], threshold: float) -> dict[str, torch.Tensor]:
         """Delete overlapping bounding boxes.
 
-        For each bounding box, the overlap with all other bounding boxes relative to their own surface area is computed.
-        When the relative overlap with any other box is higher than the specified threshold, the box is removed. when
-        both boxes have a relative overlap higher than the threshold, only the smaller box is removed.
+        For each bounding box, the overlap with all other bounding boxes relative to
+        their own surface area is computed. When the relative overlap with any other
+        box is higher than the specified threshold, the box is removed. When both boxes
+        have a relative overlap higher than the threshold, only the smaller box is
+        removed.
 
         Args:
-            regions (dict[str, torch.Tensor]): Region detections for a single image in the batch.
+            regions (dict[str, torch.Tensor]): Region detections for a single image in
+                the batch.
             threshold (float): Maximum allowed overlap between bounding boxes.
 
         Returns:
-            dict[str, torch.Tensor]: Region detections from which overlapping regions have been removed.
+            dict[str, torch.Tensor]: Region detections from which overlapping regions
+                have been removed.
         """
         # sort boxes by area
         areas = box_area(regions["boxes"])
@@ -240,11 +299,13 @@ def subsample_regions(regions: dict[str, torch.Tensor], indices: torch.Tensor) -
         """Subsample the items in a region dictionary based on a Tensor of indices.
 
         Args:
-            regions (dict[str, torch.Tensor]): Region detections for a single image in the batch.
+            regions (dict[str, torch.Tensor]): Region detections for a single image in
+                the batch.
             indices (torch.Tensor): Indices of region detections that should be kept.
 
         Returns:
-            dict[str, torch.Tensor]: Subsampled region detections.
+            dict[str, torch.Tensor]: Subsampled region detections containing only the
+                specified indices.
         """
         new_regions_dict = {}
         for key, value in regions.items():
diff --git a/src/anomalib/models/video/ai_vad/torch_model.py b/src/anomalib/models/video/ai_vad/torch_model.py
index 2679470d01..dfe3e563f6 100644
--- a/src/anomalib/models/video/ai_vad/torch_model.py
+++ b/src/anomalib/models/video/ai_vad/torch_model.py
@@ -1,6 +1,31 @@
 """PyTorch model for AI-VAD model implementation.
 
-Paper https://arxiv.org/pdf/2212.00789.pdf
+This module implements the AI-VAD model as described in the paper
+"AI-VAD: Attribute-based Representations for Accurate and Interpretable Video
+Anomaly Detection."
+
+Example:
+    >>> from anomalib.models.video import AiVad
+    >>> from anomalib.data import Avenue
+    >>> from anomalib.data.utils import VideoTargetFrame
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and datamodule
+    >>> datamodule = Avenue(
+    ...     clip_length_in_frames=2,
+    ...     frames_between_clips=1,
+    ...     target_frame=VideoTargetFrame.LAST
+    ... )
+    >>> model = AiVad()
+
+    >>> # Train using the engine
+    >>> engine = Engine()
+    >>> engine.fit(model=model, datamodule=datamodule)
+
+Reference:
+    Tal Reiss, Yedid Hoshen. "AI-VAD: Attribute-based Representations for Accurate and
+    Interpretable Video Anomaly Detection." arXiv preprint arXiv:2212.00789 (2022).
+    https://arxiv.org/pdf/2212.00789.pdf
 """
 
 # Copyright (C) 2023-2024 Intel Corporation
@@ -20,37 +45,55 @@
 class AiVadModel(nn.Module):
     """AI-VAD model.
 
+    The model consists of several stages:
+    1. Flow extraction between consecutive frames
+    2. Region extraction using object detection and foreground detection
+    3. Feature extraction including velocity, pose and deep features
+    4. Density estimation for anomaly detection
+
     Args:
-        box_score_thresh (float): Confidence threshold for region extraction stage.
-            Defaults to ``0.8``.
-        persons_only (bool): When enabled, only regions labeled as person are included.
-            Defaults to ``False``.
-        min_bbox_area (int): Minimum bounding box area. Regions with a surface area lower than this value are excluded.
-            Defaults to ``100``.
-        max_bbox_overlap (float): Maximum allowed overlap between bounding boxes.
-            Defaults to ``0.65``.
-        enable_foreground_detections (bool): Add additional foreground detections based on pixel difference between
-            consecutive frames.
-            Defaults to ``True``.
-        foreground_kernel_size (int): Gaussian kernel size used in foreground detection.
-            Defaults to ``3``.
-        foreground_binary_threshold (int): Value between 0 and 255 which acts as binary threshold in foreground
-            detection.
-            Defaults to ``18``.
-        n_velocity_bins (int): Number of discrete bins used for velocity histogram features.
-            Defaults to ``8``.
-        use_velocity_features (bool): Flag indicating if velocity features should be used.
-            Defaults to ``True``.
-        use_pose_features (bool): Flag indicating if pose features should be used.
+        box_score_thresh (float, optional): Confidence threshold for region extraction
+            stage. Defaults to ``0.8``.
+        persons_only (bool, optional): When enabled, only regions labeled as person are
+            included. Defaults to ``False``.
+        min_bbox_area (int, optional): Minimum bounding box area. Regions with a surface
+            area lower than this value are excluded. Defaults to ``100``.
+        max_bbox_overlap (float, optional): Maximum allowed overlap between bounding
+            boxes. Defaults to ``0.65``.
+        enable_foreground_detections (bool, optional): Add additional foreground
+            detections based on pixel difference between consecutive frames.
             Defaults to ``True``.
-        use_deep_features (bool): Flag indicating if deep features should be used.
-            Defaults to ``True``.
-        n_components_velocity (int): Number of components used by GMM density estimation for velocity features.
-            Defaults to ``5``.
-        n_neighbors_pose (int): Number of neighbors used in KNN density estimation for pose features.
-            Defaults to ``1``.
-        n_neighbors_deep (int): Number of neighbors used in KNN density estimation for deep features.
-            Defaults to ``1``.
+        foreground_kernel_size (int, optional): Gaussian kernel size used in foreground
+            detection. Defaults to ``3``.
+        foreground_binary_threshold (int, optional): Value between 0 and 255 which acts
+            as binary threshold in foreground detection. Defaults to ``18``.
+        n_velocity_bins (int, optional): Number of discrete bins used for velocity
+            histogram features. Defaults to ``8``.
+        use_velocity_features (bool, optional): Flag indicating if velocity features
+            should be used. Defaults to ``True``.
+        use_pose_features (bool, optional): Flag indicating if pose features should be
+            used. Defaults to ``True``.
+        use_deep_features (bool, optional): Flag indicating if deep features should be
+            used. Defaults to ``True``.
+        n_components_velocity (int, optional): Number of components used by GMM density
+            estimation for velocity features. Defaults to ``5``.
+        n_neighbors_pose (int, optional): Number of neighbors used in KNN density
+            estimation for pose features. Defaults to ``1``.
+        n_neighbors_deep (int, optional): Number of neighbors used in KNN density
+            estimation for deep features. Defaults to ``1``.
+
+    Raises:
+        ValueError: If none of the feature types (velocity, pose, deep) are enabled.
+
+    Example:
+        >>> from anomalib.models.video.ai_vad.torch_model import AiVadModel
+        >>> model = AiVadModel()
+        >>> batch = torch.randn(32, 2, 3, 256, 256)  # (N, L, C, H, W)
+        >>> output = model(batch)
+        >>> output.pred_score.shape
+        torch.Size([32])
+        >>> output.anomaly_map.shape
+        torch.Size([32, 256, 256])
     """
 
     def __init__(
@@ -110,13 +153,31 @@ def __init__(
     def forward(self, batch: torch.Tensor) -> InferenceBatch:
         """Forward pass through AI-VAD model.
 
+        The forward pass consists of the following steps:
+        1. Extract first and last frame from input clip
+        2. Extract optical flow between frames and detect regions of interest
+        3. Extract features (velocity, pose, deep) for each region
+        4. Estimate density and compute anomaly scores
+
         Args:
-            batch (torch.Tensor): Input image of shape (N, L, C, H, W)
+            batch (torch.Tensor): Input tensor of shape ``(N, L, C, H, W)`` where:
+                - ``N``: Batch size
+                - ``L``: Sequence length
+                - ``C``: Number of channels
+                - ``H``: Height
+                - ``W``: Width
 
         Returns:
-            list[torch.Tensor]: List of bbox locations for each image.
-            list[torch.Tensor]: List of per-bbox anomaly scores for each image.
-            list[torch.Tensor]: List of per-image anomaly scores.
+            InferenceBatch: Batch containing:
+                - ``pred_score``: Per-image anomaly scores of shape ``(N,)``
+                - ``anomaly_map``: Per-pixel anomaly scores of shape ``(N, H, W)``
+
+        Example:
+            >>> batch = torch.randn(32, 2, 3, 256, 256)
+            >>> model = AiVadModel()
+            >>> output = model(batch)
+            >>> output.pred_score.shape, output.anomaly_map.shape
+            (torch.Size([32]), torch.Size([32, 256, 256]))
         """
         self.flow_extractor.eval()
         self.region_extractor.eval()
diff --git a/src/anomalib/pipelines/__init__.py b/src/anomalib/pipelines/__init__.py
index 0ca537d4de..3612aed388 100644
--- a/src/anomalib/pipelines/__init__.py
+++ b/src/anomalib/pipelines/__init__.py
@@ -1,4 +1,27 @@
-"""Pipelines for end-to-end usecases."""
+"""Pipelines for end-to-end anomaly detection use cases.
+
+This module provides high-level pipeline implementations for common anomaly detection
+workflows:
+
+- :class:`Benchmark`: Pipeline for benchmarking model performance across datasets
+
+The pipelines handle:
+    - Configuration and setup
+    - Data loading and preprocessing
+    - Model training and evaluation
+    - Result collection and analysis
+    - Logging and visualization
+
+Example:
+    >>> from anomalib.pipelines import Benchmark
+    >>> benchmark = Benchmark(config_path="config.yaml")
+    >>> results = benchmark.run()
+
+The pipelines leverage components from :mod:`anomalib.pipelines.components` for:
+    - Job management and execution
+    - Parameter grid search
+    - Result gathering
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pipelines/benchmark/__init__.py b/src/anomalib/pipelines/benchmark/__init__.py
index bfb34aded2..759ba32276 100644
--- a/src/anomalib/pipelines/benchmark/__init__.py
+++ b/src/anomalib/pipelines/benchmark/__init__.py
@@ -1,4 +1,23 @@
-"""Benchmarking."""
+"""Benchmarking pipeline for anomaly detection models.
+
+This module provides functionality for benchmarking anomaly detection models in
+anomalib. The benchmarking pipeline allows evaluating and comparing multiple models
+across different datasets and metrics.
+
+Example:
+    >>> from anomalib.pipelines import Benchmark
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Padim, Patchcore
+
+    >>> # Initialize benchmark with models and datasets
+    >>> benchmark = Benchmark(
+    ...     models=[Padim(), Patchcore()],
+    ...     datasets=[MVTec(category="bottle"), MVTec(category="cable")]
+    ... )
+
+    >>> # Run benchmark
+    >>> results = benchmark.run()
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pipelines/benchmark/generator.py b/src/anomalib/pipelines/benchmark/generator.py
index 988e0111b7..2da6f93dfd 100644
--- a/src/anomalib/pipelines/benchmark/generator.py
+++ b/src/anomalib/pipelines/benchmark/generator.py
@@ -1,4 +1,22 @@
-"""Benchmark job generator."""
+"""Benchmark job generator for running model benchmarking experiments.
+
+This module provides functionality for generating benchmark jobs that evaluate model
+performance. It generates jobs based on provided configurations for models,
+datasets and other parameters.
+
+Example:
+    >>> from anomalib.pipelines.benchmark.generator import BenchmarkJobGenerator
+    >>> generator = BenchmarkJobGenerator(accelerator="gpu")
+    >>> args = {
+    ...     "seed": 42,
+    ...     "model": {"class_path": "Padim"},
+    ...     "data": {"class_path": "MVTec", "init_args": {"category": "bottle"}}
+    ... }
+    >>> jobs = list(generator.generate_jobs(args, None))
+
+The generator creates :class:`BenchmarkJob` instances that can be executed to run
+benchmarking experiments with specified models and datasets.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -17,10 +35,25 @@
 
 
 class BenchmarkJobGenerator(JobGenerator):
-    """Generate BenchmarkJob.
+    """Generate benchmark jobs for evaluating model performance.
+
+    This class generates benchmark jobs based on provided configurations for models,
+    datasets and other parameters. Each job evaluates a specific model-dataset
+    combination.
 
     Args:
-        accelerator (str): The accelerator to use.
+        accelerator (str): Type of accelerator to use for running the jobs (e.g.
+            ``"cpu"``, ``"gpu"``).
+
+    Example:
+        >>> from anomalib.pipelines.benchmark.generator import BenchmarkJobGenerator
+        >>> generator = BenchmarkJobGenerator(accelerator="gpu")
+        >>> args = {
+        ...     "seed": 42,
+        ...     "model": {"class_path": "Padim"},
+        ...     "data": {"class_path": "MVTec", "init_args": {"category": "bottle"}}
+        ... }
+        >>> jobs = list(generator.generate_jobs(args, None))
     """
 
     def __init__(self, accelerator: str) -> None:
@@ -28,7 +61,11 @@ def __init__(self, accelerator: str) -> None:
 
     @property
     def job_class(self) -> type:
-        """Return the job class."""
+        """Get the job class used by this generator.
+
+        Returns:
+            type: The :class:`BenchmarkJob` class.
+        """
         return BenchmarkJob
 
     @hide_output
@@ -37,7 +74,27 @@ def generate_jobs(
         args: dict,
         previous_stage_result: PREV_STAGE_RESULT,
     ) -> Generator[BenchmarkJob, None, None]:
-        """Return iterator based on the arguments."""
+        """Generate benchmark jobs from the provided arguments.
+
+        Args:
+            args (dict): Dictionary containing job configuration including model,
+                dataset and other parameters.
+            previous_stage_result (PREV_STAGE_RESULT): Results from previous pipeline
+                stage (unused).
+
+        Yields:
+            Generator[BenchmarkJob, None, None]: Generator yielding benchmark job
+                instances.
+
+        Example:
+            >>> generator = BenchmarkJobGenerator(accelerator="cpu")
+            >>> args = {
+            ...     "seed": 42,
+            ...     "model": {"class_path": "Padim"},
+            ...     "data": {"class_path": "MVTec"}
+            ... }
+            >>> jobs = list(generator.generate_jobs(args, None))
+        """
         del previous_stage_result  # Not needed for this job
         for _container in get_iterator_from_grid_dict(args):
             # Pass experimental configs as a flatten dictionary to the job runner.
diff --git a/src/anomalib/pipelines/benchmark/job.py b/src/anomalib/pipelines/benchmark/job.py
index d98b689304..dccacf77e7 100644
--- a/src/anomalib/pipelines/benchmark/job.py
+++ b/src/anomalib/pipelines/benchmark/job.py
@@ -1,4 +1,32 @@
-"""Benchmarking job."""
+"""Benchmarking job for evaluating model performance.
+
+This module provides functionality for running individual benchmarking jobs that
+evaluate model performance on specific datasets. Each job runs a model on a dataset
+and collects performance metrics.
+
+Example:
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Padim
+    >>> from anomalib.pipelines.benchmark.job import BenchmarkJob
+
+    >>> # Initialize model, datamodule and job
+    >>> model = Padim()
+    >>> datamodule = MVTec(category="bottle")
+    >>> job = BenchmarkJob(
+    ...     accelerator="gpu",
+    ...     model=model,
+    ...     datamodule=datamodule,
+    ...     seed=42,
+    ...     flat_cfg={"model.name": "padim"}
+    ... )
+
+    >>> # Run the benchmark job
+    >>> results = job.run()
+
+The job executes model training and evaluation, collecting metrics like accuracy,
+F1-score, and inference time. Results are returned in a standardized format for
+comparison across different model-dataset combinations.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -25,14 +53,42 @@
 
 
 class BenchmarkJob(Job):
-    """Benchmarking job.
+    """Benchmarking job for evaluating anomaly detection models.
+
+    This class implements a benchmarking job that evaluates model performance by
+    training and testing on a given dataset. It collects metrics like accuracy,
+    F1-score, and timing information.
 
     Args:
-        accelerator (str): The accelerator to use.
-        model (AnomalibModule): The model to use.
-        datamodule (AnomalibDataModule): The data module to use.
-        seed (int): The seed to use.
-        flat_cfg (dict): The flat dictionary of configs with dotted keys.
+        accelerator (str): Type of accelerator to use for computation (e.g.
+            ``"cpu"``, ``"gpu"``).
+        model (AnomalibModule): Anomaly detection model instance to benchmark.
+        datamodule (AnomalibDataModule): Data module providing the dataset.
+        seed (int): Random seed for reproducibility.
+        flat_cfg (dict): Flattened configuration dictionary with dotted keys.
+
+    Example:
+        >>> from anomalib.data import MVTec
+        >>> from anomalib.models import Padim
+        >>> from anomalib.pipelines.benchmark.job import BenchmarkJob
+
+        >>> # Initialize model, datamodule and job
+        >>> model = Padim()
+        >>> datamodule = MVTec(category="bottle")
+        >>> job = BenchmarkJob(
+        ...     accelerator="gpu",
+        ...     model=model,
+        ...     datamodule=datamodule,
+        ...     seed=42,
+        ...     flat_cfg={"model.name": "padim"}
+        ... )
+
+        >>> # Run the benchmark job
+        >>> results = job.run()
+
+    The job executes model training and evaluation, collecting metrics like
+    accuracy, F1-score, and inference time. Results are returned in a standardized
+    format for comparison across different model-dataset combinations.
     """
 
     name = "benchmark"
@@ -57,7 +113,23 @@ def run(
         self,
         task_id: int | None = None,
     ) -> dict[str, Any]:
-        """Run the benchmark."""
+        """Run the benchmark job.
+
+        This method executes the full benchmarking pipeline including model
+        training and testing. It measures execution time for different stages and
+        collects performance metrics.
+
+        Args:
+            task_id (int | None, optional): ID of the task when running in
+                distributed mode. When provided, the job will use the specified
+                device. Defaults to ``None``.
+
+        Returns:
+            dict[str, Any]: Dictionary containing benchmark results including:
+                - Timing information (job, fit and test duration)
+                - Model configuration
+                - Performance metrics from testing
+        """
         job_start_time = time.time()
         devices: str | list[int] = "auto"
         if task_id is not None:
@@ -93,7 +165,16 @@ def run(
 
     @staticmethod
     def collect(results: list[dict[str, Any]]) -> pd.DataFrame:
-        """Gather the results returned from run."""
+        """Collect and aggregate results from multiple benchmark runs.
+
+        Args:
+            results (list[dict[str, Any]]): List of result dictionaries from
+                individual benchmark runs.
+
+        Returns:
+            pd.DataFrame: DataFrame containing aggregated results with each row
+                representing a benchmark run.
+        """
         output: dict[str, Any] = {}
         for key in results[0]:
             output[key] = []
@@ -104,7 +185,14 @@ def collect(results: list[dict[str, Any]]) -> pd.DataFrame:
 
     @staticmethod
     def save(result: pd.DataFrame) -> None:
-        """Save the result to a csv file."""
+        """Save benchmark results to CSV file.
+
+        The results are saved in the ``runs/benchmark/YYYY-MM-DD-HH_MM_SS``
+        directory. The method also prints a tabular view of the results.
+
+        Args:
+            result (pd.DataFrame): DataFrame containing benchmark results to save.
+        """
         BenchmarkJob._print_tabular_results(result)
         file_path = Path("runs") / BenchmarkJob.name / datetime.now().strftime("%Y-%m-%d-%H_%M_%S") / "results.csv"
         file_path.parent.mkdir(parents=True, exist_ok=True)
@@ -113,7 +201,12 @@ def save(result: pd.DataFrame) -> None:
 
     @staticmethod
     def _print_tabular_results(gathered_result: pd.DataFrame) -> None:
-        """Print the tabular results."""
+        """Print benchmark results in a formatted table.
+
+        Args:
+            gathered_result (pd.DataFrame): DataFrame containing results to
+                display.
+        """
         if gathered_result is not None:
             console = Console()
             table = Table(title=f"{BenchmarkJob.name} Results", show_header=True, header_style="bold magenta")
diff --git a/src/anomalib/pipelines/benchmark/pipeline.py b/src/anomalib/pipelines/benchmark/pipeline.py
index 3b27caeec1..9e31c4e043 100644
--- a/src/anomalib/pipelines/benchmark/pipeline.py
+++ b/src/anomalib/pipelines/benchmark/pipeline.py
@@ -1,4 +1,27 @@
-"""Benchmarking."""
+"""Benchmarking pipeline for evaluating anomaly detection models.
+
+This module provides functionality for running benchmarking experiments that evaluate
+and compare multiple anomaly detection models. The benchmarking pipeline supports
+running experiments in parallel across multiple GPUs when available.
+
+Example:
+    >>> from anomalib.pipelines import Benchmark
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Padim, Patchcore
+
+    >>> # Initialize benchmark with models and datasets
+    >>> benchmark = Benchmark(
+    ...     models=[Padim(), Patchcore()],
+    ...     datasets=[MVTec(category="bottle"), MVTec(category="cable")]
+    ... )
+
+    >>> # Run benchmark
+    >>> results = benchmark.run()
+
+The pipeline handles setting up appropriate runners based on available hardware,
+using parallel execution when multiple GPUs are available and serial execution
+otherwise.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,11 +35,51 @@
 
 
 class Benchmark(Pipeline):
-    """Benchmarking pipeline."""
+    """Benchmarking pipeline for evaluating anomaly detection models.
+
+    This pipeline handles running benchmarking experiments that evaluate and compare
+    multiple anomaly detection models. It supports both serial and parallel execution
+    depending on available hardware.
+
+    Example:
+        >>> from anomalib.pipelines import Benchmark
+        >>> from anomalib.data import MVTec
+        >>> from anomalib.models import Padim, Patchcore
+
+        >>> # Initialize benchmark with models and datasets
+        >>> benchmark = Benchmark(
+        ...     models=[Padim(), Patchcore()],
+        ...     datasets=[MVTec(category="bottle"), MVTec(category="cable")]
+        ... )
+
+        >>> # Run benchmark
+        >>> results = benchmark.run()
+    """
 
     @staticmethod
     def _setup_runners(args: dict) -> list[Runner]:
-        """Setup the runners for the pipeline."""
+        """Set up the appropriate runners for benchmark execution.
+
+        This method configures either serial or parallel runners based on the
+        specified accelerator(s) and available hardware. For CUDA devices, parallel
+        execution is used when multiple GPUs are available.
+
+        Args:
+            args (dict): Dictionary containing configuration arguments. Must include
+                an ``"accelerator"`` key specifying either a single accelerator or
+                list of accelerators to use.
+
+        Returns:
+            list[Runner]: List of configured runner instances.
+
+        Raises:
+            ValueError: If an unsupported accelerator type is specified. Only
+                ``"cpu"`` and ``"cuda"`` are supported.
+
+        Example:
+            >>> args = {"accelerator": "cuda"}
+            >>> runners = Benchmark._setup_runners(args)
+        """
         accelerators = args["accelerator"] if isinstance(args["accelerator"], list) else [args["accelerator"]]
         runners: list[Runner] = []
         for accelerator in accelerators:
diff --git a/src/anomalib/pipelines/components/__init__.py b/src/anomalib/pipelines/components/__init__.py
index 1350937639..e831487797 100644
--- a/src/anomalib/pipelines/components/__init__.py
+++ b/src/anomalib/pipelines/components/__init__.py
@@ -1,4 +1,25 @@
-"""Utilities for the pipeline modules."""
+"""Components for building and executing pipelines.
+
+This module provides core components for constructing and running data processing
+pipelines:
+
+- :class:`Job`: Base class for defining pipeline jobs
+- :class:`JobGenerator`: Creates job instances for pipeline stages
+- :class:`Pipeline`: Manages execution flow between pipeline stages
+- :class:`Runner`: Executes jobs serially or in parallel
+
+Example:
+    >>> from anomalib.pipelines.components import Pipeline, JobGenerator
+    >>> generator = JobGenerator()
+    >>> pipeline = Pipeline([generator])
+    >>> pipeline.run({"param": "value"})
+
+The components handle:
+    - Job creation and configuration
+    - Pipeline stage organization
+    - Job execution and result gathering
+    - Error handling and logging
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pipelines/components/base/__init__.py b/src/anomalib/pipelines/components/base/__init__.py
index 90682e9cd0..4d1ec79baa 100644
--- a/src/anomalib/pipelines/components/base/__init__.py
+++ b/src/anomalib/pipelines/components/base/__init__.py
@@ -1,4 +1,28 @@
-"""Base classes for pipelines."""
+"""Base classes for pipeline components in anomalib.
+
+This module provides the core base classes used to build pipelines in anomalib:
+
+- :class:`Job`: Base class for individual pipeline jobs
+- :class:`JobGenerator`: Base class for generating pipeline jobs
+- :class:`Runner`: Base class for executing pipeline jobs
+- :class:`Pipeline`: Base class for creating complete pipelines
+
+Example:
+    >>> from anomalib.pipelines.components.base import Pipeline
+    >>> from anomalib.pipelines.components.base import Runner
+    >>> from anomalib.pipelines.components.base import Job, JobGenerator
+
+    >>> # Create custom pipeline components
+    >>> class MyJob(Job):
+    ...     pass
+    >>> class MyRunner(Runner):
+    ...     pass
+    >>> class MyPipeline(Pipeline):
+    ...     pass
+
+The base classes provide the foundation for building modular and extensible
+pipelines for tasks like training, inference and benchmarking.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pipelines/components/base/job.py b/src/anomalib/pipelines/components/base/job.py
index f10278d0f1..bdd69521e2 100644
--- a/src/anomalib/pipelines/components/base/job.py
+++ b/src/anomalib/pipelines/components/base/job.py
@@ -1,4 +1,34 @@
-"""Job from which all the jobs inherit from."""
+"""Base job class that defines the interface for pipeline jobs.
+
+This module provides the base :class:`Job` class that all pipeline jobs inherit from. Jobs
+are atomic units of work that can be executed independently, either serially or in
+parallel.
+
+Example:
+    >>> from anomalib.pipelines.components.base import Job
+    >>> class MyJob(Job):
+    ...     name = "my_job"
+    ...     def run(self, task_id=None):
+    ...         # Implement job logic
+    ...         pass
+    ...     @staticmethod
+    ...     def collect(results):
+    ...         # Combine results from multiple runs
+    ...         pass
+    ...     @staticmethod
+    ...     def save(results):
+    ...         # Save final results
+    ...         pass
+
+The base job interface defines three key methods that subclasses must implement:
+
+- :meth:`run`: Execute the core job logic
+- :meth:`collect`: Gather and combine results from multiple job runs
+- :meth:`save`: Save or export the final collected results
+
+Jobs can be used as building blocks in pipelines for tasks like training,
+inference, or benchmarking.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pipelines/components/base/pipeline.py b/src/anomalib/pipelines/components/base/pipeline.py
index 850c64afcb..8203f79b99 100644
--- a/src/anomalib/pipelines/components/base/pipeline.py
+++ b/src/anomalib/pipelines/components/base/pipeline.py
@@ -1,4 +1,27 @@
-"""Base class for pipeline."""
+"""Base class for building pipelines in anomalib.
+
+This module provides the abstract base class for creating pipelines that can execute
+jobs in a configurable way. Pipelines handle setting up runners, parsing configs,
+and orchestrating job execution.
+
+Example:
+    >>> from anomalib.pipelines.components.base import Pipeline
+    >>> class MyPipeline(Pipeline):
+    ...     def _setup_runners(self, args: dict) -> list[Runner]:
+    ...         # Configure and return list of runners
+    ...         pass
+    ...     def run(self, args: Namespace | None = None):
+    ...         # Execute pipeline logic
+    ...         pass
+
+The base pipeline interface defines key methods that subclasses must implement:
+
+- :meth:`_setup_runners`: Configure the runners that will execute pipeline jobs
+- :meth:`run`: Execute the core pipeline logic
+
+Pipelines can be used to implement workflows like training, inference, or
+benchmarking by composing jobs and runners in a modular way.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pipelines/components/base/runner.py b/src/anomalib/pipelines/components/base/runner.py
index cee46dfacb..86aa7a4222 100644
--- a/src/anomalib/pipelines/components/base/runner.py
+++ b/src/anomalib/pipelines/components/base/runner.py
@@ -1,4 +1,31 @@
-"""Base runner."""
+"""Base runner class for executing pipeline jobs.
+
+This module provides the abstract base class for runners that execute pipeline jobs.
+Runners handle the mechanics of job execution, whether serial or parallel.
+
+Example:
+    >>> from anomalib.pipelines.components.base import Runner
+    >>> from anomalib.pipelines.components.base import JobGenerator
+    >>> class MyRunner(Runner):
+    ...     def run(self, args: dict, prev_stage_results=None):
+    ...         # Implement runner logic
+    ...         pass
+
+    >>> # Create and use runner
+    >>> generator = JobGenerator()
+    >>> runner = MyRunner(generator)
+    >>> results = runner.run({"param": "value"})
+
+The base runner interface defines the core :meth:`run` method that subclasses must
+implement to execute jobs. Runners work with job generators to create and execute
+pipeline jobs.
+
+Runners can implement different execution strategies like:
+
+- Serial execution of jobs one after another
+- Parallel execution across multiple processes
+- Distributed execution across machines
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pipelines/components/runners/__init__.py b/src/anomalib/pipelines/components/runners/__init__.py
index 27ef21046f..1527244ac1 100644
--- a/src/anomalib/pipelines/components/runners/__init__.py
+++ b/src/anomalib/pipelines/components/runners/__init__.py
@@ -1,4 +1,22 @@
-"""Executor for running a single job."""
+"""Runners for executing pipeline jobs.
+
+This module provides runner implementations for executing pipeline jobs in different
+ways:
+
+- :class:`SerialRunner`: Executes jobs sequentially on a single device
+- :class:`ParallelRunner`: Executes jobs in parallel across multiple devices
+
+Example:
+    >>> from anomalib.pipelines.components.runners import SerialRunner
+    >>> from anomalib.pipelines.components.base import JobGenerator
+    >>> generator = JobGenerator()
+    >>> runner = SerialRunner(generator)
+    >>> results = runner.run({"param": "value"})
+
+The runners handle the mechanics of job execution while working with job generators
+to create and execute pipeline jobs. They implement the :class:`Runner` interface
+defined in ``anomalib.pipelines.components.base``.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pipelines/components/runners/parallel.py b/src/anomalib/pipelines/components/runners/parallel.py
index 148980a6c2..4064edf71c 100644
--- a/src/anomalib/pipelines/components/runners/parallel.py
+++ b/src/anomalib/pipelines/components/runners/parallel.py
@@ -1,4 +1,26 @@
-"""Process pool executor."""
+"""Parallel execution of pipeline jobs using process pools.
+
+This module provides the :class:`ParallelRunner` class for executing pipeline jobs in
+parallel across multiple processes. It uses Python's :class:`ProcessPoolExecutor` to
+manage a pool of worker processes.
+
+Example:
+    >>> from anomalib.pipelines.components.runners import ParallelRunner
+    >>> from anomalib.pipelines.components.base import JobGenerator
+    >>> generator = JobGenerator()
+    >>> runner = ParallelRunner(generator, n_jobs=4)
+    >>> results = runner.run({"param": "value"})
+
+The parallel runner handles:
+
+- Creating and managing a pool of worker processes
+- Distributing jobs across available workers
+- Collecting and combining results from parallel executions
+- Error handling for failed jobs
+
+The number of parallel jobs can be configured based on available compute resources
+like CPU cores or GPUs.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -22,26 +44,42 @@ class ParallelExecutionError(Exception):
 
 
 class ParallelRunner(Runner):
-    """Run the job in parallel using a process pool.
+    """Run jobs in parallel using a process pool.
 
-    It creates a pool of processes and submits the jobs to the pool.
-    This is useful when you have fixed resources that you want to re-use.
-    Once a process is done, it is replaced with a new job.
+    This runner executes jobs concurrently using a pool of worker processes. It manages
+    process creation, job distribution, and result collection.
 
     Args:
-        generator (JobGenerator): The generator that generates the jobs.
-        n_jobs (int): The number of jobs to run in parallel.
+        generator (JobGenerator): Generator that creates jobs to be executed.
+        n_jobs (int): Number of parallel processes to use.
 
     Example:
-        Creating a pool with the size of the number of available GPUs and submitting jobs to the pool.
-        >>> ParallelRunner(generator, n_jobs=torch.cuda.device_count())
-        Each time a job is submitted to the pool, an additional parameter `task_id` will be passed to `job.run` method.
-        The job can then use this `task_id` to assign a particular device to train on.
-        >>> def run(self, arg1: int, arg2: nn.Module, task_id: int) -> None:
-        >>>     device = torch.device(f"cuda:{task_id}")
-        >>>     model = arg2.to(device)
-        >>>     ...
-
+        Create a pool with size matching available GPUs and submit jobs:
+
+        >>> from anomalib.pipelines.components.runners import ParallelRunner
+        >>> from anomalib.pipelines.components.base import JobGenerator
+        >>> import torch
+        >>> generator = JobGenerator()
+        >>> runner = ParallelRunner(generator, n_jobs=torch.cuda.device_count())
+        >>> results = runner.run({"param": "value"})
+
+    Notes:
+        When a job is submitted to the pool, a ``task_id`` parameter is passed to the
+        job's ``run()`` method. Jobs can use this ID to manage device assignment:
+
+        .. code-block:: python
+
+            def run(self, arg1: int, arg2: nn.Module, task_id: int) -> None:
+                device = torch.device(f"cuda:{task_id}")
+                model = arg2.to(device)
+                # ... rest of job logic
+
+    The runner handles:
+        - Creating and managing worker processes
+        - Distributing jobs to available workers
+        - Collecting and combining results
+        - Error handling for failed jobs
+        - Resource cleanup
     """
 
     def __init__(self, generator: JobGenerator, n_jobs: int) -> None:
diff --git a/src/anomalib/pipelines/components/runners/serial.py b/src/anomalib/pipelines/components/runners/serial.py
index 86cc3533ea..3caa274660 100644
--- a/src/anomalib/pipelines/components/runners/serial.py
+++ b/src/anomalib/pipelines/components/runners/serial.py
@@ -1,4 +1,32 @@
-"""Executor for running a job serially."""
+"""Serial execution of pipeline jobs.
+
+This module provides the :class:`SerialRunner` class for executing pipeline jobs
+sequentially on a single device. It processes jobs one at a time in order.
+
+Example:
+    >>> from anomalib.pipelines.components.runners import SerialRunner
+    >>> from anomalib.pipelines.components.base import JobGenerator
+    >>> generator = JobGenerator()
+    >>> runner = SerialRunner(generator)
+    >>> results = runner.run({"param": "value"})
+
+The serial runner handles:
+
+- Sequential execution of jobs in order
+- Progress tracking with progress bars
+- Result collection and combination
+- Error handling for failed jobs
+
+This is useful when:
+
+- Resources are limited to a single device
+- Jobs need to be executed in a specific order
+- Debugging pipeline execution
+- Simple workflows that don't require parallelization
+
+The runner implements the :class:`Runner` interface defined in
+``anomalib.pipelines.components.base``.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -18,13 +46,67 @@ class SerialExecutionError(Exception):
 
 
 class SerialRunner(Runner):
-    """Serial executor for running a single job at a time."""
+    """Serial executor for running jobs sequentially.
+
+    This runner executes jobs one at a time in a sequential manner. It provides progress
+    tracking and error handling while running jobs serially.
+
+    Args:
+        generator (JobGenerator): Generator that creates jobs to be executed.
+
+    Example:
+        Create a runner and execute jobs sequentially:
+
+        >>> from anomalib.pipelines.components.runners import SerialRunner
+        >>> from anomalib.pipelines.components.base import JobGenerator
+        >>> generator = JobGenerator()
+        >>> runner = SerialRunner(generator)
+        >>> results = runner.run({"param": "value"})
+
+    The runner handles:
+        - Sequential execution of jobs
+        - Progress tracking with progress bars
+        - Result collection and combination
+        - Error handling for failed jobs
+    """
 
     def __init__(self, generator: JobGenerator) -> None:
         super().__init__(generator)
 
     def run(self, args: dict, prev_stage_results: PREV_STAGE_RESULT = None) -> GATHERED_RESULTS:
-        """Run the job."""
+        """Execute jobs sequentially and gather results.
+
+        This method runs each job one at a time, collecting results and handling any
+        failures that occur during execution.
+
+        Args:
+            args (dict): Arguments specific to the job. For example, if there is a
+                pipeline defined where one of the job generators is hyperparameter
+                optimization, then the pipeline configuration file will look something
+                like:
+
+                .. code-block:: yaml
+
+                    arg1:
+                    arg2:
+                    hpo:
+                        param1:
+                        param2:
+                        ...
+
+                In this case, ``args`` will receive a dictionary with all keys under
+                ``hpo``.
+
+            prev_stage_results (PREV_STAGE_RESULT, optional): Results from the previous
+                pipeline stage. Used when the current stage depends on previous results.
+                Defaults to None.
+
+        Returns:
+            GATHERED_RESULTS: Combined results from all executed jobs.
+
+        Raises:
+            SerialExecutionError: If any job fails during execution.
+        """
         results = []
         failures = False
         logger.info(f"Running job {self.generator.job_class.name}")
diff --git a/src/anomalib/pipelines/components/utils/__init__.py b/src/anomalib/pipelines/components/utils/__init__.py
index 230edc6891..85f293bbbe 100644
--- a/src/anomalib/pipelines/components/utils/__init__.py
+++ b/src/anomalib/pipelines/components/utils/__init__.py
@@ -1,4 +1,22 @@
-"""Utils."""
+"""Utility functions for pipeline components.
+
+This module provides utility functions used by various pipeline components for tasks
+like:
+
+- Grid search parameter iteration via :func:`get_iterator_from_grid_dict`
+- Other utility functions for pipeline execution
+
+Example:
+    >>> from anomalib.pipelines.components.utils import get_iterator_from_grid_dict
+    >>> params = {"lr": [0.1, 0.01], "batch_size": [32, 64]}
+    >>> iterator = get_iterator_from_grid_dict(params)
+    >>> for config in iterator:
+    ...     print(config)
+    {"lr": 0.1, "batch_size": 32}
+    {"lr": 0.1, "batch_size": 64}
+    {"lr": 0.01, "batch_size": 32}
+    {"lr": 0.01, "batch_size": 64}
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pipelines/components/utils/grid_search.py b/src/anomalib/pipelines/components/utils/grid_search.py
index 04e481ca6a..240d12829a 100644
--- a/src/anomalib/pipelines/components/utils/grid_search.py
+++ b/src/anomalib/pipelines/components/utils/grid_search.py
@@ -1,4 +1,30 @@
-"""Utils for benchmarking."""
+"""Utilities for grid search parameter iteration.
+
+This module provides utilities for iterating over grid search parameter combinations
+in a structured way. The main function :func:`get_iterator_from_grid_dict` takes a
+dictionary of parameters and yields all possible combinations.
+
+Example:
+    >>> from anomalib.pipelines.components.utils import get_iterator_from_grid_dict
+    >>> params = {
+    ...     "model": {
+    ...         "backbone": {"grid": ["resnet18", "resnet50"]},
+    ...         "lr": {"grid": [0.001, 0.0001]}
+    ...     }
+    ... }
+    >>> for config in get_iterator_from_grid_dict(params):
+    ...     print(config)
+    {'model': {'backbone': 'resnet18', 'lr': 0.001}}
+    {'model': {'backbone': 'resnet18', 'lr': 0.0001}}
+    {'model': {'backbone': 'resnet50', 'lr': 0.001}}
+    {'model': {'backbone': 'resnet50', 'lr': 0.0001}}
+
+The module handles:
+    - Flattening nested parameter dictionaries
+    - Generating all combinations of grid parameters
+    - Reconstructing nested dictionary structure
+    - Preserving non-grid parameters
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -7,11 +33,7 @@
 from itertools import product
 from typing import Any
 
-from anomalib.utils.config import (
-    convert_valuesview_to_tuple,
-    flatten_dict,
-    to_nested_dict,
-)
+from anomalib.utils.config import convert_valuesview_to_tuple, flatten_dict, to_nested_dict
 
 
 def get_iterator_from_grid_dict(container: dict) -> Generator[dict, Any, None]:
diff --git a/src/anomalib/pipelines/types.py b/src/anomalib/pipelines/types.py
index dbb1572122..a4af438d36 100644
--- a/src/anomalib/pipelines/types.py
+++ b/src/anomalib/pipelines/types.py
@@ -1,4 +1,20 @@
-"""Types."""
+"""Types used in pipeline components.
+
+This module defines type aliases used throughout the pipeline components for type
+hinting and documentation.
+
+The following types are defined:
+    - ``RUN_RESULTS``: Return type of individual job runs
+    - ``GATHERED_RESULTS``: Combined results from multiple job runs
+    - ``PREV_STAGE_RESULT``: Optional results from previous pipeline stage
+
+Example:
+    >>> from anomalib.pipelines.types import RUN_RESULTS, GATHERED_RESULTS
+    >>> def my_job() -> RUN_RESULTS:
+    ...     return {"metric": 0.95}
+    >>> def gather_results(results: list[RUN_RESULTS]) -> GATHERED_RESULTS:
+    ...     return {"mean_metric": sum(r["metric"] for r in results) / len(results)}
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/post_processing/__init__.py b/src/anomalib/post_processing/__init__.py
index 25e3ab2adf..1c68178d8e 100644
--- a/src/anomalib/post_processing/__init__.py
+++ b/src/anomalib/post_processing/__init__.py
@@ -1,4 +1,21 @@
-"""Anomalib post-processing module."""
+"""Post-processing module for anomaly detection results.
+
+This module provides post-processing functionality for anomaly detection outputs:
+
+- Base :class:`PostProcessor` class defining the post-processing interface
+- :class:`OneClassPostProcessor` for one-class anomaly detection results
+
+The post-processors handle:
+    - Normalizing anomaly scores
+    - Thresholding and anomaly classification
+    - Mask generation and refinement
+    - Result aggregation and formatting
+
+Example:
+    >>> from anomalib.post_processing import OneClassPostProcessor
+    >>> post_processor = OneClassPostProcessor(threshold=0.5)
+    >>> predictions = post_processor(anomaly_maps=anomaly_maps)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/post_processing/base.py b/src/anomalib/post_processing/base.py
index f5b49bc8b1..2d4d378dc2 100644
--- a/src/anomalib/post_processing/base.py
+++ b/src/anomalib/post_processing/base.py
@@ -1,4 +1,25 @@
-"""Base class for post-processor."""
+"""Base class for post-processing anomaly detection results.
+
+This module provides the abstract base class :class:`PostProcessor` that defines
+the interface for post-processing anomaly detection outputs.
+
+The post-processors handle:
+    - Normalizing anomaly scores
+    - Thresholding and anomaly classification
+    - Mask generation and refinement
+    - Result aggregation and formatting
+
+Example:
+    >>> from anomalib.post_processing import PostProcessor
+    >>> class MyPostProcessor(PostProcessor):
+    ...     def forward(self, batch):
+    ...         # Post-process the batch
+    ...         return batch
+
+The post-processors are implemented as both :class:`torch.nn.Module` and
+:class:`lightning.pytorch.Callback` to support both inference and training
+workflows.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -12,11 +33,37 @@
 
 
 class PostProcessor(nn.Module, Callback, ABC):
-    """Base class for post-processor.
+    """Base class for post-processing anomaly detection results.
+
+    The post-processor is implemented as both a :class:`torch.nn.Module` and
+    :class:`lightning.pytorch.Callback` to support inference and training workflows.
+    It handles tasks like score normalization, thresholding, and mask refinement.
 
-    The post-processor is a callback that is used to post-process the predictions of the model.
+    The class must be inherited and the :meth:`forward` method must be implemented
+    to define the post-processing logic.
+
+    Example:
+        >>> from anomalib.post_processing import PostProcessor
+        >>> class MyPostProcessor(PostProcessor):
+        ...     def forward(self, batch):
+        ...         # Normalize scores between 0 and 1
+        ...         batch.anomaly_scores = normalize(batch.anomaly_scores)
+        ...         return batch
     """
 
     @abstractmethod
     def forward(self, batch: InferenceBatch) -> InferenceBatch:
-        """Functional forward method for post-processing."""
+        """Post-process a batch of model predictions.
+
+        Args:
+            batch (:class:`anomalib.data.InferenceBatch`): Batch containing model
+                predictions and metadata.
+
+        Returns:
+            :class:`anomalib.data.InferenceBatch`: Post-processed batch with
+                normalized scores, thresholded predictions, and/or refined masks.
+
+        Raises:
+            NotImplementedError: This is an abstract method that must be
+                implemented by subclasses.
+        """
diff --git a/src/anomalib/post_processing/one_class.py b/src/anomalib/post_processing/one_class.py
index c19ef85300..ca89ba4df5 100644
--- a/src/anomalib/post_processing/one_class.py
+++ b/src/anomalib/post_processing/one_class.py
@@ -1,4 +1,19 @@
-"""Post-processing module for anomaly detection models."""
+"""Post-processing module for one-class anomaly detection results.
+
+This module provides post-processing functionality for one-class anomaly detection
+outputs through the :class:`OneClassPostProcessor` class.
+
+The post-processor handles:
+    - Normalizing image and pixel-level anomaly scores
+    - Computing adaptive thresholds for anomaly classification
+    - Applying sensitivity adjustments to thresholds
+    - Formatting results for downstream use
+
+Example:
+    >>> from anomalib.post_processing import OneClassPostProcessor
+    >>> post_processor = OneClassPostProcessor(image_sensitivity=0.5)
+    >>> predictions = post_processor(anomaly_maps=anomaly_maps)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,7 +28,28 @@
 
 
 class OneClassPostProcessor(PostProcessor):
-    """Default post-processor for one-class anomaly detection."""
+    """Post-processor for one-class anomaly detection.
+
+    This class handles post-processing of anomaly detection results by:
+        - Normalizing image and pixel-level anomaly scores
+        - Computing adaptive thresholds for anomaly classification
+        - Applying sensitivity adjustments to thresholds
+        - Formatting results for downstream use
+
+    Args:
+        image_sensitivity (float | None, optional): Sensitivity value for image-level
+            predictions. Higher values make the model more sensitive to anomalies.
+            Defaults to None.
+        pixel_sensitivity (float | None, optional): Sensitivity value for pixel-level
+            predictions. Higher values make the model more sensitive to anomalies.
+            Defaults to None.
+        **kwargs: Additional keyword arguments passed to parent class.
+
+    Example:
+        >>> from anomalib.post_processing import OneClassPostProcessor
+        >>> post_processor = OneClassPostProcessor(image_sensitivity=0.5)
+        >>> predictions = post_processor(anomaly_maps=anomaly_maps)
+    """
 
     def __init__(
         self,
@@ -39,7 +75,15 @@ def on_validation_batch_end(
         *args,
         **kwargs,
     ) -> None:
-        """Update the normalization and thresholding metrics using the batch output."""
+        """Update normalization and thresholding metrics using batch output.
+
+        Args:
+            trainer (Trainer): PyTorch Lightning trainer instance.
+            pl_module (LightningModule): PyTorch Lightning module instance.
+            outputs (Batch): Batch containing model predictions and ground truth.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+        """
         del trainer, pl_module, args, kwargs  # Unused arguments.
         if outputs.pred_score is not None:
             self._image_threshold.update(outputs.pred_score, outputs.gt_label)
@@ -51,7 +95,12 @@ def on_validation_batch_end(
             self._pixel_normalization_stats.update(outputs.anomaly_map)
 
     def on_validation_epoch_end(self, trainer: Trainer, pl_module: LightningModule) -> None:
-        """Compute the final threshold and normalization values."""
+        """Compute final threshold and normalization values.
+
+        Args:
+            trainer (Trainer): PyTorch Lightning trainer instance.
+            pl_module (LightningModule): PyTorch Lightning module instance.
+        """
         del trainer, pl_module
         if self._image_threshold.update_called:
             self._image_threshold.compute()
@@ -70,7 +119,15 @@ def on_test_batch_end(
         *args,
         **kwargs,
     ) -> None:
-        """Apply the post-processing steps to the current batch of predictions."""
+        """Apply post-processing steps to current batch of predictions.
+
+        Args:
+            trainer (Trainer): PyTorch Lightning trainer instance.
+            pl_module (LightningModule): PyTorch Lightning module instance.
+            outputs (Batch): Batch containing model predictions.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+        """
         del trainer, pl_module, args, kwargs
         self.post_process_batch(outputs)
 
@@ -82,12 +139,31 @@ def on_predict_batch_end(
         *args,
         **kwargs,
     ) -> None:
-        """Normalize the predicted scores and anomaly maps."""
+        """Normalize predicted scores and anomaly maps.
+
+        Args:
+            trainer (Trainer): PyTorch Lightning trainer instance.
+            pl_module (LightningModule): PyTorch Lightning module instance.
+            outputs (Batch): Batch containing model predictions.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+        """
         del trainer, pl_module, args, kwargs
         self.post_process_batch(outputs)
 
     def forward(self, predictions: InferenceBatch) -> InferenceBatch:
-        """Funcional forward method for post-processing."""
+        """Post-process model predictions.
+
+        Args:
+            predictions (InferenceBatch): Batch containing model predictions.
+
+        Returns:
+            InferenceBatch: Post-processed batch with normalized scores and
+                thresholded predictions.
+
+        Raises:
+            ValueError: If neither `pred_score` nor `anomaly_map` is provided.
+        """
         if predictions.pred_score is None and predictions.anomaly_map is None:
             msg = "At least one of pred_score or anomaly_map must be provided."
             raise ValueError(msg)
@@ -104,14 +180,24 @@ def forward(self, predictions: InferenceBatch) -> InferenceBatch:
         )
 
     def post_process_batch(self, batch: Batch) -> None:
-        """Normalize the predicted scores and anomaly maps."""
+        """Post-process a batch of predictions.
+
+        Applies normalization and thresholding to the batch predictions.
+
+        Args:
+            batch (Batch): Batch containing model predictions.
+        """
         # apply normalization
         self.normalize_batch(batch)
         # apply threshold
         self.threshold_batch(batch)
 
     def threshold_batch(self, batch: Batch) -> None:
-        """Apply thresholding to the batch predictions."""
+        """Apply thresholding to batch predictions.
+
+        Args:
+            batch (Batch): Batch containing model predictions.
+        """
         batch.pred_label = (
             batch.pred_label
             if batch.pred_label is not None
@@ -124,7 +210,11 @@ def threshold_batch(self, batch: Batch) -> None:
         )
 
     def normalize_batch(self, batch: Batch) -> None:
-        """Normalize the predicted scores and anomaly maps."""
+        """Normalize predicted scores and anomaly maps.
+
+        Args:
+            batch (Batch): Batch containing model predictions.
+        """
         # normalize pixel-level predictions
         batch.anomaly_map = self._normalize(batch.anomaly_map, self.pixel_min, self.pixel_max, self.raw_pixel_threshold)
         # normalize image-level predictions
@@ -132,7 +222,15 @@ def normalize_batch(self, batch: Batch) -> None:
 
     @staticmethod
     def _threshold(preds: torch.Tensor | None, threshold: float) -> torch.Tensor | None:
-        """Apply thresholding to a single tensor."""
+        """Apply thresholding to a single tensor.
+
+        Args:
+            preds (torch.Tensor | None): Predictions to threshold.
+            threshold (float): Threshold value.
+
+        Returns:
+            torch.Tensor | None: Thresholded predictions or None if input is None.
+        """
         if preds is None:
             return None
         return preds > threshold
@@ -144,7 +242,17 @@ def _normalize(
         norm_max: float,
         threshold: float,
     ) -> torch.Tensor | None:
-        """Normalize a tensor using the min, max, and threshold values."""
+        """Normalize a tensor using min, max, and threshold values.
+
+        Args:
+            preds (torch.Tensor | None): Predictions to normalize.
+            norm_min (float): Minimum value for normalization.
+            norm_max (float): Maximum value for normalization.
+            threshold (float): Threshold value.
+
+        Returns:
+            torch.Tensor | None: Normalized predictions or None if input is None.
+        """
         if preds is None:
             return None
         preds = ((preds - threshold) / (norm_max - norm_min)) + 0.5
@@ -153,44 +261,76 @@ def _normalize(
 
     @property
     def raw_image_threshold(self) -> float:
-        """Get the image-level threshold."""
+        """Get the raw image-level threshold.
+
+        Returns:
+            float: Raw image-level threshold value.
+        """
         return self._image_threshold.value
 
     @property
     def raw_pixel_threshold(self) -> float:
-        """Get the pixel-level threshold."""
+        """Get the raw pixel-level threshold.
+
+        Returns:
+            float: Raw pixel-level threshold value.
+        """
         return self._pixel_threshold.value
 
     @property
     def normalized_image_threshold(self) -> float:
-        """Get the image-level threshold."""
+        """Get the normalized image-level threshold.
+
+        Returns:
+            float: Normalized image-level threshold value, adjusted by sensitivity.
+        """
         if self.image_sensitivity is not None:
             return 1 - self.image_sensitivity
         return 0.5
 
     @property
     def normalized_pixel_threshold(self) -> float:
-        """Get the pixel-level threshold."""
+        """Get the normalized pixel-level threshold.
+
+        Returns:
+            float: Normalized pixel-level threshold value, adjusted by sensitivity.
+        """
         if self.pixel_sensitivity is not None:
             return 1 - self.pixel_sensitivity
         return 0.5
 
     @property
     def image_min(self) -> float:
-        """Get the minimum value for normalization."""
+        """Get the minimum value for image-level normalization.
+
+        Returns:
+            float: Minimum image-level value.
+        """
         return self._image_normalization_stats.min
 
     @property
     def image_max(self) -> float:
-        """Get the maximum value for normalization."""
+        """Get the maximum value for image-level normalization.
+
+        Returns:
+            float: Maximum image-level value.
+        """
         return self._image_normalization_stats.max
 
     @property
     def pixel_min(self) -> float:
-        """Get the minimum value for normalization."""
+        """Get the minimum value for pixel-level normalization.
+
+        Returns:
+            float: Minimum pixel-level value.
+        """
         return self._pixel_normalization_stats.min
 
     @property
     def pixel_max(self) -> float:
-        """Get the maximum value for normalization."""
+        """Get the maximum value for pixel-level normalization.
+
+        Returns:
+            float: Maximum pixel-level value.
+        """
         return self._pixel_normalization_stats.max
diff --git a/src/anomalib/pre_processing/__init__.py b/src/anomalib/pre_processing/__init__.py
index d70565f882..db63480c35 100644
--- a/src/anomalib/pre_processing/__init__.py
+++ b/src/anomalib/pre_processing/__init__.py
@@ -1,4 +1,23 @@
-"""Anomalib pre-processing module."""
+"""Pre-processing module for anomaly detection pipelines.
+
+This module provides functionality for pre-processing data before model training
+and inference through the :class:`PreProcessor` class.
+
+The pre-processor handles:
+    - Applying transforms to data during different pipeline stages
+    - Managing stage-specific transforms (train/val/test)
+    - Integrating with both PyTorch and Lightning workflows
+
+Example:
+    >>> from anomalib.pre_processing import PreProcessor
+    >>> from torchvision.transforms.v2 import Resize
+    >>> pre_processor = PreProcessor(transform=Resize(size=(256, 256)))
+    >>> transformed_batch = pre_processor(batch)
+
+The pre-processor is implemented as both a :class:`torch.nn.Module` and
+:class:`lightning.pytorch.Callback` to support both inference and training
+workflows.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pre_processing/pre_processing.py b/src/anomalib/pre_processing/pre_processing.py
index 27cffc7605..95a1a7b880 100644
--- a/src/anomalib/pre_processing/pre_processing.py
+++ b/src/anomalib/pre_processing/pre_processing.py
@@ -1,4 +1,23 @@
-"""Anomalib pre-processing module."""
+"""Pre-processing module for anomaly detection pipelines.
+
+This module provides functionality for pre-processing data before model training
+and inference through the :class:`PreProcessor` class.
+
+The pre-processor handles:
+    - Applying transforms to data during different pipeline stages
+    - Managing stage-specific transforms (train/val/test)
+    - Integrating with both PyTorch and Lightning workflows
+
+Example:
+    >>> from anomalib.pre_processing import PreProcessor
+    >>> from torchvision.transforms.v2 import Resize
+    >>> pre_processor = PreProcessor(transform=Resize(size=(256, 256)))
+    >>> transformed_batch = pre_processor(batch)
+
+The pre-processor is implemented as both a :class:`torch.nn.Module` and
+:class:`lightning.pytorch.Callback` to support both inference and training
+workflows.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -33,44 +52,56 @@ class PreProcessor(nn.Module, Callback):
     training, validation, testing, and prediction.
 
     Args:
-        train_transform (Transform | None): Transform to apply during training.
-        val_transform (Transform | None): Transform to apply during validation.
-        test_transform (Transform | None): Transform to apply during testing.
-        transform (Transform | None): General transform to apply if stage-specific
-            transforms are not provided.
+        train_transform (Transform | None, optional): Transform to apply during
+            training. Defaults to None.
+        val_transform (Transform | None, optional): Transform to apply during
+            validation. Defaults to None.
+        test_transform (Transform | None, optional): Transform to apply during
+            testing. Defaults to None.
+        transform (Transform | None, optional): General transform to apply if
+            stage-specific transforms are not provided. Defaults to None.
 
     Raises:
-        ValueError: If both `transform` and any of the stage-specific transforms
+        ValueError: If both ``transform`` and any of the stage-specific transforms
             are provided simultaneously.
 
     Notes:
-        If only `transform` is provided, it will be used for all stages (train, val, test).
+        If only ``transform`` is provided, it will be used for all stages (train,
+        val, test).
 
         Priority of transforms:
-        1. Explicitly set PreProcessor transforms (highest priority)
-        2. Datamodule transforms (if PreProcessor has no transforms)
-        3. Dataloader transforms (if neither PreProcessor nor datamodule have transforms)
-        4. Default transforms (lowest priority)
+            1. Explicitly set ``PreProcessor`` transforms (highest priority)
+            2. Datamodule transforms (if ``PreProcessor`` has no transforms)
+            3. Dataloader transforms (if neither ``PreProcessor`` nor datamodule
+               have transforms)
+            4. Default transforms (lowest priority)
 
-    Examples:
+    Example:
         >>> from torchvision.transforms.v2 import Compose, Resize, ToTensor
         >>> from anomalib.pre_processing import PreProcessor
-
         >>> # Define transforms
-        >>> train_transform = Compose([Resize((224, 224)), ToTensor()])
-        >>> val_transform = Compose([Resize((256, 256)), CenterCrop((224, 224)), ToTensor()])
-
+        >>> train_transform = Compose([
+        ...     Resize((224, 224)),
+        ...     ToTensor()
+        ... ])
+        >>> val_transform = Compose([
+        ...     Resize((256, 256)),
+        ...     CenterCrop((224, 224)),
+        ...     ToTensor()
+        ... ])
         >>> # Create PreProcessor with stage-specific transforms
         >>> pre_processor = PreProcessor(
         ...     train_transform=train_transform,
         ...     val_transform=val_transform
         ... )
-
         >>> # Create PreProcessor with a single transform for all stages
-        >>> common_transform = Compose([Resize((224, 224)), ToTensor()])
+        >>> common_transform = Compose([
+        ...     Resize((224, 224)),
+        ...     ToTensor()
+        ... ])
         >>> pre_processor_common = PreProcessor(transform=common_transform)
 
-        >>> # Use in a Lightning module
+    Integration with Lightning:
         >>> class MyModel(LightningModule):
         ...     def __init__(self):
         ...         super().__init__()
@@ -80,7 +111,7 @@ class PreProcessor(nn.Module, Callback):
         ...         return [self.pre_processor]
         ...
         ...     def training_step(self, batch, batch_idx):
-        ...         # The pre_processor will automatically apply the correct transform
+        ...         # Pre-processor automatically applies correct transform
         ...         processed_batch = self.pre_processor(batch)
         ...         # Rest of the training step
     """
@@ -110,7 +141,12 @@ def __init__(
         self.export_transform = get_exportable_transform(self.test_transform)
 
     def setup_datamodule_transforms(self, datamodule: "AnomalibDataModule") -> None:
-        """Set up datamodule transforms."""
+        """Set up datamodule transforms.
+
+        Args:
+            datamodule (AnomalibDataModule): The datamodule to configure
+                transforms for.
+        """
         # If PreProcessor has transforms, propagate them to datamodule
         if any([self.train_transform, self.val_transform, self.test_transform]):
             transforms = {
@@ -125,7 +161,12 @@ def setup_datamodule_transforms(self, datamodule: "AnomalibDataModule") -> None:
                     set_datamodule_stage_transform(datamodule, transform, stage)
 
     def setup_dataloader_transforms(self, dataloaders: "EVAL_DATALOADERS | TRAIN_DATALOADERS") -> None:
-        """Set up dataloader transforms."""
+        """Set up dataloader transforms.
+
+        Args:
+            dataloaders (EVAL_DATALOADERS | TRAIN_DATALOADERS): The dataloaders
+                to configure transforms for.
+        """
         if isinstance(dataloaders, DataLoader):
             dataloaders = [dataloaders]
 
@@ -153,9 +194,9 @@ def setup(self, trainer: Trainer, pl_module: LightningModule, stage: str) -> Non
         """Configure transforms at the start of each stage.
 
         Args:
-            trainer: The Lightning trainer.
-            pl_module: The Lightning module.
-            stage: The stage (e.g., 'fit', 'validate', 'test', 'predict').
+            trainer (Trainer): The Lightning trainer.
+            pl_module (LightningModule): The Lightning module.
+            stage (str): The stage (e.g., 'fit', 'validate', 'test', 'predict').
         """
         stage = TrainerFn(stage).value  # Ensure stage is str
 
@@ -171,7 +212,13 @@ def forward(self, batch: torch.Tensor) -> torch.Tensor:
         """Apply transforms to the batch of tensors for inference.
 
         This forward-pass is only used after the model is exported.
-        Within the Lightning training/validation/testing loops, the transforms are applied
-        in the `on_*_batch_start` methods.
+        Within the Lightning training/validation/testing loops, the transforms are
+        applied in the ``on_*_batch_start`` methods.
+
+        Args:
+            batch (torch.Tensor): Input batch to transform.
+
+        Returns:
+            torch.Tensor: Transformed batch.
         """
         return self.export_transform(batch) if self.export_transform else batch
diff --git a/src/anomalib/pre_processing/utils/__init__.py b/src/anomalib/pre_processing/utils/__init__.py
index 8361223189..f4ff633692 100644
--- a/src/anomalib/pre_processing/utils/__init__.py
+++ b/src/anomalib/pre_processing/utils/__init__.py
@@ -1,4 +1,17 @@
-"""Utility functions for pre-processing."""
+"""Utility functions for pre-processing.
+
+This module provides utility functions used by the pre-processing module for
+handling transforms and data processing tasks.
+
+The utilities include:
+    - Transform management for different pipeline stages
+    - Conversion between transform types
+    - Helper functions for dataloader/datamodule transform handling
+
+Example:
+    >>> from anomalib.pre_processing.utils import get_exportable_transform
+    >>> transform = get_exportable_transform(train_transform)
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/pre_processing/utils/transform.py b/src/anomalib/pre_processing/utils/transform.py
index 37eb1e9dd1..e2032e6284 100644
--- a/src/anomalib/pre_processing/utils/transform.py
+++ b/src/anomalib/pre_processing/utils/transform.py
@@ -1,4 +1,23 @@
-"""Utility functions for transforms."""
+"""Utility functions for transforms.
+
+This module provides utility functions for managing transforms in the pre-processing
+pipeline. The utilities handle:
+    - Getting and setting transforms for different pipeline stages
+    - Converting between transform types
+    - Managing transforms across dataloaders and datamodules
+
+Example:
+    >>> from anomalib.pre_processing.utils.transform import get_dataloaders_transforms
+    >>> transforms = get_dataloaders_transforms(dataloaders)
+    >>> print(transforms["train"])  # Get training stage transform
+    Compose(
+        Resize(size=(256, 256), ...),
+        ToTensor()
+    )
+
+The module ensures consistent transform handling across the training, validation,
+and testing stages of the anomaly detection pipeline.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,13 +32,40 @@
 
 
 def get_dataloaders_transforms(dataloaders: Sequence[DataLoader]) -> dict[str, Transform]:
-    """Get transforms from dataloaders.
+    """Extract transforms from a sequence of dataloaders.
+
+    This function retrieves the transforms associated with different stages (train,
+    validation, test) from a sequence of dataloaders. It maps Lightning stage names
+    to their corresponding transform stages.
+
+    The stage mapping is:
+        - ``fit`` -> ``train``
+        - ``validate`` -> ``val``
+        - ``test`` -> ``test``
+        - ``predict`` -> ``test``
 
     Args:
-        dataloaders: The dataloaders to get transforms from.
+        dataloaders: A sequence of PyTorch :class:`DataLoader` objects to extract
+            transforms from. Each dataloader should have a ``dataset`` attribute
+            with a ``transform`` property.
 
     Returns:
-        Dictionary mapping stages to their transforms.
+        A dictionary mapping stage names (``train``, ``val``, ``test``) to their
+        corresponding :class:`torchvision.transforms.v2.Transform` objects.
+
+    Example:
+        >>> from torch.utils.data import DataLoader
+        >>> from torchvision.transforms.v2 import Resize, ToTensor
+        >>> # Create dataloaders with transforms
+        >>> train_loader = DataLoader(dataset_with_transform)
+        >>> val_loader = DataLoader(dataset_with_transform)
+        >>> # Get transforms
+        >>> transforms = get_dataloaders_transforms([train_loader, val_loader])
+        >>> print(transforms["train"])  # Access training transform
+        Compose(
+            Resize(size=(256, 256)),
+            ToTensor()
+        )
     """
     transforms: dict[str, Transform] = {}
     stage_lookup = {
@@ -41,11 +87,36 @@ def get_dataloaders_transforms(dataloaders: Sequence[DataLoader]) -> dict[str, T
 
 
 def set_dataloaders_transforms(dataloaders: Sequence[DataLoader], transforms: dict[str, Transform | None]) -> None:
-    """Set transforms to dataloaders.
+    """Set transforms to dataloaders based on their stage.
+
+    This function propagates transforms to dataloaders based on their stage mapping.
+    The stage mapping follows the convention:
+
+        - ``fit`` -> ``train``
+        - ``validate`` -> ``val``
+        - ``test`` -> ``test``
+        - ``predict`` -> ``test``
 
     Args:
-        dataloaders: The dataloaders to propagate transforms to.
-        transforms: Dictionary mapping stages to their transforms.
+        dataloaders: A sequence of PyTorch :class:`DataLoader` objects to set
+            transforms for. Each dataloader should have a ``dataset`` attribute.
+        transforms: Dictionary mapping stage names (``train``, ``val``, ``test``)
+            to their corresponding :class:`torchvision.transforms.v2.Transform`
+            objects. The transforms can be ``None``.
+
+    Example:
+        >>> from torch.utils.data import DataLoader
+        >>> from torchvision.transforms.v2 import Resize, ToTensor
+        >>> # Create transforms
+        >>> transforms = {
+        ...     "train": Compose([Resize((256, 256)), ToTensor()]),
+        ...     "val": Compose([Resize((256, 256)), ToTensor()])
+        ... }
+        >>> # Create dataloaders
+        >>> train_loader = DataLoader(dataset_with_transform)
+        >>> val_loader = DataLoader(dataset_with_transform)
+        >>> # Set transforms
+        >>> set_dataloaders_transforms([train_loader, val_loader], transforms)
     """
     stage_mapping = {
         "fit": "train",
@@ -66,11 +137,31 @@ def set_dataloaders_transforms(dataloaders: Sequence[DataLoader], transforms: di
 
 
 def set_dataloader_transform(dataloader: DataLoader | Sequence[DataLoader], transform: Transform) -> None:
-    """Set a transform for a dataloader or list of dataloaders.
+    """Set a transform for a dataloader or sequence of dataloaders.
+
+    This function sets the transform for either a single dataloader or multiple dataloaders.
+    The transform is set on the dataset object of each dataloader if it has a ``transform``
+    attribute.
 
     Args:
-        dataloader: The dataloader(s) to set the transform for.
-        transform: The transform to set.
+        dataloader: A single :class:`torch.utils.data.DataLoader` or a sequence of
+            dataloaders to set the transform for. Each dataloader should have a
+            ``dataset`` attribute with a ``transform`` attribute.
+        transform: The :class:`torchvision.transforms.v2.Transform` object to set as
+            the transform.
+
+    Raises:
+        TypeError: If ``dataloader`` is neither a :class:`torch.utils.data.DataLoader`
+            nor a sequence of dataloaders.
+
+    Example:
+        >>> from torch.utils.data import DataLoader
+        >>> from torchvision.transforms.v2 import Resize
+        >>> # Create transform and dataloader
+        >>> transform = Resize(size=(256, 256))
+        >>> dataloader = DataLoader(dataset_with_transform)
+        >>> # Set transform
+        >>> set_dataloader_transform(dataloader, transform)
     """
     if isinstance(dataloader, DataLoader):
         if hasattr(dataloader.dataset, "transform"):
@@ -84,19 +175,36 @@ def set_dataloader_transform(dataloader: DataLoader | Sequence[DataLoader], tran
 
 
 def set_datamodule_stage_transform(datamodule: AnomalibDataModule, transform: Transform, stage: str) -> None:
-    """Set a transform for a specific stage in a AnomalibDataModule.
+    """Set a transform for a specific stage in a :class:`AnomalibDataModule`.
+
+    This function sets the transform for a specific stage (train/val/test/predict) in an
+    AnomalibDataModule by mapping the stage name to the corresponding dataset attribute
+    and setting its transform.
 
     Args:
-        datamodule: The AnomalibDataModule to set the transform for.
-        transform: The transform to set.
-        stage: The stage to set the transform for.
+        datamodule: The :class:`AnomalibDataModule` instance to set the transform for.
+            Must have dataset attributes corresponding to different stages.
+        transform: The :class:`torchvision.transforms.v2.Transform` object to set as
+            the transform for the specified stage.
+        stage: The pipeline stage to set the transform for. Must be one of:
+            ``'fit'``, ``'validate'``, ``'test'``, or ``'predict'``.
 
     Note:
-        The stage parameter maps to dataset attributes as follows:
-        - 'fit' -> 'train_data'
-        - 'validate' -> 'val_data'
-        - 'test' -> 'test_data'
-        - 'predict' -> 'test_data'
+        The ``stage`` parameter maps to dataset attributes as follows:
+
+        - ``'fit'`` -> ``'train_data'``
+        - ``'validate'`` -> ``'val_data'``
+        - ``'test'`` -> ``'test_data'``
+        - ``'predict'`` -> ``'test_data'``
+
+    Example:
+        >>> from torchvision.transforms.v2 import Resize
+        >>> from anomalib.data import MVTec
+        >>> # Create transform and datamodule
+        >>> transform = Resize(size=(256, 256))
+        >>> datamodule = MVTec()
+        >>> # Set transform for training stage
+        >>> set_datamodule_stage_transform(datamodule, transform, "fit")
     """
     stage_datasets = {
         "fit": "train_data",
@@ -113,9 +221,35 @@ def set_datamodule_stage_transform(datamodule: AnomalibDataModule, transform: Tr
 
 
 def get_exportable_transform(transform: Transform | None) -> Transform | None:
-    """Get exportable transform.
+    """Get an exportable version of a transform.
+
+    This function converts a torchvision transform into a format that is compatible with
+    ONNX and OpenVINO export. It handles two main compatibility issues:
 
-    Some transforms are not supported by ONNX/OpenVINO, so we need to replace them with exportable versions.
+    1. Disables antialiasing in ``Resize`` transforms
+    2. Converts ``CenterCrop`` to ``ExportableCenterCrop``
+
+    Args:
+        transform (Transform | None): The transform to convert. If ``None``, returns
+            ``None``.
+
+    Returns:
+        Transform | None: The converted transform that is compatible with ONNX/OpenVINO
+            export. Returns ``None`` if input transform is ``None``.
+
+    Example:
+        >>> from torchvision.transforms.v2 import Compose, Resize, CenterCrop
+        >>> transform = Compose([
+        ...     Resize((224, 224), antialias=True),
+        ...     CenterCrop(200)
+        ... ])
+        >>> exportable = get_exportable_transform(transform)
+        >>> # Now transform is compatible with ONNX/OpenVINO export
+
+    Note:
+        Some torchvision transforms are not directly supported by ONNX/OpenVINO. This
+        function handles the most common cases, but additional transforms may need
+        special handling.
     """
     if transform is None:
         return None
@@ -126,7 +260,30 @@ def get_exportable_transform(transform: Transform | None) -> Transform | None:
 def disable_antialiasing(transform: Transform) -> Transform:
     """Disable antialiasing in Resize transforms.
 
-    Resizing with antialiasing is not supported by ONNX, so we need to disable it.
+    This function recursively disables antialiasing in any ``Resize`` transforms found
+    within the provided transform or transform composition. This is necessary because
+    antialiasing is not supported during ONNX export.
+
+    Args:
+        transform (Transform): Transform or composition of transforms to process.
+
+    Returns:
+        Transform: The processed transform with antialiasing disabled in any
+            ``Resize`` transforms.
+
+    Example:
+        >>> from torchvision.transforms.v2 import Compose, Resize
+        >>> transform = Compose([
+        ...     Resize((224, 224), antialias=True),
+        ...     Resize((256, 256), antialias=True)
+        ... ])
+        >>> transform = disable_antialiasing(transform)
+        >>> # Now all Resize transforms have antialias=False
+
+    Note:
+        This function modifies the transforms in-place by setting their
+        ``antialias`` attribute to ``False``. The original transform object is
+        returned.
     """
     if isinstance(transform, Resize):
         transform.antialias = False
@@ -137,9 +294,33 @@ def disable_antialiasing(transform: Transform) -> Transform:
 
 
 def convert_center_crop_transform(transform: Transform) -> Transform:
-    """Convert CenterCrop to ExportableCenterCrop.
+    """Convert torchvision's CenterCrop to ExportableCenterCrop.
 
-    Torchvision's CenterCrop is not supported by ONNX, so we need to replace it with our own ExportableCenterCrop.
+    This function recursively converts any ``CenterCrop`` transforms found within the
+    provided transform or transform composition to ``ExportableCenterCrop``. This is
+    necessary because torchvision's ``CenterCrop`` is not supported during ONNX
+    export.
+
+    Args:
+        transform (Transform): Transform or composition of transforms to process.
+
+    Returns:
+        Transform: The processed transform with all ``CenterCrop`` transforms
+            converted to ``ExportableCenterCrop``.
+
+    Example:
+        >>> from torchvision.transforms.v2 import Compose, CenterCrop
+        >>> transform = Compose([
+        ...     CenterCrop(224),
+        ...     CenterCrop((256, 256))
+        ... ])
+        >>> transform = convert_center_crop_transform(transform)
+        >>> # Now all CenterCrop transforms are converted to ExportableCenterCrop
+
+    Note:
+        This function creates new ``ExportableCenterCrop`` instances to replace the
+        original ``CenterCrop`` transforms. The original transform object is
+        returned with the replacements applied.
     """
     if isinstance(transform, CenterCrop):
         transform = ExportableCenterCrop(size=transform.size)
diff --git a/src/anomalib/utils/__init__.py b/src/anomalib/utils/__init__.py
index 8ffe7654fe..2787c5772d 100644
--- a/src/anomalib/utils/__init__.py
+++ b/src/anomalib/utils/__init__.py
@@ -1,4 +1,27 @@
-"""Helpers for downloading files, calculating metrics, computing anomaly maps, and visualization."""
+"""Utility functions and helpers for anomaly detection.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides various utility functions and helpers for:
+    - File downloading and management
+    - Metric calculation and evaluation
+    - Anomaly map computation and processing
+    - Result visualization and plotting
+
+The utilities ensure consistent behavior across the library and provide common
+functionality used by multiple components.
+
+Example:
+    >>> from anomalib.utils.visualization import ImageVisualizer
+    >>> # Create visualizer
+    >>> visualizer = ImageVisualizer()
+    >>> # Generate visualization
+    >>> vis_result = visualizer.visualize(image=img, pred_mask=mask)
+
+The module is organized into submodules for different types of utilities:
+    - ``download``: Functions for downloading datasets and models
+    - ``metrics``: Implementations of evaluation metrics
+    - ``map``: Tools for generating and processing anomaly maps
+    - ``visualization``: Classes for visualizing detection results
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/utils/config.py b/src/anomalib/utils/config.py
index aadaa6a42b..a7611b24ee 100644
--- a/src/anomalib/utils/config.py
+++ b/src/anomalib/utils/config.py
@@ -1,4 +1,11 @@
-"""Get configurable parameters."""
+"""Configuration utilities.
+
+This module contains utility functions for handling configuration objects, including:
+- Converting between different configuration formats (dict, Namespace, DictConfig)
+- Flattening and nesting dictionaries
+- Converting paths and values
+- Updating configurations
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -16,7 +23,36 @@
 
 
 def _convert_nested_path_to_str(config: Any) -> Any:  # noqa: ANN401
-    """Goes over the dictionary and converts all path values to str."""
+    """Convert all path values to strings recursively in a configuration object.
+
+    This function traverses a configuration object and converts any ``Path`` or
+    ``JSONArgparsePath`` objects to string representations. It handles nested
+    dictionaries and lists recursively.
+
+    Args:
+        config: Configuration object that may contain path values. Can be a
+            dictionary, list, Path object, or other types.
+
+    Returns:
+        Any: Configuration with all path values converted to strings. The returned
+            object maintains the same structure as the input, with only path
+            values converted to strings.
+
+    Examples:
+        >>> from pathlib import Path
+        >>> config = {
+        ...     "model_path": Path("/path/to/model"),
+        ...     "data": {
+        ...         "train_path": Path("/data/train"),
+        ...         "val_path": Path("/data/val")
+        ...     }
+        ... }
+        >>> converted = _convert_nested_path_to_str(config)
+        >>> print(converted["model_path"])
+        /path/to/model
+        >>> print(converted["data"]["train_path"])
+        /data/train
+    """
     if isinstance(config, dict):
         for key, value in config.items():
             config[key] = _convert_nested_path_to_str(value)
@@ -29,22 +65,40 @@ def _convert_nested_path_to_str(config: Any) -> Any:  # noqa: ANN401
 
 
 def to_nested_dict(config: dict) -> dict:
-    """Convert the flattened dictionary to nested dictionary.
+    """Convert a flattened dictionary to a nested dictionary.
+
+    This function takes a dictionary with dot-separated keys and converts it into a nested
+    dictionary structure. Keys containing dots (`.`) are split and used to create nested
+    dictionaries.
+
+    Args:
+        config: Flattened dictionary where keys can contain dots to indicate nesting
+               levels. For example, ``"dataset.category"`` will become
+               ``{"dataset": {"category": ...}}``.
+
+    Returns:
+        dict: A nested dictionary where dot-separated keys in the input are converted
+              to nested dictionary structures. Keys without dots remain at the top
+              level.
 
     Examples:
         >>> config = {
-                "dataset.category": "bottle",
-                "dataset.image_size": 224,
-                "model_name": "padim",
-            }
-        >>> to_nested_dict(config)
-        {
-            "dataset": {
-                "category": "bottle",
-                "image_size": 224,
-            },
-            "model_name": "padim",
-        }
+        ...     "dataset.category": "bottle",
+        ...     "dataset.image_size": 224,
+        ...     "model_name": "padim"
+        ... }
+        >>> result = to_nested_dict(config)
+        >>> print(result["dataset"]["category"])
+        bottle
+        >>> print(result["dataset"]["image_size"])
+        224
+        >>> print(result["model_name"])
+        padim
+
+    Note:
+        - The function preserves the original values while only restructuring the keys
+        - Non-dot keys are kept as-is at the root level
+        - Empty key segments (e.g. ``"dataset..name"``) are handled as literal keys
     """
     out: dict[str, Any] = {}
     for key, value in config.items():
@@ -57,13 +111,34 @@ def to_nested_dict(config: dict) -> dict:
 
 
 def to_yaml(config: Namespace | ListConfig | DictConfig) -> str:
-    """Convert the config to a yaml string.
+    """Convert configuration object to YAML string.
+
+    This function takes a configuration object and converts it to a YAML formatted string.
+    It handles different configuration object types including ``Namespace``,
+    ``ListConfig``, and ``DictConfig``.
 
     Args:
-        config (Namespace | ListConfig | DictConfig): Config
+        config: Configuration object to convert. Can be one of:
+            - ``Namespace``: A namespace object from OmegaConf
+            - ``ListConfig``: A list configuration from OmegaConf
+            - ``DictConfig``: A dictionary configuration from OmegaConf
 
     Returns:
-        str: YAML string
+        str: Configuration as YAML formatted string
+
+    Examples:
+        >>> from omegaconf import DictConfig
+        >>> config = DictConfig({"model": "padim", "dataset": {"name": "mvtec"}})
+        >>> yaml_str = to_yaml(config)
+        >>> print(yaml_str)
+        model: padim
+        dataset:
+          name: mvtec
+
+    Note:
+        - For ``Namespace`` objects, the function first converts to dictionary format
+        - Nested paths in the configuration are converted to strings
+        - The original configuration object is not modified
     """
     _config = config.clone() if isinstance(config, Namespace) else config.copy()
     if isinstance(_config, Namespace):
@@ -73,22 +148,40 @@ def to_yaml(config: Namespace | ListConfig | DictConfig) -> str:
 
 
 def to_tuple(input_size: int | ListConfig) -> tuple[int, int]:
-    """Convert int or list to a tuple.
+    """Convert input size to a tuple of (height, width).
+
+    This function takes either a single integer or a sequence of two integers and
+    converts it to a tuple representing image dimensions (height, width). If a single
+    integer is provided, it is used for both dimensions.
 
     Args:
-        input_size (int | ListConfig): input_size
+        input_size: Input size specification. Can be either:
+            - A single ``int`` that will be used for both height and width
+            - A ``ListConfig`` or sequence containing exactly 2 integers for height
+              and width
+
+    Returns:
+        tuple[int, int]: A tuple of ``(height, width)`` dimensions
+
+    Examples:
+        Create a square tuple from single integer:
 
-    Example:
         >>> to_tuple(256)
         (256, 256)
+
+        Create a tuple from list of dimensions:
+
         >>> to_tuple([256, 256])
         (256, 256)
 
     Raises:
-        ValueError: Unsupported value type.
+        ValueError: If ``input_size`` is a sequence without exactly 2 elements
+        TypeError: If ``input_size`` is neither an integer nor a sequence of
+            integers
 
-    Returns:
-        tuple[int, int]: Tuple of input_size
+    Note:
+        When using a sequence input, the first value is interpreted as height and
+        the second as width.
     """
     ret_val: tuple[int, int]
     if isinstance(input_size, int):
@@ -106,30 +199,46 @@ def to_tuple(input_size: int | ListConfig) -> tuple[int, int]:
 
 
 def convert_valuesview_to_tuple(values: ValuesView) -> list[tuple]:
-    """Convert a ValuesView object to a list of tuples.
+    """Convert ``ValuesView`` to list of tuples for parameter combinations.
 
-    This is useful to get list of possible values for each parameter in the config and a tuple for values that are
-    are to be patched. Ideally this is useful when used with product.
+    This function takes a ``ValuesView`` object and converts it to a list of tuples
+    that can be used for creating parameter combinations. It is particularly useful
+    when working with ``itertools.product`` to generate all possible parameter
+    combinations.
 
-    Example:
-        >>> params = DictConfig({
-                "dataset.category": [
-                    "bottle",
-                    "cable",
-                ],
-                "dataset.image_size": 224,
-                "model_name": ["padim"],
-            })
-        >>> convert_to_tuple(params.values())
-        [('bottle', 'cable'), (224,), ('padim',)]
-        >>> list(itertools.product(*convert_to_tuple(params.values())))
-        [('bottle', 224, 'padim'), ('cable', 224, 'padim')]
+    The function handles both iterable and non-iterable values:
+    - Iterable values (except strings) are converted to tuples
+    - Non-iterable values and strings are wrapped in single-element tuples
 
     Args:
-        values: ValuesView: ValuesView object to be converted to a list of tuples.
+        values: A ``ValuesView`` object containing parameter values to convert
 
     Returns:
-        list[Tuple]: List of tuples.
+        list[tuple]: A list of tuples where each tuple contains parameter values.
+            Single values are wrapped in 1-element tuples.
+
+    Examples:
+        Create parameter combinations from a config:
+
+        >>> params = DictConfig({
+        ...     "dataset.category": [
+        ...         "bottle",
+        ...         "cable",
+        ...     ],
+        ...     "dataset.image_size": 224,
+        ...     "model_name": ["padim"],
+        ... })
+        >>> convert_valuesview_to_tuple(params.values())
+        [('bottle', 'cable'), (224,), ('padim',)]
+
+        Use with ``itertools.product`` to get all combinations:
+
+        >>> list(itertools.product(*convert_valuesview_to_tuple(params.values())))
+        [('bottle', 224, 'padim'), ('cable', 224, 'padim')]
+
+    Note:
+        Strings are treated as non-iterable values even though they are technically
+        iterable in Python. This prevents unwanted character-by-character splitting.
     """
     return_list = []
     for value in values:
@@ -141,21 +250,48 @@ def convert_valuesview_to_tuple(values: ValuesView) -> list[tuple]:
 
 
 def flatten_dict(config: dict, prefix: str = "") -> dict:
-    """Flatten the dictionary.
+    """Flatten a nested dictionary using dot notation.
+
+    Takes a nested dictionary and flattens it into a single-level dictionary where
+    nested keys are joined using dot notation. This is useful for converting
+    hierarchical configurations into a flat format.
+
+    Args:
+        config: Nested dictionary to flatten. Can contain arbitrary levels of
+            nesting.
+        prefix: Optional string prefix to prepend to all flattened keys. Defaults
+            to empty string.
+
+    Returns:
+        dict: Flattened dictionary where nested keys are joined with dots.
+            For example, ``{"a": {"b": 1}}`` becomes ``{"a.b": 1}``.
 
     Examples:
+        Basic nested dictionary flattening:
+
         >>> config = {
-                "dataset": {
-                    "category": "bottle",
-                    "image_size": 224,
-                },
-                "model_name": "padim",
-            }
-        >>> flatten_dict(config)
+        ...     "dataset": {
+        ...         "category": "bottle",
+        ...         "image_size": 224
+        ...     },
+        ...     "model_name": "padim"
+        ... }
+        >>> flattened = flatten_dict(config)
+        >>> print(flattened)  # doctest: +SKIP
         {
-            "dataset.category": "bottle",
-            "dataset.image_size": 224,
-            "model_name": "padim",
+            'dataset.category': 'bottle',
+            'dataset.image_size': 224,
+            'model_name': 'padim'
+        }
+
+        With custom prefix:
+
+        >>> flattened = flatten_dict(config, prefix="config.")
+        >>> print(flattened)  # doctest: +SKIP
+        {
+            'config.dataset.category': 'bottle',
+            'config.dataset.image_size': 224,
+            'config.model_name': 'padim'
         }
     """
     out = {}
@@ -168,18 +304,44 @@ def flatten_dict(config: dict, prefix: str = "") -> dict:
 
 
 def namespace_from_dict(container: dict) -> Namespace:
-    """Convert dictionary to Namespace recursively.
+    """Convert a dictionary to a Namespace object recursively.
+
+    This function takes a dictionary and recursively converts it and all nested
+    dictionaries into ``Namespace`` objects. This is useful for accessing dictionary
+    keys as attributes.
+
+    Args:
+        container: Dictionary to convert into a ``Namespace`` object. Can contain
+            arbitrary levels of nesting.
+
+    Returns:
+        ``Namespace`` object with equivalent structure to input dictionary. Nested
+        dictionaries are converted to nested ``Namespace`` objects.
 
     Examples:
+        Basic dictionary conversion:
+
         >>> container = {
-                "dataset": {
-                    "category": "bottle",
-                    "image_size": 224,
-                },
-                "model_name": "padim",
-            }
-        >>> namespace_from_dict(container)
-        Namespace(dataset=Namespace(category='bottle', image_size=224), model_name='padim')
+        ...     "dataset": {
+        ...         "category": "bottle",
+        ...         "image_size": 224,
+        ...     },
+        ...     "model_name": "padim",
+        ... }
+        >>> namespace = namespace_from_dict(container)
+        >>> namespace.dataset.category
+        'bottle'
+        >>> namespace.model_name
+        'padim'
+
+        The returned object allows attribute-style access:
+
+        >>> namespace.dataset.image_size
+        224
+
+    Note:
+        All dictionary keys must be valid Python identifiers to be accessed as
+        attributes in the resulting ``Namespace`` object.
     """
     output = Namespace()
     for k, v in container.items():
@@ -191,9 +353,23 @@ def namespace_from_dict(container: dict) -> Namespace:
 
 
 def dict_from_namespace(container: Namespace) -> dict:
-    """Convert Namespace to dictionary recursively.
+    """Convert a Namespace object to a dictionary recursively.
+
+    This function takes a ``Namespace`` object and recursively converts it and all nested
+    ``Namespace`` objects into dictionaries. This is useful for serializing ``Namespace``
+    objects or converting them to a format that can be easily saved or transmitted.
+
+    Args:
+        container: ``Namespace`` object to convert into a dictionary. Can contain
+            arbitrary levels of nesting.
+
+    Returns:
+        Dictionary with equivalent structure to input ``Namespace``. Nested
+        ``Namespace`` objects are converted to nested dictionaries.
 
     Examples:
+        Basic namespace conversion:
+
         >>> from jsonargparse import Namespace
         >>> ns = Namespace()
         >>> ns.a = 1
@@ -201,6 +377,20 @@ def dict_from_namespace(container: Namespace) -> dict:
         >>> ns.b.c = 2
         >>> dict_from_namespace(ns)
         {'a': 1, 'b': {'c': 2}}
+
+        The function handles arbitrary nesting:
+
+        >>> ns = Namespace()
+        >>> ns.x = Namespace()
+        >>> ns.x.y = Namespace()
+        >>> ns.x.y.z = 3
+        >>> dict_from_namespace(ns)
+        {'x': {'y': {'z': 3}}}
+
+    Note:
+        This function is the inverse of :func:`namespace_from_dict`. Together they
+        provide bidirectional conversion between dictionaries and ``Namespace``
+        objects.
     """
     output = {}
     for k, v in container.__dict__.items():
@@ -212,13 +402,34 @@ def dict_from_namespace(container: Namespace) -> dict:
 
 
 def update_config(config: DictConfig | ListConfig | Namespace) -> DictConfig | ListConfig | Namespace:
-    """Update config.
+    """Update configuration with warnings and NNCF settings.
+
+    This function processes the provided configuration by:
+        - Showing relevant configuration-specific warnings via ``_show_warnings``
+        - Updating NNCF (Neural Network Compression Framework) settings via
+          ``_update_nncf_config``
 
     Args:
-        config: Configurable parameters.
+        config: Configuration object to update. Can be either a ``DictConfig``,
+            ``ListConfig``, or ``Namespace`` instance containing model and training
+            parameters.
 
     Returns:
-        DictConfig | ListConfig | Namespace: Updated config.
+        Updated configuration with any NNCF-specific modifications applied. Returns
+        the same type as the input configuration.
+
+    Examples:
+        >>> from omegaconf import DictConfig
+        >>> config = DictConfig({"optimization": {"nncf": {"apply": True}}})
+        >>> updated = update_config(config)
+
+        >>> from jsonargparse import Namespace
+        >>> config = Namespace(data={"clip_length_in_frames": 1})
+        >>> updated = update_config(config)
+
+    Note:
+        This function is typically called after loading the initial configuration
+        but before using it for model training or inference.
     """
     _show_warnings(config)
 
@@ -226,13 +437,40 @@ def update_config(config: DictConfig | ListConfig | Namespace) -> DictConfig | L
 
 
 def _update_nncf_config(config: DictConfig | ListConfig) -> DictConfig | ListConfig:
-    """Set the NNCF input size based on the value of the crop_size parameter in the configurable parameters object.
+    """Update NNCF configuration with input size settings.
+
+    This function updates the Neural Network Compression Framework (NNCF)
+    configuration by setting default input size parameters if they are not already
+    specified. It also handles merging any NNCF-specific configuration updates.
+
+    The function checks if NNCF optimization settings exist in the config and adds
+    default input shape information of ``[1, 3, 10, 10]`` if not present. If NNCF
+    is enabled and contains update configuration, it merges those updates.
 
     Args:
-        config (DictConfig | ListConfig): Configurable parameters of the current run.
+        config: Configuration object containing NNCF settings. Must be either a
+            ``DictConfig`` or ``ListConfig`` instance.
 
     Returns:
-        DictConfig | ListConfig: Updated configurable parameters in DictConfig object.
+        ``DictConfig`` or ``ListConfig`` with updated NNCF configuration settings.
+
+    Example:
+        >>> from omegaconf import DictConfig
+        >>> config = DictConfig({
+        ...     "optimization": {
+        ...         "nncf": {
+        ...             "apply": True,
+        ...             "input_info": {"sample_size": [1, 3, 224, 224]}
+        ...         }
+        ...     }
+        ... })
+        >>> updated = _update_nncf_config(config)
+
+    Note:
+        The default input size of ``[1, 3, 10, 10]`` represents:
+        - Batch size of 1
+        - 3 input channels (RGB)
+        - Height and width of 10 pixels
     """
     if "optimization" in config and "nncf" in config.optimization:
         if "input_info" not in config.optimization.nncf:
@@ -244,10 +482,32 @@ def _update_nncf_config(config: DictConfig | ListConfig) -> DictConfig | ListCon
 
 
 def _show_warnings(config: DictConfig | ListConfig | Namespace) -> None:
-    """Show warnings if any based on the configuration settings.
+    """Show configuration-specific warnings.
+
+    This function checks the provided configuration for conditions that may cause
+    issues and displays appropriate warning messages. Currently checks for:
+
+        - Video clip length compatibility issues with models and visualizers
 
     Args:
-        config (DictConfig | ListConfig | Namespace): Configurable parameters for the current run.
+        config: Configuration object to check for warning conditions. Can be one of:
+            - ``DictConfig``
+            - ``ListConfig``
+            - ``Namespace``
+
+    Example:
+        >>> from omegaconf import DictConfig
+        >>> config = DictConfig({
+        ...     "data": {
+        ...         "init_args": {"clip_length_in_frames": 2}
+        ...     }
+        ... })
+        >>> _show_warnings(config)  # Will show video clip length warning
+
+    Note:
+        The function currently focuses on video-related configuration warnings,
+        specifically checking the ``clip_length_in_frames`` parameter in the data
+        configuration section.
     """
     if "clip_length_in_frames" in config.data and config.data.init_args.clip_length_in_frames > 1:
         logger.warning(
diff --git a/src/anomalib/utils/cv/__init__.py b/src/anomalib/utils/cv/__init__.py
index 72435b61dc..537d57173f 100644
--- a/src/anomalib/utils/cv/__init__.py
+++ b/src/anomalib/utils/cv/__init__.py
@@ -1,6 +1,22 @@
-"""Anomalib computer vision utilities."""
+"""Computer vision utilities for anomaly detection.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides computer vision utilities used by the anomalib library for
+processing and analyzing images during anomaly detection.
+
+The utilities include:
+    - Connected components analysis for both CPU and GPU
+    - Image processing operations
+    - Computer vision helper functions
+
+Example:
+    >>> from anomalib.utils.cv import connected_components_cpu
+    >>> # Process image to get binary mask
+    >>> mask = get_binary_mask(image)
+    >>> # Find connected components
+    >>> labels = connected_components_cpu(mask)
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from .connected_components import connected_components_cpu, connected_components_gpu
diff --git a/src/anomalib/utils/cv/connected_components.py b/src/anomalib/utils/cv/connected_components.py
index e2fc1000df..fe2c7fa1c2 100644
--- a/src/anomalib/utils/cv/connected_components.py
+++ b/src/anomalib/utils/cv/connected_components.py
@@ -1,6 +1,22 @@
-"""Connected component labeling."""
+"""Connected component labeling for anomaly detection.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides functions for performing connected component labeling on both
+GPU and CPU. Connected components are used to identify and label contiguous
+regions in binary images, which is useful for post-processing anomaly detection
+results.
+
+Example:
+    >>> import torch
+    >>> from anomalib.utils.cv import connected_components_gpu
+    >>> # Create a binary mask tensor (1 for anomaly, 0 for normal)
+    >>> mask = torch.zeros(1, 1, 4, 4)
+    >>> mask[0, 0, 1:3, 1:3] = 1  # Create a 2x2 square anomaly
+    >>> # Get labeled components
+    >>> labels = connected_components_gpu(mask)
+    >>> print(labels.unique())  # Should show [0, 1] for background and one component
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import cv2
@@ -10,14 +26,39 @@
 
 
 def connected_components_gpu(image: torch.Tensor, num_iterations: int = 1000) -> torch.Tensor:
-    """Perform connected component labeling on GPU and remap the labels from 0 to N.
+    """Perform connected component labeling on GPU.
+
+    Labels connected regions in a binary image and remaps the labels sequentially
+    from 0 to N, where N is the number of unique components. Uses the GPU for
+    faster processing of large images.
 
     Args:
-        image (torch.Tensor): Binary input image from which we want to extract connected components (Bx1xHxW)
-        num_iterations (int): Number of iterations used in the connected component computation.
+        image (torch.Tensor): Binary input image tensor of shape ``(B, 1, H, W)``
+            where ``B`` is batch size, ``H`` is height and ``W`` is width.
+            Values should be binary (0 or 1).
+        num_iterations (int, optional): Number of iterations for the connected
+            components algorithm. Higher values may be needed for complex regions.
+            Defaults to 1000.
 
     Returns:
-        Tensor: Components labeled from 0 to N.
+        torch.Tensor: Integer tensor of same shape as input, containing labeled
+            components from 0 to N. Background (zero) pixels in the input remain
+            ``0``, while connected regions are labeled with integers from ``1``
+            to ``N``.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.utils.cv import connected_components_gpu
+        >>> # Create a binary mask with a 2x2 square anomaly
+        >>> mask = torch.zeros(1, 1, 4, 4)
+        >>> mask[0, 0, 1:3, 1:3] = 1
+        >>> labels = connected_components_gpu(mask)
+        >>> print(labels.unique())  # Should show tensor([0, 1])
+        >>> print(labels[0, 0])  # Show the labeled components
+        tensor([[0, 0, 0, 0],
+                [0, 1, 1, 0],
+                [0, 1, 1, 0],
+                [0, 0, 0, 0]])
     """
     components = connected_components(image, num_iterations=num_iterations)
 
@@ -32,11 +73,39 @@ def connected_components_gpu(image: torch.Tensor, num_iterations: int = 1000) ->
 def connected_components_cpu(image: torch.Tensor) -> torch.Tensor:
     """Perform connected component labeling on CPU.
 
+    Labels connected regions in a binary image using OpenCV's implementation.
+    Ensures unique labeling across batched inputs by remapping component labels
+    sequentially.
+
     Args:
-        image (torch.Tensor): Binary input data from which we want to extract connected components (Bx1xHxW)
+        image (torch.Tensor): Binary input tensor of shape ``(B, 1, H, W)`` where
+            ``B`` is batch size, ``H`` is height and ``W`` is width. Values should
+            be binary (``0`` or ``1``).
 
     Returns:
-        Tensor: Components labeled from 0 to N.
+        torch.Tensor: Integer tensor of same shape as input, containing labeled
+            components from ``0`` to ``N``. Background (zero) pixels in the input
+            remain ``0``, while connected regions are labeled with integers from
+            ``1`` to ``N``, ensuring unique labels across the batch.
+
+    Example:
+        >>> import torch
+        >>> from anomalib.utils.cv import connected_components_cpu
+        >>> # Create a binary mask with a 2x2 square anomaly
+        >>> mask = torch.zeros(1, 1, 4, 4)
+        >>> mask[0, 0, 1:3, 1:3] = 1
+        >>> labels = connected_components_cpu(mask)
+        >>> print(labels.unique())  # Should show tensor([0, 1])
+        >>> print(labels[0, 0])  # Show the labeled components
+        tensor([[0, 0, 0, 0],
+                [0, 1, 1, 0],
+                [0, 1, 1, 0],
+                [0, 0, 0, 0]])
+
+    Note:
+        This function uses OpenCV's ``connectedComponents`` implementation which
+        runs on CPU. For GPU acceleration, use :func:`connected_components_gpu`
+        instead.
     """
     components = torch.zeros_like(image)
     label_idx = 1
diff --git a/src/anomalib/utils/exceptions/__init__.py b/src/anomalib/utils/exceptions/__init__.py
index 52d64883d1..fc9c2a55c2 100644
--- a/src/anomalib/utils/exceptions/__init__.py
+++ b/src/anomalib/utils/exceptions/__init__.py
@@ -1,4 +1,21 @@
-"""Utilities related to exception and error handling."""
+"""Exception and error handling utilities for anomaly detection.
+
+This module provides utilities for handling exceptions and errors in the anomalib
+library. The utilities include:
+    - Dynamic import handling with graceful fallbacks
+    - Custom exception types for anomaly detection
+    - Error handling helpers and decorators
+
+Example:
+    >>> from anomalib.utils.exceptions import try_import
+    >>> # Try importing an optional dependency
+    >>> torch_fidelity = try_import("torch_fidelity")
+    >>> if torch_fidelity is None:
+    ...     print("torch-fidelity not installed")
+
+The module ensures consistent and informative error handling across the anomalib
+codebase.
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/utils/exceptions/imports.py b/src/anomalib/utils/exceptions/imports.py
index 6ef8dbd89d..36609c9652 100644
--- a/src/anomalib/utils/exceptions/imports.py
+++ b/src/anomalib/utils/exceptions/imports.py
@@ -1,4 +1,21 @@
-"""Import handling utilities."""
+"""Import handling utilities for anomaly detection.
+
+This module provides utilities for handling dynamic imports and import-related
+exceptions in the anomalib library. The utilities include:
+    - Dynamic module import with graceful error handling
+    - Import availability checking
+    - Deprecation warnings for legacy import functions
+
+Example:
+    >>> from anomalib.utils.exceptions import try_import
+    >>> # Try importing an optional dependency
+    >>> torch_fidelity = try_import("torch_fidelity")
+    >>> if torch_fidelity is None:
+    ...     print("torch-fidelity not installed")
+
+The module ensures consistent handling of optional dependencies and provides
+helpful error messages when imports fail.
+"""
 
 # Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,13 +27,33 @@
 
 
 def try_import(import_path: str) -> bool:
-    """Try to import a module.
+    """Try to import a module and return whether the import succeeded.
+
+    This function attempts to dynamically import a Python module and handles any
+    import errors gracefully. It is deprecated and will be removed in v2.0.0.
+    Users should migrate to ``module_available`` from lightning-utilities instead.
 
     Args:
-        import_path (str): The import path of the module.
+        import_path (str): The import path of the module to try importing. This can
+            be a top-level package name (e.g. ``"torch"``) or a submodule path
+            (e.g. ``"torch.nn"``).
 
     Returns:
-        bool: True if import succeeds, False otherwise.
+        bool: ``True`` if the import succeeds, ``False`` if an ``ImportError``
+            occurs.
+
+    Warns:
+        DeprecationWarning: This function is deprecated and will be removed in
+            v2.0.0. Use ``module_available`` from lightning-utilities instead.
+
+    Example:
+        >>> from anomalib.utils.exceptions import try_import
+        >>> # Try importing an optional dependency
+        >>> has_torch = try_import("torch")
+        >>> if not has_torch:
+        ...     print("PyTorch is not installed")
+        >>> # Try importing a submodule
+        >>> has_torchvision = try_import("torchvision.transforms")
     """
     import warnings
 
diff --git a/src/anomalib/utils/logging.py b/src/anomalib/utils/logging.py
index d73ef440c4..a92149c53e 100644
--- a/src/anomalib/utils/logging.py
+++ b/src/anomalib/utils/logging.py
@@ -1,4 +1,28 @@
-"""Logging Utility functions."""
+"""Logging utility functions for anomaly detection.
+
+This module provides utilities for logging and output management. The key components include:
+
+    - ``LoggerRedirectError``: Custom exception for logging redirection failures
+    - ``hide_output``: Decorator to suppress function output streams
+    - Helper functions for redirecting output to loggers
+
+Example:
+    >>> from anomalib.utils.logging import hide_output
+    >>> @hide_output
+    >>> def my_function():
+    ...     print("This output will be hidden")
+    >>> my_function()
+
+The module ensures consistent logging behavior by:
+    - Providing decorators for output control
+    - Handling both stdout and stderr redirection
+    - Supporting exception propagation
+    - Offering flexible output management
+
+Note:
+    The logging utilities are designed to work with both standard Python logging
+    and custom logging implementations.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,35 +37,67 @@
 
 
 class LoggerRedirectError(Exception):
-    """Exception occurred when executing function with outputs redirected to logger."""
+    """Exception raised when redirecting function output to logger fails.
+
+    This exception is raised when there is an error while redirecting the output
+    streams (stdout/stderr) of a function to a logger. It typically occurs in
+    functions decorated with ``@hide_output``.
+
+    Example:
+        >>> @hide_output
+        >>> def problematic_function():
+        ...     raise ValueError("Something went wrong")
+        >>> problematic_function()
+        Traceback (most recent call last):
+            ...
+        LoggerRedirectError: Error occurred while executing problematic_function
+
+    Note:
+        This exception wraps the original exception that caused the redirection
+        failure, which can be accessed through the ``__cause__`` attribute.
+    """
 
 
 def hide_output(func: Callable[..., Any]) -> Callable[..., Any]:
-    """Hide output of the function.
+    """Hide output of a function by redirecting stdout and stderr.
+
+    This decorator captures and discards any output that would normally be printed
+    to stdout or stderr when the decorated function executes. The function's
+    return value is preserved.
 
     Args:
-        func (function): Hides output from all streams of this function.
+        func (Callable[..., Any]): Function whose output should be hidden.
+            All output streams from this function will be captured.
+
+    Returns:
+        Callable[..., Any]: Wrapped function that executes silently.
+
+    Raises:
+        LoggerRedirectError: If an error occurs during function execution. The
+            original exception can be accessed via ``__cause__``.
 
     Example:
+        Basic usage to hide print statements:
+
         >>> @hide_output
-        >>> def my_function():
-        >>>     print("This will not be printed")
-        >>> my_function()
+        ... def my_function():
+        ...     print("This will not be printed")
+        >>> my_function()  # No output will appear
+
+        Exceptions are still propagated:
 
         >>> @hide_output
-        >>> def my_function():
-        >>>     1/0
+        ... def my_function():
+        ...     1/0  # doctest: +IGNORE_EXCEPTION_DETAIL
         >>> my_function()
         Traceback (most recent call last):
-        File "", line 1, in 
-        File "", line 2, in my_fun
-        ZeroDivisionError: division by zero
+            ...
+        LoggerRedirectError: Error occurred while executing my_function
 
-    Raises:
-        Exception: In case the execution of function fails, it raises an exception.
-
-    Returns:
-        object of the called function
+    Note:
+        - The decorator preserves the function's metadata using ``functools.wraps``
+        - Both ``stdout`` and ``stderr`` streams are captured
+        - Original streams are always restored, even if an exception occurs
     """
 
     @functools.wraps(func)
@@ -66,11 +122,33 @@ def wrapper(*args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
 
 
 def redirect_logs(log_file: str) -> None:
-    """Add file handler to logger.
+    """Add file handler to logger and remove other handlers.
 
-    It also removes all other handlers from the loggers.
+    This function sets up file-based logging by:
+        - Creating a file handler for the specified log file
+        - Setting a standard format for log messages
+        - Removing all other handlers from existing loggers
+        - Configuring warning capture
 
-    Note: This feature does not work well with multiprocessing and won't redirect logs from child processes.
+    Args:
+        log_file: Path to the log file where messages will be written.
+            Parent directories will be created if they don't exist.
+
+    Example:
+        >>> from pathlib import Path
+        >>> log_path = Path("logs/app.log")
+        >>> redirect_logs(str(log_path))  # doctest: +SKIP
+        >>> import logging
+        >>> logger = logging.getLogger(__name__)
+        >>> logger.info("Test message")  # Message written to logs/app.log
+
+    Note:
+        - The log format includes timestamp, logger name, level and message
+        - All existing handlers are removed from loggers to ensure logs only go
+          to file
+        - This function does not work well with multiprocessing - logs from
+          child processes will not be redirected
+        - The function captures Python warnings in addition to regular logs
     """
     Path(log_file).parent.mkdir(exist_ok=True, parents=True)
     logger_file_handler = logging.FileHandler(log_file)
diff --git a/src/anomalib/utils/normalization/__init__.py b/src/anomalib/utils/normalization/__init__.py
index ebf4493204..6434926074 100644
--- a/src/anomalib/utils/normalization/__init__.py
+++ b/src/anomalib/utils/normalization/__init__.py
@@ -1,13 +1,51 @@
-"""Tools for anomaly score normalization."""
+"""Tools for anomaly score normalization.
 
-# Copyright (C) 2022 Intel Corporation
+This module provides utilities for normalizing anomaly scores in anomaly detection
+tasks. The utilities include:
+    - Min-max normalization to scale scores to [0,1] range
+    - Enum class to specify normalization methods
+
+Example:
+    >>> from anomalib.utils.normalization import NormalizationMethod
+    >>> # Use min-max normalization
+    >>> method = NormalizationMethod.MIN_MAX
+    >>> print(method)
+    min_max
+    >>> # Use no normalization
+    >>> method = NormalizationMethod.NONE
+    >>> print(method)
+    none
+
+The module ensures consistent normalization of anomaly scores across different
+detection algorithms.
+"""
+
+# Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 from enum import Enum
 
 
 class NormalizationMethod(str, Enum):
-    """Normalization method for normalization."""
+    """Enumeration of supported normalization methods for anomaly scores.
+
+    This enum class defines the available methods for normalizing anomaly scores:
+        - ``MIN_MAX``: Scales scores to [0,1] range using min-max normalization
+        - ``NONE``: No normalization is applied, raw scores are used
+
+    Example:
+        >>> from anomalib.utils.normalization import NormalizationMethod
+        >>> # Use min-max normalization
+        >>> method = NormalizationMethod.MIN_MAX
+        >>> print(method)
+        min_max
+        >>> # Use no normalization
+        >>> method = NormalizationMethod.NONE
+        >>> print(method)
+        none
+
+    The enum inherits from ``str`` to enable string comparison and serialization.
+    """
 
     MIN_MAX = "min_max"
     NONE = "none"
diff --git a/src/anomalib/utils/normalization/min_max.py b/src/anomalib/utils/normalization/min_max.py
index 9df69c8d06..bf1982be36 100644
--- a/src/anomalib/utils/normalization/min_max.py
+++ b/src/anomalib/utils/normalization/min_max.py
@@ -1,4 +1,25 @@
-"""Tools for min-max normalization."""
+"""Tools for min-max normalization.
+
+This module provides utilities for min-max normalization of anomaly scores. The
+main function :func:`normalize` scales values to [0,1] range and centers them
+around a threshold.
+
+Example:
+    >>> import numpy as np
+    >>> from anomalib.utils.normalization.min_max import normalize
+    >>> # Create sample anomaly scores
+    >>> scores = np.array([0.1, 0.5, 0.8])
+    >>> threshold = 0.5
+    >>> min_val = 0.0
+    >>> max_val = 1.0
+    >>> # Normalize scores
+    >>> normalized = normalize(scores, threshold, min_val, max_val)
+    >>> print(normalized)  # Values centered around 0.5
+    [0.1 0.5 0.8]
+
+The module supports both NumPy arrays and PyTorch tensors as inputs, with
+appropriate handling for each type.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,7 +34,39 @@ def normalize(
     min_val: float | np.ndarray | torch.Tensor,
     max_val: float | np.ndarray | torch.Tensor,
 ) -> np.ndarray | torch.Tensor:
-    """Apply min-max normalization and shift the values such that the threshold value is centered at 0.5."""
+    """Apply min-max normalization and center values around a threshold.
+
+    This function performs min-max normalization on the input values and shifts them
+    such that the threshold value is centered at 0.5. The output is clipped to the
+    range [0,1].
+
+    Args:
+        targets (numpy.ndarray | numpy.float32 | torch.Tensor): Input values to
+            normalize. Can be either a NumPy array or PyTorch tensor.
+        threshold (float | numpy.ndarray | torch.Tensor): Threshold value that will
+            be centered at 0.5 after normalization.
+        min_val (float | numpy.ndarray | torch.Tensor): Minimum value used for
+            normalization scaling.
+        max_val (float | numpy.ndarray | torch.Tensor): Maximum value used for
+            normalization scaling.
+
+    Returns:
+        numpy.ndarray | torch.Tensor: Normalized values in range [0,1] with
+            threshold centered at 0.5. Output type matches input type.
+
+    Raises:
+        TypeError: If ``targets`` is neither a NumPy array nor PyTorch tensor.
+
+    Example:
+        >>> import torch
+        >>> scores = torch.tensor([0.1, 0.5, 0.8])
+        >>> threshold = 0.5
+        >>> min_val = 0.0
+        >>> max_val = 1.0
+        >>> normalized = normalize(scores, threshold, min_val, max_val)
+        >>> print(normalized)
+        tensor([0.1000, 0.5000, 0.8000])
+    """
     normalized = ((targets - threshold) / (max_val - min_val)) + 0.5
     if isinstance(targets, np.ndarray | np.float32 | np.float64):
         normalized = np.minimum(normalized, 1)
diff --git a/src/anomalib/utils/path.py b/src/anomalib/utils/path.py
index c9f92937d2..aea614eb54 100644
--- a/src/anomalib/utils/path.py
+++ b/src/anomalib/utils/path.py
@@ -1,4 +1,30 @@
-"""Anomalib Path Utils."""
+"""Path utilities for anomaly detection.
+
+This module provides utilities for managing paths and directories in anomaly
+detection projects. The key components include:
+
+    - Version directory creation and management
+    - Symbolic link handling
+    - Path resolution and validation
+
+Example:
+    >>> from anomalib.utils.path import create_versioned_dir
+    >>> from pathlib import Path
+    >>> # Create versioned directory
+    >>> version_dir = create_versioned_dir(Path("experiments"))
+    >>> version_dir.name
+    'v1'
+
+The module ensures consistent path handling by:
+    - Creating incrementing version directories (v1, v2, etc.)
+    - Maintaining a ``latest`` symbolic link
+    - Handling both string and ``Path`` inputs
+    - Providing cross-platform compatibility
+
+Note:
+    All paths are resolved to absolute paths to ensure consistent behavior
+    across different working directories.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -10,28 +36,41 @@
 def create_versioned_dir(root_dir: str | Path) -> Path:
     """Create a new version directory and update the ``latest`` symbolic link.
 
+    This function creates a new versioned directory (e.g. ``v1``, ``v2``, etc.) inside the
+    specified root directory and updates a ``latest`` symbolic link to point to it.
+    The version numbers increment automatically based on existing directories.
+
     Args:
-        root_dir (Path): The root directory where the version directories are stored.
+        root_dir (Union[str, Path]): Root directory path where version directories will be
+            created. Can be provided as a string or ``Path`` object. Directory will be
+            created if it doesn't exist.
 
     Returns:
-        latest_link_path (Path): The path to the ``latest`` symbolic link.
+        Path: Path to the ``latest`` symbolic link that points to the newly created
+            version directory.
 
     Examples:
-        >>> version_dir = create_version_dir(Path('path/to/experiments/'))
-        PosixPath('/path/to/experiments/latest')
-
-        >>> version_dir.resolve().name
-        v1
-
-        Calling the function again will create a new version directory and
-        update the ``latest`` symbolic link:
-
-        >>> version_dir = create_version_dir('path/to/experiments/')
-        PosixPath('/path/to/experiments/latest')
-
-        >>> version_dir.resolve().name
-        v2
-
+        Create first version directory:
+
+        >>> from pathlib import Path
+        >>> version_dir = create_versioned_dir(Path("experiments"))
+        >>> version_dir
+        PosixPath('experiments/latest')
+        >>> version_dir.resolve().name  # Points to v1
+        'v1'
+
+        Create second version directory:
+
+        >>> version_dir = create_versioned_dir("experiments")
+        >>> version_dir.resolve().name  # Now points to v2
+        'v2'
+
+    Note:
+        - The function resolves all paths to absolute paths
+        - Creates parent directories if they don't exist
+        - Handles existing symbolic links by removing and recreating them
+        - Version directories follow the pattern ``v1``, ``v2``, etc.
+        - The ``latest`` link always points to the most recently created version
     """
     # Compile a regular expression to match version directories
     version_pattern = re.compile(r"^v(\d+)$")
@@ -66,23 +105,55 @@ def create_versioned_dir(root_dir: str | Path) -> Path:
 
 
 def convert_to_snake_case(s: str) -> str:
-    """Converts a string to snake case.
+    """Convert a string to snake case format.
+
+    This function converts various string formats (space-separated, camelCase,
+    PascalCase, etc.) to snake_case by:
+
+    - Converting spaces and punctuation to underscores
+    - Inserting underscores before capital letters
+    - Converting to lowercase
+    - Removing redundant underscores
 
     Args:
-        s (str): The input string to be converted.
+        s (str): Input string to convert to snake case.
 
     Returns:
-        str: The converted string in snake case.
+        str: The input string converted to snake case format.
 
     Examples:
+        Convert space-separated string:
+
         >>> convert_to_snake_case("Snake Case")
         'snake_case'
 
+        Convert camelCase:
+
         >>> convert_to_snake_case("snakeCase")
         'snake_case'
 
+        Convert PascalCase:
+
+        >>> convert_to_snake_case("SnakeCase")
+        'snake_case'
+
+        Handle existing snake_case:
+
         >>> convert_to_snake_case("snake_case")
         'snake_case'
+
+        Handle punctuation:
+
+        >>> convert_to_snake_case("snake.case")
+        'snake_case'
+
+        >>> convert_to_snake_case("snake-case")
+        'snake_case'
+
+    Note:
+        - Leading/trailing underscores are removed
+        - Multiple consecutive underscores are collapsed to a single underscore
+        - Punctuation marks (``.``, ``-``, ``'``) are converted to underscores
     """
     # Replace whitespace, hyphens, periods, and apostrophes with underscores
     s = re.sub(r"\s+|[-.\']", "_", s)
@@ -98,45 +169,63 @@ def convert_to_snake_case(s: str) -> str:
 
 
 def convert_to_title_case(text: str) -> str:
-    """Converts a given text to title case, handling regular text, snake_case, and camelCase.
+    """Convert text to title case, handling various text formats.
+
+    This function converts text from various formats (regular text, snake_case, camelCase,
+    PascalCase) to title case format. It preserves punctuation and handles contractions
+    appropriately.
 
     Args:
-        text (str): The input text to be converted to title case.
+        text (str): Input text to convert to title case. Can be in any text format like
+            snake_case, camelCase, PascalCase or regular text.
 
     Returns:
-        str: The input text converted to title case.
+        str: The input text converted to title case format.
 
     Raises:
-        TypeError: If the input is not a string.
+        TypeError: If the input ``text`` is not a string.
 
     Examples:
         Regular text:
+
         >>> convert_to_title_case("the quick brown fox")
         'The Quick Brown Fox'
 
         Snake case:
+
         >>> convert_to_title_case("convert_snake_case_to_title_case")
         'Convert Snake Case To Title Case'
 
         Camel case:
+
         >>> convert_to_title_case("convertCamelCaseToTitleCase")
         'Convert Camel Case To Title Case'
 
         Pascal case:
+
         >>> convert_to_title_case("ConvertPascalCaseToTitleCase")
         'Convert Pascal Case To Title Case'
 
         Mixed cases:
+
         >>> convert_to_title_case("mixed_snake_camelCase and PascalCase")
         'Mixed Snake Camel Case And Pascal Case'
 
         Handling punctuation and contractions:
+
         >>> convert_to_title_case("what's the_weather_like? it'sSunnyToday.")
         "What's The Weather Like? It's Sunny Today."
 
         With numbers and special characters:
+
         >>> convert_to_title_case("python3.9_features and camelCaseNames")
         'Python 3.9 Features And Camel Case Names'
+
+    Note:
+        - Preserves contractions (e.g., "what's" -> "What's")
+        - Handles mixed case formats in the same string
+        - Maintains punctuation and spacing
+        - Properly capitalizes words after numbers and special characters
     """
     if not isinstance(text, str):
         msg = "Input must be a string"
@@ -166,48 +255,62 @@ def generate_output_filename(
     category: str | None = None,
     mkdir: bool = True,
 ) -> Path:
-    """Generate an output filename based on the input path, preserving the directory structure.
+    """Generate an output filename based on the input path.
 
-    This function takes an input path, an output base directory, a dataset name, and an optional
-    category. It generates an output path that preserves the directory structure after the dataset
-    name (and category, if provided) while placing the file in the specified output directory.
+    This function generates an output path that preserves the directory structure after the
+    dataset name (and category if provided) while placing the file in the specified output
+    directory.
 
     Args:
-        input_path (str | Path): The input file path.
-        output_path (str | Path): The base output directory.
-        dataset_name (str): The name of the dataset in the input path.
-        category (str | None, optional): The category name in the input path. Defaults to None.
-        mkdir (bool, optional): Whether to create the output directory. Defaults to True.
+        input_path (str | Path): Path to the input file.
+        output_path (str | Path): Base output directory path.
+        dataset_name (str): Name of the dataset to find in the input path.
+        category (str | None, optional): Category name to find in the input path after
+            dataset name. Defaults to ``None``.
+        mkdir (bool, optional): Whether to create the output directory structure.
+            Defaults to ``True``.
 
     Returns:
-        Path: The generated output file path.
+        Path: Generated output file path preserving relevant directory structure.
 
     Raises:
-        ValueError: If the dataset name or category (if provided) is not found in the input path.
+        ValueError: If ``dataset_name`` is not found in ``input_path``.
+        ValueError: If ``category`` is provided but not found in ``input_path`` after
+            ``dataset_name``.
 
     Examples:
+        Basic usage with category:
+
         >>> input_path = "/data/MVTec/bottle/test/broken_large/000.png"
         >>> output_base = "/results"
         >>> dataset = "MVTec"
-
-        # With category
         >>> generate_output_filename(input_path, output_base, dataset, "bottle")
         PosixPath('/results/test/broken_large/000.png')
 
-        # Without category
+        Without category preserves more structure:
+
         >>> generate_output_filename(input_path, output_base, dataset)
         PosixPath('/results/bottle/test/broken_large/000.png')
 
-        # Different dataset structure
-        >>> input_path = "/datasets/MyDataset/train/class_A/image_001.jpg"
-        >>> generate_output_filename(input_path, "/output", "MyDataset", "class_A")
+        Different dataset structure:
+
+        >>> path = "/datasets/MyDataset/train/class_A/image_001.jpg"
+        >>> generate_output_filename(path, "/output", "MyDataset", "class_A")
         PosixPath('/output/image_001.jpg')
 
-        # Error case: Dataset not in path
-        >>> generate_output_filename("/wrong/path/image.png", "/out", "NonexistentDataset")
+        Dataset not found raises error:
+
+        >>> generate_output_filename("/wrong/path/image.png", "/out", "Missing")
         Traceback (most recent call last):
             ...
-        ValueError: Dataset name 'NonexistentDataset' not found in the input path.
+        ValueError: Dataset name 'Missing' not found in the input path.
+
+    Note:
+        - Directory structure after ``dataset_name`` (or ``category`` if provided) is
+          preserved in output path
+        - If ``mkdir=True``, creates output directory structure if it doesn't exist
+        - Dataset and category name matching is case-insensitive
+        - Original filename is preserved in output path
     """
     input_path = Path(input_path)
     output_path = Path(output_path)
diff --git a/src/anomalib/utils/post_processing.py b/src/anomalib/utils/post_processing.py
index ff6a7d33eb..18b2c3b3a5 100644
--- a/src/anomalib/utils/post_processing.py
+++ b/src/anomalib/utils/post_processing.py
@@ -1,4 +1,34 @@
-"""Post Process This module contains utils function to apply post-processing to the output predictions."""
+"""Post-processing utilities for anomaly detection predictions.
+
+This module provides utilities for post-processing anomaly detection predictions.
+The key components include:
+
+    - Label addition to images with confidence scores
+    - Morphological operations on prediction masks
+    - Normalization and thresholding of anomaly maps
+
+Example:
+    >>> import numpy as np
+    >>> from anomalib.utils.post_processing import add_label
+    >>> # Add label to image
+    >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+    >>> labeled_image = add_label(
+    ...     image=image,
+    ...     label_name="Anomalous",
+    ...     color=(255, 0, 0),
+    ...     confidence=0.95
+    ... )
+
+The module ensures consistent post-processing by:
+    - Providing standardized label formatting
+    - Supporting both classification and segmentation outputs
+    - Handling proper scaling of visual elements
+    - Offering configurable processing parameters
+
+Note:
+    All functions preserve the input data types and handle proper normalization
+    of values where needed.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -18,18 +48,54 @@ def add_label(
     font_scale: float = 5e-3,
     thickness_scale: float = 1e-3,
 ) -> np.ndarray:
-    """Add a label to an image.
+    """Add a text label with optional confidence score to an image.
+
+    This function adds a text label to the top-left corner of an image. The label has a
+    colored background patch and can optionally include a confidence percentage.
 
     Args:
-        image (np.ndarray): Input image.
-        label_name (str): Name of the label that will be displayed on the image.
-        color (tuple[int, int, int]): RGB values for background color of label.
-        confidence (float | None): confidence score of the label.
-        font_scale (float): scale of the font size relative to image size. Increase for bigger font.
-        thickness_scale (float): scale of the font thickness. Increase for thicker font.
+        image (np.ndarray): Input image to add the label to. Must be a 3-channel RGB or
+            BGR image.
+        label_name (str): Text label to display on the image (e.g. "normal",
+            "anomalous").
+        color (tuple[int, int, int]): RGB color values for the label background as a
+            tuple of 3 integers in range [0,255].
+        confidence (float | None, optional): Confidence score between 0 and 1 to display
+            as percentage. If ``None``, only the label name is shown. Defaults to
+            ``None``.
+        font_scale (float, optional): Scale factor for font size relative to image
+            dimensions. Larger values produce bigger text. Defaults to ``5e-3``.
+        thickness_scale (float, optional): Scale factor for font thickness relative to
+            image dimensions. Larger values produce thicker text. Defaults to ``1e-3``.
 
     Returns:
-        np.ndarray: Image with label.
+        np.ndarray: Copy of input image with label added to top-left corner.
+
+    Example:
+        Add a normal label with 95% confidence:
+
+        >>> import numpy as np
+        >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> labeled_image = add_label(
+        ...     image=image,
+        ...     label_name="normal",
+        ...     color=(0, 255, 0),
+        ...     confidence=0.95
+        ... )
+
+        Add an anomalous label without confidence:
+
+        >>> labeled_image = add_label(
+        ...     image=image,
+        ...     label_name="anomalous",
+        ...     color=(255, 0, 0)
+        ... )
+
+    Note:
+        - The function creates a copy of the input image to avoid modifying it
+        - Font size and thickness scale automatically with image dimensions
+        - Label is always placed in the top-left corner
+        - Uses OpenCV's FONT_HERSHEY_PLAIN font family
     """
     image = image.copy()
     img_height, img_width, _ = image.shape
@@ -62,25 +128,110 @@ def add_label(
 
 
 def add_normal_label(image: np.ndarray, confidence: float | None = None) -> np.ndarray:
-    """Add the normal label to the image."""
+    """Add a 'normal' label to the image.
+
+    This function adds a 'normal' label to the top-left corner of the image using a
+    light green color. The label can optionally include a confidence score.
+
+    Args:
+        image (np.ndarray): Input image to add the label to. Should be a 3-channel
+            RGB or BGR image.
+        confidence (float | None, optional): Confidence score between 0 and 1 to
+            display with the label. If ``None``, only the label is shown.
+            Defaults to ``None``.
+
+    Returns:
+        np.ndarray: Copy of input image with 'normal' label added.
+
+    Examples:
+        Add normal label without confidence:
+
+        >>> labeled_image = add_normal_label(image)
+
+        Add normal label with 95% confidence:
+
+        >>> labeled_image = add_normal_label(image, confidence=0.95)
+
+    Note:
+        - Creates a copy of the input image
+        - Uses a light green color (RGB: 225, 252, 134)
+        - Label is placed in top-left corner
+        - Font size scales with image dimensions
+    """
     return add_label(image, "normal", (225, 252, 134), confidence)
 
 
 def add_anomalous_label(image: np.ndarray, confidence: float | None = None) -> np.ndarray:
-    """Add the anomalous label to the image."""
+    """Add an 'anomalous' label to the image.
+
+    This function adds an 'anomalous' label to the top-left corner of the image using a
+    light red color. The label can optionally include a confidence score.
+
+    Args:
+        image (np.ndarray): Input image to add the label to. Should be a 3-channel
+            RGB or BGR image.
+        confidence (float | None, optional): Confidence score between 0 and 1 to
+            display with the label. If ``None``, only the label is shown.
+            Defaults to ``None``.
+
+    Returns:
+        np.ndarray: Copy of input image with 'anomalous' label added.
+
+    Examples:
+        Add anomalous label without confidence:
+
+        >>> labeled_image = add_anomalous_label(image)
+
+        Add anomalous label with 95% confidence:
+
+        >>> labeled_image = add_anomalous_label(image, confidence=0.95)
+
+    Note:
+        - Creates a copy of the input image
+        - Uses a light red color (RGB: 255, 100, 100)
+        - Label is placed in top-left corner
+        - Font size scales with image dimensions
+    """
     return add_label(image, "anomalous", (255, 100, 100), confidence)
 
 
 def anomaly_map_to_color_map(anomaly_map: np.ndarray, normalize: bool = True) -> np.ndarray:
-    """Compute anomaly color heatmap.
+    """Convert an anomaly map to a color heatmap visualization.
+
+    This function converts a grayscale anomaly map into a color heatmap using the JET
+    colormap. The anomaly map can optionally be normalized before coloring.
 
     Args:
-        anomaly_map (np.ndarray): Final anomaly map computed by the distance metric.
-        normalize (bool, optional): Bool to normalize the anomaly map prior to applying
-            the color map. Defaults to True.
+        anomaly_map (np.ndarray): Grayscale anomaly map computed by the model's
+            distance metric. Should be a 2D array of float values.
+        normalize (bool, optional): Whether to normalize the anomaly map to [0,1] range
+            before applying the colormap. If ``True``, the map is normalized using
+            min-max scaling. Defaults to ``True``.
 
     Returns:
-        np.ndarray: [description]
+        np.ndarray: RGB color heatmap visualization of the anomaly map. Values are in
+            range [0,255] and type uint8.
+
+    Examples:
+        Convert anomaly map without normalization:
+
+        >>> heatmap = anomaly_map_to_color_map(anomaly_map, normalize=False)
+        >>> heatmap.shape
+        (224, 224, 3)
+        >>> heatmap.dtype
+        dtype('uint8')
+
+        Convert with normalization (default):
+
+        >>> heatmap = anomaly_map_to_color_map(anomaly_map)
+        >>> heatmap.min(), heatmap.max()
+        (0, 255)
+
+    Note:
+        - Input map is converted to uint8 by scaling to [0,255] range
+        - Uses OpenCV's JET colormap for visualization
+        - Output is converted from BGR to RGB color format
+        - Shape of output matches input with added channel dimension
     """
     if normalize:
         anomaly_map = (anomaly_map - anomaly_map.min()) / np.ptp(anomaly_map)
@@ -98,23 +249,55 @@ def superimpose_anomaly_map(
     gamma: int = 0,
     normalize: bool = False,
 ) -> np.ndarray:
-    """Superimpose anomaly map on top of in the input image.
+    """Superimpose an anomaly heatmap on top of an input image.
 
-    Args:
-        anomaly_map (np.ndarray): Anomaly map
-        image (np.ndarray): Input image
-        alpha (float, optional): Weight to overlay anomaly map
-            on the input image. Defaults to 0.4.
-        gamma (int, optional): Value to add to the blended image
-            to smooth the processing. Defaults to 0. Overall,
-            the formula to compute the blended image is
-            I' = (alpha*I1 + (1-alpha)*I2) + gamma
-        normalize: whether or not the anomaly maps should
-            be normalized to image min-max at image level
+    This function overlays a colored anomaly map visualization on an input image using
+    alpha blending. The anomaly map can optionally be normalized before blending.
 
+    Args:
+        anomaly_map (np.ndarray): Grayscale anomaly map computed by the model's
+            distance metric. Should be a 2D array of float values.
+        image (np.ndarray): Input image to overlay the anomaly map on. Will be
+            resized to match anomaly map dimensions.
+        alpha (float, optional): Blending weight for the anomaly map overlay.
+            Should be in range [0,1] where 0 shows only the input image and 1
+            shows only the anomaly map. Defaults to ``0.4``.
+        gamma (int, optional): Value added to the blended result for smoothing.
+            The blending formula is:
+            ``output = (alpha * anomaly_map + (1-alpha) * image) + gamma``
+            Defaults to ``0``.
+        normalize (bool, optional): Whether to normalize the anomaly map to [0,1]
+            range before coloring. If ``True``, uses min-max scaling at the image
+            level. Defaults to ``False``.
 
     Returns:
-        np.ndarray: Image with anomaly map superimposed on top of it.
+        np.ndarray: RGB image with the colored anomaly map overlay. Values are in
+            range [0,255] and type uint8.
+
+    Examples:
+        Basic overlay without normalization:
+
+        >>> result = superimpose_anomaly_map(anomaly_map, image, alpha=0.4)
+        >>> result.shape
+        (224, 224, 3)
+        >>> result.dtype
+        dtype('uint8')
+
+        Overlay with normalization and custom blending:
+
+        >>> result = superimpose_anomaly_map(
+        ...     anomaly_map,
+        ...     image,
+        ...     alpha=0.7,
+        ...     gamma=10,
+        ...     normalize=True
+        ... )
+
+    Note:
+        - Input image is resized to match anomaly map dimensions
+        - Anomaly map is converted to a color heatmap using JET colormap
+        - Output maintains RGB color format
+        - Shape of output matches the anomaly map dimensions
     """
     anomaly_map = anomaly_map_to_color_map(anomaly_map.squeeze(), normalize=normalize)
     height, width = anomaly_map.shape[:2]
@@ -123,15 +306,46 @@ def superimpose_anomaly_map(
 
 
 def compute_mask(anomaly_map: np.ndarray, threshold: float, kernel_size: int = 4) -> np.ndarray:
-    """Compute anomaly mask via thresholding the predicted anomaly map.
+    """Compute binary anomaly mask by thresholding and post-processing anomaly map.
+
+    This function converts a continuous-valued anomaly map into a binary mask by:
+        - Thresholding the anomaly scores
+        - Applying morphological operations to reduce noise
+        - Scaling to 8-bit range [0, 255]
 
     Args:
-        anomaly_map (np.ndarray): Anomaly map predicted via the model
-        threshold (float): Value to threshold anomaly scores into 0-1 range.
-        kernel_size (int): Value to apply morphological operations to the predicted mask. Defaults to 4.
+        anomaly_map (np.ndarray): Anomaly map containing predicted anomaly scores.
+            Should be a 2D array of float values.
+        threshold (float): Threshold value to binarize anomaly scores. Values above
+            this threshold are considered anomalous (1) and below as normal (0).
+        kernel_size (int, optional): Size of the morphological structuring element
+            used for noise removal. Higher values result in smoother masks.
+            Defaults to ``4``.
 
     Returns:
-        Predicted anomaly mask
+        np.ndarray: Binary anomaly mask where anomalous regions are marked with
+            255 and normal regions with 0. Output is uint8 type.
+
+    Examples:
+        Basic thresholding with default kernel size:
+
+        >>> anomaly_scores = np.random.rand(100, 100)
+        >>> mask = compute_mask(anomaly_scores, threshold=0.5)
+        >>> mask.shape
+        (100, 100)
+        >>> mask.dtype
+        dtype('uint8')
+        >>> np.unique(mask)
+        array([  0, 255], dtype=uint8)
+
+        Custom kernel size for stronger smoothing:
+
+        >>> mask = compute_mask(anomaly_scores, threshold=0.5, kernel_size=8)
+
+    Note:
+        - Input anomaly map is squeezed to remove singleton dimensions
+        - Morphological opening is used to remove small noise artifacts
+        - Output is scaled to [0, 255] range for visualization
     """
     anomaly_map = anomaly_map.squeeze()
     mask: np.ndarray = np.zeros_like(anomaly_map).astype(np.uint8)
@@ -148,13 +362,45 @@ def compute_mask(anomaly_map: np.ndarray, threshold: float, kernel_size: int = 4
 def draw_boxes(image: np.ndarray, boxes: np.ndarray, color: tuple[int, int, int]) -> np.ndarray:
     """Draw bounding boxes on an image.
 
+    This function draws rectangular bounding boxes on an input image using OpenCV. Each box
+    is drawn with the specified color and a fixed thickness of 2 pixels.
+
     Args:
-        image (np.ndarray): Source image.
-        boxes (np.nparray): 2D array of shape (N, 4) where each row contains the xyxy coordinates of a bounding box.
-        color (tuple[int, int, int]): Color of the drawn boxes in RGB format.
+        image (np.ndarray): Source image on which to draw the boxes. Should be a valid
+            OpenCV-compatible image array.
+        boxes (np.ndarray): 2D array of shape ``(N, 4)`` where each row contains the
+            ``(x1, y1, x2, y2)`` coordinates of a bounding box in pixel units. The
+            coordinates specify the top-left and bottom-right corners.
+        color (tuple[int, int, int]): Color of the drawn boxes in RGB format, specified
+            as a tuple of 3 integers in the range ``[0, 255]``.
 
     Returns:
-        np.ndarray: Image showing the bounding boxes drawn on top of the source image.
+        np.ndarray: Modified image with bounding boxes drawn on top. Has the same
+            dimensions and type as the input image.
+
+    Examples:
+        Draw a single red box:
+
+        >>> import numpy as np
+        >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> boxes = np.array([[10, 10, 50, 50]])  # Single box
+        >>> result = draw_boxes(image, boxes, color=(255, 0, 0))
+        >>> result.shape
+        (100, 100, 3)
+
+        Draw multiple boxes in green:
+
+        >>> boxes = np.array([
+        ...     [20, 20, 40, 40],
+        ...     [60, 60, 80, 80]
+        ... ])  # Two boxes
+        >>> result = draw_boxes(image, boxes, color=(0, 255, 0))
+
+    Note:
+        - Input coordinates are converted to integers before drawing
+        - Boxes are drawn with a fixed thickness of 2 pixels
+        - The function modifies the input image in-place
+        - OpenCV uses BGR color format internally but the function expects RGB
     """
     for box in boxes:
         x_1, y_1, x_2, y_2 = box.astype(int)
diff --git a/src/anomalib/utils/types/__init__.py b/src/anomalib/utils/types/__init__.py
index a220571bc0..da61db770d 100644
--- a/src/anomalib/utils/types/__init__.py
+++ b/src/anomalib/utils/types/__init__.py
@@ -1,4 +1,23 @@
-"""Typing aliases for Anomalib."""
+"""Type aliases for anomaly detection.
+
+This module provides type aliases used throughout the anomalib library. The aliases
+include:
+    - ``NORMALIZATION``: Type for normalization methods and configurations
+    - ``THRESHOLD``: Type for threshold values and configurations
+
+Example:
+    >>> from anomalib.utils.types import NORMALIZATION, THRESHOLD
+    >>> from anomalib.utils.normalization import NormalizationMethod
+    >>> # Use min-max normalization
+    >>> norm: NORMALIZATION = NormalizationMethod.MIN_MAX
+    >>> print(norm)
+    min_max
+    >>> # Use threshold configuration
+    >>> thresh: THRESHOLD = {"method": "adaptive", "delta": 0.1}
+
+The module ensures consistent typing across the codebase and provides helpful type
+hints for configuration objects.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/utils/visualization/__init__.py b/src/anomalib/utils/visualization/__init__.py
index 404036dfad..582707aa13 100644
--- a/src/anomalib/utils/visualization/__init__.py
+++ b/src/anomalib/utils/visualization/__init__.py
@@ -1,4 +1,26 @@
-"""Visualization utils."""
+"""Tools for visualizing anomaly detection results.
+
+This module provides utilities for visualizing anomaly detection outputs. The
+utilities include:
+    - Base visualization interface and common functionality
+    - Image-based visualization for detection results
+    - Explanation visualization for model interpretability
+    - Metrics visualization for performance analysis
+
+Example:
+    >>> from anomalib.utils.visualization import ImageVisualizer
+    >>> # Create visualizer for detection results
+    >>> visualizer = ImageVisualizer()
+    >>> # Visualize detection on an image
+    >>> vis_result = visualizer.visualize(
+    ...     image=image,
+    ...     pred_mask=mask,
+    ...     anomaly_map=heatmap
+    ... )
+
+The module ensures consistent and informative visualization across different
+detection approaches and result types.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/utils/visualization/base.py b/src/anomalib/utils/visualization/base.py
index bafac0c0fa..f2a36430bd 100644
--- a/src/anomalib/utils/visualization/base.py
+++ b/src/anomalib/utils/visualization/base.py
@@ -1,4 +1,26 @@
-"""Base visualization generator."""
+"""Base visualization generator for anomaly detection.
+
+This module provides the base visualization interface and common functionality used
+across different visualization types. The key components include:
+
+    - ``GeneratorResult``: Dataclass for standardized visualization outputs
+    - ``VisualizationStep``: Enum for controlling when visualizations are generated
+    - ``BaseVisualizer``: Abstract base class defining the visualization interface
+
+Example:
+    >>> from anomalib.utils.visualization import BaseVisualizer
+    >>> # Create custom visualizer
+    >>> class CustomVisualizer(BaseVisualizer):
+    ...     def generate(self, **kwargs):
+    ...         # Generate visualization
+    ...         yield GeneratorResult(image=img)
+    >>> # Use visualizer
+    >>> vis = CustomVisualizer(visualize_on="batch")
+    >>> results = vis.generate(image=input_img)
+
+The module ensures consistent visualization behavior and output formats across
+different visualization implementations.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/utils/visualization/explanation.py b/src/anomalib/utils/visualization/explanation.py
index 10904161e3..b840f8bd11 100644
--- a/src/anomalib/utils/visualization/explanation.py
+++ b/src/anomalib/utils/visualization/explanation.py
@@ -1,6 +1,31 @@
-"""Explanation visualization generator.
-
-Note: This is a temporary visualizer, and will be replaced with the new visualizer in the future.
+"""Explanation visualization generator for model interpretability.
+
+This module provides utilities for visualizing model explanations and
+interpretability results. The key components include:
+
+    - Text-based explanations rendered on images
+    - Label visualization for model decisions
+    - Combined visualization with original image and explanation
+
+Example:
+    >>> from anomalib.utils.visualization import ExplanationVisualizer
+    >>> # Create visualizer
+    >>> visualizer = ExplanationVisualizer()
+    >>> # Generate visualization
+    >>> results = visualizer.generate(
+    ...     outputs={
+    ...         "image": images,
+    ...         "explanation": explanations,
+    ...         "image_path": paths
+    ...     }
+    ... )
+
+Note:
+    This is a temporary visualizer that will be replaced with an enhanced
+    version in a future release.
+
+The module ensures consistent visualization of model explanations across
+different interpretability approaches.
 """
 
 # Copyright (C) 2024 Intel Corporation
diff --git a/src/anomalib/utils/visualization/image.py b/src/anomalib/utils/visualization/image.py
index 16b852235f..9aa0b68822 100644
--- a/src/anomalib/utils/visualization/image.py
+++ b/src/anomalib/utils/visualization/image.py
@@ -1,4 +1,46 @@
-"""Image/video generator."""
+"""Image and video visualization generator.
+
+This module provides utilities for visualizing anomaly detection results on images
+and videos. The key components include:
+
+    - ``ImageResult``: Dataclass for storing visualization data
+    - ``ImageVisualizer``: Main visualization generator class
+    - ``VisualizationMode``: Enum for controlling visualization style
+    - ``_ImageGrid``: Helper class for creating image grids
+
+The module supports both classification and segmentation tasks, with options for:
+
+    - Full visualization showing all available outputs
+    - Simple visualization showing only key predictions
+    - Customizable normalization of anomaly maps
+    - Automatic handling of both image and video inputs
+
+Example:
+    >>> from anomalib.utils.visualization import ImageVisualizer
+    >>> from anomalib.utils.visualization.image import VisualizationMode
+    >>> # Create visualizer
+    >>> visualizer = ImageVisualizer(
+    ...     mode=VisualizationMode.FULL,
+    ...     task="segmentation",
+    ...     normalize=True
+    ... )
+    >>> # Generate visualization
+    >>> results = visualizer.generate(
+    ...     outputs={
+    ...         "image": images,
+    ...         "pred_mask": masks,
+    ...         "anomaly_map": heatmaps
+    ...     }
+    ... )
+
+The module ensures consistent visualization across different anomaly detection
+approaches and result types. It handles proper scaling and formatting of inputs,
+and provides a flexible interface for customizing the visualization output.
+
+Note:
+    When using video inputs, the visualizer automatically handles frame extraction
+    and maintains proper frame ordering in the output.
+"""
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -17,11 +59,7 @@
 from anomalib import TaskType
 from anomalib.data import ImageItem, NumpyImageItem, VideoItem
 from anomalib.data.utils import read_image
-from anomalib.utils.post_processing import (
-    add_anomalous_label,
-    add_normal_label,
-    superimpose_anomaly_map,
-)
+from anomalib.utils.post_processing import add_anomalous_label, add_normal_label, superimpose_anomaly_map
 
 from .base import BaseVisualizer, GeneratorResult, VisualizationStep
 
@@ -30,7 +68,13 @@
 
 
 class VisualizationMode(str, Enum):
-    """Type of visualization mode."""
+    """Visualization mode for controlling output style.
+
+    The mode determines how results are displayed:
+
+    - ``FULL``: Shows all available visualizations in a grid
+    - ``SIMPLE``: Shows only the key prediction results
+    """
 
     FULL = "full"
     SIMPLE = "simple"
@@ -38,7 +82,21 @@ class VisualizationMode(str, Enum):
 
 @dataclass
 class ImageResult:
-    """Collection of data needed to visualize the predictions for an image."""
+    """Collection of data needed to visualize predictions for an image.
+
+    Args:
+        image (np.ndarray): Input image to visualize
+        pred_score (float): Predicted anomaly score
+        pred_label (str): Predicted label (e.g. "normal" or "anomalous")
+        anomaly_map (np.ndarray | None): Anomaly heatmap if available
+        gt_mask (np.ndarray | None): Ground truth mask if available
+        pred_mask (np.ndarray | None): Predicted segmentation mask if available
+        normalize (InitVar[bool]): Whether to normalize anomaly maps to [0,1]
+
+    Note:
+        The class automatically handles proper scaling and type conversion of
+        inputs during initialization.
+    """
 
     image: np.ndarray
     pred_score: float
@@ -90,7 +148,14 @@ def __repr__(self) -> str:
     def from_dataset_item(cls: type["ImageResult"], item: ImageItem | NumpyImageItem) -> "ImageResult":
         """Create an ImageResult object from a DatasetItem object.
 
-        This is a temporary solution until we refactor the visualizer to take a DatasetItem object directly as input.
+        This is a temporary solution until we refactor the visualizer to take a
+        DatasetItem object directly as input.
+
+        Args:
+            item (ImageItem | NumpyImageItem): Dataset item to convert
+
+        Returns:
+            ImageResult: New image result object
         """
         if isinstance(item, ImageItem):
             item = item.to_numpy()
@@ -100,14 +165,19 @@ def from_dataset_item(cls: type["ImageResult"], item: ImageItem | NumpyImageItem
 
 
 class ImageVisualizer(BaseVisualizer):
-    """Image/video generator.
+    """Image and video visualization generator.
 
     Args:
-        mode (VisualizationMode, optional): Type of visualization mode. Defaults to VisualizationMode.FULL.
-        task (TaskType, optional): Type of task. Defaults to TaskType.CLASSIFICATION.
-        normalize (bool, optional): Whether or not the anomaly maps should be normalized to image min-max at image
-            level. Defaults to False. Note: This is more useful when NormalizationMethod is set to None. Otherwise,
-            the overlayed anomaly map will contain the raw scores.
+        mode (VisualizationMode, optional): Visualization mode. Defaults to
+            ``VisualizationMode.FULL``.
+        task (TaskType | str, optional): Type of task. Defaults to
+            ``TaskType.CLASSIFICATION``.
+        normalize (bool, optional): Whether to normalize anomaly maps to image
+            min-max. Defaults to ``False``.
+
+    Note:
+        Normalization is most useful when no other normalization method is used,
+        as otherwise the overlay will show raw anomaly scores.
     """
 
     def __init__(
@@ -122,7 +192,17 @@ def __init__(
         self.normalize = normalize
 
     def generate(self, **kwargs) -> Iterator[GeneratorResult]:
-        """Generate images and return them as an iterator."""
+        """Generate images and return them as an iterator.
+
+        Args:
+            **kwargs: Keyword arguments containing model outputs.
+
+        Returns:
+            Iterator yielding visualization results.
+
+        Raises:
+            ValueError: If outputs are not provided in kwargs.
+        """
         outputs = kwargs.get("outputs", None)
         if outputs is None:
             msg = "Outputs must be provided to generate images."
@@ -133,10 +213,14 @@ def _visualize_batch(self, batch: dict) -> Iterator[GeneratorResult]:
         """Yield a visualization result for each item in the batch.
 
         Args:
-            batch (dict): Dictionary containing the ground truth and predictions of a batch of images.
+            batch (dict): Dictionary containing the ground truth and predictions
+                of a batch of images.
 
         Returns:
             Generator that yields a display-ready visualization for each image.
+
+        Raises:
+            TypeError: If item has neither image path nor video path defined.
         """
         for item in batch:
             if hasattr(item, "image_path") and item.image_path is not None:
@@ -167,7 +251,10 @@ def visualize_image(self, image_result: ImageResult) -> np.ndarray:
             image_result (ImageResult): GT and Prediction data for a single image.
 
         Returns:
-            The full or simple visualization for the image, depending on the specified mode.
+            np.ndarray: The full or simple visualization for the image.
+
+        Raises:
+            ValueError: If visualization mode is unknown.
         """
         if self.mode == VisualizationMode.FULL:
             return self._visualize_full(image_result)
@@ -179,15 +266,21 @@ def visualize_image(self, image_result: ImageResult) -> np.ndarray:
     def _visualize_full(self, image_result: ImageResult) -> np.ndarray:
         """Generate the full set of visualization for an image.
 
-        The full visualization mode shows a grid with subplots that contain the original image, the GT mask (if
-        available), the predicted heat map, the predicted segmentation mask (if available), and the predicted
-        segmentations (if available).
+        The full visualization mode shows a grid with subplots that contain:
+            - Original image
+            - GT mask (if available)
+            - Predicted heat map
+            - Predicted segmentation mask (if available)
+            - Predicted segmentations (if available)
 
         Args:
             image_result (ImageResult): GT and Prediction data for a single image.
 
         Returns:
-            An image showing the full set of visualizations for the input image.
+            np.ndarray: Image showing the full set of visualizations.
+
+        Raises:
+            ValueError: If predicted mask is None for segmentation task.
         """
         image_grid = _ImageGrid()
         if self.task == TaskType.SEGMENTATION:
@@ -216,13 +309,17 @@ def _visualize_full(self, image_result: ImageResult) -> np.ndarray:
     def _visualize_simple(self, image_result: ImageResult) -> np.ndarray:
         """Generate a simple visualization for an image.
 
-        The simple visualization mode only shows the model's predictions in a single image.
+        The simple visualization mode only shows the model's predictions in a
+        single image.
 
         Args:
             image_result (ImageResult): GT and Prediction data for a single image.
 
         Returns:
-            An image showing the simple visualization for the input image.
+            np.ndarray: Image showing the simple visualization.
+
+        Raises:
+            ValueError: If task type is unknown.
         """
         if self.task == TaskType.SEGMENTATION:
             visualization = mark_boundaries(
@@ -245,8 +342,9 @@ def _visualize_simple(self, image_result: ImageResult) -> np.ndarray:
 class _ImageGrid:
     """Helper class that compiles multiple images into a grid using subplots.
 
-    Individual images can be added with the `add_image` method. When all images have been added, the `generate` method
-    must be called to compile the image grid and obtain the final visualization.
+    Individual images can be added with the ``add_image`` method. When all images
+    have been added, the ``generate`` method must be called to compile the image
+    grid and obtain the final visualization.
     """
 
     def __init__(self) -> None:
@@ -258,18 +356,24 @@ def add_image(self, image: np.ndarray, title: str | None = None, color_map: str
         """Add an image to the grid.
 
         Args:
-          image (np.ndarray): Image which should be added to the figure.
-          title (str): Image title shown on the plot.
-          color_map (str | None): Name of matplotlib color map used to map scalar data to colours. Defaults to None.
+            image (np.ndarray): Image to add to the figure
+            title (str | None): Image title shown on the plot
+            color_map (str | None): Name of matplotlib color map for mapping
+                scalar data to colours. Defaults to ``None``.
         """
         image_data = {"image": image, "title": title, "color_map": color_map}
         self.images.append(image_data)
 
     def generate(self) -> np.ndarray:
-        """Generate the image.
+        """Generate the image grid.
 
         Returns:
-            Image consisting of a grid of added images and their title.
+            np.ndarray: Image consisting of a grid of added images and their
+            titles.
+
+        Note:
+            Uses Agg backend to avoid issues with dimension mismatch when using
+            backends like MacOSX.
         """
         num_cols = len(self.images)
         figure_size = (num_cols * 5, 5)
@@ -290,7 +394,8 @@ def generate(self) -> np.ndarray:
                 axis.title.set_text(image_dict["title"])
         self.figure.canvas.draw()
         # convert canvas to numpy array to prepare for visualization with opencv
-        img = np.frombuffer(self.figure.canvas.tostring_rgb(), dtype=np.uint8)
-        img = img.reshape(self.figure.canvas.get_width_height()[::-1] + (3,))
+        img = np.frombuffer(self.figure.canvas.buffer_rgba(), dtype=np.uint8)
+        img = img.reshape(self.figure.canvas.get_width_height()[::-1] + (4,))  # RGBA has 4 channels
+        img = cv2.cvtColor(img, cv2.COLOR_RGBA2RGB)
         plt.close(self.figure)
         return img
diff --git a/src/anomalib/utils/visualization/metrics.py b/src/anomalib/utils/visualization/metrics.py
index 36f4948405..d5320cca4b 100644
--- a/src/anomalib/utils/visualization/metrics.py
+++ b/src/anomalib/utils/visualization/metrics.py
@@ -1,4 +1,29 @@
-"""Metrics visualization generator."""
+"""Metrics visualization generator for anomaly detection results.
+
+This module provides utilities for visualizing metric plots from anomaly detection
+models. The key components include:
+
+    - Automatic generation of metric plots from model metrics
+    - Support for both image-level and pixel-level metrics
+    - Consistent file naming and output format
+
+Example:
+    >>> from anomalib.utils.visualization import MetricsVisualizer
+    >>> # Create metrics visualizer
+    >>> visualizer = MetricsVisualizer()
+    >>> # Generate metric plots
+    >>> results = visualizer.generate(pl_module=model)
+
+The module ensures proper visualization of model performance metrics by:
+    - Automatically detecting plottable metrics
+    - Generating standardized plot formats
+    - Handling both classification and segmentation metrics
+    - Providing consistent file naming conventions
+
+Note:
+    Metrics must implement a ``generate_figure`` method to be visualized.
+    The method should return a tuple of (figure, log_name).
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -13,14 +38,36 @@
 
 
 class MetricsVisualizer(BaseVisualizer):
-    """Generate metric plots."""
+    """Generate metric plots from model metrics.
+
+    This class handles the automatic generation of metric plots from an anomalib
+    model's metrics. It supports both image-level and pixel-level metrics.
+    """
 
     def __init__(self) -> None:
         super().__init__(VisualizationStep.STAGE_END)
 
     @staticmethod
     def generate(**kwargs) -> Iterator[GeneratorResult]:
-        """Generate metric plots and return them as an iterator."""
+        """Generate metric plots and return them as an iterator.
+
+        Args:
+            **kwargs: Keyword arguments passed to the generator.
+                Must include ``pl_module`` containing the model metrics.
+
+        Yields:
+            Iterator[GeneratorResult]: Generator results containing the plot
+                figures and filenames.
+
+        Raises:
+            ValueError: If ``pl_module`` is not provided in kwargs.
+
+        Example:
+            >>> visualizer = MetricsVisualizer()
+            >>> for result in visualizer.generate(pl_module=model):
+            ...     # Process the visualization result
+            ...     print(result.file_name)
+        """
         pl_module: AnomalibModule = kwargs.get("pl_module", None)
         if pl_module is None:
             msg = "`pl_module` must be provided"
diff --git a/src/anomalib/visualization/__init__.py b/src/anomalib/visualization/__init__.py
index 989f4cc34c..c49e72a6a3 100644
--- a/src/anomalib/visualization/__init__.py
+++ b/src/anomalib/visualization/__init__.py
@@ -1,4 +1,30 @@
-"""Visualization module."""
+"""Visualization module for anomaly detection.
+
+This module provides utilities for visualizing anomaly detection results. The key
+components include:
+
+    - Base ``Visualizer`` class defining the visualization interface
+    - ``ImageVisualizer`` class for image-based visualization
+    - Functions for visualizing anomaly maps and segmentation masks
+    - Tools for visualizing ``ImageItem`` objects
+
+Example:
+    >>> from anomalib.visualization import ImageVisualizer
+    >>> # Create visualizer
+    >>> visualizer = ImageVisualizer()
+    >>> # Generate visualization
+    >>> vis_result = visualizer.visualize(image=img, pred_mask=mask)
+
+The module ensures consistent visualization by:
+    - Providing standardized visualization interfaces
+    - Supporting both classification and segmentation results
+    - Handling various input formats
+    - Maintaining consistent output formats
+
+Note:
+    All visualization functions preserve the input format and dimensions unless
+    explicitly specified otherwise.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/visualization/base.py b/src/anomalib/visualization/base.py
index dc49a85401..0229d05a3b 100644
--- a/src/anomalib/visualization/base.py
+++ b/src/anomalib/visualization/base.py
@@ -1,4 +1,30 @@
-"""Base Visualizer."""
+"""Base visualization module for anomaly detection.
+
+This module provides the base ``Visualizer`` class that defines the interface for
+visualizing anomaly detection results. The key components include:
+
+    - Base ``Visualizer`` class that inherits from PyTorch Lightning's ``Callback``
+    - Interface for visualizing model outputs during testing and prediction
+    - Support for customizable visualization formats and configurations
+
+Example:
+    >>> from anomalib.visualization import Visualizer
+    >>> # Create custom visualizer
+    >>> class CustomVisualizer(Visualizer):
+    ...     def visualize(self, **kwargs):
+    ...         # Custom visualization logic
+    ...         pass
+
+The module ensures consistent visualization by:
+    - Providing a standardized visualization interface
+    - Supporting both classification and segmentation results
+    - Enabling customizable visualization formats
+    - Maintaining consistent output formats
+
+Note:
+    All visualizer implementations should inherit from the base ``Visualizer``
+    class and implement the required visualization methods.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -9,6 +35,31 @@
 class Visualizer(Callback):
     """Base class for all visualizers.
 
-    In Anomalib, the visualizer is used to visualize the results of the model
-    during the testing and prediction phases.
+    This class serves as the foundation for implementing visualization functionality in
+    Anomalib. It inherits from PyTorch Lightning's ``Callback`` class to integrate with
+    the training workflow.
+
+    The visualizer is responsible for generating visual representations of model outputs
+    during testing and prediction phases. This includes:
+
+        - Visualizing input images
+        - Displaying model predictions
+        - Showing ground truth annotations
+        - Generating overlays and heatmaps
+        - Saving visualization results
+
+    Example:
+        >>> from anomalib.visualization import Visualizer
+        >>> # Create custom visualizer
+        >>> class CustomVisualizer(Visualizer):
+        ...     def visualize(self, **kwargs):
+        ...         # Custom visualization logic
+        ...         pass
+
+    Note:
+        All custom visualizers should:
+            - Inherit from this base class
+            - Implement the ``visualize`` method
+            - Handle relevant visualization configurations
+            - Maintain consistent output formats
     """
diff --git a/src/anomalib/visualization/image/__init__.py b/src/anomalib/visualization/image/__init__.py
index 9f60f1399a..fb7e299407 100644
--- a/src/anomalib/visualization/image/__init__.py
+++ b/src/anomalib/visualization/image/__init__.py
@@ -1,4 +1,31 @@
-"""Image visualization module."""
+"""Image visualization module for anomaly detection.
+
+This module provides utilities for visualizing images and anomaly detection results.
+The key components include:
+
+    - Functions for visualizing anomaly maps and segmentation masks
+    - Tools for overlaying images and adding text annotations
+    - Colormap application utilities
+    - Image item visualization
+    - ``ImageVisualizer`` class for consistent visualization
+
+Example:
+    >>> from anomalib.visualization.image import ImageVisualizer
+    >>> # Create visualizer
+    >>> visualizer = ImageVisualizer()
+    >>> # Generate visualization
+    >>> vis_result = visualizer.visualize(image=img, pred_mask=mask)
+
+The module ensures consistent visualization by:
+    - Providing standardized colormaps and overlays
+    - Supporting both classification and segmentation results
+    - Handling various input formats
+    - Maintaining consistent output formats
+
+Note:
+    All visualization functions preserve the input image format and dimensions
+    unless explicitly specified otherwise.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
diff --git a/src/anomalib/visualization/image/functional.py b/src/anomalib/visualization/image/functional.py
index 940586c2d6..558e55613e 100644
--- a/src/anomalib/visualization/image/functional.py
+++ b/src/anomalib/visualization/image/functional.py
@@ -1,4 +1,30 @@
-"""Visualizer for ImageItem fields using PIL and torchvision."""
+"""Image visualization functions using PIL and torchvision.
+
+This module provides functions for visualizing images and anomaly detection results using
+PIL and torchvision. The key components include:
+
+    - Functions for adding text overlays to images
+    - Tools for applying colormaps to anomaly maps
+    - Image overlay and blending utilities
+    - Mask and anomaly map visualization
+
+Example:
+    >>> from PIL import Image
+    >>> from anomalib.visualization.image.functional import add_text_to_image
+    >>> # Create image and add text
+    >>> image = Image.new('RGB', (100, 100))
+    >>> result = add_text_to_image(image, text="Anomaly")
+
+The module ensures consistent visualization by:
+    - Providing standardized text rendering
+    - Supporting various color formats and fonts
+    - Handling different image formats
+    - Maintaining aspect ratios
+
+Note:
+    All visualization functions preserve the input image format and dimensions
+    unless explicitly specified otherwise.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -11,7 +37,7 @@
 
 import torch
 import torch.nn.functional as F  # noqa: N812
-from PIL import Image, ImageDraw, ImageEnhance, ImageFilter, ImageFont
+from PIL import Image, ImageDraw, ImageEnhance, ImageFont
 from torchvision.transforms.functional import to_pil_image
 
 logger = logging.getLogger(__name__)
@@ -20,14 +46,40 @@
 def dynamic_font_size(image_size: tuple[int, int], min_size: int = 20, max_size: int = 100, divisor: int = 10) -> int:
     """Calculate a dynamic font size based on image dimensions.
 
+    This function determines an appropriate font size based on the image dimensions while
+    staying within specified bounds. The font size is calculated by dividing the smaller
+    image dimension by the divisor.
+
     Args:
-        image_size: Tuple of image dimensions (width, height).
-        min_size: Minimum font size (default: 20).
-        max_size: Maximum font size (default: 100).
-        divisor: Divisor for calculating font size (default: 10).
+        image_size (tuple[int, int]): Tuple of image dimensions ``(width, height)``.
+        min_size (int, optional): Minimum allowed font size. Defaults to ``20``.
+        max_size (int, optional): Maximum allowed font size. Defaults to ``100``.
+        divisor (int, optional): Value to divide the minimum image dimension by.
+            Defaults to ``10``.
 
     Returns:
-        Calculated font size within the specified range.
+        int: Calculated font size constrained between ``min_size`` and ``max_size``.
+
+    Examples:
+        Calculate font size for a small image:
+
+        >>> dynamic_font_size((200, 100))
+        20
+
+        Calculate font size for a large image:
+
+        >>> dynamic_font_size((1000, 800))
+        80
+
+        Font size is capped at max_size:
+
+        >>> dynamic_font_size((2000, 2000), max_size=50)
+        50
+
+    Note:
+        - The function uses the smaller dimension to ensure text fits in both directions
+        - The calculated size is clamped between ``min_size`` and ``max_size``
+        - Larger ``divisor`` values result in smaller font sizes
     """
     min_dimension = min(image_size)
     return max(min_size, min(max_size, min_dimension // divisor))
@@ -43,7 +95,64 @@ def add_text_to_image(
     position: tuple[int, int] = (10, 10),
     padding: int = 3,
 ) -> Image.Image:
-    """Add text to an image with configurable parameters."""
+    """Add text to an image with configurable parameters.
+
+    This function adds text to a PIL Image with customizable font, size, color and
+    background options. The text can be positioned anywhere on the image and includes
+    an optional background box.
+
+    Args:
+        image (Image.Image): The PIL Image to add text to.
+        text (str): The text string to add to the image.
+        font (str | None, optional): Path to a font file. If ``None`` or loading fails,
+            the default system font is used. Defaults to ``None``.
+        size (int | None, optional): Font size in pixels. If ``None``, size is
+            calculated dynamically based on image dimensions. Defaults to ``None``.
+        color (tuple[int, int, int] | str, optional): Text color as RGB tuple or color
+            name. Defaults to ``"white"``.
+        background (tuple[int, ...] | str | None, optional): Background color for text
+            box. Can be RGB/RGBA tuple or color name. If ``None``, no background is
+            drawn. Defaults to semi-transparent black ``(0, 0, 0, 128)``.
+        position (tuple[int, int], optional): Top-left position of text as ``(x, y)``
+            coordinates. Defaults to ``(10, 10)``.
+        padding (int, optional): Padding around text in background box in pixels.
+            Defaults to ``3``.
+
+    Returns:
+        Image.Image: New PIL Image with text added.
+
+    Examples:
+        Basic white text:
+
+        >>> from PIL import Image
+        >>> img = Image.new('RGB', (200, 100))
+        >>> result = add_text_to_image(img, "Hello")
+
+        Custom font and color:
+
+        >>> result = add_text_to_image(
+        ...     img,
+        ...     "Hello",
+        ...     font="arial.ttf",
+        ...     color=(255, 0, 0)
+        ... )
+
+        Text with custom background:
+
+        >>> result = add_text_to_image(
+        ...     img,
+        ...     "Hello",
+        ...     background=(0, 0, 255, 200),
+        ...     position=(50, 50)
+        ... )
+
+    Note:
+        - The function creates a transparent overlay for the text
+        - Font size is calculated dynamically if not specified
+        - Falls back to default system font if custom font fails to load
+        - Input image is converted to RGBA for compositing
+        - Output is converted back to RGB
+    """
     # Create a new RGBA image as a transparent overlay
     overlay = Image.new("RGBA", image.size, (0, 0, 0, 0))
     draw = ImageDraw.Draw(overlay)
@@ -77,24 +186,52 @@ def apply_colormap(image: Image.Image) -> Image.Image:
     """Apply a colormap to a single-channel PIL Image using torch and PIL.
 
     This function converts a grayscale image to a colored image using the 'jet' colormap.
+    The colormap is created by interpolating between 9 key colors from dark blue to dark
+    red.
 
     Args:
-        image (Image.Image): A single-channel PIL Image or an object that can be converted to PIL Image.
+        image (``Image.Image``): A single-channel PIL Image or an object that can be
+            converted to PIL Image. If not already in 'L' mode (8-bit grayscale), it will
+            be converted.
 
     Returns:
-        Image.Image: A new PIL Image with the colormap applied.
+        ``Image.Image``: A new PIL Image in RGB mode with the colormap applied.
 
     Raises:
         TypeError: If the input cannot be converted to a PIL Image.
 
     Example:
+        Create a random grayscale image and apply colormap:
+
         >>> from PIL import Image
         >>> import numpy as np
         >>> # Create a sample grayscale image
-        >>> gray_image = Image.fromarray(np.random.randint(0, 256, (100, 100), dtype=np.uint8), mode='L')
+        >>> gray = np.random.randint(0, 256, (100, 100), dtype=np.uint8)
+        >>> gray_image = Image.fromarray(gray, mode='L')
         >>> # Apply the jet colormap
         >>> colored_image = apply_colormap(gray_image)
-        >>> colored_image.show()
+        >>> colored_image.mode
+        'RGB'
+
+        Apply to non-PIL input:
+
+        >>> # NumPy array input is automatically converted
+        >>> colored_image = apply_colormap(gray)
+        >>> isinstance(colored_image, Image.Image)
+        True
+
+        Invalid input raises TypeError:
+
+        >>> apply_colormap("not an image")  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+            ...
+        TypeError: Input must be a PIL Image object or an object that can be...
+
+    Note:
+        - Input is automatically converted to grayscale if not already
+        - Uses a custom 'jet' colormap interpolated between 9 key colors
+        - Output is always in RGB mode regardless of input mode
+        - The colormap interpolation uses bilinear mode for smooth transitions
     """
     # Try to convert the input to a PIL Image if it's not already
     if not isinstance(image, Image.Image):
@@ -141,28 +278,47 @@ def apply_colormap(image: Image.Image) -> Image.Image:
 def overlay_image(base: Image.Image, overlay: Image.Image, alpha: float = 0.5) -> Image.Image:
     """Overlay an image on top of another image with a specified alpha value.
 
+    This function takes a base image and overlays another image on top of it with the
+    specified transparency level. Both images are converted to RGBA mode to enable alpha
+    compositing. If the overlay image has a different size than the base image, it will
+    be resized to match.
+
     Args:
-        base (Image.Image): The base image.
-        overlay (Image.Image): The image to overlay.
-        alpha (float): The alpha value for blending (0.0 to 1.0). Defaults to 0.5.
+        base (:class:`PIL.Image.Image`): The base image that will serve as the
+            background.
+        overlay (:class:`PIL.Image.Image`): The image to overlay on top of the base
+            image.
+        alpha (float, optional): The alpha/transparency value for blending, between
+            0.0 (fully transparent) and 1.0 (fully opaque). Defaults to ``0.5``.
 
     Returns:
-        Image.Image: The image with the overlay applied.
+        :class:`PIL.Image.Image`: A new image with the overlay composited on top of
+        the base image using the specified alpha value.
 
     Examples:
-        # Overlay a random mask on an image
-        >>> from PIL import Image, ImageDraw
+        Create a base image with a yellow triangle on a green background:
 
+        >>> from PIL import Image, ImageDraw
         >>> image = Image.new('RGB', (200, 200), color='green')
         >>> draw = ImageDraw.Draw(image)
         >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill='yellow')
 
+        Create a mask with a white rectangle on black background:
+
         >>> mask = Image.new('L', (200, 200), color=0)
         >>> draw = ImageDraw.Draw(mask)
         >>> draw.rectangle([75, 75, 125, 125], fill=255)
 
+        Overlay the mask on the image with 30% opacity:
+
         >>> result = overlay_image(image, mask, alpha=0.3)
-        >>> result.show()
+        >>> result.show()  # doctest: +SKIP
+
+    Note:
+        - Both input images are converted to RGBA mode internally
+        - The overlay is automatically resized to match the base image size
+        - The function uses PIL's alpha compositing for high-quality blending
+        - The output image preserves the RGBA mode of the composite result
     """
     base = base.convert("RGBA")
     overlay = overlay.convert("RGBA")
@@ -185,45 +341,53 @@ def overlay_images(
     overlays: Image.Image | list[Image.Image],
     alpha: float | list[float] = 0.5,
 ) -> Image.Image:
-    """Overlay multiple images on top of a base image with a specified alpha value.
+    """Overlay multiple images on top of a base image with specified transparency.
 
-    If the overlay is a mask (L mode), draw its contours on the image instead.
+    This function overlays one or more images on top of a base image with specified
+    alpha/transparency values. If an overlay is a mask (L mode), it will be drawn
+    as a semi-transparent overlay.
 
     Args:
-        base: The base PIL Image.
-        overlays: PIL Image or list of PIL Images to overlay on top of the base image.
-        alpha: The alpha value for blending (0.0 to 1.0). Defaults to 0.5.
+        base (:class:`PIL.Image.Image`): The base image to overlay on top of.
+        overlays (:class:`PIL.Image.Image` | list[:class:`PIL.Image.Image`]): One
+            or more images to overlay on the base image.
+        alpha (float | list[float], optional): Alpha/transparency value(s) between
+            0.0 (fully transparent) and 1.0 (fully opaque). Can be a single float
+            applied to all overlays, or a list of values. Defaults to ``0.5``.
 
     Returns:
-        A new PIL Image with all overlays applied.
+        :class:`PIL.Image.Image`: A new image with all overlays composited on top
+        of the base image using the specified alpha values.
 
     Examples:
-        # Overlay a single image
+        Overlay a single mask:
+
         >>> from PIL import Image, ImageDraw
+        >>> # Create base image with yellow triangle on green background
         >>> image = Image.new('RGB', (200, 200), color='green')
         >>> draw = ImageDraw.Draw(image)
         >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill='yellow')
-
+        >>> # Create mask with white rectangle
         >>> mask = Image.new('L', (200, 200), color=0)
         >>> draw = ImageDraw.Draw(mask)
         >>> draw.rectangle([75, 75, 125, 125], fill=255)
-
+        >>> # Apply overlay
         >>> result = overlay_images(image, mask)
 
-        # Overlay multiple images
-        >>> image = Image.new('RGB', (200, 200), color='green')
-        >>> draw = ImageDraw.Draw(image)
-        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill='yellow')
-
-        >>> mask1 = Image.new('L', (200, 200), color=0)
-        >>> draw = ImageDraw.Draw(mask1)
-        >>> draw.rectangle([25, 25, 75, 75], fill=255)
+        Overlay multiple masks with different alphas:
 
+        >>> # Create second mask with white ellipse
         >>> mask2 = Image.new('L', (200, 200), color=0)
         >>> draw = ImageDraw.Draw(mask2)
         >>> draw.ellipse([50, 50, 150, 100], fill=255)
-
-        >>> result = overlay_images(image, [mask1, mask2])
+        >>> # Apply overlays with different alpha values
+        >>> result = overlay_images(image, [mask, mask2], alpha=[0.3, 0.7])
+
+    Note:
+        - All images are converted to RGBA mode internally
+        - Overlays are automatically resized to match the base image size
+        - Uses PIL's alpha compositing for high-quality blending
+        - The output preserves the RGBA mode of the composite result
     """
     if not isinstance(overlays, list):
         overlays = [overlays]
@@ -240,35 +404,56 @@ def visualize_anomaly_map(
     colormap: bool = True,
     normalize: bool = False,
 ) -> Image.Image:
-    """Visualize the anomaly map.
+    """Visualize an anomaly map by applying normalization and/or colormap.
 
-    This function takes an anomaly map as input and applies normalization and/or colormap
-    based on the provided parameters.
+    This function takes an anomaly map and converts it to a visualization by optionally
+    normalizing the values and applying a colormap. The input can be either a PIL Image
+    or PyTorch tensor.
 
     Args:
-        anomaly_map (Image.Image | torch.Tensor): The input anomaly map as a PIL Image or torch Tensor.
-        colormap (bool, optional): Whether to apply a colormap to the anomaly map. Defaults to True.
-        normalize (bool, optional): Whether to normalize the anomaly map. Defaults to False.
+        anomaly_map (:class:`PIL.Image.Image` | :class:`torch.Tensor`): Input anomaly
+            map to visualize. If a tensor is provided, it will be converted to a PIL
+            Image.
+        colormap (bool, optional): Whether to apply a colormap to the anomaly map.
+            When ``True``, converts the image to a colored heatmap visualization.
+            When ``False``, converts to RGB grayscale. Defaults to ``True``.
+        normalize (bool, optional): Whether to normalize the anomaly map values to
+            [0, 255] range before visualization. When ``True``, linearly scales the
+            values using min-max normalization. Defaults to ``False``.
 
     Returns:
-        Image.Image: The visualized anomaly map as a PIL Image in RGB mode.
+        :class:`PIL.Image.Image`: Visualized anomaly map as a PIL Image in RGB mode.
+            If ``colormap=True``, returns a heatmap visualization. Otherwise returns
+            a grayscale RGB image.
+
+    Examples:
+        Visualize a PIL Image anomaly map:
 
-    Example:
         >>> from PIL import Image
         >>> import numpy as np
-        >>> import torch
+        >>> # Create sample anomaly map
+        >>> data = np.random.rand(100, 100).astype(np.float32)
+        >>> anomaly_map = Image.fromarray(data, mode='F')
+        >>> # Visualize with normalization and colormap
+        >>> vis = visualize_anomaly_map(anomaly_map, normalize=True, colormap=True)
+        >>> vis.mode
+        'RGB'
 
-        >>> # Create a sample anomaly map as PIL Image
-        >>> anomaly_map_pil = Image.fromarray(np.random.rand(100, 100).astype(np.float32), mode='F')
+        Visualize a PyTorch tensor anomaly map:
 
-        >>> # Create a sample anomaly map as torch Tensor
-        >>> anomaly_map_tensor = torch.rand(100, 100)
+        >>> import torch
+        >>> # Create random tensor
+        >>> tensor_map = torch.rand(100, 100)
+        >>> # Visualize without normalization
+        >>> vis = visualize_anomaly_map(tensor_map, normalize=False, colormap=True)
+        >>> isinstance(vis, Image.Image)
+        True
 
-        >>> # Visualize the anomaly maps
-        >>> visualized_map_pil = visualize_anomaly_map(anomaly_map_pil, normalize=True, colormap=True)
-        >>> visualized_map_tensor = visualize_anomaly_map(anomaly_map_tensor, normalize=True, colormap=True)
-        >>> visualized_map_pil.show()
-        >>> visualized_map_tensor.show()
+    Note:
+        - Input tensors are automatically converted to PIL Images
+        - The function always returns an RGB mode image
+        - When ``normalize=True``, uses min-max normalization to [0, 255] range
+        - The colormap used is the default from :func:`apply_colormap`
     """
     image = to_pil_image(anomaly_map) if isinstance(anomaly_map, torch.Tensor) else anomaly_map.copy()
 
@@ -293,81 +478,82 @@ def visualize_mask(
 ) -> Image.Image:
     """Visualize a mask with different modes.
 
+    This function takes a binary mask and visualizes it in different styles based on the
+    specified mode.
+
     Args:
-        mask (Image.Image | torch.Tensor): The input mask. Can be a PIL Image or a PyTorch tensor.
-        mode (Literal["contour", "binary", "fill"]): The visualization mode.
-            - "contour": Draw contours of the mask.
-            - "fill": Fill the masked area with a color.
-            - "binary": Return the original binary mask.
-            - "L": Return the original grayscale mask.
-            - "1": Return the original binary mask.
-        alpha (float): The alpha value for blending (0.0 to 1.0). Only used in "fill" mode.
-            Defaults to 0.5.
-        color (tuple[int, int, int]): The color to apply to the mask.
-            Defaults to (255, 0, 0) (red).
-        background_color (tuple[int, int, int, int]): The background color (RGBA).
-            Defaults to (0, 0, 0, 0) (transparent).
+        mask (:class:`PIL.Image.Image` | :class:`torch.Tensor`): Input mask to visualize.
+            Can be a PIL Image or PyTorch tensor. If tensor, should be 2D with values in
+            [0, 1] or [0, 255].
+        mode (Literal["contour", "fill", "binary", "L", "1"]): Visualization mode:
+
+            - ``"contour"``: Draw contours around masked regions
+            - ``"fill"``: Fill masked regions with semi-transparent color
+            - ``"binary"``: Return original binary mask
+            - ``"L"``: Return original grayscale mask
+            - ``"1"``: Return original binary mask
+
+        alpha (float, optional): Alpha value for blending in ``"fill"`` mode.
+            Should be between 0.0 and 1.0. Defaults to ``0.5``.
+        color (tuple[int, int, int], optional): RGB color to apply to mask.
+            Each value should be 0-255. Defaults to ``(255, 0, 0)`` (red).
+        background_color (tuple[int, int, int, int], optional): RGBA background color.
+            Each value should be 0-255. Defaults to ``(0, 0, 0, 0)`` (transparent).
 
     Returns:
-        Image.Image: The visualized mask as a PIL Image.
+        :class:`PIL.Image.Image`: Visualized mask as a PIL Image. The output mode
+        depends on the visualization mode:
+
+        - ``"contour"`` and ``"fill"``: Returns RGBA image
+        - ``"binary"``, ``"L"``, ``"1"``: Returns grayscale image
 
     Raises:
-        TypeError: If the mask is not a PIL Image or PyTorch tensor.
-        ValueError: If an invalid mode is provided.
+        TypeError: If ``mask`` is not a PIL Image or PyTorch tensor.
+        ValueError: If ``mode`` is not one of the allowed values.
 
     Examples:
+        Create a random binary mask:
+
+        >>> import numpy as np
+        >>> from PIL import Image
         >>> mask_array = np.random.randint(0, 2, size=(100, 100), dtype=np.uint8) * 255
         >>> mask_image = Image.fromarray(mask_array, mode='L')
 
-        >>> contour_mask = visualize_mask(mask_image, mode="contour", color=(255, 0, 0))
-        >>> contour_mask.show()
-
-        >>> binary_mask = visualize_mask(mask_image, mode="binary")
-        >>> binary_mask.show()
+        Visualize mask contours in red:
 
-        >>> fill_mask = visualize_mask(mask_image, mode="fill", color=(0, 255, 0), alpha=0.3)
-        >>> fill_mask.show()
-    """
-    # Convert torch.Tensor to PIL Image if necessary
-    if isinstance(mask, torch.Tensor):
-        if mask.dtype == torch.bool:
-            mask = mask.to(torch.uint8) * 255
-        mask = to_pil_image(mask)
-
-    if not isinstance(mask, Image.Image):
-        msg = "Mask must be a PIL Image or PyTorch tensor"
-        raise TypeError(msg)
-
-    # Ensure mask is in binary mode
-    mask = mask.convert("L")
-    if mode in {"binary", "L", "1"}:
-        return mask
-
-    # Create a background image
-    background = Image.new("RGBA", mask.size, background_color)
-
-    match mode:
-        case "contour":
-            # Find edges of the mask
-            edges = mask.filter(ImageFilter.FIND_EDGES)
+        >>> contour_vis = visualize_mask(
+        ...     mask_image,
+        ...     mode="contour",
+        ...     color=(255, 0, 0)
+        ... )
+        >>> isinstance(contour_vis, Image.Image)
+        True
 
-            # Create a colored version of the edges
-            colored_edges = Image.new("RGBA", mask.size, (*color, 255))
-            colored_edges.putalpha(edges)
+        Fill mask regions with semi-transparent green:
 
-            # Composite the colored edges onto the background
-            return Image.alpha_composite(background, colored_edges)
+        >>> fill_vis = visualize_mask(
+        ...     mask_image,
+        ...     mode="fill",
+        ...     color=(0, 255, 0),
+        ...     alpha=0.3
+        ... )
+        >>> isinstance(fill_vis, Image.Image)
+        True
 
-        case "fill":
-            # Create a solid color image for the overlay
-            overlay = Image.new("RGBA", mask.size, (*color, int(255 * alpha)))
+        Return original binary mask:
 
-            # Use the mask to blend the overlay with the background
-            return Image.composite(overlay, background, mask)
+        >>> binary_vis = visualize_mask(mask_image, mode="binary")
+        >>> binary_vis.mode
+        'L'
 
-        case _:
-            msg = f"Invalid mode: {mode}. Allowed modes are 'contour', 'binary', or 'fill'."
-            raise ValueError(msg)
+    Note:
+        - Input tensors are automatically converted to PIL Images
+        - Binary masks are expected to have values of 0 and 255 (or 0 and 1 for tensors)
+        - The function preserves the original mask when using ``"binary"``, ``"L"`` or
+          ``"1"`` modes
+        - ``"contour"`` mode uses edge detection to find mask boundaries
+        - ``"fill"`` mode creates a semi-transparent overlay using the specified color
+    """
 
 
 def visualize_gt_mask(
@@ -378,7 +564,49 @@ def visualize_gt_mask(
     color: tuple[int, int, int] = (255, 0, 0),
     background_color: tuple[int, int, int, int] = (0, 0, 0, 0),
 ) -> Image.Image:
-    """Visualize a ground truth mask."""
+    """Visualize a ground truth mask.
+
+    This is a convenience wrapper around :func:`visualize_mask` specifically for
+    ground truth masks. It provides the same functionality with default parameters
+    suitable for ground truth visualization.
+
+    Args:
+        mask (Image.Image | torch.Tensor): Input mask to visualize. Can be either a
+            PIL Image or PyTorch tensor.
+        mode (Literal["contour", "fill", "binary", "L", "1"]): Visualization mode.
+            Defaults to ``"binary"``.
+            - ``"contour"``: Draw mask boundaries
+            - ``"fill"``: Fill mask regions with semi-transparent color
+            - ``"binary"``, ``"L"``, ``"1"``: Return original binary mask
+        alpha (float): Opacity for the mask visualization in ``"fill"`` mode.
+            Range [0, 1]. Defaults to ``0.5``.
+        color (tuple[int, int, int]): RGB color for visualizing the mask.
+            Defaults to red ``(255, 0, 0)``.
+        background_color (tuple[int, int, int, int]): RGBA color for the
+            background. Defaults to transparent ``(0, 0, 0, 0)``.
+
+    Returns:
+        Image.Image: Visualized mask as a PIL Image.
+
+    Examples:
+        >>> import torch
+        >>> from PIL import Image
+        >>> # Create a sample binary mask
+        >>> mask = torch.zeros((100, 100))
+        >>> mask[25:75, 25:75] = 1
+        >>> # Visualize with default settings (binary mode)
+        >>> vis = visualize_gt_mask(mask)
+        >>> isinstance(vis, Image.Image)
+        True
+        >>> # Visualize with contours in blue
+        >>> vis = visualize_gt_mask(mask, mode="contour", color=(0, 0, 255))
+        >>> isinstance(vis, Image.Image)
+        True
+
+    Note:
+        See :func:`visualize_mask` for more details on the visualization modes and
+        parameters.
+    """
     return visualize_mask(mask, mode=mode, alpha=alpha, color=color, background_color=background_color)
 
 
@@ -390,19 +618,94 @@ def visualize_pred_mask(
     alpha: float = 0.5,
     background_color: tuple[int, int, int, int] = (0, 0, 0, 0),
 ) -> Image.Image:
-    """Visualize a prediction mask."""
+    """Visualize a prediction mask.
+
+    This is a convenience wrapper around :func:`visualize_mask` specifically for
+    prediction masks. It provides the same functionality with default parameters
+    suitable for prediction visualization.
+
+    Args:
+        mask (Image.Image | torch.Tensor): Input mask to visualize. Can be either a
+            PIL Image or PyTorch tensor.
+        mode (Literal["contour", "fill", "binary", "L", "1"]): Visualization mode.
+            Defaults to ``"binary"``.
+            - ``"contour"``: Draw mask boundaries
+            - ``"fill"``: Fill mask regions with semi-transparent color
+            - ``"binary"``, ``"L"``, ``"1"``: Return original binary mask
+        color (tuple[int, int, int]): RGB color for visualizing the mask.
+            Defaults to red ``(255, 0, 0)``.
+        alpha (float): Opacity for the mask visualization in ``"fill"`` mode.
+            Range [0, 1]. Defaults to ``0.5``.
+        background_color (tuple[int, int, int, int]): RGBA color for the
+            background. Defaults to transparent ``(0, 0, 0, 0)``.
+
+    Returns:
+        Image.Image: Visualized mask as a PIL Image.
+
+    Examples:
+        >>> import torch
+        >>> from PIL import Image
+        >>> # Create a sample binary mask
+        >>> mask = torch.zeros((100, 100))
+        >>> mask[25:75, 25:75] = 1
+        >>> # Visualize with default settings (binary mode)
+        >>> vis = visualize_pred_mask(mask)
+        >>> isinstance(vis, Image.Image)
+        True
+        >>> # Visualize with contours in blue
+        >>> vis = visualize_pred_mask(mask, mode="contour", color=(0, 0, 255))
+        >>> isinstance(vis, Image.Image)
+        True
+
+    Note:
+        See :func:`visualize_mask` for more details on the visualization modes and
+        parameters.
+    """
     return visualize_mask(mask, mode=mode, alpha=alpha, color=color, background_color=background_color)
 
 
 def create_image_grid(images: list[Image.Image], nrow: int) -> Image.Image:
     """Create a grid of images using PIL.
 
+    This function arranges a list of PIL images into a grid layout with a specified
+    number of images per row. All input images must have the same dimensions.
+
     Args:
-        images: List of PIL Images to arrange in a grid.
-        nrow: Number of images per row.
+        images (list[Image.Image]): List of PIL Images to arrange in a grid. All
+            images must have identical dimensions.
+        nrow (int): Number of images to display per row in the grid.
 
     Returns:
-        A new PIL Image containing the grid of images.
+        Image.Image: A new PIL Image containing the arranged grid of input images
+            with white background.
+
+    Raises:
+        ValueError: If ``images`` list is empty.
+
+    Examples:
+        Create a 2x2 grid from 4 images:
+
+        >>> from PIL import Image
+        >>> import numpy as np
+        >>> # Create sample images
+        >>> img1 = Image.fromarray(np.zeros((64, 64, 3), dtype=np.uint8))
+        >>> img2 = Image.fromarray(np.ones((64, 64, 3), dtype=np.uint8) * 255)
+        >>> images = [img1, img2, img1, img2]
+        >>> # Create grid with 2 images per row
+        >>> grid = create_image_grid(images, nrow=2)
+        >>> isinstance(grid, Image.Image)
+        True
+        >>> grid.size
+        (128, 128)
+
+    Note:
+        - All input images must have identical dimensions
+        - The grid is filled row by row, left to right, top to bottom
+        - If the number of images is not divisible by ``nrow``, the last row may
+          be partially filled
+        - The output image dimensions will be:
+          width = ``nrow`` * image_width
+          height = ceil(len(images)/nrow) * image_height
     """
     if not images:
         msg = "No images provided to create grid"
@@ -431,33 +734,59 @@ def create_image_grid(images: list[Image.Image], nrow: int) -> Image.Image:
 def get_field_kwargs(field: str) -> dict[str, Any]:
     """Get the keyword arguments for a visualization function.
 
-    This function retrieves the default keyword arguments for a given visualization function.
+    This function retrieves the default keyword arguments for a given visualization
+    function by inspecting its signature.
 
     Args:
-        field (str): The name of the visualization field (e.g., 'mask', 'anomaly_map').
+        field (str): The name of the visualization field (e.g., ``'mask'``,
+            ``'anomaly_map'``).
 
     Returns:
-        dict[str, Any]: A dictionary containing the default keyword arguments for the visualization function.
+        dict[str, Any]: A dictionary containing the default keyword arguments for
+            the visualization function. Each key is a parameter name and the value
+            is its default value.
 
     Raises:
-        ValueError: If the specified field does not have a corresponding visualization function.
+        ValueError: If the specified ``field`` does not have a corresponding
+            visualization function in the current module.
 
     Examples:
+        Get keyword arguments for visualizing a mask:
+
         >>> # Get keyword arguments for visualizing a mask
         >>> mask_kwargs = get_field_kwargs('mask')
-        >>> print(mask_kwargs)
-        {'mode': 'binary', 'color': (255, 0, 0), 'alpha': 0.5, 'background_color': (0, 0, 0, 0)}
+        >>> print(mask_kwargs)  # doctest: +SKIP
+        {
+            'mode': 'binary',
+            'color': (255, 0, 0),
+            'alpha': 0.5,
+            'background_color': (0, 0, 0, 0)
+        }
+
+        Get keyword arguments for visualizing an anomaly map:
 
         >>> # Get keyword arguments for visualizing an anomaly map
         >>> anomaly_map_kwargs = get_field_kwargs('anomaly_map')
-        >>> print(anomaly_map_kwargs)
-        {'colormap': True, 'normalize': False}
+        >>> print(anomaly_map_kwargs)  # doctest: +SKIP
+        {
+            'colormap': True,
+            'normalize': False
+        }
 
-        >>> # Attempt to get keyword arguments for an invalid field
-        >>> get_field_kwargs('invalid_field')
+        Attempt to get keyword arguments for an invalid field:
+
+        >>> get_field_kwargs('invalid_field')  # doctest: +IGNORE_EXCEPTION_DETAIL
         Traceback (most recent call last):
             ...
         ValueError: 'invalid_field' is not a valid function in the current module.
+
+    Note:
+        - The function looks for a visualization function named
+          ``visualize_{field}`` in the current module
+        - Only parameters with default values are included in the returned dict
+        - Variable keyword arguments (``**kwargs``) are noted in the dict with a
+          descriptive string
+        - Both keyword-only and positional-or-keyword parameters are included
     """
     # Get the current module
     current_module = sys.modules[__name__]
@@ -491,37 +820,61 @@ def get_field_kwargs(field: str) -> dict[str, Any]:
 def get_visualize_function(field: str) -> Callable:
     """Get the visualization function for a given field.
 
+    This function retrieves the visualization function corresponding to a specified field
+    from the current module. The function name is constructed by prepending
+    ``visualize_`` to the field name.
+
     Args:
-        field (str): The name of the visualization field
-            (e.g., 'image', 'mask', 'anomaly_map').
+        field (str): Name of the visualization field. Common values include:
+            - ``"image"``: For basic image visualization
+            - ``"mask"``: For segmentation mask visualization
+            - ``"anomaly_map"``: For anomaly heatmap visualization
 
     Returns:
-        Callable: The visualization function corresponding to the given field.
+        Callable: Visualization function corresponding to the given field.
+            The returned function will accept parameters specific to that
+            visualization type.
 
     Raises:
-        AttributeError: If the specified field does not have a corresponding
-            visualization function.
+        AttributeError: If no visualization function exists for the specified
+            ``field``. The error message will indicate which function name was
+            not found.
 
     Examples:
-        >>> from PIL import Image
+        Get visualization function for an anomaly map:
 
-        Get the visualize function for an anomaly map
+        >>> from PIL import Image
         >>> visualize_func = get_visualize_function('anomaly_map')
         >>> anomaly_map = Image.new('F', (256, 256))
-        >>> visualized_map = visualize_func(anomaly_map, colormap=True, normalize=True)
+        >>> visualized_map = visualize_func(
+        ...     anomaly_map,
+        ...     colormap=True,
+        ...     normalize=True
+        ... )
         >>> isinstance(visualized_map, Image.Image)
         True
 
+        Get visualization function for a mask:
+
         >>> visualize_func = get_visualize_function('mask')
         >>> mask = Image.new('1', (256, 256))
         >>> visualized_mask = visualize_func(mask, color=(255, 0, 0))
         >>> isinstance(visualized_mask, Image.Image)
         True
 
-        Attempt to get a function for an invalid field
-        >>> get_visualize_function('invalid_field')
-        Raises AttributeError: module 'anomalib.visualization.image.functional'
-        has no attribute 'visualize_invalid_field'
+        Attempting to get function for invalid field raises error:
+
+        >>> get_visualize_function('invalid_field')  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+            ...
+        AttributeError: module 'anomalib.visualization.image.functional' has no
+        attribute 'visualize_invalid_field'
+
+    Note:
+        - The function looks for visualization functions in the current module
+        - Function names must follow the pattern ``visualize_{field}``
+        - Each visualization function may have different parameters
+        - All visualization functions return PIL Image objects
     """
     current_module = sys.modules[__name__]
     func_name = f"visualize_{field}"
diff --git a/src/anomalib/visualization/image/visualizer.py b/src/anomalib/visualization/image/visualizer.py
index c230bdde03..906220464c 100644
--- a/src/anomalib/visualization/image/visualizer.py
+++ b/src/anomalib/visualization/image/visualizer.py
@@ -1,4 +1,30 @@
-"""Image Visualizer."""
+"""Image visualization module for anomaly detection.
+
+This module provides the ``ImageVisualizer`` class for visualizing images and their
+associated anomaly detection results. The key components include:
+
+    - Visualization of individual fields (images, masks, anomaly maps)
+    - Overlay of multiple fields
+    - Configurable visualization parameters
+    - Support for saving visualizations
+
+Example:
+    >>> from anomalib.visualization.image import ImageVisualizer
+    >>> # Create visualizer with default settings
+    >>> visualizer = ImageVisualizer()
+    >>> # Generate visualization
+    >>> vis_result = visualizer.visualize(image=img, pred_mask=mask)
+
+The module ensures consistent visualization by:
+    - Providing standardized field configurations
+    - Supporting flexible overlay options
+    - Handling text annotations
+    - Maintaining consistent output formats
+
+Note:
+    All visualization functions preserve the input image format and dimensions
+    unless explicitly specified in the configuration.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -27,70 +53,82 @@
 class ImageVisualizer(Visualizer):
     """Image Visualizer.
 
-    This class is responsible for visualizing images and their corresponding anomaly maps
-    during the testing and prediction phases of an anomaly detection model.
+    This class visualizes images and their corresponding anomaly maps during testing and
+    prediction phases of an anomaly detection model.
 
     Args:
-        fields (list[str] | None): List of fields to visualize.
-            Defaults to ["image", "gt_mask"].
-        overlay_fields (list[tuple[str, list[str]]] | None): List of tuples specifying fields to overlay.
-            Defaults to [("image", ["anomaly_map"]), ("image", ["pred_mask"])].
-        field_size (tuple[int, int]): Size of each field in the visualization.
-            Defaults to (256, 256).
-        fields_config (dict[str, dict[str, Any]]): Custom configurations for field visualization.
-            Defaults to DEFAULT_FIELDS_CONFIG.
-        overlay_fields_config (dict[str, dict[str, Any]]): Custom configurations for field overlays.
-            Defaults to DEFAULT_OVERLAY_FIELDS_CONFIG.
-        text_config (dict[str, Any]): Configuration for text overlay.
-            Defaults to DEFAULT_TEXT_CONFIG.
-        output_dir (str | Path | None): Directory to save the visualizations.
-            Defaults to None.
+        fields (list[str] | None, optional): List of fields to visualize.
+            Defaults to ``["image", "gt_mask"]``.
+        overlay_fields (list[tuple[str, list[str]]] | None, optional): List of tuples
+            specifying fields to overlay. Each tuple contains a base field and list of
+            fields to overlay on it.
+            Defaults to ``[("image", ["anomaly_map"]), ("image", ["pred_mask"])]``.
+        field_size (tuple[int, int], optional): Size of each field in visualization as
+            ``(width, height)``. Defaults to ``(256, 256)``.
+        fields_config (dict[str, dict[str, Any]] | None, optional): Custom configurations
+            for field visualization. Merged with ``DEFAULT_FIELDS_CONFIG``.
+            Defaults to ``None``.
+        overlay_fields_config (dict[str, dict[str, Any]] | None, optional): Custom
+            configurations for field overlays. Merged with
+            ``DEFAULT_OVERLAY_FIELDS_CONFIG``. Defaults to ``None``.
+        text_config (dict[str, Any] | None, optional): Configuration for text overlay.
+            Merged with ``DEFAULT_TEXT_CONFIG``. Defaults to ``None``.
+        output_dir (str | Path | None, optional): Directory to save visualizations.
+            Defaults to ``None``.
 
     Examples:
         Basic usage with default settings:
+
         >>> visualizer = ImageVisualizer()
 
-        Customizing fields to visualize:
+        Customize fields to visualize:
+
         >>> visualizer = ImageVisualizer(
         ...     fields=["image", "gt_mask", "anomaly_map"],
         ...     overlay_fields=[("image", ["anomaly_map"])]
         ... )
 
-        Adjusting field size:
+        Adjust field size:
+
         >>> visualizer = ImageVisualizer(field_size=(512, 512))
 
-        Customizing anomaly map visualization:
-        >>> visualizer = ImageVisualizer(
-        ...     fields_config={
-        ...         "anomaly_map": {"colormap": True, "normalize": True}
-        ...     }
-        ... )
+        Customize anomaly map visualization:
 
-        Modifying overlay appearance:
-        >>> visualizer = ImageVisualizer(
-        ...     overlay_fields_config={
-        ...         "pred_mask": {"alpha": 0.7, "color": (255, 0, 0), "mode": "fill"},
-        ...         "anomaly_map": {"alpha": 0.5, "color": (0, 255, 0), "mode": "contour"}
-        ...     }
-        ... )
+        >>> fields_config = {
+        ...     "anomaly_map": {"colormap": True, "normalize": True}
+        ... }
+        >>> visualizer = ImageVisualizer(fields_config=fields_config)
 
-        Customizing text overlay:
-        >>> visualizer = ImageVisualizer(
-        ...     text_config={
-        ...         "font": "arial.ttf",
-        ...         "size": 20,
-        ...         "color": "yellow",
-        ...         "background": (0, 0, 0, 200)
-        ...     }
-        ... )
+        Modify overlay appearance:
+
+        >>> overlay_config = {
+        ...     "pred_mask": {"alpha": 0.7, "color": (255, 0, 0), "mode": "fill"},
+        ...     "anomaly_map": {"alpha": 0.5, "color": (0, 255, 0), "mode": "contour"}
+        ... }
+        >>> visualizer = ImageVisualizer(overlay_fields_config=overlay_config)
+
+        Customize text overlay:
+
+        >>> text_config = {
+        ...     "font": "arial.ttf",
+        ...     "size": 20,
+        ...     "color": "yellow",
+        ...     "background": (0, 0, 0, 200)
+        ... }
+        >>> visualizer = ImageVisualizer(text_config=text_config)
+
+        Specify output directory:
 
-        Specifying output directory:
         >>> visualizer = ImageVisualizer(output_dir="./output/visualizations")
 
         Advanced configuration combining multiple customizations:
+
         >>> visualizer = ImageVisualizer(
         ...     fields=["image", "gt_mask", "anomaly_map", "pred_mask"],
-        ...     overlay_fields=[("image", ["anomaly_map"]), ("image", ["pred_mask"])],
+        ...     overlay_fields=[
+        ...         ("image", ["anomaly_map"]),
+        ...         ("image", ["pred_mask"])
+        ...     ],
         ...     field_size=(384, 384),
         ...     fields_config={
         ...         "anomaly_map": {"colormap": True, "normalize": True},
@@ -110,15 +148,21 @@ class ImageVisualizer(Visualizer):
         ... )
 
     Note:
-        - The 'fields' parameter determines which individual fields are visualized.
-        - The 'overlay_fields' parameter specifies which fields should be overlaid on others.
-        - Field configurations in 'fields_config' affect how individual fields are visualized.
-        - Overlay configurations in 'overlay_fields_config' determine how fields are blended when overlaid.
-        - Text configurations in 'text_config' control the appearance of text labels on visualizations.
-        - If 'output_dir' is not specified, visualizations will be saved in a default location.
-
-    For more details on available options for each configuration, refer to the documentation
-    of the `visualize_image_item`, `visualize_field`, and related functions.
+        - The ``fields`` parameter determines which individual fields are visualized
+        - The ``overlay_fields`` parameter specifies which fields should be overlaid
+          on others
+        - Field configurations in ``fields_config`` affect how individual fields are
+          visualized
+        - Overlay configurations in ``overlay_fields_config`` determine how fields are
+          blended when overlaid
+        - Text configurations in ``text_config`` control the appearance of text labels
+          on visualizations
+        - If ``output_dir`` is not specified, visualizations will be saved in a
+          default location
+
+    For more details on available options for each configuration, refer to the
+    documentation of the :func:`visualize_image_item`, :func:`visualize_field`, and
+    related functions.
     """
 
     def __init__(
diff --git a/tests/unit/cli/test_installation.py b/tests/unit/cli/test_installation.py
index 6a34017639..6fd32c4db2 100644
--- a/tests/unit/cli/test_installation.py
+++ b/tests/unit/cli/test_installation.py
@@ -1,6 +1,6 @@
 """Tests for installation utils."""
 
-# Copyright (C) 2023 Intel Corporation
+# Copyright (C) 2023-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
 import os

From a532cb53e8ff7b6be39c52d12aec2ba7bc9614b2 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Fri, 20 Dec 2024 05:56:48 +0000
Subject: [PATCH 41/45] Version bump to `v2.0.0-beta.1` (#2472)

Bump version

Signed-off-by: Samet Akcay 
---
 src/anomalib/__init__.py                 |  2 +-
 src/anomalib/utils/visualization/base.py | 12 +++++++++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/anomalib/__init__.py b/src/anomalib/__init__.py
index dde3a9da26..a71d83c7f2 100644
--- a/src/anomalib/__init__.py
+++ b/src/anomalib/__init__.py
@@ -34,7 +34,7 @@
 
 from enum import Enum
 
-__version__ = "2.0.0dev"
+__version__ = "2.0.0-beta.1"
 
 
 class LearningType(str, Enum):
diff --git a/src/anomalib/utils/visualization/base.py b/src/anomalib/utils/visualization/base.py
index f2a36430bd..e0c565fa52 100644
--- a/src/anomalib/utils/visualization/base.py
+++ b/src/anomalib/utils/visualization/base.py
@@ -54,9 +54,19 @@ class VisualizationStep(str, Enum):
 
 
 class BaseVisualizer(ABC):
-    """Base visualization generator."""
+    """Base visualization generator.
+
+    Deprecated: This class will be removed in v2.0.0 release.
+    """
 
     def __init__(self, visualize_on: VisualizationStep) -> None:
+        import warnings
+
+        warnings.warn(
+            "BaseVisualizer is deprecated and will be removed in v2.0.0 release.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         self.visualize_on = visualize_on
 
     @abstractmethod

From 03a53095d454c092adfc8ccfc695e738cdd1ced1 Mon Sep 17 00:00:00 2001
From: Dick Ameln 
Date: Fri, 3 Jan 2025 16:25:36 +0100
Subject: [PATCH 42/45] remove setup methods from base module (#2474)

* remove setup methods from base module

* update setup in winclip
---
 .../models/components/base/anomalib_module.py | 29 -------------------
 .../models/image/winclip/lightning_model.py   |  8 ++++-
 2 files changed, 7 insertions(+), 30 deletions(-)

diff --git a/src/anomalib/models/components/base/anomalib_module.py b/src/anomalib/models/components/base/anomalib_module.py
index b5fc6a57cf..3cd20c356b 100644
--- a/src/anomalib/models/components/base/anomalib_module.py
+++ b/src/anomalib/models/components/base/anomalib_module.py
@@ -50,7 +50,6 @@
 import lightning.pytorch as pl
 import torch
 from lightning.pytorch import Callback
-from lightning.pytorch.trainer.states import TrainerFn
 from lightning.pytorch.utilities.types import STEP_OUTPUT
 from torch import nn
 from torchvision.transforms.v2 import Compose, Normalize, Resize
@@ -143,7 +142,6 @@ def __init__(
         self.visualizer = self._resolve_visualizer(visualizer)
 
         self._input_size: tuple[int, int] | None = None
-        self._is_setup = False
 
     @property
     def name(self) -> str:
@@ -154,33 +152,6 @@ def name(self) -> str:
         """
         return self.__class__.__name__
 
-    def setup(self, stage: str | None = None) -> None:
-        """Set up the model if not already done.
-
-        This method ensures the model is built by calling ``_setup()`` if needed.
-
-        Args:
-            stage (str | None, optional): Current stage of training.
-                Defaults to ``None``.
-        """
-        if getattr(self, "model", None) is None or not self._is_setup:
-            self._setup()
-            if isinstance(stage, TrainerFn):
-                # only set the flag if the stage is a TrainerFn, which means the
-                # setup has been called from a trainer
-                self._is_setup = True
-
-    def _setup(self) -> None:
-        """Set up the model architecture.
-
-        This method should be overridden by subclasses to build their model
-        architecture. It is called by ``setup()`` when the model needs to be
-        initialized.
-
-        This is useful when the model cannot be fully initialized in ``__init__``
-        because it requires data-dependent parameters.
-        """
-
     def configure_callbacks(self) -> Sequence[Callback] | Callback:
         """Configure callbacks for the model.
 
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index e078f60e50..1bdf7686db 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -125,8 +125,9 @@ def __init__(
         self.class_name = class_name
         self.k_shot = k_shot
         self.few_shot_source = Path(few_shot_source) if few_shot_source else None
+        self.is_setup = False
 
-    def _setup(self) -> None:
+    def setup(self, stage: str) -> None:
         """Setup WinCLIP model.
 
         This method:
@@ -137,6 +138,10 @@ def _setup(self) -> None:
         Note:
             This hook is called before the model is moved to the target device.
         """
+        del stage
+        if self.is_setup:
+            return
+
         # get class name
         self.class_name = self._get_class_name()
         ref_images = None
@@ -158,6 +163,7 @@ def _setup(self) -> None:
 
         # call setup to initialize the model
         self.model.setup(self.class_name, ref_images)
+        self.is_setup = True
 
     def _get_class_name(self) -> str:
         """Get the class name used in the prompt ensemble.

From 8a82dc7cdd8734c3a3f72ced3354f4554fc95d1e Mon Sep 17 00:00:00 2001
From: Dick Ameln 
Date: Fri, 3 Jan 2025 16:25:49 +0100
Subject: [PATCH 43/45] Simplify subcomponent resolve in base module (#2473)

* simplify subcomponent resolve in base module

* add tests for AnomalibModule._resolve_component

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

Co-authored-by: Ashwin Vaidya 

* formatting

---------

Co-authored-by: Ashwin Vaidya 
---
 .../models/components/base/anomalib_module.py | 127 ++++++------------
 .../components/base/test_anomaly_module.py    |  58 ++++++++
 2 files changed, 97 insertions(+), 88 deletions(-)

diff --git a/src/anomalib/models/components/base/anomalib_module.py b/src/anomalib/models/components/base/anomalib_module.py
index 3cd20c356b..f1f87c75ef 100644
--- a/src/anomalib/models/components/base/anomalib_module.py
+++ b/src/anomalib/models/components/base/anomalib_module.py
@@ -43,7 +43,7 @@
 import logging
 import warnings
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from pathlib import Path
 from typing import Any
 
@@ -136,10 +136,10 @@ def __init__(
         self.loss: nn.Module
         self.callbacks: list[Callback]
 
-        self.pre_processor = self._resolve_pre_processor(pre_processor)
-        self.post_processor = self._resolve_post_processor(post_processor)
-        self.evaluator = self._resolve_evaluator(evaluator)
-        self.visualizer = self._resolve_visualizer(visualizer)
+        self.pre_processor = self._resolve_component(pre_processor, PreProcessor, self.configure_pre_processor)
+        self.post_processor = self._resolve_component(post_processor, PostProcessor, self.configure_post_processor)
+        self.evaluator = self._resolve_component(evaluator, Evaluator, self.configure_evaluator)
+        self.visualizer = self._resolve_component(visualizer, Visualizer, self.configure_visualizer)
 
         self._input_size: tuple[int, int] | None = None
 
@@ -270,34 +270,46 @@ def learning_type(self) -> LearningType:
         """
         raise NotImplementedError
 
-    def _resolve_pre_processor(self, pre_processor: PreProcessor | bool) -> PreProcessor | None:
-        """Resolve and validate the pre-processor configuration.
+    @staticmethod
+    def _resolve_component(
+        component: nn.Module | None,
+        component_type: type,
+        default_callable: Callable,
+    ) -> nn.Module | None:
+        """Resolve and validate the subcomponent configuration.
+
+        This method resolves the configuration for various subcomponents like
+        pre-processor, post-processor, evaluator and visualizer. It validates
+        the configuration and returns the configured component. If the component
+        is a boolean, it uses the default callable to create the component. If
+        the component is already an instance of the component type, it returns
+        the component as is.
 
         Args:
-            pre_processor (PreProcessor | bool): Pre-processor configuration
-                - ``True`` -> use default pre-processor
-                - ``False`` -> no pre-processor
-                - ``PreProcessor`` -> use provided pre-processor
+            component (object): Component configuration
+            component_type (Type): Type of the component
+            default_callable (Callable): Callable to create default component
 
         Returns:
-            PreProcessor | None: Configured pre-processor
+            Component | None: Configured component
 
         Raises:
-            TypeError: If pre_processor is invalid type
+            TypeError: If component is invalid type
         """
-        if isinstance(pre_processor, PreProcessor):
-            return pre_processor
-        if isinstance(pre_processor, bool):
-            return self.configure_pre_processor() if pre_processor else None
-        msg = f"Invalid pre-processor type: {type(pre_processor)}"
+        if isinstance(component, component_type):
+            return component
+        if isinstance(component, bool):
+            return default_callable() if component else None
+        msg = f"Passed object should be {component_type} or bool, got: {type(component)}"
         raise TypeError(msg)
 
-    @classmethod
-    def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> PreProcessor:
+    @staticmethod
+    def configure_pre_processor(image_size: tuple[int, int] | None = None) -> PreProcessor:
         """Configure the default pre-processor.
 
         The default pre-processor resizes images and normalizes using ImageNet
-        statistics.
+        statistics. Override this method to provide a custom pre-processor for
+        the model.
 
         Args:
             image_size (tuple[int, int] | None, optional): Target size for
@@ -319,31 +331,12 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
             ]),
         )
 
-    def _resolve_post_processor(self, post_processor: PostProcessor | bool) -> PostProcessor | None:
-        """Resolve and validate the post-processor configuration.
-
-        Args:
-            post_processor (PostProcessor | bool): Post-processor configuration
-                - ``True`` -> use default post-processor
-                - ``False`` -> no post-processor
-                - ``PostProcessor`` -> use provided post-processor
-
-        Returns:
-            PostProcessor | None: Configured post-processor
-
-        Raises:
-            TypeError: If post_processor is invalid type
-        """
-        if isinstance(post_processor, PostProcessor):
-            return post_processor
-        if isinstance(post_processor, bool):
-            return self.configure_post_processor() if post_processor else None
-        msg = f"Invalid post-processor type: {type(post_processor)}"
-        raise TypeError(msg)
-
     def configure_post_processor(self) -> PostProcessor | None:
         """Configure the default post-processor.
 
+        The default post-processor is based on the model's learning type. Override
+        this method to provide a custom post-processor for the model.
+
         Returns:
             PostProcessor | None: Configured post-processor based on learning type
 
@@ -365,34 +358,12 @@ def configure_post_processor(self) -> PostProcessor | None:
         )
         raise NotImplementedError(msg)
 
-    def _resolve_evaluator(self, evaluator: Evaluator | bool) -> Evaluator | None:
-        """Resolve and validate the evaluator configuration.
-
-        Args:
-            evaluator (Evaluator | bool): Evaluator configuration
-                - ``True`` -> use default evaluator
-                - ``False`` -> no evaluator
-                - ``Evaluator`` -> use provided evaluator
-
-        Returns:
-            Evaluator | None: Configured evaluator
-
-        Raises:
-            TypeError: If evaluator is invalid type
-        """
-        if isinstance(evaluator, Evaluator):
-            return evaluator
-        if isinstance(evaluator, bool):
-            return self.configure_evaluator() if evaluator else None
-        msg = f"evaluator must be of type Evaluator or bool, got {type(evaluator)}"
-        raise TypeError(msg)
-
     @staticmethod
     def configure_evaluator() -> Evaluator:
         """Configure the default evaluator.
 
         The default evaluator includes metrics for both image-level and
-        pixel-level evaluation.
+        pixel-level evaluation. Override this method to provide custom metrics for the model.
 
         Returns:
             Evaluator: Configured evaluator with default metrics
@@ -409,32 +380,12 @@ def configure_evaluator() -> Evaluator:
         test_metrics = [image_auroc, image_f1score, pixel_auroc, pixel_f1score]
         return Evaluator(test_metrics=test_metrics)
 
-    def _resolve_visualizer(self, visualizer: Visualizer | bool) -> Visualizer | None:
-        """Resolve and validate the visualizer configuration.
-
-        Args:
-            visualizer (Visualizer | bool): Visualizer configuration
-                - ``True`` -> use default visualizer
-                - ``False`` -> no visualizer
-                - ``Visualizer`` -> use provided visualizer
-
-        Returns:
-            Visualizer | None: Configured visualizer
-
-        Raises:
-            TypeError: If visualizer is invalid type
-        """
-        if isinstance(visualizer, Visualizer):
-            return visualizer
-        if isinstance(visualizer, bool):
-            return self.configure_visualizer() if visualizer else None
-        msg = f"Visualizer must be of type Visualizer or bool, got {type(visualizer)}"
-        raise TypeError(msg)
-
     @classmethod
     def configure_visualizer(cls) -> ImageVisualizer:
         """Configure the default visualizer.
 
+        Override this method to provide a custom visualizer for the model.
+
         Returns:
             ImageVisualizer: Default image visualizer instance
 
diff --git a/tests/unit/models/components/base/test_anomaly_module.py b/tests/unit/models/components/base/test_anomaly_module.py
index 1578fc9e17..0c522998ae 100644
--- a/tests/unit/models/components/base/test_anomaly_module.py
+++ b/tests/unit/models/components/base/test_anomaly_module.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torch import nn
 
 from anomalib.models.components.base import AnomalibModule
 
@@ -57,3 +58,60 @@ def test_from_config(self, model_name: str) -> None:
         model = AnomalibModule.from_config(config_path=config_path)
         assert model is not None
         assert isinstance(model, AnomalibModule)
+
+
+class TestResolveComponents:
+    """Test AnomalibModule._resolve_component."""
+
+    class DummyComponent(nn.Module):
+        """Dummy component class."""
+
+        def __init__(self, value: int) -> None:
+            self.value = value
+
+    @classmethod
+    def dummy_configure_component(cls) -> DummyComponent:
+        """Dummy configure component method, simulates configure_ methods in module."""
+        return cls.DummyComponent(value=1)
+
+    def test_component_passed(self) -> None:
+        """Test that the component is returned as is if it is an instance of the component type."""
+        component = self.DummyComponent(value=0)
+        resolved = AnomalibModule._resolve_component(  # noqa: SLF001
+            component=component,
+            component_type=self.DummyComponent,
+            default_callable=self.dummy_configure_component,
+        )
+        assert isinstance(resolved, self.DummyComponent)
+        assert resolved.value == 0
+
+    def test_component_true(self) -> None:
+        """Test that the default_callable is called if component is True."""
+        component = True
+        resolved = AnomalibModule._resolve_component(  # noqa: SLF001
+            component=component,
+            component_type=self.DummyComponent,
+            default_callable=self.dummy_configure_component,
+        )
+        assert isinstance(resolved, self.DummyComponent)
+        assert resolved.value == 1
+
+    def test_component_false(self) -> None:
+        """Test that None is returned if component is False."""
+        component = False
+        resolved = AnomalibModule._resolve_component(  # noqa: SLF001
+            component=component,
+            component_type=self.DummyComponent,
+            default_callable=self.dummy_configure_component,
+        )
+        assert resolved is None
+
+    def test_raises_type_error(self) -> None:
+        """Test that a TypeError is raised if the component is not of the correct type."""
+        component = 1
+        with pytest.raises(TypeError):
+            AnomalibModule._resolve_component(  # noqa: SLF001
+                component=component,
+                component_type=self.DummyComponent,
+                default_callable=self.dummy_configure_component,
+            )

From 235952ef4f15d2f78c3d9eed36171155dfd943cd Mon Sep 17 00:00:00 2001
From: Dick Ameln 
Date: Mon, 6 Jan 2025 10:25:33 +0100
Subject: [PATCH 44/45] Apply transforms in PreProcessor (#2467)

* apply transforms in pre-processor

* add augmentation arguments to datamodules

* update expected config for adapter tests

* fix buffer issue

* update data notebooks

* reduce num workers in MLFlow notebook

* Revert "reduce num workers in MLFlow notebook"

This reverts commit 151a17943df89a502ad498874decfeb91698dc92.

* match resize between augmentations and model transforms

* remove subset-specific transforms in preprocessor

* move nested attr helper to utils

* move transform retrieve function to transform utils

* update efficientad transform validation

* formatting

* update preprocessor docstring

* fix data notebook

* fix logic in _update_augmentations

* add unit tests for updating augmentations in data module

* add unit tests for updating augmentations in data module

* add test for collate method

* copy transform before converting

* update docstring

* rename function
---
 configs/model/cfa.yaml                        |   3 -
 configs/model/cflow.yaml                      |   4 -
 configs/model/csflow.yaml                     |   4 -
 configs/model/draem.yaml                      |   4 -
 configs/model/dsr.yaml                        |   4 -
 configs/model/efficient_ad.yaml               |   4 -
 configs/model/fastflow.yaml                   |   4 -
 configs/model/padim.yaml                      |   3 -
 configs/model/reverse_distillation.yaml       |   4 -
 configs/model/stfpm.yaml                      |   4 -
 configs/model/uflow.yaml                      |   4 -
 notebooks/100_datamodules/101_btech.ipynb     |  31 +--
 notebooks/100_datamodules/102_mvtec.ipynb     |  28 +--
 notebooks/100_datamodules/103_folder.ipynb    |  28 +--
 notebooks/200_models/201_fastflow.ipynb       |  71 ++----
 src/anomalib/data/dataclasses/generic.py      |  17 ++
 src/anomalib/data/datamodules/base/image.py   | 112 ++++++++-
 .../data/datamodules/depth/folder_3d.py       |  18 ++
 .../data/datamodules/depth/mvtec_3d.py        |  18 ++
 src/anomalib/data/datamodules/image/btech.py  |  17 ++
 .../data/datamodules/image/datumaro.py        |  20 ++
 src/anomalib/data/datamodules/image/folder.py |  18 ++
 .../data/datamodules/image/kolektor.py        |  19 +-
 src/anomalib/data/datamodules/image/mvtec.py  |  18 ++
 src/anomalib/data/datamodules/image/visa.py   |  17 ++
 src/anomalib/data/datamodules/video/avenue.py |  17 ++
 .../data/datamodules/video/shanghaitech.py    |  18 ++
 .../data/datamodules/video/ucsd_ped.py        |  18 ++
 src/anomalib/data/datasets/base/depth.py      |  13 +-
 src/anomalib/data/datasets/base/image.py      |  16 +-
 src/anomalib/data/datasets/base/video.py      |  18 +-
 src/anomalib/data/datasets/depth/folder_3d.py |   6 +-
 src/anomalib/data/datasets/depth/mvtec_3d.py  |   6 +-
 src/anomalib/data/datasets/image/btech.py     |   4 +-
 src/anomalib/data/datasets/image/datumaro.py  |   4 +-
 src/anomalib/data/datasets/image/folder.py    |   4 +-
 src/anomalib/data/datasets/image/kolektor.py  |   4 +-
 src/anomalib/data/datasets/image/mvtec.py     |   6 +-
 src/anomalib/data/datasets/image/visa.py      |   4 +-
 src/anomalib/data/datasets/video/avenue.py    |   8 +-
 .../data/datasets/video/shanghaitech.py       |   8 +-
 src/anomalib/data/datasets/video/ucsd_ped.py  |   6 +-
 src/anomalib/data/transforms/utils.py         |  26 +++
 src/anomalib/data/utils/synthetic.py          |  10 +-
 .../models/components/base/anomalib_module.py |   6 +-
 .../image/efficient_ad/lightning_model.py     |   9 +-
 .../models/image/winclip/lightning_model.py   |   2 +-
 src/anomalib/pre_processing/pre_processing.py | 216 ++++++------------
 .../pre_processing/utils/transform.py         | 211 +----------------
 src/anomalib/utils/__init__.py                |   4 +
 src/anomalib/utils/attrs.py                   |  52 +++++
 src/anomalib/utils/visualization/image.py     |   4 +-
 .../tools/upgrade/expected_draem_v1.yaml      |   4 +
 tests/unit/data/dataclasses/test_collate.py   |  45 ++++
 .../data/datamodule/depth/test_folder_3d.py   |   2 +
 .../data/datamodule/depth/test_mvtec_3d.py    |   2 +
 .../unit/data/datamodule/image/test_btech.py  |   2 +
 .../data/datamodule/image/test_datumaro.py    |   2 +
 .../unit/data/datamodule/image/test_folder.py |   2 +
 .../data/datamodule/image/test_kolektor.py    |   2 +
 .../unit/data/datamodule/image/test_mvtec.py  |   2 +
 tests/unit/data/datamodule/image/test_visa.py |   2 +
 .../datamodule/test_update_augmentations.py   | 122 ++++++++++
 .../unit/data/datamodule/video/test_avenue.py |   2 +
 .../datamodule/video/test_shanghaitech.py     |   2 +
 .../data/datamodule/video/test_ucsdped.py     |   2 +
 tests/unit/data/utils/test_synthetic.py       |   4 +-
 .../pre_processing/test_pre_processing.py     |  89 --------
 .../pre_processing/utils/test_transform.py    |  30 ---
 69 files changed, 762 insertions(+), 728 deletions(-)
 create mode 100644 src/anomalib/data/transforms/utils.py
 create mode 100644 src/anomalib/utils/attrs.py
 create mode 100644 tests/unit/data/dataclasses/test_collate.py
 create mode 100644 tests/unit/data/datamodule/test_update_augmentations.py

diff --git a/configs/model/cfa.yaml b/configs/model/cfa.yaml
index 457a7f5387..1f3ad7ec72 100644
--- a/configs/model/cfa.yaml
+++ b/configs/model/cfa.yaml
@@ -8,9 +8,6 @@ model:
     num_hard_negative_features: 3
     radius: 1.0e-05
 
-metrics:
-  pixel: AUROC
-
 trainer:
   max_epochs: 30
   callbacks:
diff --git a/configs/model/cflow.yaml b/configs/model/cflow.yaml
index dc134278ce..3d7e53917e 100644
--- a/configs/model/cflow.yaml
+++ b/configs/model/cflow.yaml
@@ -15,10 +15,6 @@ model:
     permute_soft: false
     lr: 0.0001
 
-metrics:
-  pixel:
-    - AUROC
-
 trainer:
   max_epochs: 50
   callbacks:
diff --git a/configs/model/csflow.yaml b/configs/model/csflow.yaml
index cece0b379c..796490fe97 100644
--- a/configs/model/csflow.yaml
+++ b/configs/model/csflow.yaml
@@ -6,10 +6,6 @@ model:
     clamp: 3
     num_channels: 3
 
-metrics:
-  pixel:
-    - AUROC
-
 trainer:
   max_epochs: 240
   callbacks:
diff --git a/configs/model/draem.yaml b/configs/model/draem.yaml
index 17d85220e4..04914e4282 100644
--- a/configs/model/draem.yaml
+++ b/configs/model/draem.yaml
@@ -6,10 +6,6 @@ model:
     sspcab_lambda: 0.1
     anomaly_source_path: null
 
-metrics:
-  pixel:
-    - AUROC
-
 trainer:
   max_epochs: 700
   callbacks:
diff --git a/configs/model/dsr.yaml b/configs/model/dsr.yaml
index 859438418a..7a2f84997d 100644
--- a/configs/model/dsr.yaml
+++ b/configs/model/dsr.yaml
@@ -4,10 +4,6 @@ model:
     latent_anomaly_strength: 0.2
     upsampling_train_ratio: 0.7
 
-metrics:
-  pixel:
-    - AUROC
-
 # PL Trainer Args. Don't add extra parameter here.
 trainer:
   max_epochs: 700
diff --git a/configs/model/efficient_ad.yaml b/configs/model/efficient_ad.yaml
index 1d7f70b7eb..9e64851e5f 100644
--- a/configs/model/efficient_ad.yaml
+++ b/configs/model/efficient_ad.yaml
@@ -8,10 +8,6 @@ model:
     padding: false
     pad_maps: true
 
-metrics:
-  pixel:
-    - AUROC
-
 trainer:
   max_epochs: 1000
   max_steps: 70000
diff --git a/configs/model/fastflow.yaml b/configs/model/fastflow.yaml
index 13cdd69a3e..8bcde42c78 100644
--- a/configs/model/fastflow.yaml
+++ b/configs/model/fastflow.yaml
@@ -7,10 +7,6 @@ model:
     conv3x3_only: false
     hidden_ratio: 1.0
 
-metrics:
-  pixel:
-    - AUROC
-
 trainer:
   max_epochs: 500
   callbacks:
diff --git a/configs/model/padim.yaml b/configs/model/padim.yaml
index 3787897889..daeb806b86 100644
--- a/configs/model/padim.yaml
+++ b/configs/model/padim.yaml
@@ -8,6 +8,3 @@ model:
     backbone: resnet18
     pre_trained: true
     n_features: null
-
-metrics:
-  pixel: AUROC
diff --git a/configs/model/reverse_distillation.yaml b/configs/model/reverse_distillation.yaml
index 97184b0aa0..523b303681 100644
--- a/configs/model/reverse_distillation.yaml
+++ b/configs/model/reverse_distillation.yaml
@@ -9,10 +9,6 @@ model:
     anomaly_map_mode: ADD
     pre_trained: true
 
-metrics:
-  pixel:
-    - AUROC
-
 trainer:
   callbacks:
     - class_path: lightning.pytorch.callbacks.EarlyStopping
diff --git a/configs/model/stfpm.yaml b/configs/model/stfpm.yaml
index c5e783baaa..40db04aec2 100644
--- a/configs/model/stfpm.yaml
+++ b/configs/model/stfpm.yaml
@@ -7,10 +7,6 @@ model:
       - layer2
       - layer3
 
-metrics:
-  pixel:
-    - AUROC
-
 trainer:
   max_epochs: 100
   callbacks:
diff --git a/configs/model/uflow.yaml b/configs/model/uflow.yaml
index 6b6ccd81eb..00329b9b68 100644
--- a/configs/model/uflow.yaml
+++ b/configs/model/uflow.yaml
@@ -7,10 +7,6 @@ model:
     affine_subnet_channels_ratio: 1.0
     backbone: mcait # official: mcait, other extractors tested: resnet18, wide_resnet50_2. Could use others...
 
-metrics:
-  pixel:
-    - AUROC
-
 # PL Trainer Args. Don't add extra parameter here.
 trainer:
   max_epochs: 200
diff --git a/notebooks/100_datamodules/101_btech.ipynb b/notebooks/100_datamodules/101_btech.ipynb
index cd980fc56e..19ac3277c2 100644
--- a/notebooks/100_datamodules/101_btech.ipynb
+++ b/notebooks/100_datamodules/101_btech.ipynb
@@ -39,7 +39,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -61,18 +61,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
     "# flake8: noqa\n",
     "import numpy as np\n",
     "from PIL import Image\n",
-    "from torchvision.transforms.v2 import Resize\n",
     "from torchvision.transforms.v2.functional import to_pil_image\n",
     "\n",
-    "from anomalib.data import BTech, BTechDataset\n",
-    "from anomalib import TaskType"
+    "from anomalib.data import BTech, BTechDataset"
    ]
   },
   {
@@ -99,7 +97,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -203,25 +201,6 @@
     "BTechDataset??"
    ]
   },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can add some transforms that will be applied to the images using torchvision. Let's add a transform that resizes the \n",
-    "input image to 256x256 pixels."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "image_size = (256, 256)\n",
-    "transform = Resize(image_size, antialias=True)"
-   ]
-  },
   {
    "attachments": {},
    "cell_type": "markdown",
@@ -240,7 +219,6 @@
     "btech_dataset_train = BTechDataset(\n",
     "    root=dataset_root,\n",
     "    category=\"01\",\n",
-    "    transform=transform,\n",
     "    split=\"train\",\n",
     ")\n",
     "print(len(btech_dataset_train))\n",
@@ -268,7 +246,6 @@
     "btech_dataset_test = BTechDataset(\n",
     "    root=dataset_root,\n",
     "    category=\"01\",\n",
-    "    transform=transform,\n",
     "    split=\"test\",\n",
     ")\n",
     "print(len(btech_dataset_test))\n",
diff --git a/notebooks/100_datamodules/102_mvtec.ipynb b/notebooks/100_datamodules/102_mvtec.ipynb
index cbc62f51dd..573c83f399 100644
--- a/notebooks/100_datamodules/102_mvtec.ipynb
+++ b/notebooks/100_datamodules/102_mvtec.ipynb
@@ -23,14 +23,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "# flake8: noqa\n",
     "import numpy as np\n",
     "from PIL import Image\n",
-    "from torchvision.transforms.v2 import Resize\n",
     "from torchvision.transforms.v2.functional import to_pil_image\n",
     "\n",
     "from anomalib.data import MVTec, MVTecDataset"
@@ -48,7 +47,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -76,7 +75,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -180,25 +179,6 @@
     "MVTecDataset??"
    ]
   },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can add some transforms that will be applied to the images using torchvision. Let's add a transform that resizes the \n",
-    "input image to 256x256 pixels."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "image_size = (256, 256)\n",
-    "transform = Resize(image_size, antialias=True)"
-   ]
-  },
   {
    "attachments": {},
    "cell_type": "markdown",
@@ -217,7 +197,6 @@
     "mvtec_dataset_train = MVTecDataset(\n",
     "    root=dataset_root,\n",
     "    category=\"bottle\",\n",
-    "    transform=transform,\n",
     "    split=\"train\",\n",
     ")\n",
     "print(len(mvtec_dataset_train))\n",
@@ -245,7 +224,6 @@
     "mvtec_dataset_test = MVTecDataset(\n",
     "    root=dataset_root,\n",
     "    category=\"bottle\",\n",
-    "    transform=transform,\n",
     "    split=\"test\",\n",
     ")\n",
     "print(len(mvtec_dataset_test))\n",
diff --git a/notebooks/100_datamodules/103_folder.ipynb b/notebooks/100_datamodules/103_folder.ipynb
index e40b68a858..df9154f056 100644
--- a/notebooks/100_datamodules/103_folder.ipynb
+++ b/notebooks/100_datamodules/103_folder.ipynb
@@ -33,7 +33,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -63,14 +63,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
     "# flake8: noqa\n",
     "import numpy as np\n",
     "from PIL import Image\n",
-    "from torchvision.transforms.v2 import Resize\n",
     "from torchvision.transforms.v2.functional import to_pil_image\n",
     "\n",
     "from anomalib.data import Folder, FolderDataset"
@@ -173,25 +172,6 @@
     "FolderDataset??"
    ]
   },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can add some transforms that will be applied to the images using torchvision. Let's add a transform that resizes the \n",
-    "input image to 256x256 pixels."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "image_size = (256, 256)\n",
-    "transform = Resize(image_size, antialias=True)"
-   ]
-  },
   {
    "attachments": {},
    "cell_type": "markdown",
@@ -211,7 +191,6 @@
     "    normal_dir=dataset_root / \"good\",\n",
     "    abnormal_dir=dataset_root / \"crack\",\n",
     "    split=\"train\",\n",
-    "    transform=transform,\n",
     ")\n",
     "print(len(folder_dataset_train))\n",
     "sample = folder_dataset_train[0]\n",
@@ -241,7 +220,6 @@
     "    normal_dir=dataset_root / \"good\",\n",
     "    abnormal_dir=dataset_root / \"crack\",\n",
     "    split=\"test\",\n",
-    "    transform=transform,\n",
     ")\n",
     "print(len(folder_dataset_test))\n",
     "sample = folder_dataset_test[0]\n",
@@ -270,7 +248,6 @@
     "    normal_dir=dataset_root / \"good\",\n",
     "    abnormal_dir=dataset_root / \"crack\",\n",
     "    split=\"train\",\n",
-    "    transform=transform,\n",
     "    mask_dir=dataset_root / \"mask\" / \"crack\",\n",
     ")\n",
     "print(len(folder_dataset_segmentation_train))\n",
@@ -290,7 +267,6 @@
     "    normal_dir=dataset_root / \"good\",\n",
     "    abnormal_dir=dataset_root / \"crack\",\n",
     "    split=\"test\",\n",
-    "    transform=transform,\n",
     "    mask_dir=dataset_root / \"mask\" / \"crack\",\n",
     ")\n",
     "print(len(folder_dataset_segmentation_test))\n",
diff --git a/notebooks/200_models/201_fastflow.ipynb b/notebooks/200_models/201_fastflow.ipynb
index 2e5872db60..dbace61ec9 100644
--- a/notebooks/200_models/201_fastflow.ipynb
+++ b/notebooks/200_models/201_fastflow.ipynb
@@ -35,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -73,9 +73,8 @@
     "from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint\n",
     "from matplotlib import pyplot as plt\n",
     "from PIL import Image\n",
-    "from torch.utils.data import DataLoader\n",
     "\n",
-    "from anomalib.data import MVTec, PredictDataset\n",
+    "from anomalib.data import MVTec\n",
     "from anomalib.engine import Engine\n",
     "from anomalib.models import Fastflow\n",
     "from anomalib.utils.post_processing import superimpose_anomaly_map"
@@ -97,7 +96,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -170,7 +169,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -209,7 +208,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {
     "pycharm": {
      "name": "#%%\n"
@@ -292,35 +291,7 @@
    "source": [
     "## Inference\n",
     "\n",
-    "Since we have a trained model, we could infer the model on an individual image or folder of images. Anomalib has an `PredictDataset` to let you create an inference dataset. So let's try it.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "pre_processor = Fastflow.configure_pre_processor()\n",
-    "transform = pre_processor.predict_transform\n",
-    "inference_dataset = PredictDataset(path=dataset_root / \"bottle/test/broken_large/000.png\", transform=transform)\n",
-    "inference_dataloader = DataLoader(dataset=inference_dataset, collate_fn=inference_dataset.collate_fn)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": [
-    "We could utilize `Trainer`'s `predict` method to infer, and get the outputs to visualize\n"
+    "Since we have a trained model, we could infer the model on an individual image or folder of images. To run inferende on an image (or a folder of images!), we can simply pass the path to the engine's `predict` method.\n"
    ]
   },
   {
@@ -333,7 +304,9 @@
    },
    "outputs": [],
    "source": [
-    "predictions = engine.predict(model=model, dataloaders=inference_dataloader)[0]"
+    "data_path = dataset_root / \"bottle/test/broken_large/000.png\"\n",
+    "predictions = engine.predict(model=model, data_path=data_path)\n",
+    "prediction = predictions[0]  # Get the first and only prediction"
    ]
   },
   {
@@ -345,7 +318,7 @@
     }
    },
    "source": [
-    "`predictions` contain image, anomaly maps, predicted scores, labels and masks. These are all stored in a dictionary. We could check this by printing the `prediction` keys.\n"
+    "`prediction` contains image, anomaly maps, predicted scores, labels and masks. These are all stored in a dictionary. We could check this by printing the `prediction` keys.\n"
    ]
   },
   {
@@ -359,9 +332,9 @@
    "outputs": [],
    "source": [
     "print(\n",
-    "    f\"Image Shape: {predictions.image.shape},\\n\"\n",
-    "    f\"Anomaly Map Shape: {predictions.anomaly_map.shape}, \\n\"\n",
-    "    f\"Predicted Mask Shape: {predictions.pred_mask.shape}\",\n",
+    "    f\"Image Shape: {prediction.image.shape},\\n\"\n",
+    "    f\"Anomaly Map Shape: {prediction.anomaly_map.shape}, \\n\"\n",
+    "    f\"Predicted Mask Shape: {prediction.pred_mask.shape}\",\n",
     ")"
    ]
   },
@@ -393,17 +366,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's first show the input image. To do so, we will use `image_path` key from the `predictions` dictionary, and read the image from path. Note that `predictions` dictionary already contains `image`. However, this is the normalized image with pixel values between 0 and 1. We will use the original image to visualize the input image."
+    "Let's first show the input image. To do so, we will use `image_path` key from the `prediction` dictionary, and read the image from path. Note that `predictions` dictionary already contains `image`. However, this is the normalized image with pixel values between 0 and 1. We will use the original image to visualize the input image."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
-    "image_path = predictions.image_path[0]\n",
-    "image_size = predictions.image.shape[-2:]\n",
+    "image_path = prediction.image_path[0]\n",
+    "image_size = prediction.image.shape[-2:]\n",
     "image = np.array(Image.open(image_path).resize(image_size))"
    ]
   },
@@ -429,7 +402,7 @@
    },
    "outputs": [],
    "source": [
-    "anomaly_map = predictions.anomaly_map[0]\n",
+    "anomaly_map = prediction.anomaly_map[0]\n",
     "anomaly_map = anomaly_map.cpu().numpy().squeeze()\n",
     "plt.imshow(anomaly_map)"
    ]
@@ -469,7 +442,7 @@
     }
    },
    "source": [
-    "`predictions` also contains prediction scores and labels.\n"
+    "`prediction` also contains prediction scores and labels.\n"
    ]
   },
   {
@@ -482,8 +455,8 @@
    },
    "outputs": [],
    "source": [
-    "pred_score = predictions.pred_score[0]\n",
-    "pred_labels = predictions.pred_label[0]\n",
+    "pred_score = prediction.pred_score[0]\n",
+    "pred_labels = prediction.pred_label[0]\n",
     "print(pred_score, pred_labels)"
    ]
   },
@@ -509,7 +482,7 @@
    },
    "outputs": [],
    "source": [
-    "pred_masks = predictions.pred_mask[0].squeeze().cpu().numpy()\n",
+    "pred_masks = prediction.pred_mask[0].squeeze().cpu().numpy()\n",
     "plt.imshow(pred_masks)"
    ]
   },
diff --git a/src/anomalib/data/dataclasses/generic.py b/src/anomalib/data/dataclasses/generic.py
index 3ee82153fd..521ead0f90 100644
--- a/src/anomalib/data/dataclasses/generic.py
+++ b/src/anomalib/data/dataclasses/generic.py
@@ -41,7 +41,9 @@
 
 import numpy as np
 import torch
+from torch import tensor
 from torch.utils.data import default_collate
+from torchvision.transforms.v2.functional import resize
 from torchvision.tv_tensors import Image, Mask, Video
 
 ImageT = TypeVar("ImageT", Image, Video, np.ndarray)
@@ -790,5 +792,20 @@ def collate(cls: type["BatchIterateMixin"], items: list[ItemT]) -> "BatchIterate
             New batch containing the items
         """
         keys = [key for key, value in asdict(items[0]).items() if value is not None]
+
+        # Check if all images have the same shape. If not, resize before collating
+        im_shapes = torch.vstack([tensor(item.image.shape) for item in items if item.image is not None])[..., 1:]
+        if torch.unique(im_shapes, dim=0).size(0) != 1:  # check if batch has heterogeneous shapes
+            target_shape = im_shapes[
+                torch.unravel_index(im_shapes.argmax(), im_shapes.shape)[0],
+                :,
+            ]  # shape of image with largest H or W
+            for item in items:
+                for key in keys:
+                    value = getattr(item, key)
+                    if isinstance(value, Image | Mask):
+                        setattr(item, key, resize(value, target_shape))
+
+        # collate the batch
         out_dict = {key: default_collate([getattr(item, key) for item in items]) for key in keys}
         return cls(**out_dict)
diff --git a/src/anomalib/data/datamodules/base/image.py b/src/anomalib/data/datamodules/base/image.py
index 87bbfc17c6..a2e163a3bd 100644
--- a/src/anomalib/data/datamodules/base/image.py
+++ b/src/anomalib/data/datamodules/base/image.py
@@ -25,6 +25,7 @@
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+import copy
 import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
@@ -34,15 +35,18 @@
 from lightning.pytorch.trainer.states import TrainerFn
 from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
 from torch.utils.data.dataloader import DataLoader
+from torchvision.transforms.v2 import Compose, Resize, Transform
 
 from anomalib import TaskType
+from anomalib.data.datasets.base.image import AnomalibDataset
+from anomalib.data.transforms.utils import extract_transforms_by_type
 from anomalib.data.utils import TestSplitMode, ValSplitMode, random_split, split_by_label
 from anomalib.data.utils.synthetic import SyntheticAnomalyDataset
+from anomalib.utils.attrs import get_nested_attr
 
 if TYPE_CHECKING:
     from pandas import DataFrame
 
-    from anomalib.data.datasets.base.image import AnomalibDataset
 
 logger = logging.getLogger(__name__)
 
@@ -54,9 +58,17 @@ class AnomalibDataModule(LightningDataModule, ABC):
     common functionality for anomaly detection datasets.
 
     Args:
-        train_batch_size (int): Batch size for training dataloader
-        eval_batch_size (int): Batch size for validation/test dataloaders
-        num_workers (int): Number of workers for all dataloaders
+        train_batch_size (int): Batch size used by the train dataloader.
+        eval_batch_size (int): Batch size used by the val and test dataloaders.
+        num_workers (int): Number of workers used by the train, val and test dataloaders.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         val_split_mode (ValSplitMode | str): Method to obtain validation set.
             Options:
                 - ``none``: No validation set
@@ -81,8 +93,12 @@ def __init__(
         train_batch_size: int,
         eval_batch_size: int,
         num_workers: int,
-        val_split_mode: ValSplitMode | str,
-        val_split_ratio: float,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
+        val_split_mode: ValSplitMode | str | None = None,
+        val_split_ratio: float | None = None,
         test_split_mode: TestSplitMode | str | None = None,
         test_split_ratio: float | None = None,
         seed: int | None = None,
@@ -92,11 +108,15 @@ def __init__(
         self.eval_batch_size = eval_batch_size
         self.num_workers = num_workers
         self.test_split_mode = TestSplitMode(test_split_mode) if test_split_mode else TestSplitMode.NONE
-        self.test_split_ratio = test_split_ratio
-        self.val_split_mode = ValSplitMode(val_split_mode)
-        self.val_split_ratio = val_split_ratio
+        self.test_split_ratio = test_split_ratio or 0.5
+        self.val_split_mode = ValSplitMode(val_split_mode) if val_split_mode else ValSplitMode.NONE
+        self.val_split_ratio = val_split_ratio or 0.5
         self.seed = seed
 
+        self.train_augmentations = train_augmentations or augmentations
+        self.val_augmentations = val_augmentations or augmentations
+        self.test_augmentations = test_augmentations or augmentations
+
         self.train_data: AnomalibDataset
         self.val_data: AnomalibDataset
         self.test_data: AnomalibDataset
@@ -134,6 +154,76 @@ def setup(self, stage: str | None = None) -> None:
                 # only set flag if called from trainer
                 self._is_setup = True
 
+        self._update_augmentations()
+
+    def _update_augmentations(self) -> None:
+        """Update the augmentations for each subset."""
+        for subset_name in ["train", "val", "test"]:
+            subset = getattr(self, f"{subset_name}_data", None)
+            augmentations = getattr(self, f"{subset_name}_augmentations", None)
+            model_transform = get_nested_attr(self, "trainer.model.pre_processor.transform")
+            if subset and model_transform:
+                self._update_subset_augmentations(subset, augmentations, model_transform)
+
+    @staticmethod
+    def _update_subset_augmentations(
+        dataset: AnomalibDataset,
+        augmentations: Transform | None,
+        model_transform: Transform,
+    ) -> None:
+        """Update the augmentations of the dataset.
+
+        This method passes the user-specified augmentations to a dataset subset. If the model transforms contain
+        a Resize transform, it will be appended to the augmentations. This will ensure that resizing takes place
+        before collating, which reduces the usage of shared memory by the Dataloader workers.
+
+        Args:
+            dataset (AnomalibDataset): Dataset to update.
+            augmentations (Transform): Augmentations to apply to the dataset.
+            model_transform (Transform): Transform object from the model PreProcessor.
+        """
+        model_resizes = extract_transforms_by_type(model_transform, Resize)
+
+        if model_resizes:
+            model_resize = model_resizes[0]
+            for aug_resize in extract_transforms_by_type(augmentations, Resize):  # warn user if resizes inconsistent
+                if model_resize.size != aug_resize.size:
+                    msg = f"Conflicting resize shapes found between augmentations and model transforms. You are using \
+                        a Resize transform in your input data augmentations. Please be aware that the model also \
+                        applies a Resize transform with a different output size. The final effective input size as \
+                        seen by the model will be determined by the model transforms, not the augmentations. To change \
+                        the effective input size, please change the model transforms in the PreProcessor module. \
+                        Augmentations: {aug_resize.size}, Model transforms: {model_transform.size}"
+                    logger.warning(msg)
+                if model_resize.interpolation != aug_resize.interpolation:
+                    msg = f"Conflicting interpolation method found between augmentations and model transforms. You are \
+                        using a Resize transform in your input data augmentations. Please be aware that the model also \
+                        applies a Resize transform with a different interpolation method. Using multiple interpolation \
+                        methods can lead to unexpected behaviour, so it is recommended to use the same interpolation \
+                        method between augmentations and model transforms. Augmentations: {aug_resize.interpolation}, \
+                        Model transforms: {model_resize.interpolation}"
+                    logger.warning(msg)
+                if model_resize.antialias != aug_resize.antialias:
+                    msg = f"Conflicting antialiasing setting found between augmentations and model transforms. You are \
+                        using a Resize transform in your input data augmentations. Please be aware that the model also \
+                        applies a Resize transform with a different antialising setting. Using conflicting \
+                        antialiasing settings can lead to unexpected behaviour, so it is recommended to use the same \
+                        antialiasing setting between augmentations and model transforms. Augmentations: \
+                        antialias={aug_resize.antialias}, Model transforms: antialias={model_resize.antialias}"
+                    logger.warning(msg)
+
+            # append model resize to augmentations
+            if isinstance(augmentations, Resize):
+                augmentations = model_resize
+            elif isinstance(augmentations, Compose):
+                augmentations = Compose([*augmentations.transforms, model_resize])
+            elif isinstance(augmentations, Transform):
+                augmentations = Compose([augmentations, model_resize])
+            elif augmentations is None:
+                augmentations = model_resize
+
+        dataset.augmentations = augmentations
+
     @abstractmethod
     def _setup(self, _stage: str | None = None) -> None:
         """Set up the datasets and perform dynamic subset splitting.
@@ -244,8 +334,8 @@ def _create_val_split(self) -> None:
                 seed=self.seed,
             )
         elif self.val_split_mode == ValSplitMode.SAME_AS_TEST:
-            # use test set as validation
-            self.val_data = self.test_data
+            # equal to test set
+            self.val_data = copy.deepcopy(self.test_data)
         elif self.val_split_mode == ValSplitMode.SYNTHETIC:
             # create synthetic anomalies from training samples
             self.train_data, normal_val_data = random_split(
diff --git a/src/anomalib/data/datamodules/depth/folder_3d.py b/src/anomalib/data/datamodules/depth/folder_3d.py
index fd1fd7afff..c9aa941a8a 100644
--- a/src/anomalib/data/datamodules/depth/folder_3d.py
+++ b/src/anomalib/data/datamodules/depth/folder_3d.py
@@ -20,6 +20,8 @@
 
 from pathlib import Path
 
+from torchvision.transforms.v2 import Transform
+
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.depth.folder_3d import Folder3DDataset
 from anomalib.data.utils import Split, TestSplitMode, ValSplitMode
@@ -56,6 +58,14 @@ class Folder3D(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers for data loading.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         test_split_mode (TestSplitMode | str, optional): Method to create test
             set. Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float, optional): Fraction of data for testing.
@@ -83,6 +93,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
@@ -93,6 +107,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
diff --git a/src/anomalib/data/datamodules/depth/mvtec_3d.py b/src/anomalib/data/datamodules/depth/mvtec_3d.py
index afdf981d96..57e97010bd 100644
--- a/src/anomalib/data/datamodules/depth/mvtec_3d.py
+++ b/src/anomalib/data/datamodules/depth/mvtec_3d.py
@@ -33,6 +33,8 @@
 import logging
 from pathlib import Path
 
+from torchvision.transforms.v2 import Transform
+
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.depth.mvtec_3d import MVTec3DDataset
 from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
@@ -62,6 +64,14 @@ class MVTec3D(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers for data loading.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         test_split_mode (TestSplitMode | str): Method to create test set.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of data to use for testing.
@@ -81,6 +91,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -91,6 +105,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
diff --git a/src/anomalib/data/datamodules/image/btech.py b/src/anomalib/data/datamodules/image/btech.py
index 367b6a1489..f66ab8e190 100644
--- a/src/anomalib/data/datamodules/image/btech.py
+++ b/src/anomalib/data/datamodules/image/btech.py
@@ -43,6 +43,7 @@
 from pathlib import Path
 
 import cv2
+from torchvision.transforms.v2 import Transform
 from tqdm import tqdm
 
 from anomalib.data.datamodules.base.image import AnomalibDataModule
@@ -73,6 +74,14 @@ class BTech(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         test_split_mode (TestSplitMode): Setting that determines how the testing
             subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
@@ -135,6 +144,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -145,6 +158,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
diff --git a/src/anomalib/data/datamodules/image/datumaro.py b/src/anomalib/data/datamodules/image/datumaro.py
index 8865ad7c91..2fa9352b99 100644
--- a/src/anomalib/data/datamodules/image/datumaro.py
+++ b/src/anomalib/data/datamodules/image/datumaro.py
@@ -40,6 +40,8 @@
 
 from pathlib import Path
 
+from torchvision.transforms.v2 import Transform
+
 from anomalib.data.datamodules.base import AnomalibDataModule
 from anomalib.data.datasets.image.datumaro import DatumaroDataset
 from anomalib.data.utils import Split, TestSplitMode, ValSplitMode
@@ -56,6 +58,16 @@ class Datumaro(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
+        image_size (tuple[int, int], optional): Size to which input images should be resized.
+            Defaults to ``None``.
         test_split_mode (TestSplitMode): Setting that determines how the testing
             subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
@@ -92,6 +104,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.5,
         val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
@@ -102,6 +118,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             val_split_mode=val_split_mode,
             val_split_ratio=val_split_ratio,
             test_split_mode=test_split_mode,
diff --git a/src/anomalib/data/datamodules/image/folder.py b/src/anomalib/data/datamodules/image/folder.py
index 9cb2d0e430..2b037dce17 100644
--- a/src/anomalib/data/datamodules/image/folder.py
+++ b/src/anomalib/data/datamodules/image/folder.py
@@ -35,6 +35,8 @@
 from collections.abc import Sequence
 from pathlib import Path
 
+from torchvision.transforms.v2 import Transform
+
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.folder import FolderDataset
 from anomalib.data.utils import Split, TestSplitMode, ValSplitMode
@@ -65,6 +67,14 @@ class Folder(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int): Number of workers for data loading.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         test_split_mode (TestSplitMode): Method to obtain test subset.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of train images for testing.
@@ -115,6 +125,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.FROM_TEST,
@@ -134,6 +148,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
diff --git a/src/anomalib/data/datamodules/image/kolektor.py b/src/anomalib/data/datamodules/image/kolektor.py
index 980e0ac4b4..64bb8bc79e 100644
--- a/src/anomalib/data/datamodules/image/kolektor.py
+++ b/src/anomalib/data/datamodules/image/kolektor.py
@@ -23,6 +23,8 @@
 import logging
 from pathlib import Path
 
+from torchvision.transforms.v2 import Transform
+
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.kolektor import KolektorDataset
 from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
@@ -49,6 +51,14 @@ class Kolektor(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         test_split_mode (TestSplitMode): Setting that determines how the testing
             subset is obtained.
             Defaults to ``TestSplitMode.FROM_DIR``.
@@ -63,7 +73,6 @@ class Kolektor(AnomalibDataModule):
             Defaults to ``0.5``.
         seed (int | None, optional): Seed which may be set to a fixed value for
             reproducibility.
-            Defaults to ``None``.
 
     Example:
         >>> from anomalib.data import Kolektor
@@ -85,6 +94,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -95,6 +108,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
diff --git a/src/anomalib/data/datamodules/image/mvtec.py b/src/anomalib/data/datamodules/image/mvtec.py
index b412e38c04..5c4332b69b 100644
--- a/src/anomalib/data/datamodules/image/mvtec.py
+++ b/src/anomalib/data/datamodules/image/mvtec.py
@@ -48,6 +48,8 @@
 import logging
 from pathlib import Path
 
+from torchvision.transforms.v2 import Transform
+
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.mvtec import MVTecDataset
 from anomalib.data.utils import DownloadInfo, Split, TestSplitMode, ValSplitMode, download_and_extract
@@ -77,6 +79,14 @@ class MVTec(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         test_split_mode (TestSplitMode): Method to create test set.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of data to use for testing.
@@ -126,6 +136,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -136,6 +150,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
diff --git a/src/anomalib/data/datamodules/image/visa.py b/src/anomalib/data/datamodules/image/visa.py
index c359eb7600..80a0b9b1d3 100644
--- a/src/anomalib/data/datamodules/image/visa.py
+++ b/src/anomalib/data/datamodules/image/visa.py
@@ -50,6 +50,7 @@
 from pathlib import Path
 
 import cv2
+from torchvision.transforms.v2 import Transform
 
 from anomalib.data.datamodules.base.image import AnomalibDataModule
 from anomalib.data.datasets.image.visa import VisaDataset
@@ -78,6 +79,14 @@ class Visa(AnomalibDataModule):
             Defaults to ``32``.
         num_workers (int, optional): Number of workers for data loading.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         test_split_mode (TestSplitMode | str): Method to create test set.
             Defaults to ``TestSplitMode.FROM_DIR``.
         test_split_ratio (float): Fraction of data to use for testing.
@@ -97,6 +106,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         test_split_mode: TestSplitMode | str = TestSplitMode.FROM_DIR,
         test_split_ratio: float = 0.2,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
@@ -107,6 +120,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             test_split_mode=test_split_mode,
             test_split_ratio=test_split_ratio,
             val_split_mode=val_split_mode,
diff --git a/src/anomalib/data/datamodules/video/avenue.py b/src/anomalib/data/datamodules/video/avenue.py
index f91f5dd384..218db6bc0a 100644
--- a/src/anomalib/data/datamodules/video/avenue.py
+++ b/src/anomalib/data/datamodules/video/avenue.py
@@ -61,6 +61,7 @@
 
 import cv2
 import scipy.io
+from torchvision.transforms.v2 import Transform
 
 from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
 from anomalib.data.datasets.base.video import VideoTargetFrame
@@ -101,6 +102,14 @@ class Avenue(AnomalibVideoDataModule):
             Defaults to ``32``.
         num_workers (int): Number of workers.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         val_split_mode (ValSplitMode | str): How validation subset is obtained.
             Defaults to ``ValSplitMode.SAME_AS_TEST``.
         val_split_ratio (float): Fraction of data reserved for validation.
@@ -138,6 +147,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         val_split_mode: ValSplitMode | str = ValSplitMode.SAME_AS_TEST,
         val_split_ratio: float = 0.5,
         seed: int | None = None,
@@ -146,6 +159,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             val_split_mode=val_split_mode,
             val_split_ratio=val_split_ratio,
             seed=seed,
diff --git a/src/anomalib/data/datamodules/video/shanghaitech.py b/src/anomalib/data/datamodules/video/shanghaitech.py
index babd338fc0..72b7f2a6ac 100644
--- a/src/anomalib/data/datamodules/video/shanghaitech.py
+++ b/src/anomalib/data/datamodules/video/shanghaitech.py
@@ -49,6 +49,8 @@
 from pathlib import Path
 from shutil import move
 
+from torchvision.transforms.v2 import Transform
+
 from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
 from anomalib.data.datasets.base.video import VideoTargetFrame
 from anomalib.data.datasets.video.shanghaitech import ShanghaiTechDataset
@@ -85,6 +87,14 @@ class ShanghaiTech(AnomalibVideoDataModule):
             Defaults to ``32``.
         num_workers (int): Number of workers for data loading.
             Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         val_split_mode (ValSplitMode): Setting that determines how validation
             subset is obtained.
             Defaults to ``ValSplitMode.SAME_AS_TEST``.
@@ -105,6 +115,10 @@ def __init__(
         train_batch_size: int = 32,
         eval_batch_size: int = 32,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         val_split_mode: ValSplitMode = ValSplitMode.SAME_AS_TEST,
         val_split_ratio: float = 0.5,
         seed: int | None = None,
@@ -113,6 +127,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             val_split_mode=val_split_mode,
             val_split_ratio=val_split_ratio,
             seed=seed,
diff --git a/src/anomalib/data/datamodules/video/ucsd_ped.py b/src/anomalib/data/datamodules/video/ucsd_ped.py
index e4bd9cf15e..ff5f72f604 100644
--- a/src/anomalib/data/datamodules/video/ucsd_ped.py
+++ b/src/anomalib/data/datamodules/video/ucsd_ped.py
@@ -12,6 +12,8 @@
 from pathlib import Path
 from shutil import move
 
+from torchvision.transforms.v2 import Transform
+
 from anomalib.data.datamodules.base.video import AnomalibVideoDataModule
 from anomalib.data.datasets.base.video import VideoTargetFrame
 from anomalib.data.datasets.video.ucsd_ped import UCSDpedDataset
@@ -44,6 +46,14 @@ class UCSDped(AnomalibVideoDataModule):
         eval_batch_size (int): Batch size for validation and testing.
             Defaults to ``8``.
         num_workers (int): Number of workers for data loading. Defaults to ``8``.
+        train_augmentations (Transform | None): Augmentations to apply dto the training images
+            Defaults to ``None``.
+        val_augmentations (Transform | None): Augmentations to apply to the validation images.
+            Defaults to ``None``.
+        test_augmentations (Transform | None): Augmentations to apply to the test images.
+            Defaults to ``None``.
+        augmentations (Transform | None): General augmentations to apply if stage-specific
+            augmentations are not provided.
         val_split_mode (ValSplitMode): Determines how validation set is created.
             Defaults to ``ValSplitMode.SAME_AS_TEST``.
         val_split_ratio (float): Fraction of data to use for validation.
@@ -68,6 +78,10 @@ def __init__(
         train_batch_size: int = 8,
         eval_batch_size: int = 8,
         num_workers: int = 8,
+        train_augmentations: Transform | None = None,
+        val_augmentations: Transform | None = None,
+        test_augmentations: Transform | None = None,
+        augmentations: Transform | None = None,
         val_split_mode: ValSplitMode = ValSplitMode.SAME_AS_TEST,
         val_split_ratio: float = 0.5,
         seed: int | None = None,
@@ -76,6 +90,10 @@ def __init__(
             train_batch_size=train_batch_size,
             eval_batch_size=eval_batch_size,
             num_workers=num_workers,
+            train_augmentations=train_augmentations,
+            val_augmentations=val_augmentations,
+            test_augmentations=test_augmentations,
+            augmentations=augmentations,
             val_split_mode=val_split_mode,
             val_split_ratio=val_split_ratio,
             seed=seed,
diff --git a/src/anomalib/data/datasets/base/depth.py b/src/anomalib/data/datasets/base/depth.py
index d15bcdac1b..914c46c5ec 100644
--- a/src/anomalib/data/datasets/base/depth.py
+++ b/src/anomalib/data/datasets/base/depth.py
@@ -30,8 +30,7 @@ class AnomalibDepthDataset(AnomalibDataset, ABC):
     detection tasks. It supports both classification and segmentation tasks.
 
     Args:
-        transform (Transform | None, optional): Transforms to be applied to the
-            input images and depth maps. If ``None``, no transforms are applied.
+        augmentations (Transform, optional): Augmentations that should be applied to the input images.
             Defaults to ``None``.
 
     Example:
@@ -44,10 +43,10 @@ class AnomalibDepthDataset(AnomalibDataset, ABC):
         torch.Size([1, H, W])
     """
 
-    def __init__(self, transform: Transform | None = None) -> None:
-        super().__init__(transform)
+    def __init__(self, augmentations: Transform | None = None) -> None:
+        super().__init__(augmentations=augmentations)
 
-        self.transform = transform
+        self.augmentations = augmentations
 
     def __getitem__(self, index: int) -> DepthItem:
         """Get dataset item for the given index.
@@ -80,7 +79,7 @@ def __getitem__(self, index: int) -> DepthItem:
 
         if self.task == TaskType.CLASSIFICATION:
             item["image"], item["depth_image"] = (
-                self.transform(image, depth_image) if self.transform else (image, depth_image)
+                self.augmentations(image, depth_image) if self.augmentations else (image, depth_image)
             )
         elif self.task == TaskType.SEGMENTATION:
             # Only Anomalous (1) images have masks in anomaly datasets
@@ -91,7 +90,7 @@ def __getitem__(self, index: int) -> DepthItem:
                 else Mask(to_tensor(Image.open(mask_path)).squeeze())
             )
             item["image"], item["depth_image"], item["mask"] = (
-                self.transform(image, depth_image, mask) if self.transform else (image, depth_image, mask)
+                self.augmentations(image, depth_image, mask) if self.augmentations else (image, depth_image, mask)
             )
             item["mask_path"] = mask_path
 
diff --git a/src/anomalib/data/datasets/base/image.py b/src/anomalib/data/datasets/base/image.py
index 4c5267ea2c..98ead065f4 100644
--- a/src/anomalib/data/datasets/base/image.py
+++ b/src/anomalib/data/datasets/base/image.py
@@ -71,13 +71,17 @@ class AnomalibDataset(Dataset, ABC):
         torch.Size([3, 256, 256])
 
     Note:
-        This is an abstract base class. Subclasses must implement the required methods and
-        set the samples DataFrame.
+        The example above is illustrative and may need to be adjusted based on the specific dataset structure.
+
+    Args:
+        task (str): Task type, either 'classification' or 'segmentation'
+        augmentations (Transform, optional): Augmentations that should be applied to the input images.
+            Defaults to ``None``.
     """
 
-    def __init__(self, transform: Transform | None = None) -> None:
+    def __init__(self, augmentations: Transform | None = None) -> None:
         super().__init__()
-        self.transform = transform
+        self.augmentations = augmentations
         self._samples: DataFrame | None = None
         self._category: str | None = None
 
@@ -267,7 +271,7 @@ def __getitem__(self, index: int) -> DatasetItem:
         item = {"image_path": image_path, "gt_label": label_index}
 
         if self.task == TaskType.CLASSIFICATION:
-            item["image"] = self.transform(image) if self.transform else image
+            item["image"] = self.augmentations(image) if self.augmentations else image
         elif self.task == TaskType.SEGMENTATION:
             # Only Anomalous (1) images have masks in anomaly datasets
             # Therefore, create empty mask for Normal (0) images.
@@ -276,7 +280,7 @@ def __getitem__(self, index: int) -> DatasetItem:
                 if label_index == LabelName.NORMAL
                 else read_mask(mask_path, as_tensor=True)
             )
-            item["image"], item["gt_mask"] = self.transform(image, mask) if self.transform else (image, mask)
+            item["image"], item["gt_mask"] = self.augmentations(image, mask) if self.augmentations else (image, mask)
 
         else:
             msg = f"Unknown task type: {self.task}"
diff --git a/src/anomalib/data/datasets/base/video.py b/src/anomalib/data/datasets/base/video.py
index 2e675aa717..8b4da1d763 100644
--- a/src/anomalib/data/datasets/base/video.py
+++ b/src/anomalib/data/datasets/base/video.py
@@ -65,8 +65,8 @@ class AnomalibVideoDataset(AnomalibDataset, ABC):
         clip_length_in_frames (int): Number of video frames in each clip.
         frames_between_clips (int): Number of frames between each consecutive
             video clip.
-        transform (Transform | None, optional): Transforms to be applied to the
-            input clips. Defaults to ``None``.
+        augmentations (Transform, optional): Augmentations that should be applied to the input clips.
+            Defaults to ``None``.
         target_frame (VideoTargetFrame, optional): Specifies the target frame in
             the video clip, used for ground truth retrieval.
             Defaults to ``VideoTargetFrame.LAST``.
@@ -88,14 +88,14 @@ def __init__(
         self,
         clip_length_in_frames: int,
         frames_between_clips: int,
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
     ) -> None:
-        super().__init__(transform)
+        super().__init__(augmentations=augmentations)
 
         self.clip_length_in_frames = clip_length_in_frames
         self.frames_between_clips = frames_between_clips
-        self.transform = transform
+        self.augmentations = augmentations
 
         self.indexer: ClipsIndexer | None = None
         self.indexer_cls: Callable | None = None
@@ -211,11 +211,11 @@ def __getitem__(self, index: int) -> VideoItem:
 
         # apply transforms
         if item.gt_mask is not None:
-            if self.transform:
-                item.image, item.gt_mask = self.transform(item.image, Mask(item.gt_mask))
+            if self.augmentations:
+                item.image, item.gt_mask = self.augmentations(item.image, Mask(item.gt_mask))
             item.gt_label = torch.Tensor([1 in frame for frame in item.gt_mask]).int().squeeze(0)
-        elif self.transform:
-            item.image = self.transform(item.image)
+        elif self.augmentations:
+            item.image = self.augmentations(item.image)
 
         # squeeze temporal dimensions in case clip length is 1
         item.image = item.image.squeeze(0)
diff --git a/src/anomalib/data/datasets/depth/folder_3d.py b/src/anomalib/data/datasets/depth/folder_3d.py
index 5e5d15b3b8..b55e5d201c 100644
--- a/src/anomalib/data/datasets/depth/folder_3d.py
+++ b/src/anomalib/data/datasets/depth/folder_3d.py
@@ -61,7 +61,7 @@ class Folder3DDataset(AnomalibDepthDataset):
             containing depth maps for abnormal images. Defaults to ``None``.
         normal_test_depth_dir (str | Path | None, optional): Path to directory
             containing depth maps for normal test images. Defaults to ``None``.
-        transform (Transform | None, optional): Transforms to apply to the images.
+        augmentations (Transform, optional): Augmentations that should be applied to the input images.
             Defaults to ``None``.
         split (str | Split | None, optional): Dataset split to load.
             One of ``["train", "test", "full"]``. Defaults to ``None``.
@@ -91,11 +91,11 @@ def __init__(
         normal_depth_dir: str | Path | None = None,
         abnormal_depth_dir: str | Path | None = None,
         normal_test_depth_dir: str | Path | None = None,
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         split: str | Split | None = None,
         extensions: tuple[str, ...] | None = None,
     ) -> None:
-        super().__init__(transform)
+        super().__init__(augmentations=augmentations)
 
         self._name = name
         self.split = split
diff --git a/src/anomalib/data/datasets/depth/mvtec_3d.py b/src/anomalib/data/datasets/depth/mvtec_3d.py
index 52873a0e8d..87cad4e107 100644
--- a/src/anomalib/data/datasets/depth/mvtec_3d.py
+++ b/src/anomalib/data/datasets/depth/mvtec_3d.py
@@ -53,7 +53,7 @@ class MVTec3DDataset(AnomalibDepthDataset):
             Defaults to ``"./datasets/MVTec3D"``.
         category (str): Category name, e.g. ``"bagel"``.
             Defaults to ``"bagel"``.
-        transform (Transform, optional): Transforms applied to input images.
+        augmentations (Transform, optional): Augmentations that should be applied to the input images.
             Defaults to ``None``.
         split (str | Split | None): Dataset split - usually ``Split.TRAIN`` or
             ``Split.TEST``. Defaults to ``None``.
@@ -71,10 +71,10 @@ def __init__(
         self,
         root: Path | str = "./datasets/MVTec3D",
         category: str = "bagel",
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(transform=transform)
+        super().__init__(augmentations=augmentations)
 
         self.root_category = Path(root) / Path(category)
         self.split = split
diff --git a/src/anomalib/data/datasets/image/btech.py b/src/anomalib/data/datasets/image/btech.py
index 04e4278491..1ee8168857 100644
--- a/src/anomalib/data/datasets/image/btech.py
+++ b/src/anomalib/data/datasets/image/btech.py
@@ -74,10 +74,10 @@ def __init__(
         self,
         root: str | Path,
         category: str,
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(transform)
+        super().__init__(augmentations=augmentations)
 
         self.root_category = Path(root) / category
         self.split = split
diff --git a/src/anomalib/data/datasets/image/datumaro.py b/src/anomalib/data/datasets/image/datumaro.py
index e6a65c0c54..8a26dd0e16 100644
--- a/src/anomalib/data/datasets/image/datumaro.py
+++ b/src/anomalib/data/datasets/image/datumaro.py
@@ -131,9 +131,9 @@ class DatumaroDataset(AnomalibDataset):
     def __init__(
         self,
         root: str | Path,
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(transform)
+        super().__init__(augmentations=augmentations)
         self.split = split
         self.samples = make_datumaro_dataset(root, split)
diff --git a/src/anomalib/data/datasets/image/folder.py b/src/anomalib/data/datasets/image/folder.py
index dc64e06af8..e3978000d2 100644
--- a/src/anomalib/data/datasets/image/folder.py
+++ b/src/anomalib/data/datasets/image/folder.py
@@ -90,7 +90,7 @@ def __init__(
         self,
         name: str,
         normal_dir: str | Path | Sequence[str | Path],
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         root: str | Path | None = None,
         abnormal_dir: str | Path | Sequence[str | Path] | None = None,
         normal_test_dir: str | Path | Sequence[str | Path] | None = None,
@@ -98,7 +98,7 @@ def __init__(
         split: str | Split | None = None,
         extensions: tuple[str, ...] | None = None,
     ) -> None:
-        super().__init__(transform)
+        super().__init__(augmentations=augmentations)
 
         self._name = name
         self.split = split
diff --git a/src/anomalib/data/datasets/image/kolektor.py b/src/anomalib/data/datasets/image/kolektor.py
index a5ddfe6d97..60a434661d 100644
--- a/src/anomalib/data/datasets/image/kolektor.py
+++ b/src/anomalib/data/datasets/image/kolektor.py
@@ -56,10 +56,10 @@ class KolektorDataset(AnomalibDataset):
     def __init__(
         self,
         root: Path | str = "./datasets/kolektor",
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(transform=transform)
+        super().__init__(augmentations=augmentations)
 
         self.root = root
         self.split = split
diff --git a/src/anomalib/data/datasets/image/mvtec.py b/src/anomalib/data/datasets/image/mvtec.py
index 63b95bee61..d651661ca0 100644
--- a/src/anomalib/data/datasets/image/mvtec.py
+++ b/src/anomalib/data/datasets/image/mvtec.py
@@ -68,7 +68,7 @@ class MVTecDataset(AnomalibDataset):
             Defaults to ``"./datasets/MVTec"``.
         category (str): Category name, must be one of ``CATEGORIES``.
             Defaults to ``"bottle"``.
-        transform (Transform | None, optional): Transforms to apply to the images.
+        augmentations (Transform, optional): Augmentations that should be applied to the input images.
             Defaults to ``None``.
         split (str | Split | None, optional): Dataset split - usually
             ``Split.TRAIN`` or ``Split.TEST``. Defaults to ``None``.
@@ -106,10 +106,10 @@ def __init__(
         self,
         root: Path | str = "./datasets/MVTec",
         category: str = "bottle",
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(transform=transform)
+        super().__init__(augmentations=augmentations)
 
         self.root_category = Path(root) / Path(category)
         self.category = category
diff --git a/src/anomalib/data/datasets/image/visa.py b/src/anomalib/data/datasets/image/visa.py
index fa182bfc19..d07942945d 100644
--- a/src/anomalib/data/datasets/image/visa.py
+++ b/src/anomalib/data/datasets/image/visa.py
@@ -79,10 +79,10 @@ def __init__(
         self,
         root: str | Path,
         category: str,
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         split: str | Split | None = None,
     ) -> None:
-        super().__init__(transform=transform)
+        super().__init__(augmentations=augmentations)
 
         self.root_category = Path(root) / category
         self.split = split
diff --git a/src/anomalib/data/datasets/video/avenue.py b/src/anomalib/data/datasets/video/avenue.py
index 67c0b51efd..26ed0ed16c 100644
--- a/src/anomalib/data/datasets/video/avenue.py
+++ b/src/anomalib/data/datasets/video/avenue.py
@@ -74,8 +74,8 @@ class AvenueDataset(AnomalibVideoDataset):
         target_frame (VideoTargetFrame, optional): Target frame in the video
             clip for ground truth retrieval. Defaults to
             ``VideoTargetFrame.LAST``.
-        transform (Transform | None, optional): Transforms to apply to the input
-            images. Defaults to ``None``.
+        augmentations (Transform, optional): Augmentations that should be applied to the input images.
+            Defaults to ``None``.
 
     Example:
         Create a dataset for testing:
@@ -98,14 +98,14 @@ def __init__(
         gt_dir: Path | str = "./datasets/avenue/ground_truth_demo",
         clip_length_in_frames: int = 2,
         frames_between_clips: int = 1,
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
     ) -> None:
         super().__init__(
             clip_length_in_frames=clip_length_in_frames,
             frames_between_clips=frames_between_clips,
             target_frame=target_frame,
-            transform=transform,
+            augmentations=augmentations,
         )
 
         self.root = root if isinstance(root, Path) else Path(root)
diff --git a/src/anomalib/data/datasets/video/shanghaitech.py b/src/anomalib/data/datasets/video/shanghaitech.py
index c1fad64c20..57302b920a 100644
--- a/src/anomalib/data/datasets/video/shanghaitech.py
+++ b/src/anomalib/data/datasets/video/shanghaitech.py
@@ -91,8 +91,8 @@ class ShanghaiTechDataset(AnomalibVideoDataset):
             consecutive video clip. Defaults to ``1``.
         target_frame (VideoTargetFrame): Specifies which frame in the clip to use
             for ground truth retrieval. Defaults to ``VideoTargetFrame.LAST``.
-        transform (Transform | None, optional): Transforms to apply to the input
-            images. Defaults to ``None``.
+        augmentations (Transform, optional): Augmentations that should be applied to the input images.
+            Defaults to ``None``.
 
     Example:
         >>> from anomalib.data.datasets import ShanghaiTechDataset
@@ -112,13 +112,13 @@ def __init__(
         clip_length_in_frames: int = 2,
         frames_between_clips: int = 1,
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
     ) -> None:
         super().__init__(
             clip_length_in_frames=clip_length_in_frames,
             frames_between_clips=frames_between_clips,
             target_frame=target_frame,
-            transform=transform,
+            augmentations=augmentations,
         )
 
         self.root = Path(root)
diff --git a/src/anomalib/data/datasets/video/ucsd_ped.py b/src/anomalib/data/datasets/video/ucsd_ped.py
index ffc2ab8c18..90dad16bbc 100644
--- a/src/anomalib/data/datasets/video/ucsd_ped.py
+++ b/src/anomalib/data/datasets/video/ucsd_ped.py
@@ -94,7 +94,7 @@ class UCSDpedDataset(AnomalibVideoDataset):
         target_frame (VideoTargetFrame): Specifies the target frame in the video
             clip, used for ground truth retrieval. Defaults to
             ``VideoTargetFrame.LAST``.
-        transform (Transform | None, optional): Transforms to apply to the images.
+        augmentations (Transform, optional): Augmentations that should be applied to the input images.
             Defaults to ``None``.
 
     Example:
@@ -118,13 +118,13 @@ def __init__(
         clip_length_in_frames: int = 2,
         frames_between_clips: int = 10,
         target_frame: VideoTargetFrame = VideoTargetFrame.LAST,
-        transform: Transform | None = None,
+        augmentations: Transform | None = None,
     ) -> None:
         super().__init__(
             clip_length_in_frames=clip_length_in_frames,
             frames_between_clips=frames_between_clips,
             target_frame=target_frame,
-            transform=transform,
+            augmentations=augmentations,
         )
 
         self.root_category = Path(root) / category
diff --git a/src/anomalib/data/transforms/utils.py b/src/anomalib/data/transforms/utils.py
new file mode 100644
index 0000000000..5ef1e9b0ec
--- /dev/null
+++ b/src/anomalib/data/transforms/utils.py
@@ -0,0 +1,26 @@
+"""Utility functions for working with Torchvision Transforms."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from torchvision.transforms.v2 import Compose, Transform
+
+
+def extract_transforms_by_type(
+    input_transform: Transform | None,
+    transform_type: type[Transform],
+) -> list[type[Transform]]:
+    """Extracts all transforms of a given type from a transform or transform composition.
+
+    Args:
+        input_transform (Transform): Torchvision Transform instance.
+        transform_type (Type[Transform]): Type of transform to retrieve.
+
+    Returns:
+        List[Transform]: List of Resize transform instances.
+    """
+    if isinstance(input_transform, transform_type):
+        return [input_transform]
+    if isinstance(input_transform, Compose):
+        return [transform for transform in input_transform.transforms if isinstance(transform, transform_type)]
+    return []
diff --git a/src/anomalib/data/utils/synthetic.py b/src/anomalib/data/utils/synthetic.py
index fb347aa157..befc3abfe9 100644
--- a/src/anomalib/data/utils/synthetic.py
+++ b/src/anomalib/data/utils/synthetic.py
@@ -32,7 +32,7 @@
 import cv2
 import pandas as pd
 from pandas import DataFrame, Series
-from torchvision.transforms.v2 import Compose
+from torchvision.transforms.v2 import Transform
 
 from anomalib.data.datasets.base.image import AnomalibDataset
 from anomalib.data.utils import Split, read_image
@@ -155,7 +155,7 @@ class SyntheticAnomalyDataset(AnomalibDataset):
     object is deleted.
 
     Args:
-        transform: Transform object describing the transforms applied to inputs.
+        augmentations (Transform | None): Transform object describing the input data augmentations.
         source_samples: DataFrame containing normal samples used as source for
             synthetic anomalies.
 
@@ -169,8 +169,8 @@ class SyntheticAnomalyDataset(AnomalibDataset):
         100
     """
 
-    def __init__(self, transform: Compose, source_samples: DataFrame) -> None:
-        super().__init__(transform)
+    def __init__(self, augmentations: Transform | None, source_samples: DataFrame) -> None:
+        super().__init__(augmentations=augmentations)
 
         self.source_samples = source_samples
 
@@ -212,7 +212,7 @@ def from_dataset(
             >>> normal_dataset = Dataset(...)
             >>> synthetic = SyntheticAnomalyDataset.from_dataset(normal_dataset)
         """
-        return cls(transform=dataset.transform, source_samples=dataset.samples)
+        return cls(augmentations=dataset.augmentations, source_samples=dataset.samples)
 
     def __copy__(self) -> "SyntheticAnomalyDataset":
         """Return shallow copy and prevent cleanup of original.
diff --git a/src/anomalib/models/components/base/anomalib_module.py b/src/anomalib/models/components/base/anomalib_module.py
index f1f87c75ef..a0251c4e64 100644
--- a/src/anomalib/models/components/base/anomalib_module.py
+++ b/src/anomalib/models/components/base/anomalib_module.py
@@ -58,7 +58,6 @@
 from anomalib.data import Batch, InferenceBatch
 from anomalib.metrics import AUROC, F1Score
 from anomalib.metrics.evaluator import Evaluator
-from anomalib.metrics.threshold import Threshold
 from anomalib.post_processing import OneClassPostProcessor, PostProcessor
 from anomalib.pre_processing import PreProcessor
 from anomalib.visualization import ImageVisualizer, Visualizer
@@ -409,7 +408,7 @@ def input_size(self) -> tuple[int, int] | None:
             >>> model.input_size  # Returns size after pre-processing
             (256, 256)
         """
-        transform = self.pre_processor.predict_transform if self.pre_processor else None
+        transform = self.pre_processor.transform if self.pre_processor else None
         if transform is None:
             return None
         dummy_input = torch.zeros(1, 3, 1, 1)
@@ -461,9 +460,6 @@ def from_config(
             help="Path to a configuration file in json or yaml format.",
         )
         model_parser.add_subclass_arguments(AnomalibModule, "model", required=False, fail_untyped=False)
-        model_parser.add_argument("--metrics.image", type=list[str] | str | None, default=["F1Score", "AUROC"])
-        model_parser.add_argument("--metrics.pixel", type=list[str] | str | None, default=None, required=False)
-        model_parser.add_argument("--metrics.threshold", type=Threshold | str, default="F1AdaptiveThreshold")
         model_parser.add_class_arguments(Trainer, "trainer", fail_untyped=False, instantiate=False, sub_configs=True)
         args = ["--config", str(config_path)]
         for key, value in kwargs.items():
diff --git a/src/anomalib/models/image/efficient_ad/lightning_model.py b/src/anomalib/models/image/efficient_ad/lightning_model.py
index a75f889ec3..5a0c6c5ee3 100644
--- a/src/anomalib/models/image/efficient_ad/lightning_model.py
+++ b/src/anomalib/models/image/efficient_ad/lightning_model.py
@@ -49,6 +49,7 @@
 
 from anomalib import LearningType
 from anomalib.data import Batch
+from anomalib.data.transforms.utils import extract_transforms_by_type
 from anomalib.data.utils import DownloadInfo, download_and_extract
 from anomalib.metrics import Evaluator
 from anomalib.models.components import AnomalibModule
@@ -365,11 +366,9 @@ def on_train_start(self) -> None:
             msg = "train_batch_size for EfficientAd should be 1."
             raise ValueError(msg)
 
-        if self.pre_processor and self.pre_processor.train_transform:
-            transforms = self.pre_processor.train_transform.transforms
-            if transforms and any(isinstance(transform, Normalize) for transform in transforms):
-                msg = "Transforms for EfficientAd should not contain Normalize."
-                raise ValueError(msg)
+        if self.pre_processor and extract_transforms_by_type(self.pre_processor.transform, Normalize):
+            msg = "Transforms for EfficientAd should not contain Normalize."
+            raise ValueError(msg)
 
         sample = next(iter(self.trainer.train_dataloader))
         image_size = sample.image.shape[-2:]
diff --git a/src/anomalib/models/image/winclip/lightning_model.py b/src/anomalib/models/image/winclip/lightning_model.py
index 1bdf7686db..ebc8e46853 100644
--- a/src/anomalib/models/image/winclip/lightning_model.py
+++ b/src/anomalib/models/image/winclip/lightning_model.py
@@ -304,7 +304,7 @@ def configure_pre_processor(cls, image_size: tuple[int, int] | None = None) -> P
             Resize((240, 240), antialias=True, interpolation=InterpolationMode.BICUBIC),
             Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711)),
         ])
-        return PreProcessor(val_transform=transform, test_transform=transform)
+        return PreProcessor(transform=transform)
 
     @staticmethod
     def configure_post_processor() -> OneClassPostProcessor:
diff --git a/src/anomalib/pre_processing/pre_processing.py b/src/anomalib/pre_processing/pre_processing.py
index 95a1a7b880..2ed9ea919b 100644
--- a/src/anomalib/pre_processing/pre_processing.py
+++ b/src/anomalib/pre_processing/pre_processing.py
@@ -22,191 +22,111 @@
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING
-
 import torch
 from lightning import Callback, LightningModule, Trainer
-from lightning.pytorch.trainer.states import TrainerFn
 from torch import nn
-from torch.utils.data import DataLoader
 from torchvision.transforms.v2 import Transform
 
+from anomalib.data import Batch
+
 from .utils.transform import (
-    get_dataloaders_transforms,
     get_exportable_transform,
-    set_dataloaders_transforms,
-    set_datamodule_stage_transform,
 )
 
-if TYPE_CHECKING:
-    from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
-
-    from anomalib.data import AnomalibDataModule
-
 
 class PreProcessor(nn.Module, Callback):
     """Anomalib pre-processor.
 
     This class serves as both a PyTorch module and a Lightning callback, handling
-    the application of transforms to data batches during different stages of
-    training, validation, testing, and prediction.
+    the application of transforms to data batches as a pre-processing step.
 
     Args:
-        train_transform (Transform | None, optional): Transform to apply during
-            training. Defaults to None.
-        val_transform (Transform | None, optional): Transform to apply during
-            validation. Defaults to None.
-        test_transform (Transform | None, optional): Transform to apply during
-            testing. Defaults to None.
-        transform (Transform | None, optional): General transform to apply if
-            stage-specific transforms are not provided. Defaults to None.
-
-    Raises:
-        ValueError: If both ``transform`` and any of the stage-specific transforms
-            are provided simultaneously.
-
-    Notes:
-        If only ``transform`` is provided, it will be used for all stages (train,
-        val, test).
-
-        Priority of transforms:
-            1. Explicitly set ``PreProcessor`` transforms (highest priority)
-            2. Datamodule transforms (if ``PreProcessor`` has no transforms)
-            3. Dataloader transforms (if neither ``PreProcessor`` nor datamodule
-               have transforms)
-            4. Default transforms (lowest priority)
+        transform (Transform | None): Transform to apply to the data before passing it to the model.
 
     Example:
         >>> from torchvision.transforms.v2 import Compose, Resize, ToTensor
         >>> from anomalib.pre_processing import PreProcessor
-        >>> # Define transforms
-        >>> train_transform = Compose([
-        ...     Resize((224, 224)),
-        ...     ToTensor()
-        ... ])
-        >>> val_transform = Compose([
-        ...     Resize((256, 256)),
-        ...     CenterCrop((224, 224)),
-        ...     ToTensor()
-        ... ])
-        >>> # Create PreProcessor with stage-specific transforms
-        >>> pre_processor = PreProcessor(
-        ...     train_transform=train_transform,
-        ...     val_transform=val_transform
-        ... )
-        >>> # Create PreProcessor with a single transform for all stages
-        >>> common_transform = Compose([
-        ...     Resize((224, 224)),
-        ...     ToTensor()
-        ... ])
-        >>> pre_processor_common = PreProcessor(transform=common_transform)
-
-    Integration with Lightning:
+
+        >>> # Define a custom set of transforms
+        >>> transform = Compose([Resize((224, 224)), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
+
+        >>> # Pass the custom set of transforms to a model
+        >>> pre_processor = PreProcessor(transform=transform)
+        >>> model = MyModel(pre_processor=pre_processor)
+
+        >>> # Advanced use: configure the default pre-processing behaviour of a Lightning module
         >>> class MyModel(LightningModule):
         ...     def __init__(self):
         ...         super().__init__()
-        ...         self.pre_processor = PreProcessor(...)
+        ...         ...
         ...
-        ...     def configure_callbacks(self):
-        ...         return [self.pre_processor]
+        ...     def configure_pre_processor(self):
+        ...         transform = Compose([
+        ...             Resize((224, 224)),
+        ...             Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ...         ])
+        ...         return PreProcessor(transform)
         ...
-        ...     def training_step(self, batch, batch_idx):
-        ...         # Pre-processor automatically applies correct transform
-        ...         processed_batch = self.pre_processor(batch)
-        ...         # Rest of the training step
     """
 
     def __init__(
         self,
-        train_transform: Transform | None = None,
-        val_transform: Transform | None = None,
-        test_transform: Transform | None = None,
         transform: Transform | None = None,
     ) -> None:
         super().__init__()
 
-        if transform and any([train_transform, val_transform, test_transform]):
-            msg = (
-                "`transforms` cannot be used together with `train_transform`, `val_transform`, `test_transform`.\n"
-                "If you want to apply the same transform to the training, validation and test data, "
-                "use only `transforms`. \n"
-                "Otherwise, specify transforms for training, validation and test individually."
-            )
-            raise ValueError(msg)
-
-        self.train_transform = train_transform or transform
-        self.val_transform = val_transform or transform
-        self.test_transform = test_transform or transform
-        self.predict_transform = self.test_transform
-        self.export_transform = get_exportable_transform(self.test_transform)
-
-    def setup_datamodule_transforms(self, datamodule: "AnomalibDataModule") -> None:
-        """Set up datamodule transforms.
-
-        Args:
-            datamodule (AnomalibDataModule): The datamodule to configure
-                transforms for.
-        """
-        # If PreProcessor has transforms, propagate them to datamodule
-        if any([self.train_transform, self.val_transform, self.test_transform]):
-            transforms = {
-                "fit": self.train_transform,
-                "val": self.val_transform,
-                "test": self.test_transform,
-                "predict": self.predict_transform,
-            }
-
-            for stage, transform in transforms.items():
-                if transform is not None:
-                    set_datamodule_stage_transform(datamodule, transform, stage)
-
-    def setup_dataloader_transforms(self, dataloaders: "EVAL_DATALOADERS | TRAIN_DATALOADERS") -> None:
-        """Set up dataloader transforms.
+        self.transform = transform
+        self.export_transform = get_exportable_transform(self.transform)
 
-        Args:
-            dataloaders (EVAL_DATALOADERS | TRAIN_DATALOADERS): The dataloaders
-                to configure transforms for.
-        """
-        if isinstance(dataloaders, DataLoader):
-            dataloaders = [dataloaders]
-
-        # If PreProcessor has transforms, propagate them to dataloaders
-        if any([self.train_transform, self.val_transform, self.test_transform]):
-            transforms = {
-                "train": self.train_transform,
-                "val": self.val_transform,
-                "test": self.test_transform,
-            }
-            set_dataloaders_transforms(dataloaders, transforms)
-            return
-
-        # Try to get transforms from dataloaders
-        if dataloaders:
-            dataloaders_transforms = get_dataloaders_transforms(dataloaders)
-            if dataloaders_transforms:
-                self.train_transform = dataloaders_transforms.get("train")
-                self.val_transform = dataloaders_transforms.get("val")
-                self.test_transform = dataloaders_transforms.get("test")
-                self.predict_transform = self.test_transform
-                self.export_transform = get_exportable_transform(self.test_transform)
-
-    def setup(self, trainer: Trainer, pl_module: LightningModule, stage: str) -> None:
-        """Configure transforms at the start of each stage.
+    def on_train_batch_start(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+        batch: Batch,
+        batch_idx: int,
+    ) -> None:
+        """Apply transforms to the batch of tensors during training."""
+        del trainer, pl_module, batch_idx  # Unused
+        if self.transform:
+            batch.image, batch.gt_mask = self.transform(batch.image, batch.gt_mask)
 
-        Args:
-            trainer (Trainer): The Lightning trainer.
-            pl_module (LightningModule): The Lightning module.
-            stage (str): The stage (e.g., 'fit', 'validate', 'test', 'predict').
-        """
-        stage = TrainerFn(stage).value  # Ensure stage is str
+    def on_validation_batch_start(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+        batch: Batch,
+        batch_idx: int,
+    ) -> None:
+        """Apply transforms to the batch of tensors during validation."""
+        del trainer, pl_module, batch_idx  # Unused
+        if self.transform:
+            batch.image, batch.gt_mask = self.transform(batch.image, batch.gt_mask)
 
-        if hasattr(trainer, "datamodule"):
-            self.setup_datamodule_transforms(datamodule=trainer.datamodule)
-        elif hasattr(trainer, f"{stage}_dataloaders"):
-            dataloaders = getattr(trainer, f"{stage}_dataloaders")
-            self.setup_dataloader_transforms(dataloaders=dataloaders)
+    def on_test_batch_start(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+        batch: Batch,
+        batch_idx: int,
+        dataloader_idx: int = 0,
+    ) -> None:
+        """Apply transforms to the batch of tensors during testing."""
+        del trainer, pl_module, batch_idx, dataloader_idx  # Unused
+        if self.transform:
+            batch.image, batch.gt_mask = self.transform(batch.image, batch.gt_mask)
 
-        super().setup(trainer, pl_module, stage)
+    def on_predict_batch_start(
+        self,
+        trainer: Trainer,
+        pl_module: LightningModule,
+        batch: Batch,
+        batch_idx: int,
+        dataloader_idx: int = 0,
+    ) -> None:
+        """Apply transforms to the batch of tensors during prediction."""
+        del trainer, pl_module, batch_idx, dataloader_idx  # Unused
+        if self.transform:
+            batch.image, batch.gt_mask = self.transform(batch.image, batch.gt_mask)
 
     def forward(self, batch: torch.Tensor) -> torch.Tensor:
         """Apply transforms to the batch of tensors for inference.
diff --git a/src/anomalib/pre_processing/utils/transform.py b/src/anomalib/pre_processing/utils/transform.py
index e2032e6284..3b6918abb5 100644
--- a/src/anomalib/pre_processing/utils/transform.py
+++ b/src/anomalib/pre_processing/utils/transform.py
@@ -1,225 +1,19 @@
 """Utility functions for transforms.
 
 This module provides utility functions for managing transforms in the pre-processing
-pipeline. The utilities handle:
-    - Getting and setting transforms for different pipeline stages
-    - Converting between transform types
-    - Managing transforms across dataloaders and datamodules
-
-Example:
-    >>> from anomalib.pre_processing.utils.transform import get_dataloaders_transforms
-    >>> transforms = get_dataloaders_transforms(dataloaders)
-    >>> print(transforms["train"])  # Get training stage transform
-    Compose(
-        Resize(size=(256, 256), ...),
-        ToTensor()
-    )
-
-The module ensures consistent transform handling across the training, validation,
-and testing stages of the anomaly detection pipeline.
+pipeline.
 """
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from collections.abc import Sequence
+import copy
 
-from torch.utils.data import DataLoader
 from torchvision.transforms.v2 import CenterCrop, Compose, Resize, Transform
 
-from anomalib.data import AnomalibDataModule
 from anomalib.data.transforms import ExportableCenterCrop
 
 
-def get_dataloaders_transforms(dataloaders: Sequence[DataLoader]) -> dict[str, Transform]:
-    """Extract transforms from a sequence of dataloaders.
-
-    This function retrieves the transforms associated with different stages (train,
-    validation, test) from a sequence of dataloaders. It maps Lightning stage names
-    to their corresponding transform stages.
-
-    The stage mapping is:
-        - ``fit`` -> ``train``
-        - ``validate`` -> ``val``
-        - ``test`` -> ``test``
-        - ``predict`` -> ``test``
-
-    Args:
-        dataloaders: A sequence of PyTorch :class:`DataLoader` objects to extract
-            transforms from. Each dataloader should have a ``dataset`` attribute
-            with a ``transform`` property.
-
-    Returns:
-        A dictionary mapping stage names (``train``, ``val``, ``test``) to their
-        corresponding :class:`torchvision.transforms.v2.Transform` objects.
-
-    Example:
-        >>> from torch.utils.data import DataLoader
-        >>> from torchvision.transforms.v2 import Resize, ToTensor
-        >>> # Create dataloaders with transforms
-        >>> train_loader = DataLoader(dataset_with_transform)
-        >>> val_loader = DataLoader(dataset_with_transform)
-        >>> # Get transforms
-        >>> transforms = get_dataloaders_transforms([train_loader, val_loader])
-        >>> print(transforms["train"])  # Access training transform
-        Compose(
-            Resize(size=(256, 256)),
-            ToTensor()
-        )
-    """
-    transforms: dict[str, Transform] = {}
-    stage_lookup = {
-        "fit": "train",
-        "validate": "val",
-        "test": "test",
-        "predict": "test",
-    }
-
-    for dataloader in dataloaders:
-        if not hasattr(dataloader, "dataset") or not hasattr(dataloader.dataset, "transform"):
-            continue
-
-        for stage in stage_lookup:
-            if hasattr(dataloader, f"{stage}_dataloader"):
-                transforms[stage_lookup[stage]] = dataloader.dataset.transform
-
-    return transforms
-
-
-def set_dataloaders_transforms(dataloaders: Sequence[DataLoader], transforms: dict[str, Transform | None]) -> None:
-    """Set transforms to dataloaders based on their stage.
-
-    This function propagates transforms to dataloaders based on their stage mapping.
-    The stage mapping follows the convention:
-
-        - ``fit`` -> ``train``
-        - ``validate`` -> ``val``
-        - ``test`` -> ``test``
-        - ``predict`` -> ``test``
-
-    Args:
-        dataloaders: A sequence of PyTorch :class:`DataLoader` objects to set
-            transforms for. Each dataloader should have a ``dataset`` attribute.
-        transforms: Dictionary mapping stage names (``train``, ``val``, ``test``)
-            to their corresponding :class:`torchvision.transforms.v2.Transform`
-            objects. The transforms can be ``None``.
-
-    Example:
-        >>> from torch.utils.data import DataLoader
-        >>> from torchvision.transforms.v2 import Resize, ToTensor
-        >>> # Create transforms
-        >>> transforms = {
-        ...     "train": Compose([Resize((256, 256)), ToTensor()]),
-        ...     "val": Compose([Resize((256, 256)), ToTensor()])
-        ... }
-        >>> # Create dataloaders
-        >>> train_loader = DataLoader(dataset_with_transform)
-        >>> val_loader = DataLoader(dataset_with_transform)
-        >>> # Set transforms
-        >>> set_dataloaders_transforms([train_loader, val_loader], transforms)
-    """
-    stage_mapping = {
-        "fit": "train",
-        "validate": "val",
-        "test": "test",
-        "predict": "test",  # predict uses test transform
-    }
-
-    for loader in dataloaders:
-        if not hasattr(loader, "dataset"):
-            continue
-
-        for stage in stage_mapping:
-            if hasattr(loader, f"{stage}_dataloader"):
-                transform = transforms.get(stage_mapping[stage])
-                if transform is not None:
-                    set_dataloader_transform([loader], transform)
-
-
-def set_dataloader_transform(dataloader: DataLoader | Sequence[DataLoader], transform: Transform) -> None:
-    """Set a transform for a dataloader or sequence of dataloaders.
-
-    This function sets the transform for either a single dataloader or multiple dataloaders.
-    The transform is set on the dataset object of each dataloader if it has a ``transform``
-    attribute.
-
-    Args:
-        dataloader: A single :class:`torch.utils.data.DataLoader` or a sequence of
-            dataloaders to set the transform for. Each dataloader should have a
-            ``dataset`` attribute with a ``transform`` attribute.
-        transform: The :class:`torchvision.transforms.v2.Transform` object to set as
-            the transform.
-
-    Raises:
-        TypeError: If ``dataloader`` is neither a :class:`torch.utils.data.DataLoader`
-            nor a sequence of dataloaders.
-
-    Example:
-        >>> from torch.utils.data import DataLoader
-        >>> from torchvision.transforms.v2 import Resize
-        >>> # Create transform and dataloader
-        >>> transform = Resize(size=(256, 256))
-        >>> dataloader = DataLoader(dataset_with_transform)
-        >>> # Set transform
-        >>> set_dataloader_transform(dataloader, transform)
-    """
-    if isinstance(dataloader, DataLoader):
-        if hasattr(dataloader.dataset, "transform"):
-            dataloader.dataset.transform = transform
-    elif isinstance(dataloader, Sequence):
-        for dl in dataloader:
-            set_dataloader_transform(dl, transform)
-    else:
-        msg = f"Unsupported dataloader type: {type(dataloader)}"
-        raise TypeError(msg)
-
-
-def set_datamodule_stage_transform(datamodule: AnomalibDataModule, transform: Transform, stage: str) -> None:
-    """Set a transform for a specific stage in a :class:`AnomalibDataModule`.
-
-    This function sets the transform for a specific stage (train/val/test/predict) in an
-    AnomalibDataModule by mapping the stage name to the corresponding dataset attribute
-    and setting its transform.
-
-    Args:
-        datamodule: The :class:`AnomalibDataModule` instance to set the transform for.
-            Must have dataset attributes corresponding to different stages.
-        transform: The :class:`torchvision.transforms.v2.Transform` object to set as
-            the transform for the specified stage.
-        stage: The pipeline stage to set the transform for. Must be one of:
-            ``'fit'``, ``'validate'``, ``'test'``, or ``'predict'``.
-
-    Note:
-        The ``stage`` parameter maps to dataset attributes as follows:
-
-        - ``'fit'`` -> ``'train_data'``
-        - ``'validate'`` -> ``'val_data'``
-        - ``'test'`` -> ``'test_data'``
-        - ``'predict'`` -> ``'test_data'``
-
-    Example:
-        >>> from torchvision.transforms.v2 import Resize
-        >>> from anomalib.data import MVTec
-        >>> # Create transform and datamodule
-        >>> transform = Resize(size=(256, 256))
-        >>> datamodule = MVTec()
-        >>> # Set transform for training stage
-        >>> set_datamodule_stage_transform(datamodule, transform, "fit")
-    """
-    stage_datasets = {
-        "fit": "train_data",
-        "validate": "val_data",
-        "test": "test_data",
-        "predict": "test_data",
-    }
-
-    dataset_attr = stage_datasets.get(stage)
-    if dataset_attr and hasattr(datamodule, dataset_attr):
-        dataset = getattr(datamodule, dataset_attr)
-        if hasattr(dataset, "transform"):
-            dataset.transform = transform
-
-
 def get_exportable_transform(transform: Transform | None) -> Transform | None:
     """Get an exportable version of a transform.
 
@@ -253,6 +47,7 @@ def get_exportable_transform(transform: Transform | None) -> Transform | None:
     """
     if transform is None:
         return None
+    transform = copy.deepcopy(transform)
     transform = disable_antialiasing(transform)
     return convert_center_crop_transform(transform)
 
diff --git a/src/anomalib/utils/__init__.py b/src/anomalib/utils/__init__.py
index 2787c5772d..cf8bb2c5c6 100644
--- a/src/anomalib/utils/__init__.py
+++ b/src/anomalib/utils/__init__.py
@@ -25,3 +25,7 @@
 
 # Copyright (C) 2022-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
+
+from .attrs import get_nested_attr
+
+__all__ = ["get_nested_attr"]
diff --git a/src/anomalib/utils/attrs.py b/src/anomalib/utils/attrs.py
new file mode 100644
index 0000000000..af53ca01e3
--- /dev/null
+++ b/src/anomalib/utils/attrs.py
@@ -0,0 +1,52 @@
+"""Utility functions for working with attributes."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+
+def get_nested_attr(obj: Any, attr_path: str, default: Any | None = None) -> Any:  # noqa: ANN401
+    """Safely retrieves a nested attribute from an object.
+
+    This function helps reduce boilerplate code when working with nested attributes, by allowing you to retrieve a
+    nested attribute with a single function call instead of multiple nested calls to `getattr`.
+
+    Args:
+        obj: The object to retrieve the attribute from.
+        attr_path: A dot-separated string representing the attribute path.
+        default: The default value to return if any attribute in the path is missing.
+
+    Returns:
+        The value of the nested attribute, or `default` if any attribute in the path is missing.
+
+    Example:
+        >>> class A:
+        ...     def __init__(self, b):
+        ...         self.b = b
+        >>>
+        >>> class B:
+        ...     def __init__(self, c):
+        ...         self.c = c
+        >>>
+        >>> class C:
+        ...     def __init__(self, d):
+        ...         self.d = d
+        >>>
+        >>> d = 42
+        >>> c = C(d)
+        >>> b = B(c)
+        >>> a = A(b)
+        >>> get_nested_attr(a, "b.c.d")  # 42
+        >>> # this is equivalent to:
+        >>> # getattr(getattr(getattr(a, "b", None), "c", None), "value", None)
+        >>>
+        >>> get_nested_attr(a, "b.c.foo")  # None
+        >>> get_nested_attr(a, "b.c.foo", "bar")  # "bar"
+        >>> get_nested_attr(a, "b.d.c")  # None
+    """
+    for attr in attr_path.split("."):
+        obj = getattr(obj, attr, default)
+        if obj is default:
+            return default
+    return obj
diff --git a/src/anomalib/utils/visualization/image.py b/src/anomalib/utils/visualization/image.py
index 9aa0b68822..6b7747f528 100644
--- a/src/anomalib/utils/visualization/image.py
+++ b/src/anomalib/utils/visualization/image.py
@@ -394,8 +394,6 @@ def generate(self) -> np.ndarray:
                 axis.title.set_text(image_dict["title"])
         self.figure.canvas.draw()
         # convert canvas to numpy array to prepare for visualization with opencv
-        img = np.frombuffer(self.figure.canvas.buffer_rgba(), dtype=np.uint8)
-        img = img.reshape(self.figure.canvas.get_width_height()[::-1] + (4,))  # RGBA has 4 channels
-        img = cv2.cvtColor(img, cv2.COLOR_RGBA2RGB)
+        img = np.array(self.figure.canvas.buffer_rgba(), dtype=np.uint8)[..., :3]
         plt.close(self.figure)
         return img
diff --git a/tests/integration/tools/upgrade/expected_draem_v1.yaml b/tests/integration/tools/upgrade/expected_draem_v1.yaml
index feb059214d..0e65e8f49b 100644
--- a/tests/integration/tools/upgrade/expected_draem_v1.yaml
+++ b/tests/integration/tools/upgrade/expected_draem_v1.yaml
@@ -6,6 +6,10 @@ data:
     train_batch_size: 72
     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
diff --git a/tests/unit/data/dataclasses/test_collate.py b/tests/unit/data/dataclasses/test_collate.py
new file mode 100644
index 0000000000..aaf83c87ff
--- /dev/null
+++ b/tests/unit/data/dataclasses/test_collate.py
@@ -0,0 +1,45 @@
+"""Tests for the collating DatasetItems into Batches."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass
+
+import torch
+from torchvision.tv_tensors import Image, Mask
+
+from anomalib.data.dataclasses.generic import BatchIterateMixin
+
+
+@dataclass
+class DummyDatasetItem:
+    """Dummy dataset item with image and mask."""
+
+    image: Image
+    mask: Mask
+
+
+@dataclass
+class DummyBatch(BatchIterateMixin[DummyDatasetItem]):
+    """Dummy batch with image and mask."""
+
+    item_class = DummyDatasetItem
+    image: Image
+    mask: Mask
+
+
+def test_collate_heterogeneous_shapes() -> None:
+    """Test collating items with different shapes."""
+    items = [
+        DummyDatasetItem(
+            image=Image(torch.rand((3, 256, 256))),
+            mask=Mask(torch.ones((256, 256))),
+        ),
+        DummyDatasetItem(
+            image=Image(torch.rand((3, 224, 224))),
+            mask=Mask(torch.ones((224, 224))),
+        ),
+    ]
+    batch = DummyBatch.collate(items)
+    # the collated batch should have the shape of the largest item
+    assert batch.image.shape == (2, 3, 256, 256)
diff --git a/tests/unit/data/datamodule/depth/test_folder_3d.py b/tests/unit/data/datamodule/depth/test_folder_3d.py
index 71adef7b12..9deec32b9c 100644
--- a/tests/unit/data/datamodule/depth/test_folder_3d.py
+++ b/tests/unit/data/datamodule/depth/test_folder_3d.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import Folder3D
 from tests.unit.data.datamodule.base.depth import _TestAnomalibDepthDatamodule
@@ -31,6 +32,7 @@ def datamodule(dataset_path: Path) -> Folder3D:
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
+            augmentations=Resize((256, 256)),
         )
         _datamodule.prepare_data()
         _datamodule.setup()
diff --git a/tests/unit/data/datamodule/depth/test_mvtec_3d.py b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
index 2a90822763..f07266c56a 100644
--- a/tests/unit/data/datamodule/depth/test_mvtec_3d.py
+++ b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import MVTec3D
 from tests.unit.data.datamodule.base.depth import _TestAnomalibDepthDatamodule
@@ -24,6 +25,7 @@ def datamodule(dataset_path: Path) -> MVTec3D:
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
+            augmentations=Resize((256, 256)),
         )
         _datamodule.prepare_data()
         _datamodule.setup()
diff --git a/tests/unit/data/datamodule/image/test_btech.py b/tests/unit/data/datamodule/image/test_btech.py
index fb559641c1..6dcb7969a5 100644
--- a/tests/unit/data/datamodule/image/test_btech.py
+++ b/tests/unit/data/datamodule/image/test_btech.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import BTech
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
@@ -23,6 +24,7 @@ def datamodule(dataset_path: Path) -> BTech:
             category="dummy",
             train_batch_size=4,
             eval_batch_size=4,
+            augmentations=Resize((256, 256)),
         )
 
         _datamodule.prepare_data()
diff --git a/tests/unit/data/datamodule/image/test_datumaro.py b/tests/unit/data/datamodule/image/test_datumaro.py
index e10009a71c..9b527bd864 100644
--- a/tests/unit/data/datamodule/image/test_datumaro.py
+++ b/tests/unit/data/datamodule/image/test_datumaro.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import Datumaro
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
@@ -22,6 +23,7 @@ def datamodule(dataset_path: Path) -> Datumaro:
             root=dataset_path / "datumaro",
             train_batch_size=4,
             eval_batch_size=4,
+            augmentations=Resize((256, 256)),
         )
         _datamodule.setup()
 
diff --git a/tests/unit/data/datamodule/image/test_folder.py b/tests/unit/data/datamodule/image/test_folder.py
index e564b5a5e3..9c32239008 100644
--- a/tests/unit/data/datamodule/image/test_folder.py
+++ b/tests/unit/data/datamodule/image/test_folder.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import Folder
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
@@ -35,6 +36,7 @@ def datamodule(dataset_path: Path) -> Folder:
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
+            augmentations=Resize((256, 256)),
         )
         _datamodule.setup()
 
diff --git a/tests/unit/data/datamodule/image/test_kolektor.py b/tests/unit/data/datamodule/image/test_kolektor.py
index 3d6b896d50..b0456c05fd 100644
--- a/tests/unit/data/datamodule/image/test_kolektor.py
+++ b/tests/unit/data/datamodule/image/test_kolektor.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import Kolektor
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
@@ -22,6 +23,7 @@ def datamodule(dataset_path: Path) -> Kolektor:
             root=dataset_path / "kolektor",
             train_batch_size=4,
             eval_batch_size=4,
+            augmentations=Resize((256, 256)),
         )
 
         _datamodule.prepare_data()
diff --git a/tests/unit/data/datamodule/image/test_mvtec.py b/tests/unit/data/datamodule/image/test_mvtec.py
index 8f40c9e38a..537fa9c4e0 100644
--- a/tests/unit/data/datamodule/image/test_mvtec.py
+++ b/tests/unit/data/datamodule/image/test_mvtec.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import MVTec
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
@@ -23,6 +24,7 @@ def datamodule(dataset_path: Path) -> MVTec:
             category="dummy",
             train_batch_size=4,
             eval_batch_size=4,
+            augmentations=Resize((256, 256)),
         )
         _datamodule.prepare_data()
         _datamodule.setup()
diff --git a/tests/unit/data/datamodule/image/test_visa.py b/tests/unit/data/datamodule/image/test_visa.py
index b24b1d42c0..5f3968b531 100644
--- a/tests/unit/data/datamodule/image/test_visa.py
+++ b/tests/unit/data/datamodule/image/test_visa.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import Visa
 from tests.unit.data.datamodule.base.image import _TestAnomalibImageDatamodule
@@ -24,6 +25,7 @@ def datamodule(dataset_path: Path) -> Visa:
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
+            augmentations=Resize((256, 256)),
         )
         _datamodule.prepare_data()
         _datamodule.setup()
diff --git a/tests/unit/data/datamodule/test_update_augmentations.py b/tests/unit/data/datamodule/test_update_augmentations.py
new file mode 100644
index 0000000000..fb9ed3e206
--- /dev/null
+++ b/tests/unit/data/datamodule/test_update_augmentations.py
@@ -0,0 +1,122 @@
+"""Tests for the _update_subset_augmentations method in AnomalibDataModule."""
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+import pytest
+from torchvision.transforms.v2 import (
+    Compose,
+    InterpolationMode,
+    Normalize,
+    RandomHorizontalFlip,
+    RandomVerticalFlip,
+    Resize,
+)
+
+from anomalib.data import AnomalibDataModule, AnomalibDataset
+
+
+class DummyDataset(AnomalibDataset):
+    """Dummy dataset class for testing."""
+
+    def __init__(self) -> None:
+        pass
+
+
+class TestUpdateAugmentations:
+    """Tests for the _update_subset_augmentations method in AnomalibDataModule."""
+
+    @staticmethod
+    def test_conflicting_shape(caplog: pytest.LogCaptureFixture) -> None:
+        """Test that a warning is logged if resize shapes mismatch."""
+        dataset = DummyDataset()
+        model_transform = Resize((224, 224))
+        augmentations = Resize((256, 256))
+
+        with caplog.at_level(logging.WARNING):
+            AnomalibDataModule._update_subset_augmentations(dataset, augmentations, model_transform=model_transform)  # noqa: SLF001
+        # check if a warning was logged
+        assert any(record.levelname == "WARNING" for record in caplog.records)
+        assert "Conflicting resize shape" in caplog.text
+        # check if augmentations were overwritten by model transform
+        assert dataset.augmentations == model_transform
+
+    @staticmethod
+    def test_conflicting_interpolation(caplog: pytest.LogCaptureFixture) -> None:
+        """Test that a warning is logged if interpolation methods mismatch."""
+        dataset = DummyDataset()
+        model_transform = Resize((224, 224), interpolation=InterpolationMode.BILINEAR)
+        augmentations = Resize((224, 224), interpolation=InterpolationMode.NEAREST)
+
+        with caplog.at_level(logging.WARNING):
+            AnomalibDataModule._update_subset_augmentations(dataset, augmentations, model_transform=model_transform)  # noqa: SLF001
+        # check if a warning was logged
+        assert any(record.levelname == "WARNING" for record in caplog.records)
+        assert "Conflicting interpolation method" in caplog.text
+        # check if augmentations were overwritten by model transform
+        assert dataset.augmentations == model_transform
+
+    @staticmethod
+    def test_conflicting_antialias(caplog: pytest.LogCaptureFixture) -> None:
+        """Test that a warning is logged if antialiasing setting mismatch."""
+        dataset = DummyDataset()
+        model_transform = Resize((224, 224), antialias=True)
+        augmentations = Resize((224, 224), antialias=False)
+
+        with caplog.at_level(logging.WARNING):
+            AnomalibDataModule._update_subset_augmentations(dataset, augmentations, model_transform=model_transform)  # noqa: SLF001
+        # check if a warning was logged
+        assert any(record.levelname == "WARNING" for record in caplog.records)
+        assert "Conflicting antialiasing setting" in caplog.text
+        # check if augmentations were overwritten by model transform
+        assert dataset.augmentations == model_transform
+
+    @staticmethod
+    def test_augmentations_as_compose() -> None:
+        """Test that the Resize transform is added to the augmentations if augmentations is a Compose object."""
+        dataset = DummyDataset()
+        model_transform = Resize((224, 224))
+        augmentations = Compose([RandomHorizontalFlip(), RandomVerticalFlip()])
+
+        AnomalibDataModule._update_subset_augmentations(dataset, augmentations, model_transform=model_transform)  # noqa: SLF001
+        assert dataset.augmentations.transforms[-1] == model_transform
+
+    @staticmethod
+    def test_augmentations_as_transform() -> None:
+        """Test that the Resize transform is added to the augmentations if augmentations is a single transform."""
+        dataset = DummyDataset()
+        model_transform = Resize((224, 224))
+        augmentations = RandomHorizontalFlip()
+
+        AnomalibDataModule._update_subset_augmentations(dataset, augmentations, model_transform=model_transform)  # noqa: SLF001
+        assert dataset.augmentations.transforms[-1] == model_transform
+
+    @staticmethod
+    def test_model_transform_as_compose() -> None:
+        """Test that the Resize transform is added to the augmentations if model_transform is a Compose object."""
+        dataset = DummyDataset()
+        model_transform = Compose([Resize(224, 224), Normalize(mean=[0.5, 0.5, 0.5], std=[1.0, 1.0, 1.0])])
+        augmentations = Compose([RandomHorizontalFlip(), RandomVerticalFlip()])
+
+        AnomalibDataModule._update_subset_augmentations(dataset, augmentations, model_transform=model_transform)  # noqa: SLF001
+        assert dataset.augmentations.transforms[-1] == model_transform.transforms[0]
+
+    @staticmethod
+    def test_no_model_transforms() -> None:
+        """Test that the augmentations are added but not modified if model_transform is None."""
+        dataset = DummyDataset()
+        augmentations = Compose([RandomHorizontalFlip(), RandomVerticalFlip()])
+
+        AnomalibDataModule._update_subset_augmentations(dataset, augmentations, model_transform=None)  # noqa: SLF001
+        assert dataset.augmentations == augmentations
+
+    @staticmethod
+    def test_no_augmentations() -> None:
+        """Test that the model_transform resize is added to the augmentations if augmentations is None."""
+        dataset = DummyDataset()
+        model_transform = Resize((224, 224))
+
+        AnomalibDataModule._update_subset_augmentations(dataset, augmentations=None, model_transform=model_transform)  # noqa: SLF001
+        assert dataset.augmentations == model_transform
diff --git a/tests/unit/data/datamodule/video/test_avenue.py b/tests/unit/data/datamodule/video/test_avenue.py
index f63e240e15..e7c3e8546e 100644
--- a/tests/unit/data/datamodule/video/test_avenue.py
+++ b/tests/unit/data/datamodule/video/test_avenue.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import Avenue
 from tests.unit.data.datamodule.base.video import _TestAnomalibVideoDatamodule
@@ -31,6 +32,7 @@ def datamodule(dataset_path: Path, clip_length_in_frames: int) -> Avenue:
             num_workers=0,
             train_batch_size=4,
             eval_batch_size=4,
+            augmentations=Resize((256, 256)),
         )
 
         _datamodule.prepare_data()
diff --git a/tests/unit/data/datamodule/video/test_shanghaitech.py b/tests/unit/data/datamodule/video/test_shanghaitech.py
index e1dc1ba3c3..dfee8ca519 100644
--- a/tests/unit/data/datamodule/video/test_shanghaitech.py
+++ b/tests/unit/data/datamodule/video/test_shanghaitech.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import ShanghaiTech
 from tests.unit.data.datamodule.base.video import _TestAnomalibVideoDatamodule
@@ -31,6 +32,7 @@ def datamodule(dataset_path: Path, clip_length_in_frames: int) -> ShanghaiTech:
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
+            augmentations=Resize((256, 256)),
         )
 
         _datamodule.prepare_data()
diff --git a/tests/unit/data/datamodule/video/test_ucsdped.py b/tests/unit/data/datamodule/video/test_ucsdped.py
index 3da6c076d1..f55347c3f2 100644
--- a/tests/unit/data/datamodule/video/test_ucsdped.py
+++ b/tests/unit/data/datamodule/video/test_ucsdped.py
@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data import UCSDped
 from tests.unit.data.datamodule.base.video import _TestAnomalibVideoDatamodule
@@ -31,6 +32,7 @@ def datamodule(dataset_path: Path, clip_length_in_frames: int) -> UCSDped:
             train_batch_size=4,
             eval_batch_size=4,
             num_workers=0,
+            augmentations=Resize((256, 256)),
         )
         _datamodule.prepare_data()
         _datamodule.setup()
diff --git a/tests/unit/data/utils/test_synthetic.py b/tests/unit/data/utils/test_synthetic.py
index 09cb77e777..5bab62f0a9 100644
--- a/tests/unit/data/utils/test_synthetic.py
+++ b/tests/unit/data/utils/test_synthetic.py
@@ -7,6 +7,7 @@
 from pathlib import Path
 
 import pytest
+from torchvision.transforms.v2 import Resize
 
 from anomalib.data.datasets.image.folder import FolderDataset
 from anomalib.data.utils.synthetic import SyntheticAnomalyDataset
@@ -23,6 +24,7 @@ def folder_dataset(dataset_path: Path) -> FolderDataset:
         normal_test_dir="test/good",
         mask_dir="ground_truth/bad",
         split="train",
+        augmentations=Resize((256, 256)),
     )
 
 
@@ -36,7 +38,7 @@ def synthetic_dataset(folder_dataset: FolderDataset) -> SyntheticAnomalyDataset:
 def synthetic_dataset_from_samples(folder_dataset: FolderDataset) -> SyntheticAnomalyDataset:
     """Fixture that returns a SyntheticAnomalyDataset instance."""
     return SyntheticAnomalyDataset(
-        transform=folder_dataset.transform,
+        augmentations=folder_dataset.augmentations,
         source_samples=folder_dataset.samples,
     )
 
diff --git a/tests/unit/pre_processing/test_pre_processing.py b/tests/unit/pre_processing/test_pre_processing.py
index 36394d54a3..dbc677f66a 100644
--- a/tests/unit/pre_processing/test_pre_processing.py
+++ b/tests/unit/pre_processing/test_pre_processing.py
@@ -3,11 +3,8 @@
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-from unittest.mock import MagicMock
-
 import pytest
 import torch
-from torch.utils.data import DataLoader
 from torchvision.transforms.v2 import Compose, Resize, ToDtype, ToImage
 from torchvision.tv_tensors import Image, Mask
 
@@ -26,26 +23,6 @@ def setup(self) -> None:
         self.dummy_batch = ImageBatch(image=image, gt_mask=gt_mask)
         self.common_transform = Compose([Resize((224, 224)), ToImage(), ToDtype(torch.float32, scale=True)])
 
-    def test_init(self) -> None:
-        """Test the initialization of the PreProcessor class."""
-        # Test with stage-specific transforms
-        train_transform = Compose([Resize((224, 224)), ToImage(), ToDtype(torch.float32, scale=True)])
-        val_transform = Compose([Resize((256, 256)), ToImage(), ToDtype(torch.float32, scale=True)])
-        pre_processor = PreProcessor(train_transform=train_transform, val_transform=val_transform)
-        assert pre_processor.train_transform == train_transform
-        assert pre_processor.val_transform == val_transform
-        assert pre_processor.test_transform is None
-
-        # Test with single transform for all stages
-        pre_processor = PreProcessor(transform=self.common_transform)
-        assert pre_processor.train_transform == self.common_transform
-        assert pre_processor.val_transform == self.common_transform
-        assert pre_processor.test_transform == self.common_transform
-
-        # Test error case: both transform and stage-specific transform
-        with pytest.raises(ValueError, match="`transforms` cannot be used together with"):
-            PreProcessor(transform=self.common_transform, train_transform=train_transform)
-
     def test_forward(self) -> None:
         """Test the forward method of the PreProcessor class."""
         pre_processor = PreProcessor(transform=self.common_transform)
@@ -59,69 +36,3 @@ def test_no_transform(self) -> None:
         processed_batch = pre_processor(self.dummy_batch.image)
         assert isinstance(processed_batch, torch.Tensor)
         assert processed_batch.shape == (1, 3, 256, 256)
-
-    @staticmethod
-    def test_different_stage_transforms() -> None:
-        """Test different stage transforms."""
-        train_transform = Compose([Resize((224, 224)), ToImage(), ToDtype(torch.float32, scale=True)])
-        val_transform = Compose([Resize((256, 256)), ToImage(), ToDtype(torch.float32, scale=True)])
-        test_transform = Compose([Resize((288, 288)), ToImage(), ToDtype(torch.float32, scale=True)])
-
-        pre_processor = PreProcessor(
-            train_transform=train_transform,
-            val_transform=val_transform,
-            test_transform=test_transform,
-        )
-
-        # Test train transform
-        test_batch = ImageBatch(image=Image(torch.rand(3, 256, 256)), gt_mask=Mask(torch.zeros(256, 256)))
-        processed_batch = pre_processor.train_transform(test_batch.image)
-        assert isinstance(processed_batch, torch.Tensor)
-        assert processed_batch.shape == (1, 3, 224, 224)
-
-        # Test validation transform
-        test_batch = ImageBatch(image=Image(torch.rand(3, 256, 256)), gt_mask=Mask(torch.zeros(256, 256)))
-        processed_batch = pre_processor.val_transform(test_batch.image)
-        assert isinstance(processed_batch, torch.Tensor)
-        assert processed_batch.shape == (1, 3, 256, 256)
-
-        # Test test transform
-        test_batch = ImageBatch(image=Image(torch.rand(3, 256, 256)), gt_mask=Mask(torch.zeros(256, 256)))
-        processed_batch = pre_processor.test_transform(test_batch.image)
-        assert isinstance(processed_batch, torch.Tensor)
-        assert processed_batch.shape == (1, 3, 288, 288)
-
-    def test_setup_transforms_from_dataloaders(self) -> None:
-        """Test setup method when transforms are obtained from dataloaders."""
-        # Mock dataloader with dataset having a transform
-        dataloader = MagicMock()
-        dataloader.dataset.transform = self.common_transform
-
-        pre_processor = PreProcessor()
-        pre_processor.setup_dataloader_transforms(dataloaders=[dataloader])
-
-        assert pre_processor.train_transform == self.common_transform
-        assert pre_processor.val_transform == self.common_transform
-        assert pre_processor.test_transform == self.common_transform
-
-    def test_setup_transforms_priority(self) -> None:
-        """Test setup method prioritizes PreProcessor transforms over datamodule/dataloaders."""
-        # Mock datamodule
-        datamodule = MagicMock()
-        datamodule.train_transform = Compose([Resize((128, 128)), ToImage(), ToDtype(torch.float32, scale=True)])
-        datamodule.eval_transform = Compose([Resize((128, 128)), ToImage(), ToDtype(torch.float32, scale=True)])
-
-        # Mock dataloader
-        dataset_mock = MagicMock()
-        dataset_mock.transform = Compose([Resize((64, 64)), ToImage(), ToDtype(torch.float32, scale=True)])
-        dataloader = MagicMock(spec=DataLoader)
-        dataloader.dataset = dataset_mock
-
-        # Initialize PreProcessor with a custom transform
-        pre_processor = PreProcessor(transform=self.common_transform)
-        pre_processor.setup_datamodule_transforms(datamodule=datamodule)
-
-        # Ensure PreProcessor's own transform is used
-        assert pre_processor.train_transform == self.common_transform
-        assert pre_processor.val_transform == self.common_transform
-        assert pre_processor.test_transform == self.common_transform
diff --git a/tests/unit/pre_processing/utils/test_transform.py b/tests/unit/pre_processing/utils/test_transform.py
index 6974bcdbc8..d4c416e00f 100644
--- a/tests/unit/pre_processing/utils/test_transform.py
+++ b/tests/unit/pre_processing/utils/test_transform.py
@@ -3,9 +3,6 @@
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import pytest
-import torch
-from torch.utils.data import DataLoader, TensorDataset
 from torchvision.transforms.v2 import CenterCrop, Compose, Resize, ToTensor
 
 from anomalib.data.transforms import ExportableCenterCrop
@@ -13,36 +10,9 @@
     convert_center_crop_transform,
     disable_antialiasing,
     get_exportable_transform,
-    set_dataloader_transform,
 )
 
 
-def test_set_dataloader_transform() -> None:
-    """Test the set_dataloader_transform function."""
-
-    # Test with single DataLoader
-    class TransformableDataset(TensorDataset):
-        def __init__(self, *tensors) -> None:
-            super().__init__(*tensors)
-            self.transform = None
-
-    dataset = TransformableDataset(torch.randn(10, 3, 224, 224))
-    dataloader = DataLoader(dataset)
-    transform = ToTensor()
-    set_dataloader_transform(dataloader, transform)
-    assert dataloader.dataset.transform == transform
-
-    # Test with sequence of DataLoaders
-    dataloaders = [DataLoader(TransformableDataset(torch.randn(10, 3, 224, 224))) for _ in range(3)]
-    set_dataloader_transform(dataloaders, transform)
-    for dl in dataloaders:
-        assert dl.dataset.transform == transform
-
-    # Test with unsupported type
-    with pytest.raises(TypeError):
-        set_dataloader_transform({"key": "value"}, transform)
-
-
 def test_get_exportable_transform() -> None:
     """Test the get_exportable_transform function."""
     # Test with None transform

From 7008be2df018693c876293bc1f46b944704c5ff5 Mon Sep 17 00:00:00 2001
From: Samet Akcay 
Date: Mon, 6 Jan 2025 12:47:36 +0000
Subject: [PATCH 45/45] =?UTF-8?q?=F0=9F=93=9AAdd=20how-to-guides=20and=20e?=
 =?UTF-8?q?xamples=20dir=20(#2475)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* update conf.py

Signed-off-by: Samet Akcay 

* Remove requirements.txt

Signed-off-by: Samet Akcay 

* Remove topic guide

Signed-off-by: Samet Akcay 

* Update conf.py

Signed-off-by: Samet Akcay 

* Add api guide landing page

Signed-off-by: Samet Akcay 

* Add data landing page

Signed-off-by: Samet Akcay 

* Add data documentation

Signed-off-by: Samet Akcay 

* Deleted files

Signed-off-by: Samet Akcay 

* Deleted files

Signed-off-by: Samet Akcay 

* Deleted files

Signed-off-by: Samet Akcay 

* Modified files

Signed-off-by: Samet Akcay 

* Modified files

Signed-off-by: Samet Akcay 

* Update callback docstrings

Signed-off-by: Samet Akcay 

* Update cli docstrings

Signed-off-by: Samet Akcay 

* Update callback docstrings

Signed-off-by: Samet Akcay 

* Update dataclasses and datamodules docstrings

Signed-off-by: Samet Akcay 

* Update datasets docstrings

Signed-off-by: Samet Akcay 

* Update utils docstrings

Signed-off-by: Samet Akcay 

* Update validators docstrings

Signed-off-by: Samet Akcay 

* Add the remaining docstrings

Signed-off-by: Samet Akcay 

* Add deploy docstrings

Signed-off-by: Samet Akcay 

* Add engine docstrings

Signed-off-by: Samet Akcay 

* Add logger docstrings

Signed-off-by: Samet Akcay 

* Add pimo docstrings

Signed-off-by: Samet Akcay 

* Add threshold docstrings

Signed-off-by: Samet Akcay 

* Add threshold docstrings

Signed-off-by: Samet Akcay 

* Add model components docstrings

Signed-off-by: Samet Akcay 

* add cfa

Signed-off-by: Samet Akcay 

* add cflow

Signed-off-by: Samet Akcay 

* add csflow

Signed-off-by: Samet Akcay 

* add dfm

Signed-off-by: Samet Akcay 

* add draem

Signed-off-by: Samet Akcay 

* add dsr

Signed-off-by: Samet Akcay 

* Add efficient-ad

Signed-off-by: Samet Akcay 

* add fastflow

Signed-off-by: Samet Akcay 

* add fre

Signed-off-by: Samet Akcay 

* add ganomaly

Signed-off-by: Samet Akcay 

* add patchcore

Signed-off-by: Samet Akcay 

* add reverse distillation

Signed-off-by: Samet Akcay 

* add stfpm

Signed-off-by: Samet Akcay 

* add uflow

Signed-off-by: Samet Akcay 

* add vlm-ad

Signed-off-by: Samet Akcay 

* add winclip

Signed-off-by: Samet Akcay 

* Add ai-vad

Signed-off-by: Samet Akcay 

* Add pipelines

Signed-off-by: Samet Akcay 

* Add pre and post processors

Signed-off-by: Samet Akcay 

* Add utils

Signed-off-by: Samet Akcay 

* Add visualizer

Signed-off-by: Samet Akcay 

* Update the licenses

Signed-off-by: Samet Akcay 

* Revert validators

Signed-off-by: Samet Akcay 

* Create examples directory

Signed-off-by: Samet Akcay 

* Create examples directory

Signed-off-by: Samet Akcay 

* Move notebooks to examples directory

Signed-off-by: Samet Akcay 

* Update links

Signed-off-by: Samet Akcay 

* Fix mypy issues

Signed-off-by: Samet Akcay 

* Move configs to examples

Signed-off-by: Samet Akcay 

* Update README.md file

Signed-off-by: Samet Akcay 

* Fix the notebook links

Signed-off-by: Samet Akcay 

* Fix incorrect docstrings

Signed-off-by: Samet Akcay 

* Fix incorrect docstrings

Signed-off-by: Samet Akcay 

* add missing 501 notebooks

Signed-off-by: Samet Akcay 

* Add how-to-guides

Signed-off-by: Samet Akcay 

* update dataclasses how-to-guides

Signed-off-by: Samet Akcay 

* update datasets how-to-guides

Signed-off-by: Samet Akcay 

* update datamodules how-to-guides

Signed-off-by: Samet Akcay 

* Disable old transforms how-to-guides

Signed-off-by: Samet Akcay 

* Add git lfs to tox ini

Signed-off-by: Samet Akcay 

* Set LFS to true when checking out the repo

Signed-off-by: Samet Akcay 

* Update post-processor how-to-guides

Signed-off-by: Samet Akcay 

* Add missing code. Misteriously disappeared

Signed-off-by: Samet Akcay 

* update dataclasses guide

* update metrics and evaluator guide

* Update docs/source/markdown/guides/how_to/evaluation/metrics.md

Signed-off-by: Samet Akcay 

* Update docs/source/markdown/guides/how_to/evaluation/metrics.md

Signed-off-by: Samet Akcay 

* Update docs/source/markdown/guides/how_to/evaluation/metrics.md

Signed-off-by: Samet Akcay 

* Update docs/source/markdown/guides/how_to/evaluation/metrics.md

Signed-off-by: Samet Akcay 

* update transforms guide

* fix typo

* add PreProcessor guide

* update examples

* Update the path to dataset in notebooks

Signed-off-by: Samet Akcay 

* update post-processor guide

* update readme badges

Signed-off-by: Samet Akcay 

* Update API emoji

Signed-off-by: Samet Akcay 

* Add how-to-guide links to the release features

Signed-off-by: Samet Akcay 

* Update README.md

Co-authored-by: Dick Ameln 

---------

Signed-off-by: Samet Akcay 
Co-authored-by: Dick Ameln 
Co-authored-by: Dick Ameln 
---
 .gitattributes                                |   3 +-
 .github/CODEOWNERS                            |  12 +-
 .github/workflows/_reusable-code-quality.yaml |   1 +
 .github/workflows/pre_merge.yml               |   4 +-
 .gitignore                                    |   4 +-
 README.md                                     | 256 +++----
 docs/source/conf.py                           |   2 +
 docs/source/markdown/get_started/anomalib.md  |  41 +-
 docs/source/markdown/get_started/migration.md |  49 +-
 .../guides/how_to/data/dataclasses.md         | 314 ++++++++
 .../guides/how_to/data/datamodules.md         | 233 ++++++
 .../markdown/guides/how_to/data/datasets.md   | 296 +++++++
 .../markdown/guides/how_to/data/index.md      |  40 +-
 .../markdown/guides/how_to/data/transforms.md | 280 +++++--
 .../guides/how_to/evaluation/evaluator.md     | 175 +++++
 .../guides/how_to/evaluation/index.md         |  31 +
 .../guides/how_to/evaluation/metrics.md       | 191 +++++
 docs/source/markdown/guides/how_to/index.md   |  15 +-
 .../markdown/guides/how_to/models/index.md    |  22 +-
 .../guides/how_to/models/post_processor.md    | 226 ++++++
 .../guides/how_to/models/pre_processor.md     | 325 ++++++++
 .../guides/how_to/visualization/index.md      |  31 +
 .../how_to/visualization/visualize_image.md   | 302 ++++++++
 docs/source/snippets/logging/api.txt          |   1 -
 docs/source/snippets/logging/cli.txt          |   1 -
 .../api/01_getting_started/basic_inference.py |  41 +
 .../api/01_getting_started/basic_training.py  |  33 +
 examples/api/02_data/folder.py                |  45 ++
 examples/api/02_data/mvtec.py                 |  38 +
 examples/api/03_models/efficient_ad.py        |  45 ++
 examples/api/03_models/padim.py               |  47 ++
 examples/api/03_models/patchcore.py           |  47 ++
 examples/api/04_advanced/loggers.py           |  75 ++
 .../api/05_pipelines/complete_pipeline.py     |  82 ++
 .../cli/00_installation/anomalib_install.sh   |  71 ++
 examples/cli/00_installation/pip_install.sh   |  38 +
 .../cli/00_installation/source_install.sh     |  91 +++
 .../cli/01_getting_started/basic_inference.sh |  52 ++
 .../cli/01_getting_started/basic_training.sh  |  26 +
 examples/cli/02_data/folder.sh                |  48 ++
 examples/cli/02_data/mvtec.sh                 |  38 +
 examples/cli/03_models/efficient_ad.sh        |  46 ++
 examples/cli/03_models/padim.sh               |  46 ++
 examples/cli/03_models/patchcore.sh           |  45 ++
 examples/cli/04_advanced/custom_components.sh |  53 ++
 examples/cli/04_advanced/custom_pipeline.sh   |  74 ++
 examples/cli/04_advanced/loggers.sh           |  52 ++
 .../cli/05_pipelines/complete_pipeline.sh     |  60 ++
 {configs => examples/configs}/README.md       |   0
 .../configs}/data/avenue.yaml                 |   0
 {configs => examples/configs}/data/btech.yaml |   0
 .../configs}/data/datumaro.yaml               |   0
 .../configs}/data/folder.yaml                 |   0
 .../configs}/data/kolektor.yaml               |   0
 {configs => examples/configs}/data/mvtec.yaml |   0
 .../configs}/data/mvtec_3d.yaml               |   0
 .../configs}/data/shanghaitech.yaml           |   0
 .../configs}/data/ucsd_ped.yaml               |   0
 {configs => examples/configs}/data/visa.yaml  |   0
 .../configs}/model/ai_vad.yaml                |   0
 {configs => examples/configs}/model/cfa.yaml  |   0
 .../configs}/model/cflow.yaml                 |   0
 .../configs}/model/csflow.yaml                |   0
 .../configs}/model/dfkde.yaml                 |   0
 {configs => examples/configs}/model/dfm.yaml  |   0
 .../configs}/model/draem.yaml                 |   0
 {configs => examples/configs}/model/dsr.yaml  |   0
 .../configs}/model/efficient_ad.yaml          |   0
 .../configs}/model/fastflow.yaml              |   0
 {configs => examples/configs}/model/fre.yaml  |   0
 .../configs}/model/ganomaly.yaml              |   0
 .../configs}/model/padim.yaml                 |   0
 .../configs}/model/patchcore.yaml             |   0
 .../configs}/model/reverse_distillation.yaml  |   0
 .../configs}/model/stfpm.yaml                 |   0
 .../configs}/model/uflow.yaml                 |   0
 .../001_getting_started.ipynb                 |   6 +-
 .../notebooks}/000_getting_started/README.md  |   2 +-
 .../100_datamodules/101_btech.ipynb           |   2 +-
 .../100_datamodules/102_mvtec.ipynb           |   2 +-
 .../100_datamodules/103_folder.ipynb          |   2 +-
 .../100_datamodules/104_tiling.ipynb          |   2 +-
 .../notebooks}/100_datamodules/README.md      |  12 +-
 .../notebooks}/200_models/201_fastflow.ipynb  |   4 +-
 .../notebooks}/200_models/README.md           |   2 +-
 .../notebooks}/400_openvino/401_nncf.ipynb    |   8 +-
 .../notebooks}/400_openvino/README.md         |   2 +-
 ..._model_with_cubes_from_a_robotic_arm.ipynb |   3 +
 .../501b_inference_with_a_robotic_arm.ipynb   |   0
 .../500_use_cases/501_dobot/README.md         |   0
 .../600_loggers/601_mlflow_logging.ipynb      |   4 +-
 .../notebooks}/600_loggers/README.md          |   0
 .../notebooks}/700_metrics/701a_aupimo.ipynb  |   6 +-
 .../700_metrics/701b_aupimo_advanced_i.ipynb  |   6 +-
 .../700_metrics/701c_aupimo_advanced_ii.ipynb |   6 +-
 .../701d_aupimo_advanced_iii.ipynb            |   0
 .../700_metrics/701e_aupimo_advanced_iv.ipynb |   0
 .../notebooks}/700_metrics/pimo_viz.svg       |   0
 .../notebooks}/700_metrics/roc_pro_pimo.svg   |   0
 {notebooks => examples/notebooks}/README.md   |  50 +-
 ..._model_with_cubes_from_a_robotic_arm.ipynb | 722 ------------------
 pyproject.toml                                |   2 +-
 src/anomalib/data/datamodules/base/image.py   |   4 +-
 src/anomalib/data/datamodules/base/video.py   |   2 +-
 .../models/components/base/anomalib_module.py |   4 +-
 src/anomalib/models/image/__init__.py         |  15 +-
 src/anomalib/models/image/cfa/__init__.py     |  17 +-
 .../models/image/padim/lightning_model.py     |  27 +-
 .../models/image/patchcore/__init__.py        |  16 +-
 .../models/image/patchcore/lightning_model.py |  32 +-
 .../image/reverse_distillation/__init__.py    |  16 +-
 .../reverse_distillation/lightning_model.py   |  16 +-
 src/anomalib/models/image/vlm_ad/__init__.py  |  13 +-
 .../models/image/vlm_ad/lightning_model.py    |   9 +-
 src/anomalib/models/image/winclip/__init__.py |  18 +-
 .../visualization/image/functional.py         |  42 +-
 .../visualization/image/item_visualizer.py    | 111 ++-
 tests/conftest.py                             |   2 +-
 .../data/datamodule/depth/test_folder_3d.py   |   2 +-
 .../data/datamodule/depth/test_mvtec_3d.py    |   2 +-
 .../unit/data/datamodule/image/test_btech.py  |   2 +-
 .../data/datamodule/image/test_datumaro.py    |   2 +-
 .../unit/data/datamodule/image/test_folder.py |   2 +-
 .../data/datamodule/image/test_kolektor.py    |   2 +-
 .../unit/data/datamodule/image/test_mvtec.py  |   2 +-
 tests/unit/data/datamodule/image/test_visa.py |   2 +-
 .../unit/data/datamodule/video/test_avenue.py |   2 +-
 .../datamodule/video/test_shanghaitech.py     |   2 +-
 .../data/datamodule/video/test_ucsdped.py     |   2 +-
 .../components/base/test_anomaly_module.py    |   2 +-
 tox.ini                                       |   9 +-
 131 files changed, 4116 insertions(+), 1152 deletions(-)
 create mode 100644 docs/source/markdown/guides/how_to/data/dataclasses.md
 create mode 100644 docs/source/markdown/guides/how_to/data/datamodules.md
 create mode 100644 docs/source/markdown/guides/how_to/data/datasets.md
 create mode 100644 docs/source/markdown/guides/how_to/evaluation/evaluator.md
 create mode 100644 docs/source/markdown/guides/how_to/evaluation/index.md
 create mode 100644 docs/source/markdown/guides/how_to/evaluation/metrics.md
 create mode 100644 docs/source/markdown/guides/how_to/models/post_processor.md
 create mode 100644 docs/source/markdown/guides/how_to/models/pre_processor.md
 create mode 100644 docs/source/markdown/guides/how_to/visualization/index.md
 create mode 100644 docs/source/markdown/guides/how_to/visualization/visualize_image.md
 create mode 100644 examples/api/01_getting_started/basic_inference.py
 create mode 100644 examples/api/01_getting_started/basic_training.py
 create mode 100644 examples/api/02_data/folder.py
 create mode 100644 examples/api/02_data/mvtec.py
 create mode 100644 examples/api/03_models/efficient_ad.py
 create mode 100644 examples/api/03_models/padim.py
 create mode 100644 examples/api/03_models/patchcore.py
 create mode 100644 examples/api/04_advanced/loggers.py
 create mode 100644 examples/api/05_pipelines/complete_pipeline.py
 create mode 100644 examples/cli/00_installation/anomalib_install.sh
 create mode 100644 examples/cli/00_installation/pip_install.sh
 create mode 100644 examples/cli/00_installation/source_install.sh
 create mode 100644 examples/cli/01_getting_started/basic_inference.sh
 create mode 100644 examples/cli/01_getting_started/basic_training.sh
 create mode 100644 examples/cli/02_data/folder.sh
 create mode 100644 examples/cli/02_data/mvtec.sh
 create mode 100644 examples/cli/03_models/efficient_ad.sh
 create mode 100644 examples/cli/03_models/padim.sh
 create mode 100644 examples/cli/03_models/patchcore.sh
 create mode 100644 examples/cli/04_advanced/custom_components.sh
 create mode 100644 examples/cli/04_advanced/custom_pipeline.sh
 create mode 100644 examples/cli/04_advanced/loggers.sh
 create mode 100644 examples/cli/05_pipelines/complete_pipeline.sh
 rename {configs => examples/configs}/README.md (100%)
 rename {configs => examples/configs}/data/avenue.yaml (100%)
 rename {configs => examples/configs}/data/btech.yaml (100%)
 rename {configs => examples/configs}/data/datumaro.yaml (100%)
 rename {configs => examples/configs}/data/folder.yaml (100%)
 rename {configs => examples/configs}/data/kolektor.yaml (100%)
 rename {configs => examples/configs}/data/mvtec.yaml (100%)
 rename {configs => examples/configs}/data/mvtec_3d.yaml (100%)
 rename {configs => examples/configs}/data/shanghaitech.yaml (100%)
 rename {configs => examples/configs}/data/ucsd_ped.yaml (100%)
 rename {configs => examples/configs}/data/visa.yaml (100%)
 rename {configs => examples/configs}/model/ai_vad.yaml (100%)
 rename {configs => examples/configs}/model/cfa.yaml (100%)
 rename {configs => examples/configs}/model/cflow.yaml (100%)
 rename {configs => examples/configs}/model/csflow.yaml (100%)
 rename {configs => examples/configs}/model/dfkde.yaml (100%)
 rename {configs => examples/configs}/model/dfm.yaml (100%)
 rename {configs => examples/configs}/model/draem.yaml (100%)
 rename {configs => examples/configs}/model/dsr.yaml (100%)
 rename {configs => examples/configs}/model/efficient_ad.yaml (100%)
 rename {configs => examples/configs}/model/fastflow.yaml (100%)
 rename {configs => examples/configs}/model/fre.yaml (100%)
 rename {configs => examples/configs}/model/ganomaly.yaml (100%)
 rename {configs => examples/configs}/model/padim.yaml (100%)
 rename {configs => examples/configs}/model/patchcore.yaml (100%)
 rename {configs => examples/configs}/model/reverse_distillation.yaml (100%)
 rename {configs => examples/configs}/model/stfpm.yaml (100%)
 rename {configs => examples/configs}/model/uflow.yaml (100%)
 rename {notebooks => examples/notebooks}/000_getting_started/001_getting_started.ipynb (99%)
 rename {notebooks => examples/notebooks}/000_getting_started/README.md (88%)
 rename {notebooks => examples/notebooks}/100_datamodules/101_btech.ipynb (99%)
 rename {notebooks => examples/notebooks}/100_datamodules/102_mvtec.ipynb (98%)
 rename {notebooks => examples/notebooks}/100_datamodules/103_folder.ipynb (99%)
 rename {notebooks => examples/notebooks}/100_datamodules/104_tiling.ipynb (99%)
 rename {notebooks => examples/notebooks}/100_datamodules/README.md (88%)
 rename {notebooks => examples/notebooks}/200_models/201_fastflow.ipynb (97%)
 rename {notebooks => examples/notebooks}/200_models/README.md (90%)
 rename {notebooks => examples/notebooks}/400_openvino/401_nncf.ipynb (94%)
 rename {notebooks => examples/notebooks}/400_openvino/README.md (90%)
 create mode 100644 examples/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb
 rename {notebooks => examples/notebooks}/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb (100%)
 rename {notebooks => examples/notebooks}/500_use_cases/501_dobot/README.md (100%)
 rename {notebooks => examples/notebooks}/600_loggers/601_mlflow_logging.ipynb (98%)
 rename {notebooks => examples/notebooks}/600_loggers/README.md (100%)
 rename {notebooks => examples/notebooks}/700_metrics/701a_aupimo.ipynb (96%)
 rename {notebooks => examples/notebooks}/700_metrics/701b_aupimo_advanced_i.ipynb (99%)
 rename {notebooks => examples/notebooks}/700_metrics/701c_aupimo_advanced_ii.ipynb (99%)
 rename {notebooks => examples/notebooks}/700_metrics/701d_aupimo_advanced_iii.ipynb (100%)
 rename {notebooks => examples/notebooks}/700_metrics/701e_aupimo_advanced_iv.ipynb (100%)
 rename {notebooks => examples/notebooks}/700_metrics/pimo_viz.svg (100%)
 rename {notebooks => examples/notebooks}/700_metrics/roc_pro_pimo.svg (100%)
 rename {notebooks => examples/notebooks}/README.md (67%)
 delete mode 100644 notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb

diff --git a/.gitattributes b/.gitattributes
index 687d38334e..575b174994 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -2,7 +2,6 @@
 * text=auto eol=lf
 *.{cmd,[cC][mM][dD]} text eol=crlf
 *.{bat,[bB][aA][tT]} text eol=crlf
-
 # Ignore *ipynb files to detect the language.
 # This is because GitHub misdetects the repo language when ipynb files are included.
-*.ipynb linguist-detectable=false
+*.ipynb filter=lfs diff=lfs merge=lfs -text
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 5703b7174c..c2ae2f560b 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -15,12 +15,12 @@
 /docs                                                       @samet-akcay
 
 # Notebooks
-/notebooks/000_getting_started                              @samet-akcay
-/notebooks/100_datamodules                                  @djdameln
-/notebooks/200_models                                       @samet-akcay
-/notebooks/300_benchmarking                                 @ashwinvaidya17
-/notebooks/400_openvino                                     @samet-akcay
-/notebooks/README.md                                        @samet-akcay
+/examples/notebooks/000_getting_started                              @samet-akcay
+/examples/notebooks/100_datamodules                                  @djdameln
+/examples/notebooks/200_models                                       @samet-akcay
+/examples/notebooks/300_benchmarking                                 @ashwinvaidya17
+/examples/notebooks/400_openvino                                     @samet-akcay
+/examples/notebooks/README.md                                        @samet-akcay
 
 # Requirements
 /requirements/                                              @samet-akcay @ashwinvaidya17 @djdameln
diff --git a/.github/workflows/_reusable-code-quality.yaml b/.github/workflows/_reusable-code-quality.yaml
index 077285a972..9c1d015c6a 100644
--- a/.github/workflows/_reusable-code-quality.yaml
+++ b/.github/workflows/_reusable-code-quality.yaml
@@ -62,6 +62,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          lfs: true
       - uses: ./.github/actions/code-quality/pre-commit
         with:
           python-version: ${{ inputs.python-version }}
diff --git a/.github/workflows/pre_merge.yml b/.github/workflows/pre_merge.yml
index 4742955d40..c66de4360b 100644
--- a/.github/workflows/pre_merge.yml
+++ b/.github/workflows/pre_merge.yml
@@ -23,6 +23,8 @@ jobs:
     steps:
       - name: CHECKOUT REPOSITORY
         uses: actions/checkout@v4
+        with:
+          lfs: true
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
@@ -53,7 +55,7 @@ jobs:
       - name: Link the dataset path to the dataset directory in the repository root.
         run: |
           ln -s $ANOMALIB_DATASET_PATH ./datasets
-          ln -s $ANOMALIB_DATASET_PATH ./notebooks/datasets
+          ln -s $ANOMALIB_DATASET_PATH ./examples/notebooks/datasets
       - name: Coverage
         run: tox -e pre-merge-${{ matrix.tox-env }}
       - name: Upload coverage report
diff --git a/.gitignore b/.gitignore
index 8362f12559..cbd16e82cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,8 +8,8 @@ results
 tmp*
 
 # Jupyter Notebooks
-notebooks/500_use_cases/501_dobot/
-!notebooks/500_use_cases/501_dobot/*.ipynb
+examples/notebooks/500_use_cases/501_dobot/
+!examples/notebooks/500_use_cases/501_dobot/*.ipynb
 
 # VENV
 .python-version
diff --git a/README.md b/README.md
index fdce3572a3..ea525474b6 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 

 
-Anomalib Logo
+Anomalib Logo - A deep learning library for anomaly detection
 
 **A library for benchmarking, developing and deploying deep learning anomaly detection algorithms**
 
@@ -8,23 +8,40 @@
 
 [Key Features](#key-features) •
 [Docs](https://anomalib.readthedocs.io/en/latest/) •
-[Notebooks](notebooks) •
+[Notebooks](examples/notebooks) •
 [License](LICENSE)
 
-[![python](https://img.shields.io/badge/python-3.7%2B-green)]()
-[![pytorch](https://img.shields.io/badge/pytorch-1.8.1%2B-orange)]()
-[![openvino](https://img.shields.io/badge/openvino-2022.3.0-purple)]()
+[![python](https://img.shields.io/badge/python-3.10%2B-green)]()
+[![pytorch](https://img.shields.io/badge/pytorch-2.0%2B-orange)]()
+[![lightning](https://img.shields.io/badge/lightning-2.2%2B-blue)]()
+[![openvino](https://img.shields.io/badge/openvino-2024.0%2B-purple)]()
 
 [![Pre-Merge Checks](https://github.com/openvinotoolkit/anomalib/actions/workflows/pre_merge.yml/badge.svg)](https://github.com/openvinotoolkit/anomalib/actions/workflows/pre_merge.yml)
-[![Documentation Status](https://readthedocs.org/projects/anomalib/badge/?version=latest)](https://anomalib.readthedocs.io/en/latest/?badge=latest)
 [![codecov](https://codecov.io/gh/openvinotoolkit/anomalib/branch/main/graph/badge.svg?token=Z6A07N1BZK)](https://codecov.io/gh/openvinotoolkit/anomalib)
 [![Downloads](https://static.pepy.tech/personalized-badge/anomalib?period=total&units=international_system&left_color=grey&right_color=green&left_text=PyPI%20Downloads)](https://pepy.tech/project/anomalib)
-[![Discord](https://img.shields.io/discord/1230798452577800237?style=plastic)](https://discord.com/channels/1230798452577800237)
+
+[![ReadTheDocs](https://readthedocs.org/projects/anomalib/badge/?version=latest)](https://anomalib.readthedocs.io/en/latest/?badge=latest)
+[![Anomalib - Gurubase docs](https://img.shields.io/badge/Gurubase-Ask%20Anomalib%20Guru-006BFF)](https://gurubase.io/g/anomalib)
 
 

 
 ---
 
+> 🌟 **Announcing v2.0.0 Beta Release!** 🌟
+>
+> We're excited to announce the beta release of Anomalib v2.0.0! This version introduces significant improvements and customization options to enhance your anomaly detection workflows. Please be aware that there are several API changes between `v1.2.0` and `v2.0.0`, so please be careful when updating your existing pipelines. We invite you to try it out and share your feedback:
+>
+> - Multi-GPU support
+> - New [dataclasses](https://anomalib.readthedocs.io/en/latest/markdown/guides/how_to/data/dataclasses.html) for model in- and outputs.
+> - Flexible configuration of [model transforms and data augmentations](https://anomalib.readthedocs.io/en/latest/markdown/guides/how_to/data/transforms.html).
+> - Configurable modules for pre- and post-processing operations via [`Preprocessor`](https://anomalib.readthedocs.io/en/latest/markdown/guides/how_to/models/pre_processor.html) and [`Postprocessor`](https://anomalib.readthedocs.io/en/latest/markdown/guides/how_to/models/post_processor.html)
+> - Customizable model evaluation workflow with new [Metrics API](https://anomalib.readthedocs.io/en/latest/markdown/guides/how_to/evaluation/metrics.html) and [`Evaluator`](https://anomalib.readthedocs.io/en/latest/markdown/guides/how_to/evaluation/evaluator.html) module.
+> - Configurable module for visualization via `Visualizer` (docs guide: coming soon)
+>
+> We value your input! Please test and share feedback via [GitHub Issues](https://github.com/openvinotoolkit/anomalib/issues) or our [Discussions](https://github.com/openvinotoolkit/anomalib/discussions)
+>
+> Install beta: `pip install anomalib==2.0.0-beta.1`
+
 # 👋 Introduction
 
 Anomalib is a deep learning library that aims to collect state-of-the-art anomaly detection algorithms for benchmarking on both public and private datasets. Anomalib provides several ready-to-use implementations of anomaly detection algorithms described in the recent literature, as well as a set of tools that facilitate the development and implementation of custom models. The library has a strong focus on visual anomaly detection, where the goal of the algorithm is to detect and/or localize anomalies within images or videos in a dataset. Anomalib is constantly updated with new algorithms and training/inference extensions, so keep checking!
@@ -43,91 +60,73 @@ Anomalib is a deep learning library that aims to collect state-of-the-art anomal
 
 # 📦 Installation
 
-Anomalib provides two ways to install the library. The first is through PyPI, and the second is through a local installation. PyPI installation is recommended if you want to use the library without making any changes to the source code. If you want to make changes to the library, then a local installation is recommended.
+Anomalib provides multiple installation options to suit your needs. Choose the one that best fits your requirements:
 
-

-Install from PyPI
-Installing the library with pip is the easiest way to get started with anomalib.
+## 🚀 Quick Install (Stable)
 
 ```bash
+# Basic installation
 pip install anomalib
+
+# Full installation with all dependencies
+pip install anomalib[full]
+```
+
+## 🌟 Beta Version (v2.0.0-beta.1)
+
+Try our latest beta release with new features and improvements:
+
+```bash
+# Basic beta installation
+pip install anomalib==2.0.0-beta.1
+
+# Full beta installation with all dependencies
+pip install anomalib[full]==2.0.0-beta.1
 ```
 
-This will install Anomalib CLI using the [dependencies](/pyproject.toml) in the `pyproject.toml` file. Anomalib CLI is a command line interface for training, inference, benchmarking, and hyperparameter optimization. If you want to use the library as a Python package, you can install the library with the following command:
+### 🛠️ Installation Options
+
+Use the CLI for customized installation:
 
 ```bash
-# Get help for the installation arguments
+# Get help for installation options
 anomalib install -h
 
-# Install the full package
+# Full package installation
 anomalib install
 
-# Install with verbose output
-anomalib install -v
-
-# Install the core package option only to train and evaluate models via Torch and Lightning
+# Core package only (for training and evaluation)
 anomalib install --option core
 
-# Install with OpenVINO option only. This is useful for edge deployment as the wheel size is smaller.
+# OpenVINO optimization support
 anomalib install --option openvino
 ```
 
-

+### 🔧 Development Install
 
-

-Install from source
-To install from source, you need to clone the repository and install the library using pip via editable mode.
+For contributing or customizing the library:
 
 ```bash
-# Use of virtual environment is highly recommended
-# Using conda
-yes | conda create -n anomalib_env python=3.10
-conda activate anomalib_env
-
-# Or using your favorite virtual environment
-# ...
-
-# Clone the repository and install in editable mode
 git clone https://github.com/openvinotoolkit/anomalib.git
 cd anomalib
 pip install -e .
-```
 
-This will install Anomalib CLI using the [dependencies](/pyproject.toml) in the `pyproject.toml` file. Anomalib CLI is a command line interface for training, inference, benchmarking, and hyperparameter optimization. If you want to use the library as a Python package, you can install the library with the following command:
-
-```bash
-# Get help for the installation arguments
-anomalib install -h
-
-# Install the full package
-anomalib install
-
-# Install with verbose output
-anomalib install -v
-
-# Install the core package option only to train and evaluate models via Torch and Lightning
-anomalib install --option core
-
-# Install with OpenVINO option only. This is useful for edge deployment as the wheel size is smaller.
-anomalib install --option openvino
+# Full development installation with all dependencies
+pip install -e .[full]
 ```
 
-

-
 # 🧠 Training
 
-Anomalib supports both API and CLI-based training. The API is more flexible and allows for more customization, while the CLI training utilizes command line interfaces, and might be easier for those who would like to use anomalib off-the-shelf.
+Anomalib supports both API and CLI-based training approaches:
 
-

-Training via API
+## 🔌 Python API
 
 ```python
-# Import the required modules
 from anomalib.data import MVTec
 from anomalib.models import Patchcore
 from anomalib.engine import Engine
 
-# Initialize the datamodule, model and engine
+# Initialize components
 datamodule = MVTec()
 model = Patchcore()
 engine = Engine()
@@ -136,39 +135,27 @@ engine = Engine()
 engine.fit(datamodule=datamodule, model=model)
 ```
 
-

-
-

-Training via CLI
+## ⌨️ Command Line
 
 ```bash
-# Get help about the training arguments, run:
-anomalib train -h
-
-# Train by using the default values.
+# Train with default settings
 anomalib train --model Patchcore --data anomalib.data.MVTec
 
-# Train by overriding arguments.
+# Train with custom category
 anomalib train --model Patchcore --data anomalib.data.MVTec --data.category transistor
 
-# Train by using a config file.
-anomalib train --config 
+# Train with config file
+anomalib train --config path/to/config.yaml
 ```
 
-

-
 # 🤖 Inference
 
-Anomalib includes multiple inferencing scripts, including Torch, Lightning, Gradio, and OpenVINO inferencers to perform inference using the trained/exported model. Here we show an inference example using the Lightning inferencer. For other inferencers, please refer to the [Inference Documentation](https://anomalib.readthedocs.io).
+Anomalib provides multiple inference options including Torch, Lightning, Gradio, and OpenVINO. Here's how to get started:
 
-

-Inference via API
-
-The following example demonstrates how to perform Lightning inference by loading a model from a checkpoint file.
+## 🔌 Python API
 
 ```python
-# Assuming the datamodule, model and engine is initialized from the previous step,
-# a prediction via a checkpoint file can be performed as follows:
+# Load model and make predictions
 predictions = engine.predict(
     datamodule=datamodule,
     model=model,
@@ -176,115 +163,68 @@ predictions = engine.predict(
 )
 ```
 
-

-
-

-Inference via CLI
+## ⌨️ Command Line
 
 ```bash
-# To get help about the arguments, run:
-anomalib predict -h
-
-# Predict by using the default values.
+# Basic prediction
 anomalib predict --model anomalib.models.Patchcore \
                  --data anomalib.data.MVTec \
-                 --ckpt_path 
+                 --ckpt_path path/to/model.ckpt
 
-# Predict by overriding arguments.
+# Prediction with results
 anomalib predict --model anomalib.models.Patchcore \
                  --data anomalib.data.MVTec \
-                 --ckpt_path 
+                 --ckpt_path path/to/model.ckpt \
                  --return_predictions
-
-# Predict by using a config file.
-anomalib predict --config  --return_predictions
 ```
 
-

+> 📘 **Note:** For advanced inference options including Gradio and OpenVINO, check our [Inference Documentation](https://anomalib.readthedocs.io).
 
 # ⚙️ Hyperparameter Optimization
 
-Anomalib supports hyperparameter optimization (HPO) using [wandb](https://wandb.ai/) and [comet.ml](https://www.comet.com/). For more details refer the [HPO Documentation](https://openvinotoolkit.github.io/anomalib/tutorials/hyperparameter_optimization.html)
-
-

-HPO via API
-
-```python
-# To be enabled in v1.1
-```
-
-

-
-

-HPO via CLI
-
-The following example demonstrates how to perform HPO for the Patchcore model.
+Anomalib supports hyperparameter optimization (HPO) using [Weights & Biases](https://wandb.ai/) and [Comet.ml](https://www.comet.com/).
 
 ```bash
-anomalib hpo --backend WANDB  --sweep_config tools/hpo/configs/wandb.yaml
+# Run HPO with Weights & Biases
+anomalib hpo --backend WANDB --sweep_config tools/hpo/configs/wandb.yaml
 ```
 
-

+> 📘 **Note:** For detailed HPO configuration, check our [HPO Documentation](https://openvinotoolkit.github.io/anomalib/tutorials/hyperparameter_optimization.html).
 
 # 🧪 Experiment Management
 
-Anomalib is integrated with various libraries for experiment tracking such as Comet, tensorboard, and wandb through [pytorch lighting loggers](https://pytorch-lightning.readthedocs.io/en/stable/extensions/logging.html). For more information, refer to the [Logging Documentation](https://openvinotoolkit.github.io/anomalib/tutorials/logging.html)
-
-

-Experiment Management via API
-
-```python
-# To be enabled in v1.1
-```
-
-

-
-

-Experiment Management via CLI
-
-Below is an example of how to enable logging for hyper-parameters, metrics, model graphs, and predictions on images in the test data-set.
+Track your experiments with popular logging platforms through [PyTorch Lightning loggers](https://pytorch-lightning.readthedocs.io/en/stable/extensions/logging.html):
 
-You first need to modify the `config.yaml` file to enable logging. The following example shows how to enable logging:
+- 📊 Weights & Biases
+- 📈 Comet.ml
+- 📉 TensorBoard
 
-```yaml
-# Place the experiment management config here.
-```
+Enable logging in your config file to track:
 
-```bash
-# Place the Experiment Management CLI command here.
-```
+- Hyperparameters
+- Metrics
+- Model graphs
+- Test predictions
 
-

+> 📘 **Note:** For logging setup, see our [Logging Documentation](https://openvinotoolkit.github.io/anomalib/tutorials/logging.html).
 
 # 📊 Benchmarking
 
-Anomalib provides a benchmarking tool to evaluate the performance of the anomaly detection models on a given dataset. The benchmarking tool can be used to evaluate the performance of the models on a given dataset, or to compare the performance of multiple models on a given dataset.
-
-Each model in anomalib is benchmarked on a set of datasets, and the results are available in `src/anomalib/models///README.md`. For example, the MVTec AD results for the Patchcore model are available in the corresponding [README.md](src/anomalib/models/image/patchcore/README.md#mvtec-ad-dataset) file.
-
-

-Benchmarking via API
-
-```python
-# To be enabled in v1.1
-```
-
-

-
-

-Benchmarking via CLI
-
-To run the benchmarking tool, run the following command:
+Evaluate and compare model performance across different datasets:
 
 ```bash
+# Run benchmarking with default configuration
 anomalib benchmark --config tools/benchmarking/benchmark_params.yaml
 ```
 
-

+> 💡 **Tip:** Check individual model performance in their respective README files:
+>
+> - [Patchcore Results](src/anomalib/models/image/patchcore/README.md#mvtec-ad-dataset)
+> - [Other Models](src/anomalib/models/)
 
 # ✍️ Reference
 
-If you use this library and love it, use this to cite it 🤗
+If you find Anomalib useful in your research or work, please cite:
 
 ```tex
 @inproceedings{akcay2022anomalib,
@@ -299,10 +239,14 @@ If you use this library and love it, use this to cite it 🤗
 
 # 👥 Contributing
 
-For those who would like to contribute to the library, see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+We welcome contributions! Check out our [Contributing Guide](CONTRIBUTING.md) to get started.
 
-Thank you to all of the people who have already made a contribution - we appreciate your support!
+

+  
+    Contributors to openvinotoolkit/anomalib
+  
+

 
-
-  Contributors to openvinotoolkit/anomalib
-
+

+  Thank you to all our contributors!
+

diff --git a/docs/source/conf.py b/docs/source/conf.py
index 890bb5100b..65e831a153 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -50,6 +50,8 @@
     "tasklist",
     "deflist",
     "fieldlist",
+    "amsmath",
+    "dollarmath",
 ]
 
 # Add separate setting for eval-rst
diff --git a/docs/source/markdown/get_started/anomalib.md b/docs/source/markdown/get_started/anomalib.md
index 4580c7fae5..34a9f130e9 100644
--- a/docs/source/markdown/get_started/anomalib.md
+++ b/docs/source/markdown/get_started/anomalib.md
@@ -17,8 +17,9 @@ The installer can be installed using the following commands:
 :::{tab-item} API
 :sync: label-1
 
-```{literalinclude} /snippets/install/pypi.txt
+```{literalinclude} ../../../../examples/cli/00_installation/pip_install.sh
 :language: bash
+:lines: 15
 ```
 
 :::
@@ -26,8 +27,9 @@ The installer can be installed using the following commands:
 :::{tab-item} Source
 :sync: label-2
 
-```{literalinclude} /snippets/install/source.txt
+```{literalinclude} ../../../../examples/cli/00_installation/source_install.sh
 :language: bash
+:lines: 10-34
 ```
 
 :::
@@ -42,23 +44,21 @@ The next section demonstrates how to install the full package using the CLI inst
 :::::{dropdown} Installing the Full Package
 After installing anomalib, you can install the full package using the following commands:
 
-```{literalinclude} /snippets/install/anomalib_help.txt
+```{literalinclude} ../../../../examples/cli/00_installation/anomalib_install.sh
 :language: bash
+:lines: 17-36
 ```
 
 As can be seen above, the only available sub-command is `install` at the moment.
 The `install` sub-command has options to install either the full package or the
 specific components of the package.
 
-```{literalinclude} /snippets/install/anomalib_install_help.txt
-:language: bash
-```
-
 By default the `install` sub-command installs the full package. If you want to
 install only the specific components of the package, you can use the `--option` flag.
 
-```{literalinclude} /snippets/install/anomalib_install.txt
+```{literalinclude} ../../../../examples/cli/00_installation/anomalib_install.sh
 :language: bash
+:lines: 39-68
 ```
 
 After following these steps, your environment will be ready to use anomalib!
@@ -74,15 +74,16 @@ interfaces, and might be easier for those who would like to use anomalib off-the
 
 :::{tab-item} API
 
-```{literalinclude} /snippets/train/api/default.txt
+```{literalinclude} ../../../../examples/api/01_getting_started/basic_training.py
 :language: python
+:lines: 10-34
 ```
 
 :::
 
 :::{tab-item} CLI
 
-```{literalinclude} /snippets/train/cli/default.txt
+```{literalinclude} ../../../../examples/cli/01_getting_started/basic_training.sh
 :language: bash
 ```
 
@@ -102,7 +103,7 @@ Anomalib includes multiple inferencing scripts, including Torch, Lightning, Grad
 :::{tab-item} API
 :sync: label-1
 
-```{literalinclude} /snippets/inference/api/lightning.txt
+```{literalinclude} ../../../../examples/api/01_getting_started/basic_inference.py
 :language: python
 ```
 
@@ -111,7 +112,7 @@ Anomalib includes multiple inferencing scripts, including Torch, Lightning, Grad
 :::{tab-item} CLI
 :sync: label-2
 
-```{literalinclude} /snippets/inference/cli/lightning.txt
+```{literalinclude} ../../../../examples/cli/01_getting_started/basic_inference.sh
 :language: bash
 ```
 
@@ -128,7 +129,7 @@ Anomalib includes multiple inferencing scripts, including Torch, Lightning, Grad
 :sync: label-1
 
 ```{code-block} python
-Python code here.
+
 ```
 
 :::
@@ -137,7 +138,7 @@ Python code here.
 :sync: label-2
 
 ```{code-block} bash
-CLI command here.
+
 ```
 
 :::
@@ -153,7 +154,7 @@ CLI command here.
 :sync: label-1
 
 ```{code-block} python
-Python code here.
+
 ```
 
 :::
@@ -162,7 +163,7 @@ Python code here.
 :sync: label-2
 
 ```{code-block} bash
-CLI command here.
+
 ```
 
 :::
@@ -178,7 +179,7 @@ CLI command here.
 :sync: label-1
 
 ```{code-block} python
-Python code here.
+
 ```
 
 :::
@@ -187,7 +188,7 @@ Python code here.
 :sync: label-2
 
 ```{code-block} bash
-CLI command here.
+
 ```
 
 :::
@@ -230,7 +231,7 @@ Anomalib is integrated with various libraries for experiment tracking such as co
 To run a training experiment with experiment tracking, you will need the following configuration file:
 
 ```{code-block} yaml
-# Place the experiment management config here.
+
 ```
 
 By using the configuration file above, you can run the experiment with the following command:
@@ -272,7 +273,7 @@ anomalib benchmark --config tools/benchmarking/benchmark_params.yaml
 :::{tab-item} API
 
 ```{code-block} python
-# To be enabled in v1.1
+
 ```
 
 :::
diff --git a/docs/source/markdown/get_started/migration.md b/docs/source/markdown/get_started/migration.md
index 8380e23a3c..65545e4787 100644
--- a/docs/source/markdown/get_started/migration.md
+++ b/docs/source/markdown/get_started/migration.md
@@ -1,18 +1,41 @@
-# Migrating from 0.\* to 1.0
+# Migration Guide
 
-## Overview
+::::{grid} 1 2 2 2
+:gutter: 2
+:padding: 1
+
+:::{grid-item-card} {octicon}`versions` v0.\* to v1.0
+:link: migrating-from-0-to-1-0
+:link-type: ref
+
+Learn how to migrate from v0.\* to v1.0, including changes to configuration, CLI, and API.
+:::
+
+:::{grid-item-card} {octicon}`versions` v1.0 to v2.0
+:link: migrating-from-1-0-to-2-0
+:link-type: ref
+
+Learn how to migrate from v1.0 to v2.0.
+:::
+::::
+
+(migrating-from-0-to-1-0)=
+
+## Migrating from 0.\* to 1.0
+
+### Overview
 
 The 1.0 release of the Anomaly Detection Library (AnomalyLib) introduces several
 changes to the library. This guide provides an overview of the changes and how
 to migrate from 0.\* to 1.0.
 
-## Installation
+### Installation
 
 For installation instructions, refer to the [installation guide](anomalib.md).
 
-## Changes to the CLI
+### Changes to the CLI
 
-### Upgrading the Configuration
+#### Upgrading the Configuration
 
 There are several changes to the configuration of Anomalib. The configuration
 file has been updated to include new parameters and remove deprecated parameters.
@@ -33,9 +56,9 @@ This script will ensure that the configuration file is updated to the 1.0 format
 In the following sections, we will discuss the changes to the configuration file
 in more detail.
 
-### Changes to the Configuration File
+#### Changes to the Configuration File
 
-#### Data
+##### Data
 
 The `data` section of the configuration file has been updated such that the args
 can be directly used to instantiate the data object. Below are the differences
@@ -91,7 +114,7 @@ Here is the summary of the changes to the configuration file:
   removed in the new configuration. v1.0.0 does not support tiling. This feature
   will be added back in a future release.
 
-#### Model
+##### Model
 
 Similar to data configuration, the `model` section of the configuration file has
 been updated such that the args can be directly used to instantiate the model object.
@@ -130,7 +153,7 @@ Here is the summary of the changes to the configuration file:
 - Normalization Method: The `normalization_method` key is removed from the `model`
   section and moved to a separate `normalization` section in the new configuration.
 
-#### Metrics
+##### Metrics
 
 The `metrics` section of the configuration file has been updated such that the
 args can be directly used to instantiate the metrics object. Below are the differences
@@ -162,3 +185,11 @@ Here is the summary of the changes to the configuration file:
   loaded configuration system.
 - Threshold Method: The `method` key is removed from the `threshold` section and
   moved to a separate `class_path` section in the new configuration.
+
+(migrating-from-1-0-to-2-0)=
+
+## Migrating from 1.0 to 2.0
+
+### Overview
+
+The 2.0 release of Anomalib introduces several changes to the library. This guide will be updated with migration instructions when v2.0 is released.
diff --git a/docs/source/markdown/guides/how_to/data/dataclasses.md b/docs/source/markdown/guides/how_to/data/dataclasses.md
new file mode 100644
index 0000000000..fe8810bf3c
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/data/dataclasses.md
@@ -0,0 +1,314 @@
+```{eval-rst}
+:orphan:
+```
+
+# Dataclasses
+
+This guide explains how to use the dataclasses in Anomalib, from basic usage to advanced use cases across different modalities.
+
+## Basic Concepts
+
+Anomalib uses dataclasses to represent and validate data throughout the pipeline. Anomalib's dataclasses are based on python's
+native dataclasses, but are extended with several useful features to facilitate input validation and easy conversion.
+Dataclasses are used by the `AnomalibDataset` and `AnomalibDatamodule` to represent input data and ground truth annotations,
+and by the `AnomalibModule` to store the model predictions. For basic users, knowing how to access and update the fields
+of Anomalib's dataclasses is sufficient to cover most use-cases.
+
+The dataclasses are designed to be:
+
+- **Type-safe**: All fields are validated to ensure correct types and shapes
+- **Modality-specific**: Specialized classes for images, videos, and depth data
+- **Framework-specific**: Support for both PyTorch and NumPy backends
+- **Batch-aware**: Handle both single items and batches of data
+
+The dataclass system is built around two main concepts:
+
+1. **Item**: Single data instance (e.g., one image)
+2. **Batch**: Collection of items with batch processing capabilities
+
+The Item and Batch classes are defined separately for the different data modalities in the libary. For example, when
+working with image data, the relevant classes are `ImageItem` and `ImageBatch`.
+
+## Input- and Output fields
+
+All dataclasses are equipped with the following standard data fields:
+
+1. **Input Fields**: Base fields for anomaly detection data
+
+   - `image`: Input image/video
+   - `gt_label`: Ground truth label
+   - `gt_mask`: Ground truth segmentation mask
+   - `mask_path`: Path to mask file
+
+2. **Output Fields**: Fields for model predictions
+   - `anomaly_map`: Predicted anomaly heatmap
+   - `pred_score`: Predicted anomaly score
+   - `pred_mask`: Predicted segmentation mask
+   - `pred_label`: Predicted label
+   - `explanation`: Path to explanation visualization
+
+Out of these standard fields, only `image` is mandatory. All other fields are optional. In addition to the standard fields,
+Anomalib's dataclasses may contain additional modality-specific input and output fields, depending on the modality of the
+data (Image, Video, Depth).
+
+## Basic Usage
+
+### Creating a dataclass instance
+
+To create a new dataclass instance, simply pass the data to the constructor using the keyword arguments. For example, we could use the following code to create a new instance of an `ImageItem` from a randomly generated image and an all-negative (no anomalous pixels) ground truth mask.
+
+```{code-block} python
+import torch
+from anomalib.data import ImageItem
+
+item = ImageItem(
+    image=torch.rand((3, 224, 224)),
+    image_path="path/to/my/image.png"
+    gt_label=0,
+    gt_mask=torch.zeros((224, 224)),
+)
+```
+
+After creating the instance, you can directly access any of the provided fields of the dataclass
+
+```{code-block} python
+print(item.image_path)   # "path/to/my/image.png"
+print(item.image.shape)  # torch.Size([3, 224, 224])
+```
+
+Similarly, we could create a batch of images, by directly defining an image tensor with a leading batch dimension. Let's create a random batch consisting of 8 images.
+
+```{code-block} python
+import torch
+from anomalib.data import ImageItem
+
+batch = ImageBatch(
+    image=torch.rand((8, 3, 224, 224)),
+    gt_label=[0, ] * 8,
+    gt_mask=torch.zeros((8, 224, 224)),
+)
+```
+
+Again, we can inspect the fields of the batch instance by accessing them directly. In addition, the `Batch` class provides
+a useful `batch_size` property to quickly retrieve the number of items in the batch.
+
+```{code-block} python
+print(batch.image.shape)  # torch.Size([8, 3, 224, 224])
+print(batch.batch_size)   # 8
+```
+
+> **Note:**
+> The above examples are for illustrative purposes. In general, most use-cases don't require instantiating dataclasses explicitly,
+> as Anomalib's modules create and return the dataclass instances.
+
+### Validation and formatting
+
+The dataclass performs some validation checks to assert that the provided values have the expected shape and format, and
+automatically converts the values to the correct datatype where possible. This ensures that all instances of the dataclass
+will always use the same shapes and data types to represent the input- and output fields!
+
+```{code-block} python
+item = ImageItem(
+    image=torch.rand((8, 3, 224, 224))
+)
+# raises ValueError because provided value has one dimension too many (batch cannot be converted to single item).
+
+batch = ImageBatch(
+    image=torch.rand((3, 224, 224)),
+    gt_label = [1],
+)
+print(batch.image.shape)  # torch.Size([1, 3, 224, 224])  <-- leading batch dimension added automatically
+print(batch.gt_label)     # tensor([True])                 <-- positive label converted to boolean tensor
+```
+
+### Updating a dataclass instance
+
+To update a field of a dataclass instance, simply overwrite its value. The dataclass will automatically run the validation
+checks before assigning the updated value to the instance!
+
+```{code-block} python
+item = ImageItem(
+    image=torch.rand((3, 224, 224)),
+    gt_label=tensor(False),
+)
+
+# overwrite an existing field
+item.gt_label = tensor(True)
+print(item.gt_label)  # tensor(True)
+
+# assign a previously unassigned field
+item.image_path = "path/to/my/image.png"
+print(item.image_path)  # "path/to/my/image.png"
+
+# input validation and auto formatting still works
+item.pred_score = 0.45
+print(item.pred_score)  # tensor(0.4500)
+```
+
+As an alternative method of updating dataclass fields, Anomalib's dataclasses are equipped with the `update` method. By default,
+the `update` method updates the dataclass instance inplace, meaning that the original instance will be modified.
+
+```{code-block} python
+item = ImageItem(
+    image=torch.rand((3, 224, 224)),
+    pred_score=0.33,
+)
+item.update(pred_score=0.87)  # this is equivalent to item.pred_score=0.87
+print(item.pred_score)        # 0.87
+```
+
+If you want to keep the original item, you can pass `inplace=False`, and use the new instance returned by `update`.
+
+```{code-block} python
+item = ImageItem(
+    image=torch.rand((3, 224, 224)),
+    pred_score=0.33,
+)
+new_item = item.update(pred_score=0.87, inplace=False)  # the original item will remain unmodified
+print(item.pred_score)      # 0.33
+print(new_item.pred_score)  # 0.87
+```
+
+The `update` method can be useful in situations where you want to update multiple fields at once, for example from a dictionary
+of predictions returned by your model. This can be achieved by specifying each field as a keyword argument, or by passing an
+entire dictionary using the `**` notation:
+
+```{code-block} python
+item.update(
+    pred_score=0.87,
+    pred_label=True,
+)
+
+# the following would have the same effect as the statement above
+predictions = {
+    "pred_score": 0.87,
+    "pred_label": True,
+}
+item.update(**predictions)
+```
+
+### Converting between items and batch
+
+It is very easy to switch between `Item` and `Batch` instances. To separate a `Batch` instance into a list of `Item`s, simply
+use the `items` property:
+
+```{code-block} python
+batch = ImageBatch(
+    image=torch.rand((4, 3, 360, 240))
+)
+items = batch.items  # list of Item instances
+```
+
+Conversely, `Batch` has a `collate` method that can be invoked to create a new `Batch` instance from a list of `Item`s.
+
+```{code-block} python
+new_batch = ImageBatch.collate(items)  # construct a new batch from a list of Items
+```
+
+It is also possible to directly iterate over the `Item`s in a batch, without explicitly calling the `items` property:
+
+```{code-block} python
+for item in batch:
+    # use item
+```
+
+### Converting Between Frameworks
+
+All dataclasses support conversion between PyTorch and NumPy:
+
+```{code-block} python
+# Items
+numpy_item = torch_item.to_numpy()
+
+# Batches
+numpy_batch = torch_batch.to_numpy()
+```
+
+## Supported Modalities
+
+### 1. Image Data
+
+The most basic form, supporting RGB images:
+
+```{code-block} python
+from anomalib.data.dataclasses.torch import ImageItem, ImageBatch
+
+# Single image
+item = ImageItem(
+    image=torch.rand(3, 224, 224),
+    gt_label=torch.tensor(0),
+    image_path="image.jpg"
+)
+
+# Batch of images
+batch = ImageBatch(
+    image=torch.rand(32, 3, 224, 224),
+    gt_label=torch.randint(0, 2, (32,)),
+    image_path=[f"image_{i}.jpg" for i in range(32)]
+)
+```
+
+### 2. Video Data
+
+For video processing with temporal information:
+
+```{code-block} python
+from anomalib.data.dataclasses.torch import VideoItem, VideoBatch
+
+# Single video item
+item = VideoItem(
+    image=torch.rand(10, 3, 224, 224),  # 10 frames
+    gt_label=torch.tensor(0),
+    video_path="path/to/video.mp4",
+)
+
+# Batch of video items
+batch = VideoBatch(
+    image=torch.rand(32, 10, 3, 224, 224),  # 32 videos, 10 frames
+    gt_label=torch.randint(0, 2, (32,)),
+    video_path=["video_{}.mp4".format(i) for i in range(32)],
+)
+```
+
+### 3. Depth Data
+
+For RGB-D or depth-only processing:
+
+```{code-block} python
+from anomalib.data.dataclasses.torch import DepthItem, DepthBatch
+
+# Single depth item
+item = DepthItem(
+    image=torch.rand(3, 224, 224),          # RGB image
+    depth_map=torch.rand(224, 224),         # Depth map
+    image_path="rgb.jpg",
+    depth_path="depth.png",
+)
+
+# Batch of depth items
+batch = DepthBatch(
+    image=torch.rand(32, 3, 224, 224),           # RGB images
+    depth_map=torch.rand(32, 224, 224),          # Depth maps
+    image_path=[f"rgb_{i}.jpg" for i in range(32)],
+    depth_path=[f"depth_{i}.png" for i in range(32)],
+)
+```
+
+## Best Practices
+
+1. **Type Hints**: Always use appropriate type hints when subclassing
+2. **Validation**: Implement custom validators for special requirements
+3. **Batch Size**: Keep batch dimensions consistent across all fields
+4. **Paths**: Use relative paths when possible for portability
+5. **Batch Processing**: Use batch operations when possible for better performance
+6. **Device Management**: Keep tensors on the same device within a batch
+
+## Common Pitfalls
+
+1. **Inconsistent Shapes**: Ensure all batch dimensions match
+2. **Missing Fields**: Required fields must be provided
+3. **Type Mismatches**: Use correct tensor types (torch vs numpy)
+4. **Memory Leaks**: Clear large batches when no longer needed
+5. **Path Issues**: Use proper path separators for cross-platform compatibility
+6. **Device Mismatches**: Ensure all tensors in a batch are on the same device
+7. **Batch Size Inconsistency**: Maintain consistent batch sizes across all fields
diff --git a/docs/source/markdown/guides/how_to/data/datamodules.md b/docs/source/markdown/guides/how_to/data/datamodules.md
new file mode 100644
index 0000000000..6be8a64b99
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/data/datamodules.md
@@ -0,0 +1,233 @@
+```{eval-rst}
+:orphan:
+```
+
+# Datamodules
+
+This guide explains how Lightning DataModules work in Anomalib and how they integrate with {doc}`datasets <./datasets>` and {doc}`dataclasses <./dataclasses>`.
+
+## Overview
+
+DataModules encapsulate all the steps needed to process data:
+
+- Download/prepare the data
+- Set up train/val/test datasets
+- Apply transforms
+- Create data loaders
+
+## Basic Structure
+
+A typical Anomalib DataModule follows this structure:
+
+```python
+from lightning.pytorch import LightningDataModule
+from anomalib.data.datasets.base.image import AnomalibDataset
+from torch.utils.data import DataLoader
+
+class AnomalibDataModule(LightningDataModule):
+    def __init__(
+        self,
+        root: str = "./datasets",
+        category: str = "bottle",
+        image_size: tuple[int, int] = (256, 256),
+        train_batch_size: int = 32,
+        eval_batch_size: int = 32,
+        num_workers: int = 8,
+        transform = None,
+    ):
+        super().__init__()
+        self.root = root
+        self.category = category
+        self.image_size = image_size
+        self.train_batch_size = train_batch_size
+        self.eval_batch_size = eval_batch_size
+        self.num_workers = num_workers
+        self.transform = transform
+```
+
+## Integration with Datasets
+
+DataModules create and manage dataset instances:
+
+```python
+def setup(self, stage: str | None = None):
+    """Set up train, validation and test datasets."""
+    if stage == "fit" or stage is None:
+        self.train_dataset = AnomalibDataset(
+            root=self.root,
+            category=self.category,
+            transform=self.transform,
+            split="train"
+        )
+
+        self.val_dataset = AnomalibDataset(
+            root=self.root,
+            category=self.category,
+            transform=self.transform,
+            split="val"
+        )
+
+    if stage == "test" or stage is None:
+        self.test_dataset = AnomalibDataset(
+            root=self.root,
+            category=self.category,
+            transform=self.transform,
+            split="test"
+        )
+```
+
+## Integration with Dataclasses
+
+DataModules use DataLoaders to convert dataset items into batches:
+
+```python
+def train_dataloader(self) -> DataLoader:
+    """Create the train dataloader."""
+    return DataLoader(
+        dataset=self.train_dataset,
+        batch_size=self.train_batch_size,
+        shuffle=True,
+        num_workers=self.num_workers,
+        collate_fn=ImageBatch.collate    # Converts list of ImageItems to ImageBatch
+    )
+```
+
+The data flow is:
+
+1. Dataset returns {doc}`ImageItem <./dataclasses>` objects
+2. DataLoader collates them into {doc}`ImageBatch <./dataclasses>` objects
+3. Model receives ImageBatch for training/inference
+
+## Example DataModules
+
+### 1. Image DataModule
+
+```python
+from anomalib.data import MVTec
+
+datamodule = MVTec(
+    root="./datasets/MVTec",
+    category="bottle",
+    train_batch_size=32,
+    eval_batch_size=32,
+    num_workers=8
+)
+
+# Setup creates the datasets
+datamodule.setup()
+
+# Get train dataloader
+train_loader = datamodule.train_dataloader()
+
+# Access batches
+for batch in train_loader:
+    print(batch.image.shape)      # torch.Size([32, 3, 256, 256])
+    print(batch.gt_label.shape)   # torch.Size([32])
+```
+
+### 2. Video DataModule
+
+```python
+from anomalib.data import Avenue
+
+datamodule = Avenue(
+    clip_length_in_frames=2,
+    frames_between_clips=1,
+    target_frame="last",
+)
+datamodule.setup()
+i, data = next(enumerate(datamodule.train_dataloader()))
+data["image"].shape
+# torch.Size([32, 2, 3, 256, 256])
+```
+
+### 3. Depth DataModule
+
+```python
+from anomalib.data import MVTec3D
+
+datamodule = MVTec3D(
+    root="./datasets/MVTec3D",
+    category="bagel",
+    train_batch_size=32,
+)
+
+# Access RGB-D batches
+i, data = next(enumerate(datamodule.train_dataloader()))
+data["image"].shape
+# torch.Size([32, 3, 256, 256])
+data["depth_map"].shape
+# torch.Size([32, 1, 256, 256])
+```
+
+## Creating Custom DataModules
+
+To create a custom DataModule:
+
+```python
+from pytorch_lightning import LightningDataModule
+from torch.utils.data import DataLoader
+from anomalib.data.dataclasses import ImageBatch
+
+class CustomDataModule(LightningDataModule):
+    def __init__(
+        self,
+        root: str,
+        category: str,
+        train_batch_size: int = 32,
+        **kwargs
+    ):
+        super().__init__()
+        self.root = root
+        self.category = category
+        self.image_size = image_size
+        self.train_batch_size = train_batch_size
+
+    def setup(self, stage: str | None = None):
+        """Initialize datasets."""
+        if stage == "fit" or stage is None:
+            self.train_dataset = CustomDataset(
+                root=self.root,
+                category=self.category,
+                split="train"
+            )
+
+    def train_dataloader(self) -> DataLoader:
+        """Create train dataloader."""
+        return DataLoader(
+            dataset=self.train_dataset,
+            batch_size=self.train_batch_size,
+            shuffle=True,
+            collate_fn=ImageBatch.collate
+        )
+```
+
+## Best Practices
+
+1. **Data Organization**:
+
+   - Keep dataset creation in `setup()`
+   - Use appropriate batch sizes for train/eval
+   - Handle multi-GPU scenarios
+
+2. **Memory Management**:
+
+   - Use appropriate number of workers
+   - Clear cache between epochs if needed
+   - Handle GPU memory efficiently
+
+3. **Transforms**:
+
+   - Apply consistent transforms across splits
+   - Use torchvision.transforms.v2
+   - Handle different input modalities
+
+4. **Validation**:
+   - Verify data shapes and types
+   - Check batch size consistency
+   - Validate paths and parameters
+
+```{seealso}
+- For details on dataset implementation, see the {doc}`datasets guide <./datasets>`.
+- For information about the data objects, see the {doc}`dataclasses guide <./dataclasses>`.
+```
diff --git a/docs/source/markdown/guides/how_to/data/datasets.md b/docs/source/markdown/guides/how_to/data/datasets.md
new file mode 100644
index 0000000000..3a8a593984
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/data/datasets.md
@@ -0,0 +1,296 @@
+```{eval-rst}
+:orphan:
+```
+
+# Datasets
+
+This guide explains how datasets work in Anomalib, from the base implementation to specific dataset types and how to create your own dataset.
+
+## Base Dataset Structure
+
+Anomalib's dataset system is built on top of PyTorch's `Dataset` class and uses pandas DataFrames to manage dataset samples. The base class `AnomalibDataset` provides the foundation for all dataset implementations.
+
+### Core Components
+
+The dataset consists of three main components:
+
+1. **Samples DataFrame**: The heart of each dataset is a DataFrame containing:
+
+   - `image_path`: Path to the image file
+   - `split`: Dataset split (train/test/val)
+   - `label_index`: Label index (0 for normal, 1 for anomalous)
+   - `mask_path`: Path to mask file (for segmentation tasks)
+
+   Example DataFrame:
+
+   ```python
+   df = pd.DataFrame({
+       'image_path': ['path/to/image.png'],
+       'label': ['anomalous'],
+       'label_index': [1],
+       'mask_path': ['path/to/mask.png'],
+       'split': ['train']
+   })
+   ```
+
+2. **Transforms**: Optional transformations applied to images
+
+3. **Task Type**: Classification or Segmentation
+
+## Dataset Types
+
+Anomalib supports different types of datasets based on modality:
+
+### 1. Image Datasets
+
+The most common type, supporting RGB images:
+
+```python
+from anomalib.data.datasets import MVTecDataset
+
+# Create MVTec dataset
+dataset = MVTecDataset(
+    root="./datasets/MVTec",
+    category="bottle",
+    split="train"
+)
+
+# Access an item
+item = dataset[0]
+print(item.image.shape)         # RGB image
+print(item.gt_label.item())     # Label (0 or 1)
+print(item.gt_mask.shape)       # Segmentation mask (if available)
+```
+
+### 2. Video Datasets
+
+For video anomaly detection:
+
+```python
+from anomalib.data.datasets import Avenue
+
+# Create video dataset
+dataset = AvenueDataset(
+    root="./datasets/avenue",
+    split="test",
+    transform=transform
+)
+
+# Access an item
+item = dataset[0]
+print(item.frames.shape)        # Video frames
+print(item.target_frame)        # Frame number
+```
+
+### 3. Depth Datasets
+
+For RGB-D or depth-only data:
+
+```python
+from anomalib.data.datasets import MVTec3DDataset
+
+# Create depth dataset
+dataset = MVTec3DDataset(
+    root="./datasets/MVTec3D",
+    category="bagel",
+    split="train",
+)
+
+# Access an item
+item = dataset[0]
+print(item.image.shape)         # RGB image
+print(item.depth_map.shape)     # Depth map
+```
+
+## Dataset Loading Process
+
+The dataset loading process follows these steps:
+
+1. **Initialization**:
+
+   ```python
+   def __init__(self, transform=None):
+       self.transform = transform
+       self._samples = None
+       self._category = None
+   ```
+
+2. **Sample Collection**:
+
+   ```python
+   @property
+   def samples(self):
+       if self._samples is None:
+           raise RuntimeError("Samples DataFrame not set")
+       return self._samples
+   ```
+
+3. **Item Loading**:
+
+   ```python
+   def __getitem__(self, index):
+       sample = self.samples.iloc[index]
+       image = read_image(sample.image_path)
+
+       if self.transform:
+           image = self.transform(image)
+
+       return ImageItem(
+           image=image,
+           gt_label=sample.label_index
+       )
+   ```
+
+### Integration with Dataclasses
+
+Anomalib datasets are designed to work seamlessly with the dataclass system. When you access items from a dataset:
+
+- Single items are returned as {doc}`Item objects <./dataclasses>` (e.g., `ImageItem`, `VideoItem`, `DepthItem`)
+- When used with PyTorch's DataLoader, items are automatically collated into {doc}`Batch objects <./dataclasses>` (e.g., `ImageBatch`, `VideoBatch`, `DepthBatch`)
+
+For example:
+
+```python
+# Single item access returns an Item object
+item = dataset[0]              # Returns ImageItem
+
+# DataLoader automatically creates Batch objects
+dataloader = DataLoader(dataset, batch_size=32)
+batch = next(iter(dataloader))  # Returns ImageBatch
+```
+
+```{seealso}
+For more details on working with Item and Batch objects, see the {doc}`dataclasses guide <./dataclasses>`.
+```
+
+## Creating Custom Datasets
+
+To create a custom dataset, extend the `AnomalibDataset` class:
+
+```python
+from anomalib.data.datasets.base import AnomalibDataset
+from pathlib import Path
+import pandas as pd
+
+class CustomDataset(AnomalibDataset):
+    """Custom dataset implementation."""
+
+    def __init__(
+        self,
+        root: Path | str = "./datasets/Custom",
+        category: str = "default",
+        transform = None,
+        split = None,
+    ):
+        super().__init__(transform=transform)
+
+        # Set up dataset
+        self.root = Path(root)
+        self.category = category
+        self.split = split
+
+        # Create samples DataFrame
+        self.samples = self._make_dataset()
+
+    def _make_dataset(self) -> pd.DataFrame:
+        """Create dataset samples DataFrame."""
+        samples_list = []
+
+        # Collect normal samples
+        normal_path = self.root / "normal"
+        for image_path in normal_path.glob("*.png"):
+            samples_list.append({
+                "image_path": str(image_path),
+                "label": "normal",
+                "label_index": 0,
+                "split": "train"
+            })
+
+        # Collect anomalous samples
+        anomaly_path = self.root / "anomaly"
+        for image_path in anomaly_path.glob("*.png"):
+            mask_path = anomaly_path / "masks" / f"{image_path.stem}_mask.png"
+            samples_list.append({
+                "image_path": str(image_path),
+                "label": "anomaly",
+                "label_index": 1,
+                "mask_path": str(mask_path),
+                "split": "test"
+            })
+
+        # Create DataFrame
+        samples = pd.DataFrame(samples_list)
+        samples.attrs["task"] = "segmentation"
+
+        return samples
+```
+
+### Expected Directory Structure
+
+For the custom dataset above:
+
+```bash
+datasets/
+└── Custom/
+    ├── normal/
+    │   ├── 001.png
+    │   ├── 002.png
+    │   └── ...
+    └── anomaly/
+        ├── 001.png
+        ├── 002.png
+        └── masks/
+            ├── 001_mask.png
+            ├── 002_mask.png
+            └── ...
+```
+
+## Best Practices
+
+1. **Data Organization**:
+
+   - Keep consistent directory structure
+   - Use clear naming conventions
+   - Separate train/test splits
+
+2. **Validation**:
+
+   - Validate image paths exist
+   - Ensure mask-image correspondence
+   - Check label consistency
+
+3. **Performance**:
+
+   - Use appropriate data types
+   - Implement efficient data loading
+   - Cache frequently accessed data
+
+4. **Error Handling**:
+   - Provide clear error messages
+   - Handle missing files gracefully
+   - Validate input parameters
+
+## Common Pitfalls
+
+1. **Path Issues**:
+
+   - Incorrect root directory
+   - Missing mask files
+   - Inconsistent file extensions
+
+2. **Data Consistency**:
+
+   - Mismatched image-mask pairs
+   - Inconsistent image sizes
+   - Wrong label assignments
+
+3. **Memory Management**:
+
+   - Loading too many images at once
+   - Not releasing unused resources
+   - Inefficient data structures
+
+4. **Transform Issues**:
+   - Incompatible transforms
+   - Missing normalization
+   - Incorrect transform order
diff --git a/docs/source/markdown/guides/how_to/data/index.md b/docs/source/markdown/guides/how_to/data/index.md
index f5d0bbc9ae..e41fe4b7d8 100644
--- a/docs/source/markdown/guides/how_to/data/index.md
+++ b/docs/source/markdown/guides/how_to/data/index.md
@@ -2,22 +2,44 @@
 
 This section contains tutorials on how to fully utilize the data components of anomalib.
 
-::::{grid}
-:margin: 1 1 0 0
-:gutter: 1
+::::{grid} 2 2 2 3
+:gutter: 2
+:padding: 1
 
-:::{grid-item-card} {octicon}`database` Train on Custom Data.
-:link: ./custom_data
+:::{grid-item-card} {octicon}`package` Dataclasses
+:link: ./dataclasses
 :link-type: doc
 
+Learn how to use Anomalib's dataclasses for different modalities and batch processing.
+:::
+
+:::{grid-item-card} {octicon}`package` Datasets
+:link: ./datasets
+:link-type: doc
+
+Learn how to use Anomalib's Datasets for different modalities and batch processing.
+:::
+
+:::{grid-item-card} {octicon}`package` Datamodules
+:link: ./datamodules
+:link-type: doc
+
+Learn how to use Anomalib's Datamodules for different modalities and batch processing.
+:::
+
+:::{grid-item-card} {octicon}`database` Custom Data
+
+
+
 Learn more about how to use `Folder` dataset to train anomalib models on your custom data.
 :::
 
-:::{grid-item-card} {octicon}`versions` Using Data Transforms.
+:::{grid-item-card} {octicon}`versions` Data Transforms
 :link: ./transforms
 :link-type: doc
 
-Learn how to apply custom data transforms to the input images.
+Learn how to apply custom data transforms and random augmentations to the input images.
 :::
 
 :::{grid-item-card} {octicon}`table` Input tiling
@@ -33,7 +55,9 @@ Learn more about how to use the tiler for input tiling.
 :caption: Data
 :hidden:
 
-./custom_data
+./dataclasses
+./datasets
+./datamodules
 ./transforms
 ./input_tiling
 ```
diff --git a/docs/source/markdown/guides/how_to/data/transforms.md b/docs/source/markdown/guides/how_to/data/transforms.md
index fffe066e4f..d3e9f7fc4b 100644
--- a/docs/source/markdown/guides/how_to/data/transforms.md
+++ b/docs/source/markdown/guides/how_to/data/transforms.md
@@ -1,131 +1,263 @@
+```{eval-rst}
+:orphan:
+```
+
 # Data Transforms
 
-This tutorial will show how Anomalib applies transforms to the input images, and how these transforms can be configured. Anomalib uses the [Torchvision Transforms v2 API](https://pytorch.org/vision/main/auto_examples/transforms/plot_transforms_getting_started.html) to apply transforms to the input images.
+This guide will explain how Anomalib applies transforms to the input images, and how these transforms can be configured for various use-cases.
 
-Common transforms are the `Resize` transform, which is used to resize the input images to a fixed width and height, and the `Normalize` transform, which normalizes the pixel values of the input images to a pre-determined range. The normalization statistics are usually chosen to correspond to the pre-training characteristics of the model's backbone. For example, when the backbone of the model was pre-trained on ImageNet dataset, it is usually recommended to normalize the model's input images to the mean and standard deviation of the pixel values of ImageNet. In addition, there are many other transforms which could be useful to achieve the desired pre-processing of the input images and to apply data augmentations during training.
+## Prerequisites
 
-## Using custom transforms for training and evaluation
+- [Torchvision Transforms](https://pytorch.org/vision/stable/transforms.html)
+- {doc}`Datasets <./datasets>`
+- {doc}`Datamodules <./datamodules>`
 
-When we create a new datamodule, it will not be equipped with any transforms by default. When we load an image from the datamodule, it will have the same shape and pixel values as the original image from the file system.
+## Overview
 
-```{literalinclude} ../../../../snippets/data/transforms/datamodule_default.txt
-:language: python
-```
+Data transforms are operations that are applied to the raw input images before they are passed to the model. In Anomalib, we distinguish between two types of transforms:
 
-Now let's create another datamodule, this time passing a simple resize transform to the datamodule using the `transform` argument.
+- **Model-specific transforms** that convert the input images to the format expected by the model.
+- **Data augmentations** for dataset enrichment and increasing the effective sample size.
 
-::::{tab-set}
-:::{tab-item} API
-:sync: label-1
+After reading this guide, you will understand the difference between these two transforms, and know when and how to use both types of transform.
 
-```{literalinclude} ../../../../snippets/data/transforms/datamodule_custom.txt
-:language: python
+```{note}
+Anomalib uses the [Torchvision Transforms v2 API](https://pytorch.org/vision/main/auto_examples/transforms/plot_transforms_getting_started.html) to apply transforms to the input images. Before reading this guide, please make sure that you are familiar with the basic principles of Torchvision transforms.
 ```
 
-:::
+## Model-specific transforms
+
+Most vision models make some explicit assumptions about the format of the input images. For example, the model may be configured to read the images in a specific shape, or the model may expect the images to be normalized to the mean and standard deviation of the dataset on which the backbone was pre-trained. These type of transforms are tightly coupled to the chosen model architecture, and need to be applied to any image that is passed to the model. In Anomalib, we refer to these transforms as "model-specific transforms".
+
+### Default model-specific transforms
+
+Model-specific transforms in Anomalib are defined in the model implementation, and applied by the {doc}`PreProcessor <../models/pre_processor>`. To ensure that the right transforms are applied to the input images, each Anomalib model is required to implement the `configure_pre_processor` class, which returns a default `PreProcessor` instance that contains the model-specific transforms. These transforms will be applied to any input images before passing the images to the model, unless a custom set of model-specific transforms is passed by the user (see {ref}`custom_model_transforms`).
 
-:::{tab-item} CLI
-:sync: label-2
+We can inspect the default pre-processor of the `Padim` model to find the default set of model-specific transforms for this model:
 
-In the CLI, we can specify a custom transforms by providing the class path and init args of the Torchvision transforms class:
+```python
+from anomalib.models import Padim
 
-```{literalinclude} ../../../../snippets/data/transforms/datamodule_custom_cli.yaml
-:language: yaml
+pre_processor = Padim.configure_pre_processor()
+print(pre_processor.transform)
+
+# Compose(
+#       Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=True)
+#       Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+# )
 ```
 
-::::
+As we can see, Padim's default set of transforms consists of a `Resize` transform to resize the images to an input shape of 256x256 pixels, followed by a `Normalize` transform to normalize the images to the mean and standard deviation of the ImageNet dataset.
+
+(custom_model_transforms)=
 
-As we can see, the datamodule now applies the custom transform when loading the images, resizing both training and test data to the specified shape.
+### Custom model-specific transforms
 
-In the above example, we used the `transform` argument to assign a single set of transforms to be used both in the training and in the evaluation subsets. In some cases, we might want to apply distinct sets of transforms between training and evaluation. This can be useful, for example, when we want to apply random data augmentations during training to improve generalization of our model. Using different transforms for training and evaluation can be done easily by specifying different values for the `train_transform` and `eval_transform` arguments. The train transforms will be applied to the images in the training subset, while the eval transforms will be applied to images in the validation, testing and prediction subsets.
+In some cases it may be desired to change the model-specific transforms. For example, we may want to increase the input resolution of the images or change the normalization statistics to reflect a different pre-training dataset. To achieve this, we can define a new set of transforms, wrap the transforms in a new `PreProcessor` instance, and pass the pre-processor when instantiating the model:
 
-::::{tab-set}
-:::{tab-item} API
-:sync: label-1
+```python
+from anomalib.models import Padim
+from anomalib.pre_processing import PreProcessor
+from torchvision.transforms.v2 import Compose, Normalize, Resize
 
-```{literalinclude} ../../../../snippets/data/transforms/datamodule_train_eval.txt
-:language: python
+transform = Compose([
+    Resize(size=(512, 512)),
+    Normalize(mean=[0.48145466, 0.4578275, 0.40821073], std=[0.26862954, 0.26130258, 0.27577711]),  # CLIP stats
+])
+
+pre_processor = PreProcessor(transform=transform)
+model = Padim(pre_processor=pre_processor)
 ```
 
-:::
+The most common use-case for custom model-specific transforms is varying the input size. Most Anomalib models are largely invariant to the shape of the input images, so we can freely change the size of the Resize transform. To accommodate this use-case, the Lightning model's `configure_pre_processor` method allows passing an optional `image_size` argument, which updates the size of the `Resize` transform from its default value. This allows us to easily obtain a pre-processor instance which transforms the images to the new input shape, but in which the other model-specific transforms are unmodified.
 
-:::{tab-item} CLI
-:sync: label-2
+```python
+from anomalib.models import Padim
 
-`train_transform` and `eval_transform` can also be set separately from CLI. Note that the CLI also supports stacking multiple transforms using a `Compose` object.
+pre_processor = Padim.configure_pre_processor(image_size=(240, 360))
+model = Padim(pre_processor=pre_processor)
 
-```{literalinclude} ../../../../snippets/data/transforms/datamodule_train_eval_cli.yaml
-:language: yaml
+print(model.pre_processor.transform)
+# Compose(
+#       Resize(size=[240, 360], interpolation=InterpolationMode.BILINEAR, antialias=True)
+#       Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+# )
 ```
 
-::::
+For models that require a fixed input size, such as WinClip, passing an image size to the `configure_pre_processor` method won't work. These models will notify the user that the input size of the model cannot be changed, and use the default, required input size instead.
+
+```python
+from anomalib.models import WinClip
+
+pre_processor = WinClip.configure_pre_processor(image_size=(240, 360))
+# WARNING:anomalib.models.image.winclip.lightning_model:Image size is not used in WinCLIP. The input image size is determined by the model.
+
+print(pre_processor.transform)
+# Compose(
+#       Resize(size=[240, 240], interpolation=InterpolationMode.BICUBIC, antialias=True)
+#       Normalize(mean=[0.48145466, 0.4578275, 0.40821073], std=[0.26862954, 0.26130258, 0.27577711], inplace=False)
+# )
+```
 
 ```{note}
-Please note that it is not recommended to pass only one of `train_transform` and `eval_transform` while keeping the other parameter empty. This could lead to unexpected behaviour, as it might lead to a mismatch between the training and testing subsets in terms of image shape and normalization characteristics.
+Some caution is required when passing custom model-specific transforms. Models may have some strict requirements for their input images which could be violated when using a custom set of transforms. Always make sure that you understand the model's input requirements before changing the model-specific transforms!
 ```
 
-## Model-specific transforms
+### Export and inference
 
-Each Anomalib model defines a default set of transforms, that will be applied to the input data when the user does not specify any custom transforms. The default transforms of a model can be inspected using the `configure_transforms` method, for example:
+For consistent model behaviour in inference settings, it is important that the appropriate model-specific transforms are applied in the model deployment stage. To facilitate this, Anomalib infuses the model-specific transforms in the model graph when exporting models to ONNX and OpenVINO. This saves the user the effort of transforming the input images in their inference pipeline, and mitigates the risk of inconsistent input transforms between training/validation and inference.
 
-```{literalinclude} ../../../../snippets/data/transforms/model_configure.txt
-:language: python
-```
+As shown in the following example, defining a custom transform and passing it to the model is sufficient to ingrain the transforms in the exported model graph (of course, the same principle applies when using the default model-specific transforms).
 
-As shown in the example, the default transforms for PatchCore consist of resizing the image to 256x256 pixels, followed by center cropping to an image size of 224x224. Finally, the pixel values are normalized to the mean and standard deviation of the ImageNet dataset. These transforms correspond to the recommended pre-processing steps described in the original PatchCore paper.
+```python
+from torchvision.transforms.v2 import Resize
+from anomalib.pre_processing import PreProcessor
 
-The use of these model-specific transforms ensures that Anomalib automatically applies the right transforms when no custom transforms are passed to the datamodule by the user. When no user-defined transforms are passed to the datamodule, Anomalib's engine assigns the model's default transform to the `train_transform` and `eval_transform` of the datamodule at the start of the fit/val/test sequence:
 
-::::{tab-set}
-:::{tab-item} API
-:sync: label-1
+transform = Resize((112, 112))
+pre_processor = PreProcessor(transform=transform)
+model = MyModel(pre_processor=pre_processor)
 
-```{literalinclude} ../../../../snippets/data/transforms/model_fit.txt
-:language: python
+model.to_onnx("model.onnx")  # the resize transform is included in the ONNX model
 ```
 
-:::
+The `Resize` transform will get added to the exported model graph, and applied to the input images during inference. This greatly simplifies the deployment workflow, as no explicit pre-processing steps are needed anymore. You can just pass the raw images directly to the model, and the model will transform the input images before passing them to the first layer of the model.
+
+## Data augmentations
+
+Data augmentation refers to the practice of applying transforms to input images to increase the variability in the dataset. By transforming the images, we effectively increase the sample size which helps improve a model's generalization and robustness to variations in real-world scenarios. Augmentations are often randomized to maximize variability between training runs and/or epochs. Some common augmentations include flipping, rotating, or scaling images, adjusting brightness or contrast, adding noise, and cropping.
+
+In Anomalib, data augmentations are configured from the `DataModule` and applied by the `Dataset`. Augmentations can be configured separately for each of the subsets (train, val, test) to suit different use-cases such as training set enrichment or test-time augmentations (TTA). All datamodules in Anomalib have the `train_augmentations`, `val_augmentations` and `test_augmentations` arguments, to which the user can pass a set of augmentation transforms. The following example shows how to add some random augmentations to the training set of an MVTec dataset:
 
-:::{tab-item} CLI
-:sync: label-2
+```python
+from anomalib.data import MVTec
+from torchvision.transforms import v2
 
-Since the CLI uses the Anomalib engine under the hood, the same principles concerning model-specific transforms apply when running a model from the CI. Hence, the following command will ensure that Patchcore's model-specific default transform is used when fitting the model.
+augmentations = v2.Compose([
+    v2.RandomHorizontalFlip(p=0.5),   # Randomly flip images horizontally with 50% probability
+    v2.RandomVerticalFlip(p=0.2),     # Randomly flip images vertically with 20% probability
+    v2.RandomRotation(degrees=30),    # Randomly rotate images within a range of ±30 degrees
+    v2.RandomResizedCrop(size=(224, 224), scale=(0.8, 1.0)),  # Randomly crop and resize images
+    v2.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.2),  # Randomly adjust colors
+    v2.RandomGrayscale(p=0.1),        # Convert images to grayscale with 10% probability
+])
 
-```{literalinclude} ../../../../snippets/data/transforms/model_fit_cli.sh
-:language: bash
+datamodule = MVTec(
+    category="transistor",
+    train_augmentations=augmentations,
+    val_augmentations=None,
+    test_augmentations=None,
+    augmentations=None,  # use this argument to set train, val and test augmentations simultaneously
+)
 ```
 
-::::
+In this example, the datamodule will pass the provided training augmentations to the dataset instance that holds the training samples. The transforms will be applied to each image when the dataloader fetches the images from the dataset.
 
-## Transforms during inference
+Note that unlike model-specific transforms, data augmentations will not be included in the model graph during export. Please take this into consideration when deciding which type of transform is most suitable for your use-case when designing your data pipeline.
 
-To ensure consistent transforms between training and inference, Anomalib includes the eval transform in the exported model. During inference, the transforms are infused in the model's forward pass which ensures that the transforms are always applied. The following example illustrates how Anomalib's torch inferencer automatically applies the transforms stored in the model. The same principles apply to both Lightning inference and OpenVINO inference.
+## Additional resizing in collate
 
-::::{tab-set}
-:::{tab-item} API
-:sync: label-1
+In some rare cases, an additional resize operation may be applied to the input images when the `Dataloader` collates the input images into a batch. This only happens when the dataset contains images of different shapes, and neither the data augmentations nor the model-specific transforms contain a `Resize` transform. In this case, the collate method resizes all images to a common shape as a safeguard to prevent shape mismatch error when concatenating. The images will be resized to the dimensions of the image within the batch with the largest width or height.
 
-```{literalinclude} ../../../../snippets/data/transforms/inference.txt
-:language: python
-```
+Note that this is not desirable, as the user has no control over the interpolation method and antialiasing setting of the resize operation. For this reason, it is advised to always include a resize transform in the model-specific transforms.
+
+## Common pitfalls
+
+### 1. Passing a model-specific transforms as augmentation
 
-:::
+Anomalib expects un-normalized images from the dataset, so that any Normalize transforms present in the model-specific transforms get applied correctly. Adding a Normalize transform to the augmentations will lead to unexpected behaviour as the model-specific transform will apply an additional normalization operation.
 
-:::{tab-item} CLI
-:sync: label-2
+```python
+# Wrong: by passing the Normalize transform as an augmentation, the transform will not
+# be included in the model graph during export. The model may also apply its default Normalize
+# transform, leading to incorrect and unpredictable behaviour.
+augmentations = Compose(
+    RandomHorizontalFlip(p=0.5),
+    Normalize(mean=[0.48145466, 0.4578275, 0.40821073], std=[0.26862954, 0.26130258, 0.27577711]),
+)
+datamodule = MVTec(train_augmentations=augmentations)
+model = Padim()
+engine = Engine()
+engine.fit(model, datamodule=datamodule)
 
-The CLI behaviour is equivalent to that of the API. When a model is trained with a custom `eval_transform` like in the example below, the `eval_transform` is included both in the saved lightning model as in the exported torch model.
+# Correct: pass the random flip as an augmentation to the datamodule, and pass the updated
+# Normalize transform to a new PreProcessor instance.
+augmentations = RandomHorizontalFlip(p=0.5)
+datamodule = MVTec(train_augmentations=augmentations)
 
-```{literalinclude} ../../../../snippets/data/transforms/inference_cli.yaml
-:language: yaml
+transform = Compose(
+    Resize(size=(256, 256)),
+    Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+)
+pre_processor = PreProcessor(transform=transform)
+model = Padim(pre_processor=pre_processor)
+
+engine = Engine()
+engine.fit(model, datamodule=datamodule)
 ```
 
-```{literalinclude} ../../../../snippets/data/transforms/inference_cli.sh
-:language: bash
+Similarly, adding a Resize transform to the augmentations with the intention of changing the input size of the images will not have the desired effect. Any Resize transform present in the model-specific transforms will overrule the Resize from the augmentations.
+
+```python
+# Wrong: The resize in the augmentations will be overruled by the resize in the
+# model-specific transforms. The final image size will not be 224x224, but 256x256,
+# as dictated by the default model-specific transforms.
+augmentations = Compose(
+    RandomHorizontalFlip(p=0.5),
+    Resize(size=(224, 224)),  # overruled by resize in default model-specific transform
+)
+datamodule = MVTec(augmentations=augmentations)
+
+model = Padim()
+
+engine = Engine()
+engine.fit(model, datamodule=datamodule)
+
+# Correct: pass the random flip as an augmentation to the datamodule, and pass an
+# updated pre-processor instance with the new image shape to the model. The final
+# image size will be 224x224.
+augmentations = RandomHorizontalFlip(p=0.5)
+datamodule = MVTec(augmentations=augmentations)
+
+pre_processor = Padim.configure_pre_processor(image_size=(224, 224))
+model = Padim(pre_processor=pre_processor)
+
+engine = Engine()
+engine.fit(model, datamodule=datamodule)
 ```
 
-::::
+### 2. Passing an augmentation as model-specific transform
 
-:::
-::::
-:::::
+Passing an augmentation transform to the `PreProcessor` can have unwanted effects. The augmentation will be included in the model graph, so during inference we will apply random horizontal flips. Since the PreProcessor defines a single transform for all stages, the random flips will also be applied during validation and testing.
+
+```python
+# Wrong: Augmentation transform added to model-specific transforms
+transform = Compose(
+    RandomHorizontalFlip(p=0.5),
+    Resize(size=(256, 256)),
+    Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+)
+pre_processor = PreProcessor(transform=transform)
+model = Padim(pre_processor=pre_processor)
+
+datamodule = MVTec()
+
+engine = Engine()
+engine.fit(model, datamodule=datamodule)
+
+# Correct: Pass the transform to the datamodule as `train_augmentation`.
+augmentations = RandomHorizontalFlip(p=0.5)
+datamodule = MVTec(train_augmentation=augmentations)
+
+model = Padim()
+
+engine = Engine()
+engine.fit(model, datamodule=datamodule)
+```
+
+```{seealso}
+For more information:
+- {doc}`PreProcessor Guide <../models/pre_processor>`
+- {doc}`DataModules Guide <./datamodules>`
+- {doc}`Datasets Guide<./datasets>`
+```
diff --git a/docs/source/markdown/guides/how_to/evaluation/evaluator.md b/docs/source/markdown/guides/how_to/evaluation/evaluator.md
new file mode 100644
index 0000000000..2984fa3509
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/evaluation/evaluator.md
@@ -0,0 +1,175 @@
+```{eval-rst}
+:orphan:
+```
+
+# Evaluator
+
+This guide explains how the Evaluator class works in Anomalib, its integration with metrics, and how to use it effectively.
+
+## Prerequisites
+
+- {doc}`Metrics <./metrics>`
+- AnomalibModule
+- Engine
+
+## Overview
+
+The Evaluator is a core component in Anomalib that:
+
+- Computes and logs metrics during the validation and test sequence
+- Integrates with PyTorch Lightning's training loop
+- Manages metric computation across different devices (CPU/GPU)
+- Provides flexibility in metric selection for validation and testing
+
+The Evaluator serves as both:
+
+1. A PyTorch Module for storing and organizing metrics
+2. A Lightning Callback for metric computation during training
+
+> **Note:**
+> This guide assumes that you know how to create and use Anomalib metrics. If you are not familiar with this, please read the {doc}`Metrics How to Guide <./metrics>` first.
+
+## Basic Usage
+
+The Evaluator can be used to specify which metrics Anomalib should compute during your validation and/or training run. To achieve this, simply create some metrics (if you're unsure how to create metrics, please refer to the {doc}`Metrics How to Guide <./metrics>`), and pass them to a new `Evaluator` instance using either the `val_metrics` or the `test_metrics` argument, depending on in which stage of the pipeline you want the metrics to be used (of course, it's also possible to pass both validation and test metrics).
+
+```python
+from anomalib.metrics import F1Score, AUROC
+from anomalib.metrics import Evaluator
+
+# Initialize metrics with specific fields
+f1_score = F1Score(fields=["pred_label", "gt_label"])
+auroc = AUROC(fields=["pred_score", "gt_label"])
+
+# Create evaluator with test metrics (for validation, use val_metrics arg)
+evaluator = Evaluator(test_metrics=[f1_score, auroc])
+```
+
+To ensure that Anomalib uses your metrics during the testing sequence, the newly created evaluator instance should be passed to the model upon construction. For example, when we want to use the metrics to evaluate a Patchcore model:
+
+```python
+# Pass evaluator to model
+model = Patchcore(
+    evaluator=evaluator
+)
+```
+
+That's it! Anomalib will now compute and report your metrics when running a testing sequence with your model. To trigger the testing sequence, simply call the `test` method of the engine and pass your model and the datamodule that contains your test set (if you are unsure how to create a datamodule, please refer to the {doc}`Datamodules How to Guide <../data/datamodules>`):
+
+```python
+from anomalib.engine import Engine
+
+engine = Engine()
+engine.test(model, datamodule=datamodule)  # make sure to create a datamodule first
+```
+
+## Stage-specific Metrics
+
+You can configure different metrics for validation and testing:
+
+```python
+from anomalib.metrics import Evaluator, AUROC, F1Score
+
+# Validation metrics
+val_metrics = [
+    AUROC(fields=["pred_score", "gt_label"]),     # Image-level AUROC
+    F1Score(fields=["pred_label", "gt_label"])    # Image-level F1
+]
+
+# Test metrics (more comprehensive)
+test_metrics = [
+    AUROC(fields=["pred_score", "gt_label"]),     # Image-level AUROC
+    AUROC(fields=["anomaly_map", "gt_mask"]),     # Pixel-level AUROC
+    F1Score(fields=["pred_label", "gt_label"]),   # Image-level F1
+    F1Score(fields=["pred_mask", "gt_mask"])      # Pixel-level F1
+]
+
+# Create evaluator with both sets
+evaluator = Evaluator(
+    val_metrics=val_metrics,
+    test_metrics=test_metrics
+)
+
+# Use with model
+model = Patchcore(evaluator=evaluator)
+```
+
+## Device Management
+
+The Evaluator manages metric computation across devices. By default, the metrics are computed on CPU to save GPU memory. To enforce metric computation on the same device as your model and data, you can set the `compute_on_cpu` argument to `False`. This will also ensure that the internal states of all metric instances will be stored on the same device as the model.
+
+```python
+# Compute on CPU (default)
+evaluator = Evaluator(
+    test_metrics=metrics,
+    compute_on_cpu=True  # Default
+)
+
+# Compute on same device as model
+evaluator = Evaluator(
+    test_metrics=metrics,
+    compute_on_cpu=False
+)
+```
+
+> **Note:**
+> For multi-GPU training, `compute_on_cpu` is automatically set to `False`.
+
+## Best Practices
+
+### 1. Strategic Metric Selection
+
+Choose metrics based on your specific use case and requirements:
+
+```python
+# Image Classification Task
+image_metrics = [
+    AUROC(fields=["pred_score", "gt_label"]),     # Overall detection performance
+    F1Score(fields=["pred_label", "gt_label"]),   # Balance between precision and recall
+]
+
+# Segmentation Task
+segmentation_metrics = [
+    AUROC(fields=["pred_score", "gt_label"]),     # Image-level detection
+    AUROC(fields=["anomaly_map", "gt_mask"]),     # Pixel-level detection accuracy
+    F1Score(fields=["pred_mask", "gt_mask"]),     # Segmentation quality
+    PRO(fields=["anomaly_map", "gt_mask"])        # Region-based evaluation
+]
+
+# Multi-task Evaluation
+evaluator = Evaluator(
+    test_metrics=[
+        *image_metrics,          # Image-level metrics
+        *segmentation_metrics    # Pixel-level metrics
+    ]
+)
+```
+
+### 2. Efficient Resource Management
+
+Balance between accuracy and computational efficiency:
+
+```python
+# Memory-Efficient Configuration
+evaluator = Evaluator(
+    # Validation: Light-weight metrics for quick feedback
+    val_metrics=[
+        F1Score(fields=["pred_label", "gt_label"]),
+        AUROC(fields=["pred_score", "gt_label"])
+    ],
+    # Testing: Comprehensive evaluation
+    test_metrics=[
+        F1Score(fields=["pred_label", "gt_label"]),
+        AUROC(fields=["pred_score", "gt_label"]),
+        PRO(fields=["anomaly_map", "gt_mask"]),    # Compute-intensive metric
+    ],
+    # Move computation to CPU for large datasets
+    compute_on_cpu=True
+)
+```
+
+```{seealso}
+For more information:
+- {doc}`Metrics Documentation <../../reference/metrics/index>`
+- {doc}`AnomalibModule Guide <../models/anomalib_module>`
+```
diff --git a/docs/source/markdown/guides/how_to/evaluation/index.md b/docs/source/markdown/guides/how_to/evaluation/index.md
new file mode 100644
index 0000000000..20b7d2e494
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/evaluation/index.md
@@ -0,0 +1,31 @@
+# Evaluation and Metrics
+
+This section contains tutorials on how to use the different evaluation and metrics of anomalib.
+
+::::{grid}
+:margin: 2 2 2 3
+:gutter: 2
+
+:::{grid-item-card} {octicon}`meter` Metrics
+:link: ./metrics
+:link-type: doc
+
+Learn more about the `AnomalibMetric` class, and how model performance is rated in Anomalib.
+:::
+
+:::{grid-item-card} {octicon}`sync` Evaluator
+:link: ./evaluator
+:link-type: doc
+
+Learn more about how `Evaluator` works, and how stage-specific metrics are computed.
+:::
+
+::::
+
+```{toctree}
+:caption: Evaluation and Metrics
+:hidden:
+
+./metrics
+./evaluator
+```
diff --git a/docs/source/markdown/guides/how_to/evaluation/metrics.md b/docs/source/markdown/guides/how_to/evaluation/metrics.md
new file mode 100644
index 0000000000..84d69c69e5
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/evaluation/metrics.md
@@ -0,0 +1,191 @@
+```{eval-rst}
+:orphan:
+```
+
+# Metrics
+
+This guide explains how to use and configure Anomalib's Evaluation metrics to rate the performance of Anomalib models.
+
+## Preprequisites
+
+- {doc}`Dataclasses <../data/dataclasses>`
+- Torchmetrics
+
+## Overview
+
+Metric computation in Anomalib is built around the `AnomalibMetric` class, which acts as an extension of TorchMetrics' `Metric` class. `AnomalibMetric` adds Anomalib-specific functionalities to integrate seamlessly with Anomalib's dataclasses and improve ease-of-use within various parts the library.
+
+## Field-Based Metrics
+
+The main difference between standard `TorchMetrics` classes and `AnomalibMetric` classes is the addition of the `fields` argument in the latter. When instantiating an `AnomalibMetric` subclass, the user has to specify which fields from Anomalib's dataclasses should be used when updating the metric. When `update` is called, the user can pass a dataclass instance directly, and the metric will automatically fetch the required fields from the instance.
+
+Consider the following example which computes the image-level Area Under the ROC curve (AUROC) given a set of batch predictions. The example shows both the classical `TorchMetrics` approach, and the new `AnomalibMetric` approach to illustrate the difference between the two.
+
+```python
+# standard torch metric
+from torchmetrics import AUROC
+auroc = AUROC()
+for batch in predictions:
+    auroc.update(batch.pred_label, gt_label)
+print(auroc.compute())  # tensor(0.94)
+
+# anomalib version of metric
+from anomalib.metrics import AUROC
+auroc = AUROC(fields=["pred_label", "gt_label"])
+for batch in predictions:
+    auroc.update(batch)
+print(auroc.compute())  # tensor(0.94)
+```
+
+This may look like a trivial difference, but directly passing the batch to the update method greatly simplifies evaluation pipelines, as we don't need to keep track of which type of predictions need to be passed to which metric. Instead, the metric itself holds this information and fetches the appropriate fields from the batch when its update method is called.
+
+For example, we can use Anomalib's metric class to compute both image- and pixel-level AUROC. Note how we don't need to pass the image- and pixel-level predictions explicitly when iterating over the batches.
+
+```python
+from anomalib.metrics import AUROC
+
+# prefix is optional, but useful to distinguish between two metrics of the same type
+image_auroc = AUROC(fields=["pred_score", "gt_label"], prefix="image_")
+pixel_auroc = AUROC(fields=["anomaly_map", "gt_mask"], prefix="pixel_")
+
+# name that will be used by Lightning when logging the metrics
+print(image_auroc.name)  # 'image_AUROC'
+print(pixel_auroc.name)  # 'pixel_AUROC'
+
+for batch in predictions:
+    image_auroc.update(batch)
+    pixel_auroc.update(batch)
+print(image_auroc.compute())  # tensor(0.98)
+print(pixel_auroc.compute())  # tensor(0.96)
+```
+
+### Creating a new AnomalibMetric class
+
+Anomalib's `metrics` module provides Anomalib versions of various performance metrics commonly used in anomaly detection, such as `AUROC`, `AUPRO` and `F1Score`. In addition, any subclass of `Metric` can easily be converted into an `AnomalibMetric`, as shown below:
+
+```python
+from torchmetrics import Accuracy  # metric that we want to convert
+
+# option 1: Define the new class explicitly
+class AnomalibAccuracy(AnomalibMetric, Accuracy):
+    pass
+
+# option 2: use the helper function
+AnomalibAccuracy = create_anomalib_metric(Accuracy)
+
+# after creating the new class, we gain access to AnomalibMetric's extended functinality
+accuracy = AnomalibAccuracy(fields=["pred_label", "gt_label"])
+accuracy.update(batch)
+print(accuracy.compute())  # tensor(0.76)
+```
+
+Note that we still have access to all the constructor arguments of the original metric. For example, we can configure the Accuracy metric created above to compute either the micro average or the macro average:
+
+```python
+from torchmetrics import Accuracy
+from anomalib.metrics import create_anomalib_metric
+
+# create the Anomalib metric
+AnomalibAccuracy = create_anomalib_metric(Accuracy)
+
+# instantiate with different init args
+micro_acc = AnomalibAccuracy(fields=["pred_label", "gt_label"], average="micro")
+macro_acc = AnomalibAccuracy(fields=["pred_label", "gt_label"], average="macro")
+
+# update and compute the metrics
+for batch in predictions:
+    micro_acc.update(batch)
+    macro_acc.update(batch)
+print(micro_acc.compute())  # tensor(0.87)
+print(macro_acc.compute())  # tensor(0.79)
+```
+
+## Usage in Anomalib pipeline
+
+Anomalib provides an {doc}`Evaluator <./evaluator>` class to facilitate metric computation. The evaluator takes care of all the aspects of metric computation, including updating and computing the metrics, and logging the final metric values.
+
+To include a set of metrics to an Anomalib pipeline, simply wrap them in an evaluator instance, and pass it to the model using the `evaluator` argument, for example:
+
+```python
+from anomalib.models import Patchcore
+from anomalib.metrics import AUROC, F1Score, Evaluator
+
+# Create metrics
+metrics = [
+    AUROC(fields=["pred_score", "gt_label"]),
+    F1Score(fields=["pred_label", "gt_label"])
+]
+
+# Create evaluator with metrics
+evaluator = Evaluator(test_metrics=metrics)
+
+# Pass evaluator to model
+model = Patchcore(
+    evaluator=evaluator
+)
+```
+
+When `Engine.test()` is called, the `Evaluator` will ensure that all metrics get updated and that the final metric values are computed and logged at the end of the testing sequence.
+
+Note that specifying custom evaluation metrics is optional. By default, each model defines a default set of metrics that will be computed when nothing is specified by the user.
+
+For a more detailed description and more examples of the `Evaluator` class, please visit the {doc}`Evaluator How to Guide <./evaluator>`.
+
+## Common Pitfalls
+
+### 1. No use of prefixes when using metrics of same type
+
+Adding a prefix to your metric name helps avoid problems with Lightning's metric logging:
+
+```python
+from anomalib.metrics import F1Score
+
+# Wrong: Same type metrics without prefix will have same name
+image_f1 = F1Score(fields=["pred_label", "gt_label"])
+pixel_f1 = F1Score(fields=["pred_mask", "gt_mask"])
+print(image_f1.name)  # F1Score
+print(pixel_f1.name)  # F1Score
+
+# Correct: Prefixes will ensure unique metric names
+image_f1 = F1Score(fields=["pred_label", "gt_label"], prefix="image_")
+pixel_f1 = F1Score(fields=["pred_mask", "gt_mask"], prefix="pixel_")
+print(image_f1.name)  # 'image_F1Score'
+print(pixel_f1.name)  # 'pixel_F1Score'
+```
+
+### 2. Incorrect Field Specifications
+
+Field mismatches might be a common source of errors:
+
+```python
+# Wrong: Mismatched field names
+metrics = [
+    AUROC(fields=["predictions", "labels"]),           # Wrong names
+    F1Score(fields=["anomaly_scores", "gt_labels"])    # Wrong names
+]
+
+# Wrong: Missing required fields
+metrics = [
+    AUROC(fields=["pred_score"]),      # Missing ground truth field
+    F1Score(fields=["pred_label"])     # Missing ground truth field
+]
+
+# Correct: Match your data batch fields
+batch = ImageBatch(
+    image=torch.rand(32, 3, 224, 224),
+    pred_score=torch.rand(32),
+    pred_label=torch.randint(2, (32,)),
+    gt_label=torch.randint(2, (32,))
+)
+
+metrics = [
+    AUROC(fields=["pred_score", "gt_label"]),     # Matches batch fields
+    F1Score(fields=["pred_label", "gt_label"])    # Matches batch fields
+]
+```
+
+```{seealso}
+For more information:
+- {doc}`Evaluator Documentation <./evaluator>`
+- {doc}`AnomalibModule Guide <../models/anomalib_module>`
+```
diff --git a/docs/source/markdown/guides/how_to/index.md b/docs/source/markdown/guides/how_to/index.md
index a8eb3fca22..171c655ab6 100644
--- a/docs/source/markdown/guides/how_to/index.md
+++ b/docs/source/markdown/guides/how_to/index.md
@@ -31,9 +31,18 @@ Learn more about image and video models.
 Learn more about anomalib Engine.
 :::
 
-:::{grid-item-card} {octicon}`meter` Metrics
+:::{grid-item-card} {octicon}`meter` Evaluation
+:link: ./evaluation/index
+:link-type: doc
+
+Learn more about model evaluation.
+:::
+
+:::{grid-item-card} {octicon}`graph` Visualization
+:link: ./visualization/index
+:link-type: doc
 
-Learn more about anomalib metrics
+Learn more about anomalib visualization
 :::
 
 :::{grid-item-card} {octicon}`graph` Loggers
@@ -70,6 +79,8 @@ Learn more about anomalib hpo, sweep and benchmarking pipelines
 :hidden:
 
 ./data/index
+./evaluation/index
 ./models/index
 ./pipelines/index
+./visualization/index
 ```
diff --git a/docs/source/markdown/guides/how_to/models/index.md b/docs/source/markdown/guides/how_to/models/index.md
index 27647f2f34..fc75456556 100644
--- a/docs/source/markdown/guides/how_to/models/index.md
+++ b/docs/source/markdown/guides/how_to/models/index.md
@@ -3,16 +3,30 @@
 This section contains tutorials on how to use the different model components of anomalib.
 
 ::::{grid}
-:margin: 1 1 0 0
-:gutter: 1
+:margin: 2 2 2 3
+:gutter: 2
 
-:::{grid-item-card} {octicon}`database` Feature Extractors
+:::{grid-item-card} {octicon}`sync` Pre-Processing
+:link: ./pre_processor
+:link-type: doc
+
+Learn more about how to use the PreProcessor class.
+:::
+
+:::{grid-item-card} {octicon}`cpu` Feature Extraction
 :link: ./feature_extractors
 :link-type: doc
 
 Learn more about how to use the different backbones as feature extractors.
 :::
 
+:::{grid-item-card} {octicon}`graph` Post-Processing
+:link: ./post_processor
+:link-type: doc
+
+Learn more about how to use the PostProcessor class.
+:::
+
 ::::
 
 ```{toctree}
@@ -20,4 +34,6 @@ Learn more about how to use the different backbones as feature extractors.
 :hidden:
 
 ./feature_extractors
+./pre_processor
+./post_processor
 ```
diff --git a/docs/source/markdown/guides/how_to/models/post_processor.md b/docs/source/markdown/guides/how_to/models/post_processor.md
new file mode 100644
index 0000000000..9a5a956ad9
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/models/post_processor.md
@@ -0,0 +1,226 @@
+```{eval-rst}
+:orphan:
+```
+
+# Post-processing in Anomalib
+
+This guide explains how post-processing works in Anomalib, its integration with models, and how to create custom post-processors.
+
+## Overview
+
+Post-processing in Anomalib refers to any additional operations that are applied after the model generates its raw predictions. Most anomaly detection models do not generate hard classification labels directly. Instead, the models generate an anomaly score, which can be seen as an estimation of the distance from the sample to the learned representation of normality. The raw anomaly scores may consist of a single score per image for anomaly classification, or a pixel-level anomaly map for anomaly localization/segmentation. The raw anomaly scores may be hard to interpret, as they are unbounded, and the range of values may differ between models. To convert the raw anomaly scores into useable predictions, we need to apply a threshold that maps the raw scores to the binary (normal vs. anomalous) classification labels. In addition, we may want to normalize the raw scores to the [0, 1] range for interpretability and visualization.
+
+The thresholding and normalization steps described above are typical post-processing steps in an anomaly detection workflow. The module that is responsible for these operations in Anomalib is the `PostProcessor`. The `PostProcessor` applies a set of post-processing operations on the raw predictions returned by the model. Similar to the {doc}`PreProcessor <./pre_processor>`, the `PostProcessor` also infuses its operations in the model graph during export. This ensures that during deployment:
+
+- Post-processing is part of the exported model (ONNX, OpenVINO)
+- Users don't need to manually apply post-processing steps such as thresholding and normalization
+- Edge deployment is simplified with automatic post-processing
+
+To achieve this, the `PostProcessor` class implements the following components:
+
+1. A PyTorch Module for processing model outputs that gets exported with the model
+2. A Lightning Callback for managing thresholds during training
+
+The `PostProcessor` is an abstract base class that can be implemented to suit different post-processing workflows. In addition, Anomalib also provides a default `OneClassPostProcessor` implementation, which suits most one-class learning algorithms. Other learning types, such as zero-shot learning or VLM-based models may require different post-processing steps.
+
+## OneClassPostProcessor
+
+The `OneClassPostProcessor` is Anomalib's default post-processor class which covers the most common anomaly detection workflow. It is responsible for adaptively computing the optimal threshold value for the dataset, applying this threshold during testing/inference, and normalizing the predicted anomaly scores to the [0, 1] range for interpretability. Thresholding and normalization is applied separately for both image- and pixel-level predictions. The following descriptions focus on the image-level predictions, but the same principles apply for the pixel-level predictions.
+
+**Thresholding**
+
+The post-processor adaptively computes the optimal threshold value during the validation sequence. The threshold is computed by collecting the raw anomaly scores and the corresponding ground truth labels for all the images in the validation set, and plotting the Precision-Recall (PR) curve for the range of possible threshold values $\mathbf{\theta}$.
+
+The resulting precision and recall values are then used to calculate the F1-score for each threshold value ${\theta}_i$ using the following formula:
+
+$$
+F1_i = 2 \times \frac{Precision(\theta_i) × Recall(\theta_i)}{Precision(\theta_i) + Recall(\theta_i)}
+$$
+
+Finally, the optimal threshold value $\theta^*$ is determined as the threshold value that yields the highest the F1-score:
+
+$$
+\theta^* = \text{arg}\max_{i} F1_{i}
+$$
+
+During testing and predicting, the post-processor computes the binary classification labels by assigning a positive label (anomalous) to all anomaly scores that are higher than the threshold, and a negative label (normal) to all anomaly scores below the threshold. Given an anomaly score $s_{\text{test},i}$, the binary classifical label $\hat{y}_{\text{test},i}$ is given by:
+
+$$
+\hat{y}_{\text{test},i} =
+\begin{cases}
+1 & \text{if } s_{\text{test},i} \geq \theta^* \\
+0 & \text{if } s_{\text{test},i} < \theta^*
+\end{cases}
+$$
+
+**Normalization**
+
+During the validation sequence, the post-processor iterates over the raw anomaly score predictions for the validation set, $\mathbf{s}_{\text{val}}$, and keeps track of the lowest and highest observed values, $\min\mathbf{s}_{\text{val}}$ and $\max \mathbf{s}_{\text{val}}$.
+
+During testing and predicting, the post-processor uses the stored min and max values, together with the optimal threshold value, to normalize the values to the [0, 1] range. For a raw anomaly score $s_{\text{test},i}$, the normalized score $\tilde{s}_{\text{test},i}$ is given by:
+
+$$
+\tilde{s}_{\text{test},i} = \frac{s_{\text{test},i} - \theta^*}{\max\mathbf{s}_\text{val} - \min\mathbf{s}_\text{val}} + 0.5
+$$
+
+As a last step, the normalized scores are capped between 0 and 1.
+
+The $\theta^*$ term in the formula above ensures that the normalized values are centered around the threshold value, such that a value of 0.5 in the normalized domain corresponds to the value of the threshold in the un-normalized domain. This helps with interpretability of the results, as it asserts that normalized values of 0.5 and higher are labeled anomalous, while values below 0.5 are labeled normal.
+
+Centering the threshold value around 0.5 has the additional advantage that it allows us to add a sensitivity parameter $\alpha$ that changes the sensitivity of the anomaly detector. In the normalized domain, the binary classification label is given by:
+
+$$
+\hat{y}_{\text{test},i} =
+\begin{cases}
+1 & \text{if } \tilde{s}_{\text{test},i} \geq 1 - \alpha \\
+0 & \text{if } \tilde{s}_{\text{test},i} < 1 - \alpha
+\end{cases}
+$$
+
+Where $\alpha$ is a sensitivity parameter that can be varied between 0 and 1, such that a higher sensitivity value lowers the effective anomaly score threshold. The sensitivity parameter can be tuned depending on the use case. For example, use-cases in which false positives should be avoided may benefit from reducing the sensitivity.
+
+```{note}
+Normalization and thresholding only works when your datamodule contains a validation set, preferably cosisting of both normal and anomalous samples. When your validation set only contains normal samples, the threshold will be set to the value of the highest observed anomaly score in your validation set.
+```
+
+## Basic Usage
+
+To use the `OneClassPostProcessor`, simply add it to any Anomalib model when creating the model:
+
+```python
+from anomalib.models import Padim
+from anomalib.post_processing import OneClassPostProcessor
+
+post_processor = OneClassPostProcessor()
+model = Padim(post_processor=post_processor)
+```
+
+The post-processor can be configured using its constructor arguments. In the case of the `OneClassPostProcessor`, the only configuration parameters are the sensitivity for the thresholding operation on the image- and pixel-level:
+
+```python
+post_processor = OneClassPostProcessor(
+    image_sensitivity=0.4,
+    pixel_sensitivity=0.4,
+)
+model = Padim(post_processor=post_processor)
+```
+
+When a post-processor instance is not passed explicitly to the model, the model will automatically configure a default post-processor instance. Let's confirm this by creating a Padim model and printing the `post_processor` attribute:
+
+```python
+model = Padim()
+print(model.post_processor)
+# OneClassPostProcessor(
+#   (_image_threshold): F1AdaptiveThreshold() (value=0.50)
+#   (_pixel_threshold): F1AdaptiveThreshold() (value=0.50)
+#   (_image_normalization_stats): MinMax()
+#   (_pixel_normalization_stats): MinMax()
+# )
+```
+
+Each model implementation in Anomalib is required to implement the `configure_post_processor` method, which defines the default post-processor for that model. We can use this method to quickly inspect the default post-processing behaviour of an Anomalib model class:
+
+```python
+print(Padim.configure_post_processor())
+```
+
+In some cases it may be desirable to disable post-processing entirely. This is done by passing `False` to the model's `post_processor` argument:
+
+```python
+from anomalib.models import Padim
+
+model = Padim(post_processor=False)
+print(model.post_processor is None)  # True
+```
+
+### Exporting
+
+One key advantage of Anomalib's post-processor design is that it becomes part of the model graph during export. This means:
+
+1. Post-processing is included in the exported OpenVINO model
+2. No need for separate post-processing code in deployment
+3. Consistent results between training and deployment
+
+### Example: OpenVINO Deployment
+
+```python
+from anomalib.models import Patchcore
+from anomalib.post_processing import OneClassPostProcessor
+from openvino.runtime import Core
+import numpy as np
+
+# Training: Post-processor is part of the model
+model = Patchcore(
+    post_processor=OneClassPostProcessor(
+        image_sensitivity=0.5,
+        pixel_sensitivity=0.5
+    )
+)
+
+# Export: Post-processing is included in the graph
+model.export("model", export_mode="openvino")
+
+# Deployment: Simple inference without manual post-processing
+core = Core()
+ov_model = core.read_model("model.xml")
+compiled_model = core.compile_model(ov_model)
+
+# Get input and output names
+input_key = compiled_model.input(0)
+output_key = compiled_model.output(0)
+
+# Prepare input
+image = np.expand_dims(image, axis=0)  # Add batch dimension
+
+# Run inference - everything is handled by the model
+results = compiled_model([image])[output_key]
+
+# Results are ready to use
+anomaly_maps = results[..., 0]     # Already normalized maps
+pred_scores = results[..., 1]      # Already normalized scores
+pred_labels = results[..., 2]      # Already thresholded (0/1)
+pred_masks = results[..., 3]       # Already thresholded masks (if applicable)
+```
+
+## Creating Custom Post-processors
+
+Advanced users may want to define their own post-processing pipeline. This can be useful when the default post-processing behaviour of the `OneClassPostProcessor` is not suitable for the model and its predictions. To create a custom post-processor, inherit from the abstract base class `PostProcessor`:
+
+```python
+from anomalib.post_processing import PostProcessor
+from anomalib.data import InferenceBatch
+import torch
+
+class CustomPostProcessor(PostProcessor):
+    """Custom post-processor implementation."""
+
+    def forward(self, predictions: InferenceBatch) -> InferenceBatch:
+        """Post-process predictions.
+
+        This method must be implemented by all subclasses.
+        """
+        # Implement your post-processing logic here
+        raise NotImplementedError
+```
+
+After defining the class, it can be used in any Anomalib workflow by passing it to the model:
+
+```python
+from anomalib.models import Padim
+
+post_processor = CustomPostProcessor()
+model = Padim(post_processor=post_processor)
+```
+
+## Best Practices
+
+**Validation**:
+
+- Ensure that your validation set contains both normal and anomalous samples.
+- Ensure that your validation set contains sufficient representative samples.
+
+```{seealso}
+For more information:
+- {doc}`PreProcessing guide <./pre_processing>`
+- {doc}`AnomalibModule Documentation <../../reference/models/base>`
+```
diff --git a/docs/source/markdown/guides/how_to/models/pre_processor.md b/docs/source/markdown/guides/how_to/models/pre_processor.md
new file mode 100644
index 0000000000..e2c3c6298e
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/models/pre_processor.md
@@ -0,0 +1,325 @@
+```{eval-rst}
+:orphan:
+```
+
+# Pre-processing in Anomalib
+
+This guide explains how pre-processing works in Anomalib, its integration with models, and how to create custom pre-processors.
+
+## Prerequisites
+
+- {doc}`Transforms <../data/transforms>`
+
+```{note}
+Before reading this guide, it is important that you are familiar with the concept of model-specific transforms, see {doc}`Transforms <../data/transforms>`.
+```
+
+## Overview
+
+Anomalib's pre-processing step consists of applying the model-specific input data transforms (like input size and normalization) to the images before passing the images to the model. This ensures that the images are in the format that is expected by the model. The module that handles the pre-processing steps in Anomalib is the `PreProcessor`. The `PreProcessor` is responsible for applying the transforms to the input images, and handling any stage-specific logic related to this.
+
+Another important role of the `PreProcessor` is to encapsulate the model-specific transforms within the model graph during export. This design ensures that during deployment:
+
+- Pre-processing is part of the exported model (ONNX, OpenVINO)
+- Users don't need to manually resize or normalize inputs
+- Edge deployment is simplified with automatic pre-processing
+
+To achieve this, the `PreProcessor` class implements the following components:
+
+1. A Lightning Callback for managing stage-specific pre-processing steps (e.g. training, validation, testing)
+2. A PyTorch Module for transform application that gets exported with the model
+
+## Basic Usage
+
+To create a simple pre-processor, simply define some transforms and pass them to a new `PreProcessor` instance using the `transform` argument.
+
+```python
+from anomalib.pre_processing import PreProcessor
+from torchvision.transforms.v2 import Compose, Normalize, Resize
+
+transform = Compose([
+    Resize((300, 300)),
+    Normalize(mean=[0.43, 0.48, 0.45], std=[0.23, 0.22, 0.25]),
+])
+pre_processor = PreProcessor(transform=transform)
+```
+
+The newly created pre-processor is fully compatible with Anomalib. It can be used it in an Anomalib workflow by passing it to the model using the `pre_processor` argument. Let's try this with a Fastflow model.
+
+```python
+from anomalib.models import FastFlow
+
+model = Fastflow(pre_processor=pre_processor)
+```
+
+The pre-processor which we created earlier is now attached to the Fastflow model. Let's print the transform stored in the pre-processor to confirm that the model contains our transform:
+
+```python
+print(model.pre_processor.transform)
+# Compose(
+#       Resize(size=[300, 300], interpolation=InterpolationMode.BILINEAR, antialias=True)
+#       Normalize(mean=[0.43, 0.48, 0.45], std=[0.23, 0.22, 0.25], inplace=False)
+# )
+```
+
+We can now create an engine and run an anomaly detection workflow. In each stage of the pipeline, the pre-processor will use its callback hooks to intercept the batch before it is passed to the model, and update the contents of the batch by applying the transform.
+
+```python
+from anomalib.engine import Engine
+
+engine = Engine()
+engine.train(model, datamodule=datamodule)  # pre-processor stored in the model will be used for input transforms
+```
+
+### Exporting
+
+In addition to applying the transforms in the callback hooks, the pre-processor also applies the transforms in the forward pass of the model. As a result, the transforms will get included in the model graph when it is exported to ONNX or OpenVINO format. The transform that is used for exporting is a modified version of the original transform. This is needed because not all operations from Torchvision's standard transforms are compabitle with ONNX. The exported version of the transform can be inspected using the `export_transform` attribute of the pre-processor. The exported transform is obtained internally using a utility function that replaces several commonly used operations with a modified, exportable counterpart.
+
+```python
+from anomalib.pre_processing import PreProcessor
+from anomalib.pre_processing.utils.transform import get_exportable_transform
+
+transform = Compose([
+      Resize(size=(256, 256)),
+      CenterCrop(size=(224, 224)),
+      Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])
+pre_processor = PreProcessor(transform=transform)
+
+print(pre_processor.transform)
+# Compose(
+#       Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=True)
+#       CenterCrop(size=(224, 224))
+#       Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+# )
+print(pre_processor.export_transform)
+# Compose(
+#       Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=False)
+#       ExportableCenterCrop(size=[224, 224])
+#       Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+# )
+
+exportable_transform = get_exportable_transform(pre_processor.transform)
+print(exportable_transform == pre_processor.export_transform)  # True
+```
+
+```{note}
+The exportable transform that is infused in the model graph uses slightly different operations compared to the standard transform that is used during training and evaluation. This may cause small differences in the final model predictions between the standard model and the exported model. When encountering unexpected behaviour of your exported model, a good first step may be to confirm that the exported transforms are working as intended.
+```
+
+```{note}
+The `get_exportable_transform` function supports conversion of several commonly used transforms. It may occur that your custom set of transforms contains a transform that is not compatible with ONNX but is also not supported by `get_exportable_transforms`. In this case, please feel free to submit a [Feature Request](https://github.com/openvinotoolkit/anomalib/discussions/new?category=feature-requests) in our Discussions section on Github.
+```
+
+After training a model, we can export our model to ONNX format, and our custom set of transforms automatically gets applied when running the model in onnxruntime.
+
+```python
+# Export model with pre-processing included
+model.export("model.onnx")
+
+# During deployment - no manual pre-processing needed
+deployed_model = onnxruntime.InferenceSession("model.onnx")
+raw_image = cv2.imread("test.jpg")  # Any size, unnormalized
+prediction = deployed_model.run(None, {"input": raw_image})
+```
+
+## Default Pre-processor
+
+The example above illustrated how to create a `PreProcessor` instance and pass it to an Anomalib model. Depending on the use-case, this may not always be necessary. When the user does not pass a `PreProcessor` instance to the model, the model will automatically configure a `PreProcessor` instance that applies a default set of model-specific transforms. Let's inspect the `pre_processor` attribute of a default Padim model:
+
+```python
+from anomalib.models import Padim
+
+model = Padim()
+print(model.pre_processor)
+# PreProcessor(
+#   (transform): Compose(
+#         Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=True)
+#         Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+#   )
+#   (export_transform): Compose(
+#         Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=False)
+#         Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+#   )
+# )
+```
+
+As you can see, Padim has automatically configured a `PreProcessor` instance which contains a `Resize` and a `Normalize` transform as its default model-specific transforms.
+
+Internally, the default pre-processor is configured with the `configure_pre_processor` method, which each subclass of `AnomalibModule` is expected to implement. Let's see what happens if we call Padim's implementation of this method directly.
+
+```python
+print(Padim.configure_pre_processor())
+# PreProcessor(
+#   (transform): Compose(
+#         Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=True)
+#         Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+#   )
+#   (export_transform): Compose(
+#         Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=False)
+#         Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+#   )
+# )
+```
+
+It's the same pre-processor as earlier! The `configure_pre_processor` method can be a useful tool to inspect the default pre-processing behaviour and model-specific transforms of an Anomalib model, without first having to create a model instance. To illustrate why this is useful, consider the following example where we want to change the input normalization for a Patchcore model, but keep the other model-specific transforms unchanged. In this case, we can call `configure_pre_processor` to inspect the default set of model-specific transforms, and then create a new pre-processor with a modified `Normalize` transform.
+
+```python
+from anomalib.models import Patchcore
+
+print(Patchcore.configure_pre_processor().transform)
+# Compose(
+#       Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=True)
+#       CenterCrop(size=(224, 224))
+#       Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+# )
+
+from torchvision.transforms.v2 import Compose, CenterCrop, Normalize, Resize
+
+# replace the Normalize transform, but replicate the other transforms
+transform = Compose([
+    Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=True),
+    CenterCrop(size=(224, 224)),
+    Normalize([0.48145466, 0.4578275, 0.40821073], std=[0.26862954, 0.26130258, 0.27577711]),  # CLIP stats
+])
+pre_processor = PreProcessor(transform=transform)
+```
+
+The `configure_pre_processor` method contains a useful shortcut for updating the image size (which is the most common use-case for custom transforms). Passing a size tuple to the `image_size` argument of the `configure_pre_processor` method yields a pre-processor with an updated `Resize` transform, as shown below:
+
+```python
+from anomalib.models import Padim
+pre_processor = Padim.configure_pre_processor(image_size=(200, 200))
+
+print(pre_processor.transform)
+# Compose(
+#       Resize(size=[200, 200], interpolation=InterpolationMode.BILINEAR, antialias=True)
+#       Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+# )
+
+model = Padim(pre_processor=pre_processor)
+```
+
+Finally, in some cases it may be desired to disable pre-processing entirely. This is done by passing `False` to the model's pre_processor argument.
+
+```python
+model = Padim(pre_processor=False)
+print(model.pre_processor is None)  # True
+```
+
+Note that it is rarely recommended to disable pre-processing in Anomalib workflows. This functionality is intended for advanced use-cases or demo purposes.
+
+## Custom Pre-processor Class
+
+Advanced users may want to define their own pre-processing pipeline. This can be useful when additional logic is needed, or when the pre-processing behaviour should differ between the stages of the Anomalib workflow. As an example, let's create a PreProcessor which uses separate transforms for each of the train, val and test stages:
+
+```python
+from anomalib.pre_processing import PreProcessor
+from anomalib.utils.transform import get_exportable_transform
+from torchvision.transforms.v2 import Transform
+
+
+class StageSpecificPreProcessor(PreProcessor):
+
+    def __init__(
+        self,
+        train_transform: Transform | None = None,
+        val_transform: Transform | None = None,
+        test_transform: Transform | None = None,
+    ):
+        self.train_transform = train_transform
+        self.val_transform = val_transform
+        self.test_transform = test_transform
+        self.export_transform = get_exportable_transform(test_transform)
+
+    def on_train_batch_start(self, trainer, pl_module, batch, batch_idx):
+        if self.train_transform:
+            batch.image, batch.gt_mask = self.train_transform(batch.image, batch.gt_mask)
+
+    def on_val_batch_start(self, trainer, pl_module, batch, batch_idx):
+        if self.val_transform:
+            batch.image, batch.gt_mask = self.val_transform(batch.image, batch.gt_mask)
+
+    def on_test_batch_start(self, trainer, pl_module, batch, batch_idx):
+        if self.test_transform:
+            batch.image, batch.gt_mask = self.test_transform(batch.image, batch.gt_mask)
+
+    def on_predict_batch_start(self, trainer, pl_module, batch, batch_idx):
+        if self.test_transform:
+            batch.image, batch.gt_mask = self.test_transform(batch.image, batch.gt_mask)
+```
+
+Now that we have defined a custom `PreProcessor` sublass, we can create an instance and pass some transforms for the different stages. Just like the standard `PreProcessor`, we can add the new `PreProcessor` to any Anomalib model to use its stage-specific transforms in the Anomalib workflow:
+
+```python
+from torchvision.transforms.v2 import Compose, Centercrop, RandomCrop, Resize
+
+train_transform = Resize((224, 224))
+val_transform = Compose([
+    Resize((256, 256)),
+    CenterCrop((224, 224))
+])
+test_transform = Compose([
+    Resize((256, 256)),
+    RandomCrop((224, 224)),
+
+])
+
+pre_processor = StageSpecificPreProcessor(
+    train_transform=train_transform,
+    val_transform=val_transform,
+    test_transform=test_transform,
+)
+# add the custom pre-processor to an Anomalib model.
+model = MyModel(pre_processor=pre_processor)
+```
+
+```{note}
+The example above is for illustrative purposes only. In practice, it would rarely be sensible to use different model-specific transforms for different stages. This should not be confused with **data augmentations**, where different augmentation transforms for different stages is a valid use-case. For further reading about the differences between model-specific transforms and data augmentations, please refer to our {doc}`Transforms guide <../data/transforms>`.
+```
+
+## Best Practices
+
+## Common Pitfalls
+
+### 1. Omitting required model-specific transforms
+
+In many cases we only want to change a specific part of the model-specific transforms, such as the input size. We need to be careful that we don't omit any other model-specific transforms that the model may need
+
+```python
+from anomalib.models import Padim
+from anomalib.pre_processing import PreProcessor
+from torchvision.transforms.v2 import Compose, Normalize, Resize
+
+# Wrong: only specify the new resize, without considering any other
+# model-specific transforms that may be needed by the model.
+transform = Resize(size=(240, 240))
+pre_processor = PreProcessor(transform=transform)
+model = Padim(pre_processor=pre_processor)
+
+# Better: inspect the default transforms before specifying custom
+# transforms, and include the transforms that we don't want to modify.
+print(Padim.configure_pre_processor().transform)
+# Compose(
+#       Resize(size=[256, 256], interpolation=InterpolationMode.BILINEAR, antialias=True)
+#       Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False)
+# )
+
+transform = Compose(
+    Resize(size=(240, 240), interpolation=InterpolationMode.BILINEAR, antialias=True),
+    Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], inplace=False),
+)
+pre_processor = PreProcessor(transform=transform)
+model = Padim(pre_processor=pre_processor)
+
+# Best: use the image_size argument in `configure_pre_processor` to directly
+# obtain a PreProcessor instance with the right input size transform.
+pre_processor = Padim.configure_pre_processor(image_size=(240, 240))
+model = Padim(pre_processor=pre_processor)
+```
+
+```{seealso}
+For more information about transforms:
+- {doc}`Data Transforms Guide <../data/transforms>`
+- {doc}`AnomalibModule Documentation <../../reference/models/base>`
+```
diff --git a/docs/source/markdown/guides/how_to/visualization/index.md b/docs/source/markdown/guides/how_to/visualization/index.md
new file mode 100644
index 0000000000..c523cb8960
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/visualization/index.md
@@ -0,0 +1,31 @@
+# Visualization
+
+This guide contains tutorials on how to visualize the results of your model.
+
+::::{grid}
+:margin: 2 2 2 3
+:gutter: 2
+
+:::{grid-item-card} {octicon}`sync` Image Visualization
+:link: ./visualize_image
+:link-type: doc
+
+Learn how to visualize the results of your model.
+
+:::
+
+::::
+
+```{toctree}
+:caption: Image Visualization
+:hidden:
+
+./visualize_image
+```
+
+```{toctree}
+:caption: Visualization
+:hidden:
+
+./visualize_image
+```
diff --git a/docs/source/markdown/guides/how_to/visualization/visualize_image.md b/docs/source/markdown/guides/how_to/visualization/visualize_image.md
new file mode 100644
index 0000000000..d9e0d14828
--- /dev/null
+++ b/docs/source/markdown/guides/how_to/visualization/visualize_image.md
@@ -0,0 +1,302 @@
+```{eval-rst}
+:orphan:
+```
+
+# Visualization in Anomalib
+
+```{warning}
+The visualization module is currently experimental. The API and functionality may change in future releases without following semantic versioning. Use with caution in production environments.
+
+Key points:
+- API may change without notice
+- Some features might be unstable
+- Default configurations might be adjusted
+- New visualization methods may be added or removed
+```
+
+This guide explains how visualization works in Anomalib, its components, and how to use them effectively.
+
+## Overview
+
+Anomalib provides a powerful visualization system that:
+
+- Visualizes anomaly detection results (images, masks, anomaly maps)
+- Supports both classification and segmentation results
+- Offers customizable visualization options
+- Maintains consistent output formats
+
+The visualization system consists of:
+
+1. `ImageVisualizer` - A Lightning Callback for automatic visualization during training/testing
+2. `visualize_image_item` - Core function for visualizing `ImageItem` objects
+3. Utility functions for specific visualization tasks (masks, anomaly maps, etc.)
+
+## Basic Usage
+
+### Using the Visualizer Callback
+
+The `ImageVisualizer` is a callback that automatically visualizes results during test time:
+
+```python
+from anomalib.visualization import ImageVisualizer
+from anomalib.engine import Engine
+from anomalib.models import Patchcore
+
+# Create visualizer with default settings
+visualizer = ImageVisualizer()
+
+# Create model with visualizer
+model = Patchcore(
+    visualizer=visualizer  # Pass visualizer to the model
+)
+
+# Create engine
+engine = Engine()
+
+# The visualizer will automatically create visualizations
+# during test_step and predict_step
+engine.test(model, datamodule)
+```
+
+### Direct Visualization
+
+For direct visualization of `ImageItem` objects, use `visualize_image_item`:
+
+```python
+from anomalib.visualization.image.item_visualizer import visualize_image_item
+from anomalib.data import ImageItem
+from PIL import Image
+import torch
+from torchvision.io import read_image
+
+# Create sample data
+image_path = "./datasets/MVTec/bottle/test/broken_large/000.png"
+mask_path = "./datasets/MVTec/bottle/ground_truth/broken_large/000_mask.png"
+image = read_image(image_path)
+mask = read_image(mask_path)
+
+# Create an ImageItem
+item = ImageItem(
+    image_path=image_path,
+    mask_path=mask_path,
+    image=image,
+    gt_mask=mask,
+)
+
+# Generate visualization
+vis_result = visualize_image_item(item, fields=["image", "gt_mask"])
+```
+
+## Visualization Components
+
+### 1. Anomaly Maps
+
+Visualize anomaly heatmaps:
+
+```python
+from anomalib.visualization import visualize_anomaly_map
+import torch
+
+# Create sample anomaly map
+anomaly_map = torch.rand(256, 256)
+
+# Visualize with default settings
+vis = visualize_anomaly_map(anomaly_map)
+
+# Customize visualization
+vis = visualize_anomaly_map(
+    anomaly_map,
+    colormap=True,      # Apply colormap
+    normalize=True      # Normalize values to [0, 255]
+)
+```
+
+### 2. Segmentation Masks
+
+Visualize ground truth and predicted masks:
+
+```python
+import torch
+
+from anomalib.visualization.image.functional import visualize_gt_mask, visualize_pred_mask
+
+# Create sample mask
+mask = torch.zeros((256, 256))
+mask[100:150, 100:150] = 1
+
+# Visualize ground truth mask
+gt_vis = visualize_gt_mask(
+    mask,
+    mode="contour",            # Draw mask boundaries
+    color=(0, 255, 0),        # Green color
+    alpha=0.7                  # Opacity
+)
+
+# Visualize prediction mask
+pred_vis = visualize_pred_mask(
+    mask,
+    mode="fill",              # Fill mask regions
+    color=(255, 0, 0),        # Red color
+    alpha=0.5,                # Opacity
+)
+```
+
+## Advanced Usage
+
+### 1. Custom Visualization Configurations
+
+Configure visualization settings and pass to the model:
+
+```python
+from anomalib.visualization import ImageVisualizer
+
+# Custom visualization settings
+visualizer = ImageVisualizer(
+    fields_config={
+        "image": {},  # Default image display
+        "anomaly_map": {
+            "colormap": True,
+            "normalize": True
+        },
+        "pred_mask": {
+            "mode": "contour",
+            "color": (255, 0, 0),
+            "alpha": 0.7
+        },
+        "gt_mask": {
+            "mode": "contour",
+            "color": (0, 255, 0),
+            "alpha": 0.7
+        }
+    }
+)
+
+# Pass visualizer to the model
+model = Patchcore(visualizer=visualizer)
+```
+
+### 2. Direct Visualization with Custom Settings
+
+For more control over visualization, use `visualize_image_item` directly:
+
+```python
+from anomalib.visualization.image.item_visualizer import visualize_image_item
+
+# Customize which fields to visualize
+result = visualize_image_item(
+    item,
+    fields=["image", "anomaly_map"],
+    fields_config={
+        "anomaly_map": {"colormap": True, "normalize": True}
+    }
+)
+
+# Create overlays
+result = visualize_image_item(
+    item,
+    overlay_fields=[("image", ["gt_mask", "pred_mask"])],
+    overlay_fields_config={
+        "gt_mask": {"mode": "contour", "color": (0, 255, 0), "alpha": 0.7},
+        "pred_mask": {"mode": "fill", "color": (255, 0, 0), "alpha": 0.3}
+    }
+)
+```
+
+## Best Practices
+
+1. **Automatic Visualization During Training/Testing**:
+
+   ```python
+   # Configure visualization as part of the model
+   visualizer = ImageVisualizer(
+       fields_config={"anomaly_map": {"normalize": True}}
+   )
+   model = Patchcore(visualizer=visualizer)
+   engine = Engine()
+   engine.test(model, datamodule)
+   ```
+
+2. **Custom Visualization Pipeline**:
+
+   ```python
+   # Create a custom visualization pipeline
+   def create_visualization_pipeline(datamodule):
+       visualizer = ImageVisualizer()
+       model = Patchcore(visualizer=visualizer)
+       engine = Engine()
+
+       # Visualizations will be automatically generated
+       # during test/predict steps
+       engine.test(model, datamodule)
+   ```
+
+3. **Manual Batch Processing**:
+
+   ```python
+   from anomalib.visualization.image.item_visualizer import visualize_image_item
+
+   def process_batch(batch_items):
+       visualizations = []
+       for item in batch_items:
+           vis = visualize_image_item(
+               item,
+               fields=["image", "anomaly_map"],
+               fields_config={"anomaly_map": {"normalize": True}}
+           )
+           visualizations.append(vis)
+       return visualizations
+   ```
+
+## Common Pitfalls
+
+1. **Callback Configuration**:
+
+   ```python
+   # Wrong: Trying to call visualize directly
+   visualizer = ImageVisualizer()
+   visualizer.visualize(item)  # This won't work!
+
+   # Correct: Use as a callback through the model or use visualize_image_item directly
+   from anomalib.visualization.image.item_visualizer import visualize_image_item
+   result = visualize_image_item(item)
+   ```
+
+2. **Memory Management**:
+
+   ```python
+   # Wrong: Keeping all visualizations in memory
+   visualizations = []
+   for batch in test_dataloader:
+       for item in batch:
+           vis = visualize_image_item(item)
+           visualizations.append(vis)  # Memory accumulates
+
+   # Better: Process and save immediately
+   for batch in test_dataloader:
+       for item in batch:
+           vis = visualize_image_item(item)
+           vis.save(f"vis_{item.image_path.stem}.png")
+           del vis  # Clear memory
+   ```
+
+3. **Visualization Settings**:
+
+   ```python
+   # Wrong: Inconsistent settings across visualizations
+   vis1 = visualize_image_item(item1, fields_config={"anomaly_map": {"normalize": True}})
+   vis2 = visualize_image_item(item2, fields_config={"anomaly_map": {"normalize": False}})
+
+   # Better: Use consistent settings
+   config = {
+       "anomaly_map": {"normalize": True},
+       "pred_mask": {"mode": "contour", "alpha": 0.7}
+   }
+   vis1 = visualize_image_item(item1, fields_config=config)
+   vis2 = visualize_image_item(item2, fields_config=config)
+   ```
+
+```{seealso}
+For more information:
+- {doc}`AnomalibModule Documentation <../../reference/models/base>`
+- {doc}`Metrics Guide <../metrics/index>`
+```
diff --git a/docs/source/snippets/logging/api.txt b/docs/source/snippets/logging/api.txt
index 3cbae7f66c..e69de29bb2 100644
--- a/docs/source/snippets/logging/api.txt
+++ b/docs/source/snippets/logging/api.txt
@@ -1 +0,0 @@
-# To be enabled in v1.1
diff --git a/docs/source/snippets/logging/cli.txt b/docs/source/snippets/logging/cli.txt
index 5667fbaf29..e69de29bb2 100644
--- a/docs/source/snippets/logging/cli.txt
+++ b/docs/source/snippets/logging/cli.txt
@@ -1 +0,0 @@
-# Place the Experiment Management CLI command here.
diff --git a/examples/api/01_getting_started/basic_inference.py b/examples/api/01_getting_started/basic_inference.py
new file mode 100644
index 0000000000..b16dc9da62
--- /dev/null
+++ b/examples/api/01_getting_started/basic_inference.py
@@ -0,0 +1,41 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Getting Started with Anomalib Inference using the Python API.
+
+This example shows how to perform inference on a trained model
+using the Anomalib Python API.
+"""
+
+# 1. Import required modules
+from pathlib import Path
+
+from anomalib.data import PredictDataset
+from anomalib.engine import Engine
+from anomalib.models import EfficientAd
+
+# 2. Initialize the model and load weights
+model = EfficientAd()
+engine = Engine()
+
+# 3. Prepare test data
+# You can use a single image or a folder of images
+dataset = PredictDataset(
+    path=Path("path/to/test/images"),
+    image_size=(256, 256),
+)
+
+# 4. Get predictions
+predictions = engine.predict(
+    model=model,
+    dataset=dataset,
+    ckpt_path="path/to/model.ckpt",
+)
+
+# 5. Access the results
+if predictions is not None:
+    for prediction in predictions:
+        image_path = prediction.image_path
+        anomaly_map = prediction.anomaly_map  # Pixel-level anomaly heatmap
+        pred_label = prediction.pred_label  # Image-level label (0: normal, 1: anomalous)
+        pred_score = prediction.pred_score  # Image-level anomaly score
diff --git a/examples/api/01_getting_started/basic_training.py b/examples/api/01_getting_started/basic_training.py
new file mode 100644
index 0000000000..51ca2d70cb
--- /dev/null
+++ b/examples/api/01_getting_started/basic_training.py
@@ -0,0 +1,33 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Getting Started with Anomalib Training using the Python API.
+
+This example shows the basic steps to train an anomaly detection model
+using the Anomalib Python API.
+"""
+
+# 1. Import required modules
+from anomalib.data import MVTec
+from anomalib.engine import Engine
+from anomalib.models import EfficientAd
+
+# 2. Create a dataset
+# MVTec is a popular dataset for anomaly detection
+datamodule = MVTec(
+    root="./datasets/MVTec",  # Path to download/store the dataset
+    category="bottle",  # MVTec category to use
+    train_batch_size=32,  # Number of images per training batch
+    eval_batch_size=32,  # Number of images per validation/test batch
+    num_workers=8,  # Number of parallel processes for data loading
+)
+
+# 3. Initialize the model
+# EfficientAd is a good default choice for beginners
+model = EfficientAd()
+
+# 4. Create the training engine
+engine = Engine(max_epochs=10)  # Train for 10 epochs
+
+# 5. Train the model
+engine.fit(datamodule=datamodule, model=model)
diff --git a/examples/api/02_data/folder.py b/examples/api/02_data/folder.py
new file mode 100644
index 0000000000..ffee804a15
--- /dev/null
+++ b/examples/api/02_data/folder.py
@@ -0,0 +1,45 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Example showing how to use your own dataset with Anomalib.
+
+This example demonstrates how to use a custom folder dataset where images
+are organized in a specific directory structure.
+"""
+
+from pathlib import Path
+
+from anomalib.data import Folder
+
+# 1. Basic Usage with Default Structure
+# Default structure expects:
+# - train/good: Normal (good) training images
+# - test/good: Normal test images
+# - test/defect: Anomalous test images
+datamodule = Folder(
+    name="my_dataset",
+    root=Path("./datasets/my_dataset"),
+    normal_dir="good",  # Subfolder containing normal images
+    abnormal_dir="defect",  # Subfolder containing anomalous images
+)
+
+# 2. Custom Directory Structure
+# For a different directory structure:
+# my_dataset/
+# ├── train/
+# │   └── normal/         # Normal training images
+# ├── val/
+# │   ├── normal/         # Normal validation images
+# │   └── anomaly/        # Anomalous validation images
+# └── test/
+#     ├── normal/         # Normal test images
+#     └── anomaly/        # Anomalous test images
+datamodule = Folder(
+    name="my_dataset",
+    root=Path("./datasets/my_dataset"),
+    normal_dir="normal",  # Subfolder containing normal images
+    abnormal_dir="anomaly",  # Subfolder containing anomalous images
+    train_batch_size=32,
+    eval_batch_size=32,
+    num_workers=8,
+)
diff --git a/examples/api/02_data/mvtec.py b/examples/api/02_data/mvtec.py
new file mode 100644
index 0000000000..56ac8a4dfd
--- /dev/null
+++ b/examples/api/02_data/mvtec.py
@@ -0,0 +1,38 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Example showing how to use the MVTec dataset with Anomalib.
+
+MVTec is a widely-used dataset for anomaly detection, containing multiple
+categories of industrial objects with various types of defects.
+"""
+
+from anomalib.data import MVTec
+
+# 1. Basic Usage
+# Load a specific category with default settings
+datamodule = MVTec(
+    root="./datasets/MVTec",
+    category="bottle",
+)
+
+# 2. Advanced Configuration
+# Customize data loading and preprocessing
+datamodule = MVTec(
+    root="./datasets/MVTec",
+    category="bottle",
+    train_batch_size=32,
+    eval_batch_size=32,
+    num_workers=8,
+    val_split_mode="from_test",  # Create validation set from test set
+    val_split_ratio=0.5,  # Use 50% of test set for validation
+)
+
+# 3. Using Multiple Categories
+# Train on multiple categories (if supported by the model)
+for category in ["bottle", "cable", "capsule"]:
+    category_data = MVTec(
+        root="./datasets/MVTec",
+        category=category,
+    )
+    # Use category_data with your model...
diff --git a/examples/api/03_models/efficient_ad.py b/examples/api/03_models/efficient_ad.py
new file mode 100644
index 0000000000..338133d920
--- /dev/null
+++ b/examples/api/03_models/efficient_ad.py
@@ -0,0 +1,45 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Example showing how to use the EfficientAd model.
+
+EfficientAd is a fast and accurate model for anomaly detection,
+particularly well-suited for industrial inspection tasks.
+"""
+
+from anomalib.data import MVTec
+from anomalib.engine import Engine
+from anomalib.models import EfficientAd
+
+# 1. Basic Usage
+# Initialize with default settings
+model = EfficientAd()
+
+# 2. Custom Configuration
+# Configure model parameters
+model = EfficientAd(
+    teacher_out_channels=384,  # Number of teacher output channels
+    model_size="m",
+    lr=1e-4,
+)
+
+# 3. Training Pipeline
+# Set up the complete training pipeline
+datamodule = MVTec(
+    root="./datasets/MVTec",
+    category="bottle",
+    train_batch_size=32,
+)
+
+# Initialize training engine with specific settings
+engine = Engine(
+    max_epochs=20,
+    accelerator="auto",  # Automatically detect GPU/CPU
+    devices=1,  # Number of devices to use
+)
+
+# Train the model
+engine.fit(
+    model=model,
+    datamodule=datamodule,
+)
diff --git a/examples/api/03_models/padim.py b/examples/api/03_models/padim.py
new file mode 100644
index 0000000000..c61edb5111
--- /dev/null
+++ b/examples/api/03_models/padim.py
@@ -0,0 +1,47 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Example showing how to use the Padim model.
+
+PaDiM (Patch Distribution Modeling) is a model that uses pretrained CNN features
+and multivariate Gaussian modeling for anomaly detection.
+"""
+
+from anomalib.data import MVTec
+from anomalib.engine import Engine
+from anomalib.models import Padim
+
+# 1. Basic Usage
+# Initialize with default settings
+model = Padim()
+
+# 2. Custom Configuration
+# Configure model parameters
+model = Padim(
+    backbone="resnet18",  # Feature extraction backbone
+    layers=["layer1", "layer2", "layer3"],  # Layers to extract features from
+    pre_trained=True,  # Use pretrained weights
+    n_features=100,  # Number of features to retain
+)
+
+# 3. Training Pipeline
+# Set up the complete training pipeline
+datamodule = MVTec(
+    root="./datasets/MVTec",
+    category="bottle",
+    train_batch_size=32,
+    eval_batch_size=32,  # Important for feature extraction
+)
+
+# Initialize training engine with specific settings
+engine = Engine(
+    max_epochs=1,  # PaDiM needs only one epoch
+    accelerator="auto",  # Automatically detect GPU/CPU
+    devices=1,  # Number of devices to use
+)
+
+# Train the model
+engine.fit(
+    model=model,
+    datamodule=datamodule,
+)
diff --git a/examples/api/03_models/patchcore.py b/examples/api/03_models/patchcore.py
new file mode 100644
index 0000000000..9acf435402
--- /dev/null
+++ b/examples/api/03_models/patchcore.py
@@ -0,0 +1,47 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Example showing how to use the Patchcore model.
+
+Patchcore is a memory-based model that uses a pretrained CNN backbone
+to extract and store patch features for anomaly detection.
+"""
+
+from anomalib.data import MVTec
+from anomalib.engine import Engine
+from anomalib.models import Patchcore
+
+# 1. Basic Usage
+# Initialize with default settings
+model = Patchcore()
+
+# 2. Custom Configuration
+# Configure model parameters
+model = Patchcore(
+    backbone="wide_resnet50_2",  # Feature extraction backbone
+    layers=["layer2", "layer3"],  # Layers to extract features from
+    pre_trained=True,  # Use pretrained weights
+    num_neighbors=9,  # Number of nearest neighbors
+)
+
+# 3. Training Pipeline
+# Set up the complete training pipeline
+datamodule = MVTec(
+    root="./datasets/MVTec",
+    category="bottle",
+    train_batch_size=32,
+    eval_batch_size=32,  # Important for feature extraction
+)
+
+# Initialize training engine with specific settings
+engine = Engine(
+    max_epochs=1,  # Patchcore typically needs only one epoch
+    accelerator="auto",  # Automatically detect GPU/CPU
+    devices=1,  # Number of devices to use
+)
+
+# Train the model
+engine.fit(
+    model=model,
+    datamodule=datamodule,
+)
diff --git a/examples/api/04_advanced/loggers.py b/examples/api/04_advanced/loggers.py
new file mode 100644
index 0000000000..ad2a81a426
--- /dev/null
+++ b/examples/api/04_advanced/loggers.py
@@ -0,0 +1,75 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Example showing how to use advanced logging features in Anomalib.
+
+This example demonstrates how to configure different loggers (TensorBoard,
+WandB, MLflow, Comet) and customize logging behavior.
+"""
+
+from pathlib import Path
+
+from anomalib.data import MVTec
+from anomalib.engine import Engine
+from anomalib.loggers import AnomalibMLFlowLogger, AnomalibTensorBoardLogger, AnomalibWandbLogger
+from anomalib.models import Patchcore
+
+# 1. Basic TensorBoard Logging
+# This is the default logger
+engine = Engine(
+    logger=AnomalibTensorBoardLogger(save_dir="logs/tensorboard"),
+    max_epochs=1,
+)
+
+# 2. Weights & Biases (WandB) Logging
+# Track experiments with WandB
+engine = Engine(
+    logger=AnomalibWandbLogger(
+        project="anomalib",
+        name="patchcore_experiment",
+        save_dir="logs/wandb",
+    ),
+    max_epochs=1,
+)
+
+# 3. MLflow Logging
+# Track experiments with MLflow
+engine = Engine(
+    logger=AnomalibMLFlowLogger(
+        experiment_name="anomalib",
+        tracking_uri="logs/mlflow",
+    ),
+    max_epochs=1,
+)
+
+# 4. Multiple Loggers
+# Use multiple loggers simultaneously
+engine = Engine(
+    logger=[
+        AnomalibTensorBoardLogger(save_dir="logs/tensorboard"),
+        AnomalibWandbLogger(project="anomalib", save_dir="logs/wandb"),
+    ],
+    max_epochs=1,
+)
+
+# 5. Complete Training Example with Logging
+model = Patchcore()
+datamodule = MVTec(
+    root=Path("./datasets/MVTec"),
+    category="bottle",
+)
+
+# Configure engine with logging
+engine = Engine(
+    logger=AnomalibTensorBoardLogger(save_dir="logs/tensorboard"),
+    max_epochs=1,
+    log_graph=True,  # Log model graph
+    enable_checkpointing=True,  # Save model checkpoints
+    default_root_dir="results",  # Root directory for all outputs
+)
+
+# Train with logging enabled
+engine.fit(
+    model=model,
+    datamodule=datamodule,
+)
diff --git a/examples/api/05_pipelines/complete_pipeline.py b/examples/api/05_pipelines/complete_pipeline.py
new file mode 100644
index 0000000000..001f7800fb
--- /dev/null
+++ b/examples/api/05_pipelines/complete_pipeline.py
@@ -0,0 +1,82 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Complete Pipeline Example for Anomalib.
+
+This example demonstrates a complete workflow including:
+1. Training a model
+2. Exporting for deployment
+3. Running inference
+"""
+
+from pathlib import Path
+
+from anomalib.data import MVTec, PredictDataset
+from anomalib.deploy import ExportType
+from anomalib.engine import Engine
+from anomalib.models import Patchcore
+
+# 1. Training Phase
+# ----------------
+print("Starting Training Phase...")
+
+# Initialize components
+model = Patchcore()
+datamodule = MVTec(
+    root=Path("./datasets/MVTec"),
+    category="bottle",
+    train_batch_size=32,
+)
+
+# Configure training engine
+engine = Engine(
+    max_epochs=1,
+    enable_checkpointing=True,
+    default_root_dir="results",
+)
+
+# Train the model
+engine.fit(model=model, datamodule=datamodule)
+
+
+# 2. Inference Phase
+# ----------------
+print("\nStarting Inference Phase...")
+
+# Prepare test data
+test_data = PredictDataset(
+    path=Path("path/to/test/images"),
+    image_size=(256, 256),
+)
+
+# Run inference on Lightning model.
+predictions = engine.predict(
+    model=model,
+    dataset=test_data,
+)
+
+# Process results
+print("\nProcessing Results...")
+if predictions is not None:
+    for prediction in predictions:
+        image_path = prediction.image_path
+        anomaly_score = prediction.pred_score
+    is_anomalous = prediction.pred_label > 0.5
+
+    print(f"Image: {image_path}")
+    print(f"Anomaly Score: {anomaly_score:.3f}")
+    print(f"Is Anomalous: {is_anomalous}\n")
+
+# 3. Export Phase
+# --------------
+print("\nStarting Export Phase...")
+
+# Export to OPENVINO format
+engine.export(
+    model=model,
+    export_root=Path("exported_models"),
+    input_size=(256, 256),  # Adjust based on your needs
+    export_type=ExportType.OPENVINO,  # or OPENVINO
+)
+
+# Exported model can be used for inference to accelerate the inference speed.
diff --git a/examples/cli/00_installation/anomalib_install.sh b/examples/cli/00_installation/anomalib_install.sh
new file mode 100644
index 0000000000..dc0c0cd67c
--- /dev/null
+++ b/examples/cli/00_installation/anomalib_install.sh
@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# shellcheck shell=bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# This script demonstrates how to use the anomalib installer
+# to install different dependency options.
+
+echo "=== Installing Anomalib using the anomalib installer ==="
+
+echo -e "\n1. Base Installation"
+echo "# First, install the base package"
+echo "$ pip install anomalib"
+# pip install anomalib
+
+echo -e "\n=== Anomalib Installer Help ==="
+echo "$ anomalib install -h"
+echo '
+╭─ Arguments ───────────────────────────────────────────────────────────────────╮
+│ Usage: anomalib install [-h] [-v] [--option {core,full,openvino,dev}]         │
+│                                                                               │
+│ Install the full-package for anomalib.                                        │
+│                                                                               │
+│ Options:                                                                      │
+│   -h, --help            Show this help message and exit.                      │
+│   -v, --verbose         Show verbose output during installation.              │
+│   --option {core,full,openvino,dev}                                           │
+│                         Installation option to use. Options are:              │
+│                         - core: Install only core dependencies                │
+│                         - full: Install all dependencies                      │
+│                         - openvino: Install OpenVINO dependencies             │
+│                         - dev: Install development dependencies               │
+│                         (default: full)                                       │
+╰───────────────────────────────────────────────────────────────────────────────╯'
+
+echo -e "\n=== Installation Options ==="
+
+echo -e "\n2. Install core dependencies only"
+echo "# For basic training and evaluation via Torch and Lightning"
+echo "$ anomalib install --option core"
+# anomalib install --option core
+
+echo -e "\n3. Install full dependencies"
+echo "# Includes all optional dependencies"
+echo "$ anomalib install --option full"
+# anomalib install --option full
+
+echo -e "\n4. Install OpenVINO dependencies"
+echo "# For edge deployment with smaller wheel size"
+echo "$ anomalib install --option openvino"
+# anomalib install --option openvino
+
+echo -e "\n5. Install development dependencies"
+echo "# For contributing to anomalib"
+echo "$ anomalib install --option dev"
+# anomalib install --option dev
+
+echo -e "\n6. Install with verbose output"
+echo "# Shows detailed installation progress"
+echo "$ anomalib install -v"
+# anomalib install -v
+
+echo -e "\n=== Example Installation Output ==="
+echo '
+❯ anomalib install --option full
+Installing anomalib with full dependencies...
+Successfully installed anomalib and all dependencies.'
+
+echo -e "\nNote: The actual installation commands are commented out above."
+echo "To install anomalib, uncomment the desired installation command by removing the '#' at the start of the line."
diff --git a/examples/cli/00_installation/pip_install.sh b/examples/cli/00_installation/pip_install.sh
new file mode 100644
index 0000000000..2e67d119b1
--- /dev/null
+++ b/examples/cli/00_installation/pip_install.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# shellcheck shell=bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# This script demonstrates how to install anomalib using pip
+# with different dependency options.
+
+echo "=== Installing Anomalib using pip ==="
+
+echo -e "\n1. Base Installation"
+echo "# Install the base package with minimal dependencies"
+echo "$ pip install anomalib"
+# pip install anomalib
+
+echo -e "\n2. Install with OpenVINO dependencies"
+echo "$ pip install anomalib[openvino]"
+# pip install anomalib[openvino]
+
+echo -e "\n3. Install with full dependencies"
+echo "$ pip install anomalib[full]"
+# pip install anomalib[full]
+
+echo -e "\n4. Install with development dependencies"
+echo "$ pip install anomalib[dev]"
+# pip install anomalib[dev]
+
+echo -e "\n5. Install with multiple dependency groups"
+echo "$ pip install anomalib[openvino,dev]"
+# pip install anomalib[openvino,dev]
+
+echo -e "\n=== Verifying Installation ==="
+echo "$ python -c 'import anomalib; print(f\"Anomalib version: {anomalib.__version__}\")'"
+# python -c 'import anomalib; print(f"Anomalib version: {anomalib.__version__}")'
+
+echo -e "\nNote: The actual installation commands are commented out above."
+echo "To install anomalib, uncomment the desired installation command by removing the '#' at the start of the line."
diff --git a/examples/cli/00_installation/source_install.sh b/examples/cli/00_installation/source_install.sh
new file mode 100644
index 0000000000..191099a704
--- /dev/null
+++ b/examples/cli/00_installation/source_install.sh
@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# shellcheck shell=bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# This script demonstrates how to install anomalib from source
+# starting with virtual environment setup.
+
+echo "=== Installing Anomalib from source ==="
+
+echo -e "\n1. Create and activate a virtual environment"
+echo "# Create a new virtual environment"
+echo "$ python -m venv .venv"
+# python -m venv .venv
+
+echo "# Activate the virtual environment (Linux/macOS)"
+echo "$ source .venv/bin/activate"
+# source .venv/bin/activate
+
+echo "# Activate the virtual environment (Windows)"
+echo "$ .venv\\Scripts\\activate"
+
+echo -e "\n2. Clone the repository"
+echo "$ git clone https://github.com/openvinotoolkit/anomalib.git"
+# git clone https://github.com/openvinotoolkit/anomalib.git
+
+echo "$ cd anomalib"
+# cd anomalib
+
+echo -e "\n3. Install in development mode"
+echo "# Install the base package in development mode"
+echo "$ pip install -e ."
+# pip install -e .
+
+echo -e "\n4. Install additional dependencies"
+echo "# You can use either pip or anomalib install"
+
+echo -e "\n4a. Using pip:"
+echo "# Install full dependencies"
+echo "$ pip install -e .[full]"
+# pip install -e .[full]
+
+echo "# Install development dependencies"
+echo "$ pip install -e .[dev]"
+# pip install -e .[dev]
+
+echo "# Install OpenVINO dependencies"
+echo "$ pip install -e .[openvino]"
+# pip install -e .[openvino]
+
+echo -e "\n4b. Using anomalib install:"
+echo "# Install full dependencies"
+echo "$ anomalib install --option full"
+# anomalib install --option full
+
+echo "# Install development dependencies"
+echo "$ anomalib install --option dev"
+# anomalib install --option dev
+
+echo "# Install OpenVINO dependencies"
+echo "$ anomalib install --option openvino"
+# anomalib install --option openvino
+
+echo -e "\n5. Verify the installation"
+echo "$ python -c 'import anomalib; print(f\"Anomalib version: {anomalib.__version__}\")'"
+# python -c 'import anomalib; print(f"Anomalib version: {anomalib.__version__}")'
+
+echo -e "\n=== Example Installation Output ==="
+echo '
+❯ python -m venv .venv
+❯ source .venv/bin/activate
+(.venv) ❯ git clone https://github.com/openvinotoolkit/anomalib.git
+Cloning into '"'"'anomalib'"'"'...
+remote: Enumerating objects: 9794, done.
+remote: Counting objects: 100% (2052/2052), done.
+remote: Compressing objects: 100% (688/688), done.
+remote: Total 9794 (delta 1516), reused 1766 (delta 1349), pack-reused 7742
+Receiving objects: 100% (9794/9794), 106.63 MiB | 5.92 MiB/s, done.
+Resolving deltas: 100% (6947/6947), done.
+(.venv) ❯ cd anomalib
+(.venv) ❯ pip install -e .[full]
+Installing collected packages: anomalib
+  Running setup.py develop for anomalib
+Successfully installed anomalib-0.0.0
+(.venv) ❯ python -c '"'"'import anomalib; print(f"Anomalib version: {anomalib.__version__}")'"'"'
+Anomalib version: 2.0.0'
+
+echo -e "\nNote: The actual installation commands are commented out above."
+echo "To install anomalib, uncomment the desired installation command by removing the '#' at the start of the line."
+echo "Make sure to activate the virtual environment before running the installation commands."
diff --git a/examples/cli/01_getting_started/basic_inference.sh b/examples/cli/01_getting_started/basic_inference.sh
new file mode 100644
index 0000000000..c3369d5919
--- /dev/null
+++ b/examples/cli/01_getting_started/basic_inference.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# shellcheck shell=bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Getting Started with Anomalib Inference
+# This example shows how to perform inference using Engine().predict() arguments.
+
+echo "=== Anomalib Inference Examples ==="
+
+echo -e "\n1. Basic Inference with Checkpoint Path"
+echo "# Predict using a model checkpoint"
+anomalib predict \
+    --ckpt_path "./results/efficient_ad/mvtec/bottle/weights/model.ckpt" \
+    --data_path path/to/image.jpg
+
+echo -e "\n2. Inference with Directory Path"
+echo "# Predict on all images in a directory"
+anomalib predict \
+    --ckpt_path "./results/efficient_ad/mvtec/bottle/weights/model.ckpt" \
+    --data_path "./datasets/mvtec/bottle/test"
+
+echo -e "\n3. Inference with Datamodule"
+echo "# Use a datamodule for inference"
+anomalib predict \
+    --ckpt_path "./results/my_dataset/weights/model.ckpt" \
+    --datamodule.class_path anomalib.data.Folder \
+    --datamodule.init_args.name "my_dataset" \
+    --datamodule.init_args.root "./datasets/my_dataset" \
+    --datamodule.init_args.normal_dir "good" \
+    --datamodule.init_args.abnormal_dir "defect"
+
+echo -e "\n4. Inference with Return Predictions"
+echo "# Return predictions instead of saving to disk"
+anomalib predict \
+    --ckpt_path "./results/efficient_ad/mvtec/bottle/weights/model.ckpt" \
+    --data_path path/to/image.jpg \
+    --return_predictions
+
+echo -e "\n=== Example Output ==="
+echo '
+GPU available: True (cuda), used: True
+TPU available: False, using: 0 TPU cores
+IPU available: False, using: 0 IPUs
+HPU available: False, using: 0 HPUs
+[2024-01-01 12:00:00][INFO][anomalib][predict]: Loading model from ./results/my_dataset/weights/model.ckpt
+[2024-01-01 12:00:01][INFO][anomalib][predict]: Prediction started
+[2024-01-01 12:00:02][INFO][anomalib][predict]: Predictions saved to ./results/my_dataset/predictions'
+
+echo -e "\nNote: Replace paths according to your setup."
+echo "The predictions will be saved in the results directory by default unless --return_predictions is used."
diff --git a/examples/cli/01_getting_started/basic_training.sh b/examples/cli/01_getting_started/basic_training.sh
new file mode 100644
index 0000000000..64d53d0916
--- /dev/null
+++ b/examples/cli/01_getting_started/basic_training.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Getting Started with Anomalib Training
+# ------------------------------------
+# This example shows the basic steps to train an anomaly detection model.
+
+# 1. Basic Training
+# Train a model using default configuration (recommended for beginners)
+echo "Training with default configuration..."
+anomalib train --model efficient_ad
+
+# 2. Training with Basic Customization
+# Customize basic parameters like batch size and epochs
+echo -e "\nTraining with custom parameters..."
+anomalib train --model efficient_ad \
+    --data.train_batch_size 32 \
+    --trainer.max_epochs 10
+
+# 3. Using a Different Dataset
+# Train on a specific category of MVTec dataset
+echo -e "\nTraining on MVTec bottle category..."
+anomalib train --model efficient_ad \
+    --data.category bottle
diff --git a/examples/cli/02_data/folder.sh b/examples/cli/02_data/folder.sh
new file mode 100644
index 0000000000..6234fa848e
--- /dev/null
+++ b/examples/cli/02_data/folder.sh
@@ -0,0 +1,48 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Using Custom Folder Dataset with Anomalib CLI
+# ------------------------------------------
+# This example shows how to use your own dataset organized in folders.
+
+# 1. Basic Usage with Default Structure
+# Train using the default folder structure
+echo "Training on custom dataset with default structure..."
+anomalib train \
+    --model efficient_ad \
+    --data Folder \
+    --data.name my_dataset \
+    --data.root ./datasets/my_dataset \
+    --data.normal_dir good \
+    --data.abnormal_dir defect
+
+# 2. Custom Configuration
+# Train with custom data settings
+echo -e "\nTraining with custom data settings..."
+anomalib train \
+    --model efficient_ad \
+    --data Folder \
+    --data.name my_dataset \
+    --data.root ./datasets/my_dataset \
+    --data.normal_dir normal \
+    --data.abnormal_dir anomaly \
+    --data.train_batch_size 32 \
+    --data.eval_batch_size 32 \
+    --data.num_workers 8
+
+# 3. Training with Multiple Dataset Variations
+# Train on different subsets or configurations
+echo -e "\nTraining on multiple dataset variations..."
+for defect_type in "scratch" "crack" "stain"; do
+    echo "Training on defect type: $defect_type"
+    anomalib train \
+        --model efficient_ad \
+        --data Folder \
+        --data.name my_dataset \
+        --data.root "./datasets/my_dataset/$defect_type" \
+        --data.normal_dir good \
+        --data.abnormal_dir "$defect_type" \
+        --trainer.default_root_dir "results/$defect_type"
+done
diff --git a/examples/cli/02_data/mvtec.sh b/examples/cli/02_data/mvtec.sh
new file mode 100644
index 0000000000..61c1e51c76
--- /dev/null
+++ b/examples/cli/02_data/mvtec.sh
@@ -0,0 +1,38 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Using MVTec Dataset with Anomalib CLI
+# -----------------------------------
+# This example shows different ways to use the MVTec dataset.
+
+# 1. Basic Usage
+# Train on a specific MVTec category
+echo "Training on MVTec bottle category..."
+anomalib train \
+    --model efficient_ad \
+    --data.category bottle
+
+# 2. Advanced Configuration
+# Customize data loading and preprocessing
+echo -e "\nTraining with custom data settings..."
+anomalib train \
+    --model efficient_ad \
+    --data.category bottle \
+    --data.train_batch_size 32 \
+    --data.eval_batch_size 32 \
+    --data.num_workers 8 \
+    --data.val_split_mode from_test \
+    --data.val_split_ratio 0.5
+
+# 3. Training Multiple Categories
+# Train separate models for different categories
+echo -e "\nTraining on multiple MVTec categories..."
+for category in "bottle" "cable" "capsule"; do
+    echo "Training on category: $category"
+    anomalib train \
+        --model efficient_ad \
+        --data.category "$category" \
+        --trainer.default_root_dir "results/$category"
+done
diff --git a/examples/cli/03_models/efficient_ad.sh b/examples/cli/03_models/efficient_ad.sh
new file mode 100644
index 0000000000..ed111d788c
--- /dev/null
+++ b/examples/cli/03_models/efficient_ad.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Using EfficientAd Model with Anomalib CLI
+# --------------------------------------
+# This example shows how to use the EfficientAd model for anomaly detection.
+
+# 1. Basic Usage
+# Train with default settings
+echo "Training EfficientAd with default settings..."
+anomalib train \
+    --model efficient_ad
+
+# 2. Custom Configuration
+# Train with custom model settings
+echo -e "\nTraining with custom model settings..."
+anomalib train \
+    --model efficient_ad \
+    --model.teacher_out_channels 384 \
+    --model.model_size m \
+    --model.lr 1e-4
+
+# 3. Advanced Training Pipeline
+# Train with custom training settings
+echo -e "\nTraining with custom pipeline settings..."
+anomalib train \
+    --model efficient_ad \
+    --data.category bottle \
+    --trainer.max_epochs 20 \
+    --trainer.accelerator auto \
+    --trainer.devices 1 \
+    --trainer.default_root_dir results/efficient_ad
+
+# 4. Hyperparameter Search
+# Train multiple variations to find best settings
+echo -e "\nRunning hyperparameter search..."
+for channels in 128 256 384; do
+    echo "Training with $channels channels..."
+    anomalib train \
+        --model efficient_ad \
+        --model.teacher_out_channels $channels \
+        --model.student_out_channels $channels \
+        --trainer.default_root_dir "results/efficient_ad_${channels}"
+done
diff --git a/examples/cli/03_models/padim.sh b/examples/cli/03_models/padim.sh
new file mode 100644
index 0000000000..068df2f519
--- /dev/null
+++ b/examples/cli/03_models/padim.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Using PaDiM Model with Anomalib CLI
+# ---------------------------------
+# This example shows how to use the PaDiM model for anomaly detection.
+
+# 1. Basic Usage
+# Train with default settings
+echo "Training PaDiM with default settings..."
+anomalib train \
+    --model padim
+
+# 2. Custom Configuration
+# Train with custom model settings
+echo -e "\nTraining with custom model settings..."
+anomalib train \
+    --model padim \
+    --model.backbone resnet18 \
+    --model.layers layer1 layer2 layer3 \
+    --model.pre_trained true \
+    --model.n_features 100
+
+# 3. Advanced Training Pipeline
+# Train with custom training settings
+echo -e "\nTraining with custom pipeline settings..."
+anomalib train \
+    --model padim \
+    --data.category bottle \
+    --trainer.max_epochs 1 \
+    --trainer.accelerator auto \
+    --trainer.devices 1 \
+    --trainer.default_root_dir results/padim
+
+# 4. Feature Extraction Comparison
+# Compare different backbones and feature combinations
+echo -e "\nComparing different feature configurations..."
+for backbone in "resnet18" "wide_resnet50_2"; do
+    echo "Training with backbone: $backbone"
+    anomalib train \
+        --model padim \
+        --model.backbone "$backbone" \
+        --trainer.default_root_dir "results/padim_${backbone}"
+done
diff --git a/examples/cli/03_models/patchcore.sh b/examples/cli/03_models/patchcore.sh
new file mode 100644
index 0000000000..539f5069ca
--- /dev/null
+++ b/examples/cli/03_models/patchcore.sh
@@ -0,0 +1,45 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Using Patchcore Model with Anomalib CLI
+# ------------------------------------
+# This example shows how to use the Patchcore model for anomaly detection.
+
+# 1. Basic Usage
+# Train with default settings
+echo "Training Patchcore with default settings..."
+anomalib train \
+    --model patchcore
+
+# 2. Custom Configuration
+# Train with custom model settings
+echo -e "\nTraining with custom model settings..."
+anomalib train \
+    --model patchcore \
+    --model.backbone wide_resnet50_2 \
+    --model.layers layer2 layer3 \
+    --model.pre_trained true \
+    --model.num_neighbors 9
+
+# 3. Advanced Training Pipeline
+# Train with custom training settings
+echo -e "\nTraining with custom pipeline settings..."
+anomalib train \
+    --model patchcore \
+    --data.category bottle \
+    --trainer.max_epochs 1 \
+    --trainer.accelerator auto \
+    --trainer.devices 1 \
+    --trainer.default_root_dir results/patchcore
+
+# 4. Multi-GPU Training
+# Train using multiple GPUs for faster feature extraction
+echo -e "\nTraining with multiple GPUs..."
+anomalib train \
+    --model patchcore \
+    --data.category bottle \
+    --trainer.accelerator gpu \
+    --trainer.devices 2 \
+    --trainer.strategy ddp
diff --git a/examples/cli/04_advanced/custom_components.sh b/examples/cli/04_advanced/custom_components.sh
new file mode 100644
index 0000000000..c41e8fdcf2
--- /dev/null
+++ b/examples/cli/04_advanced/custom_components.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Advanced Custom Components with Anomalib CLI
+# ---------------------------------------
+# This example shows how to use custom metrics and evaluators.
+
+# 1. Basic Metrics Setup
+# Create metrics with specific fields to compute
+echo "Training with basic metrics setup..."
+anomalib train \
+    --model efficient_ad \
+    --model.evaluator.test_metrics auroc f1_score \
+    --model.evaluator.val_metrics auroc f1_score \
+    --model.evaluator.metrics.auroc.fields pred_score gt_label \
+    --model.evaluator.metrics.f1_score.fields pred_label gt_label \
+    --trainer.default_root_dir results/basic_metrics
+
+# 2. Advanced Metrics Setup
+# Create a comprehensive set of metrics
+echo -e "\nTraining with comprehensive metrics..."
+anomalib train \
+    --model efficient_ad \
+    --model.evaluator.test_metrics auroc f1_score precision recall \
+    --model.evaluator.val_metrics auroc f1_score precision recall \
+    --model.evaluator.metrics.auroc.fields pred_score gt_label \
+    --model.evaluator.metrics.f1_score.fields pred_label gt_label \
+    --model.evaluator.metrics.precision.fields pred_label gt_label \
+    --model.evaluator.metrics.recall.fields pred_label gt_label \
+    --model.evaluator.compute_on_cpu true \
+    --trainer.default_root_dir results/advanced_metrics
+
+# 3. Complete Training Pipeline with Custom Metrics
+# Initialize components and run training
+echo -e "\nRunning complete training pipeline..."
+anomalib train \
+    --model efficient_ad \
+    --model.teacher_out_channels 384 \
+    --data.category bottle \
+    --data.train_batch_size 32 \
+    --data.eval_batch_size 32 \
+    --data.num_workers 8 \
+    --model.evaluator.test_metrics auroc f1_score precision recall \
+    --model.evaluator.val_metrics auroc f1_score precision recall \
+    --model.evaluator.compute_on_cpu true \
+    --trainer.max_epochs 20 \
+    --trainer.accelerator auto \
+    --trainer.devices 1 \
+    --trainer.gradient_clip_val 0.1 \
+    --trainer.enable_checkpointing true \
+    --trainer.default_root_dir results/complete
diff --git a/examples/cli/04_advanced/custom_pipeline.sh b/examples/cli/04_advanced/custom_pipeline.sh
new file mode 100644
index 0000000000..81515113b4
--- /dev/null
+++ b/examples/cli/04_advanced/custom_pipeline.sh
@@ -0,0 +1,74 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Advanced Anomalib Pipeline Configuration
+# -------------------------------------
+# This example shows how to configure advanced pipeline settings using the CLI.
+
+# 1. Training with Custom Components
+# Configure pre-processing, metrics, and visualization
+echo "Training with custom pipeline components..."
+anomalib train \
+    --model patchcore \
+    --data MVTec \
+    --data.category bottle \
+    --model.backbone resnet18 \
+    --model.layers layer2 layer3 \
+    --pre_processor.transform.name Compose \
+    --pre_processor.transform.transforms "[
+        {name: Resize, size: [256, 256]},
+        {name: ToTensor},
+        {name: Normalize, mean: [0.485, 0.456, 0.406], std: [0.229, 0.224, 0.225]}
+    ]" \
+    --metrics "[auroc, f1_score]" \
+
+# 2. Advanced Training Configuration
+# Configure training behavior and optimization
+echo -e "\nTraining with advanced settings..."
+anomalib train \
+    --model patchcore \
+    --data MVTec \
+    --trainer.max_epochs 1 \
+    --trainer.accelerator gpu \
+    --trainer.devices 1 \
+    --trainer.precision 16 \
+    --trainer.deterministic true \
+    --optimizer.name Adam \
+    --optimizer.lr 0.001 \
+    --scheduler.name CosineAnnealingLR \
+    --scheduler.T_max 100
+
+# 3. Export and Deploy
+# Export the trained model and run inference
+echo -e "\nExporting and running inference..."
+# First, export the model
+anomalib export \
+    --model patchcore \
+    --weights path/to/weights.ckpt \
+    --export_mode onnx \
+    --output_path exported_models
+
+# Then, run inference with the exported model
+anomalib predict \
+    --model patchcore \
+    --weights exported_models/model.onnx \
+    --input path/to/test/images \
+    --output results/predictions \
+
+# 4. Hyperparameter Search
+# Run multiple training configurations
+echo -e "\nRunning hyperparameter search..."
+for backbone in "resnet18" "wide_resnet50_2"; do
+    for layer_combo in "layer2,layer3" "layer1,layer2,layer3"; do
+        IFS=',' read -ra layers <<< "$layer_combo"
+        echo "Training with backbone: $backbone, layers: ${layers[*]}"
+        anomalib train \
+            --model patchcore \
+            --data MVTec \
+            --model.backbone "$backbone" \
+            --model.layers "${layers[@]}" \
+            --trainer.default_root_dir "results/search/${backbone}_${layer_combo}"
+    done
+done
diff --git a/examples/cli/04_advanced/loggers.sh b/examples/cli/04_advanced/loggers.sh
new file mode 100644
index 0000000000..ddc62f13e2
--- /dev/null
+++ b/examples/cli/04_advanced/loggers.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Advanced Logging with Anomalib CLI
+# -------------------------------
+# This example shows how to use different logging options.
+
+# 1. Basic TensorBoard Logging
+echo "Training with TensorBoard logging..."
+anomalib train \
+    --model patchcore \
+    --trainer.logger tensorboard \
+    --trainer.default_root_dir logs/tensorboard
+
+# 2. Weights & Biases (WandB) Logging
+echo -e "\nTraining with WandB logging..."
+anomalib train \
+    --model patchcore \
+    --trainer.logger wandb \
+    --trainer.logger.project anomalib \
+    --trainer.logger.name patchcore_experiment \
+    --trainer.default_root_dir logs/wandb
+
+# 3. MLflow Logging
+echo -e "\nTraining with MLflow logging..."
+anomalib train \
+    --model patchcore \
+    --trainer.logger mlflow \
+    --trainer.logger.experiment_name anomalib \
+    --trainer.logger.tracking_uri logs/mlflow
+
+# 4. Advanced Logging Configuration
+echo -e "\nTraining with advanced logging settings..."
+anomalib train \
+    --model patchcore \
+    --trainer.logger tensorboard \
+    --trainer.logger.save_dir logs \
+    --trainer.enable_checkpointing true \
+    --trainer.log_every_n_steps 10 \
+    --trainer.default_root_dir results
+
+# 5. Logging with Model Export
+echo -e "\nTraining with logging and model export..."
+anomalib train \
+    --model patchcore \
+    --trainer.logger tensorboard \
+    --trainer.default_root_dir results \
+    --trainer.enable_checkpointing true \
+    --export.format onnx \
+    --export.export_root exported_models
diff --git a/examples/cli/05_pipelines/complete_pipeline.sh b/examples/cli/05_pipelines/complete_pipeline.sh
new file mode 100644
index 0000000000..aa4378a75e
--- /dev/null
+++ b/examples/cli/05_pipelines/complete_pipeline.sh
@@ -0,0 +1,60 @@
+#!/bin/bash
+
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Complete Anomalib Pipeline Example
+# ------------------------------
+# This script demonstrates a complete workflow from training to deployment.
+
+# 0. Setup
+# Create necessary directories
+mkdir -p results exported_models predictions
+
+# 1. Training Phase
+# ----------------
+echo "Starting Training Phase..."
+anomalib train \
+    --model patchcore \
+    --data.category bottle \
+    --trainer.max_epochs 1 \
+    --trainer.enable_checkpointing true \
+    --trainer.default_root_dir results
+
+# 2. Export Phase
+# --------------
+echo -e "\nStarting Export Phase..."
+anomalib export \
+    --model patchcore \
+    --weights results/*/checkpoints/*.ckpt \
+    --export_root exported_models \
+    --export_mode onnx \
+    --input_size 256 256
+
+# 3. Inference Phase
+# ----------------
+echo -e "\nStarting Inference Phase..."
+
+# 3.1 Using PyTorch Model
+echo "Running inference with PyTorch model..."
+anomalib predict \
+    --model patchcore \
+    --weights results/*/checkpoints/*.ckpt \
+    --input path/to/test/images \
+    --output predictions/torch_results
+
+# 3.2 Using Exported Model
+echo -e "\nRunning inference with exported ONNX model..."
+anomalib predict \
+    --model patchcore \
+    --weights exported_models/model.onnx \
+    --input path/to/test/images \
+    --output predictions/onnx_results
+
+# 4. Results Summary
+# ----------------
+echo -e "\nPipeline Complete!"
+echo "Results are saved in:"
+echo "- Training results: results/"
+echo "- Exported models: exported_models/"
+echo "- Predictions: predictions/"
diff --git a/configs/README.md b/examples/configs/README.md
similarity index 100%
rename from configs/README.md
rename to examples/configs/README.md
diff --git a/configs/data/avenue.yaml b/examples/configs/data/avenue.yaml
similarity index 100%
rename from configs/data/avenue.yaml
rename to examples/configs/data/avenue.yaml
diff --git a/configs/data/btech.yaml b/examples/configs/data/btech.yaml
similarity index 100%
rename from configs/data/btech.yaml
rename to examples/configs/data/btech.yaml
diff --git a/configs/data/datumaro.yaml b/examples/configs/data/datumaro.yaml
similarity index 100%
rename from configs/data/datumaro.yaml
rename to examples/configs/data/datumaro.yaml
diff --git a/configs/data/folder.yaml b/examples/configs/data/folder.yaml
similarity index 100%
rename from configs/data/folder.yaml
rename to examples/configs/data/folder.yaml
diff --git a/configs/data/kolektor.yaml b/examples/configs/data/kolektor.yaml
similarity index 100%
rename from configs/data/kolektor.yaml
rename to examples/configs/data/kolektor.yaml
diff --git a/configs/data/mvtec.yaml b/examples/configs/data/mvtec.yaml
similarity index 100%
rename from configs/data/mvtec.yaml
rename to examples/configs/data/mvtec.yaml
diff --git a/configs/data/mvtec_3d.yaml b/examples/configs/data/mvtec_3d.yaml
similarity index 100%
rename from configs/data/mvtec_3d.yaml
rename to examples/configs/data/mvtec_3d.yaml
diff --git a/configs/data/shanghaitech.yaml b/examples/configs/data/shanghaitech.yaml
similarity index 100%
rename from configs/data/shanghaitech.yaml
rename to examples/configs/data/shanghaitech.yaml
diff --git a/configs/data/ucsd_ped.yaml b/examples/configs/data/ucsd_ped.yaml
similarity index 100%
rename from configs/data/ucsd_ped.yaml
rename to examples/configs/data/ucsd_ped.yaml
diff --git a/configs/data/visa.yaml b/examples/configs/data/visa.yaml
similarity index 100%
rename from configs/data/visa.yaml
rename to examples/configs/data/visa.yaml
diff --git a/configs/model/ai_vad.yaml b/examples/configs/model/ai_vad.yaml
similarity index 100%
rename from configs/model/ai_vad.yaml
rename to examples/configs/model/ai_vad.yaml
diff --git a/configs/model/cfa.yaml b/examples/configs/model/cfa.yaml
similarity index 100%
rename from configs/model/cfa.yaml
rename to examples/configs/model/cfa.yaml
diff --git a/configs/model/cflow.yaml b/examples/configs/model/cflow.yaml
similarity index 100%
rename from configs/model/cflow.yaml
rename to examples/configs/model/cflow.yaml
diff --git a/configs/model/csflow.yaml b/examples/configs/model/csflow.yaml
similarity index 100%
rename from configs/model/csflow.yaml
rename to examples/configs/model/csflow.yaml
diff --git a/configs/model/dfkde.yaml b/examples/configs/model/dfkde.yaml
similarity index 100%
rename from configs/model/dfkde.yaml
rename to examples/configs/model/dfkde.yaml
diff --git a/configs/model/dfm.yaml b/examples/configs/model/dfm.yaml
similarity index 100%
rename from configs/model/dfm.yaml
rename to examples/configs/model/dfm.yaml
diff --git a/configs/model/draem.yaml b/examples/configs/model/draem.yaml
similarity index 100%
rename from configs/model/draem.yaml
rename to examples/configs/model/draem.yaml
diff --git a/configs/model/dsr.yaml b/examples/configs/model/dsr.yaml
similarity index 100%
rename from configs/model/dsr.yaml
rename to examples/configs/model/dsr.yaml
diff --git a/configs/model/efficient_ad.yaml b/examples/configs/model/efficient_ad.yaml
similarity index 100%
rename from configs/model/efficient_ad.yaml
rename to examples/configs/model/efficient_ad.yaml
diff --git a/configs/model/fastflow.yaml b/examples/configs/model/fastflow.yaml
similarity index 100%
rename from configs/model/fastflow.yaml
rename to examples/configs/model/fastflow.yaml
diff --git a/configs/model/fre.yaml b/examples/configs/model/fre.yaml
similarity index 100%
rename from configs/model/fre.yaml
rename to examples/configs/model/fre.yaml
diff --git a/configs/model/ganomaly.yaml b/examples/configs/model/ganomaly.yaml
similarity index 100%
rename from configs/model/ganomaly.yaml
rename to examples/configs/model/ganomaly.yaml
diff --git a/configs/model/padim.yaml b/examples/configs/model/padim.yaml
similarity index 100%
rename from configs/model/padim.yaml
rename to examples/configs/model/padim.yaml
diff --git a/configs/model/patchcore.yaml b/examples/configs/model/patchcore.yaml
similarity index 100%
rename from configs/model/patchcore.yaml
rename to examples/configs/model/patchcore.yaml
diff --git a/configs/model/reverse_distillation.yaml b/examples/configs/model/reverse_distillation.yaml
similarity index 100%
rename from configs/model/reverse_distillation.yaml
rename to examples/configs/model/reverse_distillation.yaml
diff --git a/configs/model/stfpm.yaml b/examples/configs/model/stfpm.yaml
similarity index 100%
rename from configs/model/stfpm.yaml
rename to examples/configs/model/stfpm.yaml
diff --git a/configs/model/uflow.yaml b/examples/configs/model/uflow.yaml
similarity index 100%
rename from configs/model/uflow.yaml
rename to examples/configs/model/uflow.yaml
diff --git a/notebooks/000_getting_started/001_getting_started.ipynb b/examples/notebooks/000_getting_started/001_getting_started.ipynb
similarity index 99%
rename from notebooks/000_getting_started/001_getting_started.ipynb
rename to examples/notebooks/000_getting_started/001_getting_started.ipynb
index 664aaa2116..60e967cdbe 100644
--- a/notebooks/000_getting_started/001_getting_started.ipynb
+++ b/examples/notebooks/000_getting_started/001_getting_started.ipynb
@@ -123,8 +123,8 @@
     "current_directory = Path.cwd()\n",
     "if current_directory.name == \"000_getting_started\":\n",
     "    # On the assumption that, the notebook is located in\n",
-    "    #   ~/anomalib/notebooks/000_getting_started/\n",
-    "    root_directory = current_directory.parent.parent\n",
+    "    #   ~/anomalib/examples/notebooks/000_getting_started/\n",
+    "    root_directory = current_directory.parent.parent.parent\n",
     "elif current_directory.name == \"anomalib\":\n",
     "    # This means that the notebook is run from the main anomalib directory.\n",
     "    root_directory = current_directory\n",
@@ -648,7 +648,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.14"
+   "version": "3.11.8"
   },
   "orig_nbformat": 4
  },
diff --git a/notebooks/000_getting_started/README.md b/examples/notebooks/000_getting_started/README.md
similarity index 88%
rename from notebooks/000_getting_started/README.md
rename to examples/notebooks/000_getting_started/README.md
index 535d131ca1..29f0a972f7 100644
--- a/notebooks/000_getting_started/README.md
+++ b/examples/notebooks/000_getting_started/README.md
@@ -1,6 +1,6 @@
 # Getting Started Tutorial
 
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/000_getting_started/001_getting_started.ipynb)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/000_getting_started/001_getting_started.ipynb)
 
 ## Installation Instructions
 
diff --git a/notebooks/100_datamodules/101_btech.ipynb b/examples/notebooks/100_datamodules/101_btech.ipynb
similarity index 99%
rename from notebooks/100_datamodules/101_btech.ipynb
rename to examples/notebooks/100_datamodules/101_btech.ipynb
index 19ac3277c2..efb64c9303 100644
--- a/notebooks/100_datamodules/101_btech.ipynb
+++ b/examples/notebooks/100_datamodules/101_btech.ipynb
@@ -48,7 +48,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"BTech\""
+    "dataset_root = Path.cwd().parent.parent.parent / \"datasets\" / \"BTech\""
    ]
   },
   {
diff --git a/notebooks/100_datamodules/102_mvtec.ipynb b/examples/notebooks/100_datamodules/102_mvtec.ipynb
similarity index 98%
rename from notebooks/100_datamodules/102_mvtec.ipynb
rename to examples/notebooks/100_datamodules/102_mvtec.ipynb
index 573c83f399..b64bbe069a 100644
--- a/notebooks/100_datamodules/102_mvtec.ipynb
+++ b/examples/notebooks/100_datamodules/102_mvtec.ipynb
@@ -56,7 +56,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
+    "dataset_root = Path.cwd().parent.parent.parent / \"datasets\" / \"MVTec\""
    ]
   },
   {
diff --git a/notebooks/100_datamodules/103_folder.ipynb b/examples/notebooks/100_datamodules/103_folder.ipynb
similarity index 99%
rename from notebooks/100_datamodules/103_folder.ipynb
rename to examples/notebooks/100_datamodules/103_folder.ipynb
index df9154f056..112f9c0751 100644
--- a/notebooks/100_datamodules/103_folder.ipynb
+++ b/examples/notebooks/100_datamodules/103_folder.ipynb
@@ -42,7 +42,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"hazelnut_toy\""
+    "dataset_root = Path.cwd().parent.parent.parent / \"datasets\" / \"hazelnut_toy\""
    ]
   },
   {
diff --git a/notebooks/100_datamodules/104_tiling.ipynb b/examples/notebooks/100_datamodules/104_tiling.ipynb
similarity index 99%
rename from notebooks/100_datamodules/104_tiling.ipynb
rename to examples/notebooks/100_datamodules/104_tiling.ipynb
index dd901c37e7..c8d39f0a1a 100644
--- a/notebooks/100_datamodules/104_tiling.ipynb
+++ b/examples/notebooks/100_datamodules/104_tiling.ipynb
@@ -44,7 +44,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\" / \"transistor\""
+    "dataset_root = Path.cwd().parent.parent.parent / \"datasets\" / \"MVTec\" / \"transistor\""
    ]
   },
   {
diff --git a/notebooks/100_datamodules/README.md b/examples/notebooks/100_datamodules/README.md
similarity index 88%
rename from notebooks/100_datamodules/README.md
rename to examples/notebooks/100_datamodules/README.md
index 0fd1a4049b..5e6d07f44c 100644
--- a/notebooks/100_datamodules/README.md
+++ b/examples/notebooks/100_datamodules/README.md
@@ -1,11 +1,11 @@
 # Anomalib DataModules Tutorial
 
-| Notebook | GitHub                         | Colab                                                                                                                                                                                                |
-| -------- | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| BTech    | [101_btech](101_btech.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/100_datamodules/101_btech.ipynb)  |
-| MVTec    | [102_mvtec](102_mvtec.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/100_datamodules/102_mvtec.ipynb)  |
-| Folder   | [103_folder](103_folder.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/100_datamodules/103_folder.ipynb) |
-| Tiling   | [104_tiling](104_tiling.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/100_datamodules/104_tiling.ipynb) |
+| Notebook | GitHub                         | Colab                                                                                                                                                                                                         |
+| -------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BTech    | [101_btech](101_btech.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/100_datamodules/101_btech.ipynb)  |
+| MVTec    | [102_mvtec](102_mvtec.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/100_datamodules/102_mvtec.ipynb)  |
+| Folder   | [103_folder](103_folder.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/100_datamodules/103_folder.ipynb) |
+| Tiling   | [104_tiling](104_tiling.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/100_datamodules/104_tiling.ipynb) |
 
 ## Notebook Contents
 
diff --git a/notebooks/200_models/201_fastflow.ipynb b/examples/notebooks/200_models/201_fastflow.ipynb
similarity index 97%
rename from notebooks/200_models/201_fastflow.ipynb
rename to examples/notebooks/200_models/201_fastflow.ipynb
index dbace61ec9..5fbeea8eaf 100644
--- a/notebooks/200_models/201_fastflow.ipynb
+++ b/examples/notebooks/200_models/201_fastflow.ipynb
@@ -44,7 +44,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
+    "dataset_root = Path.cwd().parent.parent.parent / \"datasets\" / \"MVTec\""
    ]
   },
   {
@@ -91,7 +91,7 @@
    "source": [
     "## Data Module\n",
     "\n",
-    "To train the model end-to-end, we do need to have a dataset. In our [previous notebooks](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules), we demonstrate how to initialize benchmark- and custom datasets. In this tutorial, we will use MVTec AD DataModule. We assume that `datasets` directory is created in the `anomalib` root directory and `MVTec` dataset is located in `datasets` directory.\n"
+    "To train the model end-to-end, we do need to have a dataset. In our [previous notebooks](https://github.com/openvinotoolkit/anomalib/tree/main/examples/notebooks/100_datamodules), we demonstrate how to initialize benchmark- and custom datasets. In this tutorial, we will use MVTec AD DataModule. We assume that `datasets` directory is created in the `anomalib` root directory and `MVTec` dataset is located in `datasets` directory.\n"
    ]
   },
   {
diff --git a/notebooks/200_models/README.md b/examples/notebooks/200_models/README.md
similarity index 90%
rename from notebooks/200_models/README.md
rename to examples/notebooks/200_models/README.md
index 23e60e40da..4973205e91 100644
--- a/notebooks/200_models/README.md
+++ b/examples/notebooks/200_models/README.md
@@ -1,6 +1,6 @@
 # Models Tutorial
 
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/200_models/201_fastflow.ipynb)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/200_models/201_fastflow.ipynb)
 
 ## Installation Instructions
 
diff --git a/notebooks/400_openvino/401_nncf.ipynb b/examples/notebooks/400_openvino/401_nncf.ipynb
similarity index 94%
rename from notebooks/400_openvino/401_nncf.ipynb
rename to examples/notebooks/400_openvino/401_nncf.ipynb
index 64af5ae4f5..532aef0513 100644
--- a/notebooks/400_openvino/401_nncf.ipynb
+++ b/examples/notebooks/400_openvino/401_nncf.ipynb
@@ -23,8 +23,8 @@
     "current_directory = Path.cwd()\n",
     "if current_directory.name == \"400_openvino\":\n",
     "    # On the assumption that, the notebook is located in\n",
-    "    #   ~/anomalib/notebooks/400_openvino/\n",
-    "    root_directory = current_directory.parent.parent\n",
+    "    #   ~/anomalib/examples/notebooks/400_openvino/\n",
+    "    root_directory = current_directory.parent.parent.parent\n",
     "elif current_directory.name == \"anomalib\":\n",
     "    # This means that the notebook is run from the main anomalib directory.\n",
     "    root_directory = current_directory\n",
@@ -47,7 +47,7 @@
     "This notebook demonstrates how NNCF is enabled in anomalib to optimize the model for inference. Before diving into the details, let's first train a model using the standard Torch training loop.\n",
     "\n",
     "## 1. Standard Training without NNCF\n",
-    "To train model without NNCF, we use the standard training loop. We use the same training loop as in the [Getting Started Notebook](https://github.com/openvinotoolkit/anomalib/blob/main/notebooks/000_getting_started/001_getting_started.ipynb)."
+    "To train model without NNCF, we use the standard training loop. We use the same training loop as in the [Getting Started Notebook](https://github.com/openvinotoolkit/anomalib/blob/main/examples/notebooks/000_getting_started/001_getting_started.ipynb)."
    ]
   },
   {
@@ -69,7 +69,7 @@
    "metadata": {},
    "source": [
     "### Configuration\n",
-    "Similar to the [Getting Started Notebook](https://github.com/openvinotoolkit/anomalib/blob/main/notebooks/000_getting_started/001_getting_started.ipynb), we will start with the [PADIM](https://github.com/openvinotoolkit/anomalib/tree/main/anomalib/models/padim) model. We follow the standard training loop, where we first import the config file, with which we import datamodule, model, callbacks and trainer, respectively."
+    "Similar to the [Getting Started Notebook](https://github.com/openvinotoolkit/anomalib/blob/main/examples/notebooks/000_getting_started/001_getting_started.ipynb), we will start with the [PADIM](https://github.com/openvinotoolkit/anomalib/tree/main/anomalib/models/padim) model. We follow the standard training loop, where we first import the config file, with which we import datamodule, model, callbacks and trainer, respectively."
    ]
   },
   {
diff --git a/notebooks/400_openvino/README.md b/examples/notebooks/400_openvino/README.md
similarity index 90%
rename from notebooks/400_openvino/README.md
rename to examples/notebooks/400_openvino/README.md
index 306e9e0bc7..0421ad7f2f 100644
--- a/notebooks/400_openvino/README.md
+++ b/examples/notebooks/400_openvino/README.md
@@ -1,6 +1,6 @@
 # OpenVINO Tutorials
 
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/400_openvino/401_nncf.ipynb)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/400_openvino/401_nncf.ipynb)
 
 ## Installation Instructions
 
diff --git a/examples/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb b/examples/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb
new file mode 100644
index 0000000000..3a52fa67ef
--- /dev/null
+++ b/examples/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a45835680c3d5bed9bd57d3ba2aaa50cecdef69d5bf37a498f44ad90b1079744
+size 739508
diff --git a/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb b/examples/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb
similarity index 100%
rename from notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb
rename to examples/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb
diff --git a/notebooks/500_use_cases/501_dobot/README.md b/examples/notebooks/500_use_cases/501_dobot/README.md
similarity index 100%
rename from notebooks/500_use_cases/501_dobot/README.md
rename to examples/notebooks/500_use_cases/501_dobot/README.md
diff --git a/notebooks/600_loggers/601_mlflow_logging.ipynb b/examples/notebooks/600_loggers/601_mlflow_logging.ipynb
similarity index 98%
rename from notebooks/600_loggers/601_mlflow_logging.ipynb
rename to examples/notebooks/600_loggers/601_mlflow_logging.ipynb
index c3cbe0fdb5..dbb274d8c5 100644
--- a/notebooks/600_loggers/601_mlflow_logging.ipynb
+++ b/examples/notebooks/600_loggers/601_mlflow_logging.ipynb
@@ -91,7 +91,7 @@
     "You can execute the following command in a seperate terminal to access the MLFlow UI.\n",
     "\n",
     "```bash\n",
-    "mlflow server --backend-store-uri ./notebooks/600_loggers/mlruns/\n",
+    "mlflow server --backend-store-uri ./examples/notebooks/600_loggers/mlruns/\n",
     "```\n",
     "\n",
     "Or you can return to the following cell, uncomment the cell and then execute it.\n",
@@ -135,7 +135,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
+    "dataset_root = Path.cwd().parent.parent.parent / \"datasets\" / \"MVTec\""
    ]
   },
   {
diff --git a/notebooks/600_loggers/README.md b/examples/notebooks/600_loggers/README.md
similarity index 100%
rename from notebooks/600_loggers/README.md
rename to examples/notebooks/600_loggers/README.md
diff --git a/notebooks/700_metrics/701a_aupimo.ipynb b/examples/notebooks/700_metrics/701a_aupimo.ipynb
similarity index 96%
rename from notebooks/700_metrics/701a_aupimo.ipynb
rename to examples/notebooks/700_metrics/701a_aupimo.ipynb
index 18c82caa2e..ddc1c92c4b 100644
--- a/notebooks/700_metrics/701a_aupimo.ipynb
+++ b/examples/notebooks/700_metrics/701a_aupimo.ipynb
@@ -80,7 +80,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
+    "dataset_root = Path.cwd().parent.parent.parent / \"datasets\" / \"MVTec\""
    ]
   },
   {
@@ -126,7 +126,7 @@
     "We will use dataset Leather from MVTec AD. \n",
     "\n",
     "> See the notebooks below for more details on datamodules. \n",
-    "> [github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules)"
+    "> [github.com/openvinotoolkit/anomalib/tree/main/examples/notebooks/100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/examples/notebooks/100_datamodules)"
    ]
   },
   {
@@ -175,7 +175,7 @@
     "We will use `PaDiM` (performance is not the best, but it is fast to train).\n",
     "\n",
     "> See the notebooks below for more details on models. \n",
-    "> [github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models)"
+    "> [github.com/openvinotoolkit/anomalib/tree/main/examples/notebooks/200_models](https://github.com/openvinotoolkit/anomalib/tree/main/examples/notebooks/200_models)"
    ]
   },
   {
diff --git a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb b/examples/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
similarity index 99%
rename from notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
rename to examples/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
index c8cc3c5b0c..1955c73cda 100644
--- a/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
+++ b/examples/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb
@@ -86,7 +86,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
+    "dataset_root = Path.cwd().parent.parent.parent / \"datasets\" / \"MVTec\""
    ]
   },
   {
@@ -148,8 +148,8 @@
     "We will use dataset Leather from MVTec AD with `PaDiM` (performance is not the best, but it is fast to train).\n",
     "\n",
     "> See the notebooks below for more details on:\n",
-    "> - datamodules: [100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules);\n",
-    "> - models: [200_models](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models)."
+    "> - datamodules: [100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/examples/notebooks/100_datamodules);\n",
+    "> - models: [200_models](https://github.com/openvinotoolkit/anomalib/tree/main/examples/notebooks/200_models)."
    ]
   },
   {
diff --git a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb b/examples/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
similarity index 99%
rename from notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
rename to examples/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
index 524c4b0941..aafa59c647 100644
--- a/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
+++ b/examples/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb
@@ -88,7 +88,7 @@
     "# NOTE: Provide the path to the dataset root directory.\n",
     "#   If the datasets is not downloaded, it will be downloaded\n",
     "#   to this directory.\n",
-    "dataset_root = Path.cwd().parent.parent / \"datasets\" / \"MVTec\""
+    "dataset_root = Path.cwd().parent.parent.parent / \"datasets\" / \"MVTec\""
    ]
   },
   {
@@ -142,8 +142,8 @@
     "We will use dataset Leather from MVTec AD with `PaDiM` (performance is not the best, but it is fast to train).\n",
     "\n",
     "> See the notebooks below for more details on:\n",
-    "> - datamodules: [100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/100_datamodules);\n",
-    "> - models: [200_models](https://github.com/openvinotoolkit/anomalib/tree/main/notebooks/200_models)."
+    "> - datamodules: [100_datamodules](https://github.com/openvinotoolkit/anomalib/tree/main/examples/notebooks/100_datamodules);\n",
+    "> - models: [200_models](https://github.com/openvinotoolkit/anomalib/tree/main/examples/notebooks/200_models)."
    ]
   },
   {
diff --git a/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb b/examples/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb
similarity index 100%
rename from notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb
rename to examples/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb
diff --git a/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb b/examples/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb
similarity index 100%
rename from notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb
rename to examples/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb
diff --git a/notebooks/700_metrics/pimo_viz.svg b/examples/notebooks/700_metrics/pimo_viz.svg
similarity index 100%
rename from notebooks/700_metrics/pimo_viz.svg
rename to examples/notebooks/700_metrics/pimo_viz.svg
diff --git a/notebooks/700_metrics/roc_pro_pimo.svg b/examples/notebooks/700_metrics/roc_pro_pimo.svg
similarity index 100%
rename from notebooks/700_metrics/roc_pro_pimo.svg
rename to examples/notebooks/700_metrics/roc_pro_pimo.svg
diff --git a/notebooks/README.md b/examples/notebooks/README.md
similarity index 67%
rename from notebooks/README.md
rename to examples/notebooks/README.md
index de33e5b7e9..8c9e998cfb 100644
--- a/notebooks/README.md
+++ b/examples/notebooks/README.md
@@ -21,43 +21,43 @@ To install Python, Git and other required tools, [OpenVINO Notebooks](https://gi
 
 ## 0. Training and Inference
 
-| Notebook        | GitHub                                                               | Colab                                                                                                                                                                                                             |
-| --------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Getting Started | [001_getting_started](000_getting_started/001_getting_started.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/000_getting_started/001_getting_started.ipynb) |
+| Notebook        | GitHub                                                               | Colab                                                                                                                                                                                                                      |
+| --------------- | -------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Getting Started | [001_getting_started](000_getting_started/001_getting_started.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/000_getting_started/001_getting_started.ipynb) |
 
 ## 1. Data Modules
 
-| Notebook | GitHub                                         | Colab                                                                                                                                                                                                |
-| -------- | ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| BTech    | [101_btech](100_datamodules/101_btech.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/100_datamodules/101_btech.ipynb)  |
-| MVTec    | [102_mvtec](100_datamodules/102_mvtec.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/100_datamodules/102_mvtec.ipynb)  |
-| Folder   | [103_folder](100_datamodules/103_folder.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/100_datamodules/103_folder.ipynb) |
+| Notebook | GitHub                                         | Colab                                                                                                                                                                                                         |
+| -------- | ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BTech    | [101_btech](100_datamodules/101_btech.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/100_datamodules/101_btech.ipynb)  |
+| MVTec    | [102_mvtec](100_datamodules/102_mvtec.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/100_datamodules/102_mvtec.ipynb)  |
+| Folder   | [103_folder](100_datamodules/103_folder.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/100_datamodules/103_folder.ipynb) |
 
 ## 2. Models
 
-| Notebook | GitHub                                        | Colab                                                                                                                                                                                             |
-| -------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Model    | [201_fastflow](200_models/201_fastflow.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/200_models/201_fastflow.ipynb) |
+| Notebook | GitHub                                        | Colab                                                                                                                                                                                                      |
+| -------- | --------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Model    | [201_fastflow](200_models/201_fastflow.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/200_models/201_fastflow.ipynb) |
 
 ## 3. OpenVINO Optimization
 
-| Notebook     | GitHub                                             | Colab |
-| ------------ | -------------------------------------------------- | ----- |
-| Quantization | [401_NNCF](/notebooks/400_openvino/401_nncf.ipynb) |       |
+| Notebook     | GitHub                                  | Colab |
+| ------------ | --------------------------------------- | ----- |
+| Quantization | [401_NNCF](400_openvino/401_nncf.ipynb) |       |
 
 ## 4. Use cases
 
-| Notebook               | GitHub                                                                                                        | Colab |
-| ---------------------- | ------------------------------------------------------------------------------------------------------------- | ----- |
-| Dobot Dataset Creation | [501a_training](/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb) |       |
-| Training               | [501b_training](/notebooks/500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb)                   |       |
+| Notebook               | GitHub                                                                                             | Colab |
+| ---------------------- | -------------------------------------------------------------------------------------------------- | ----- |
+| Dobot Dataset Creation | [501a_training](500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb) |       |
+| Training               | [501b_training](500_use_cases/501_dobot/501b_inference_with_a_robotic_arm.ipynb)                   |       |
 
 ## 7. Metrics
 
-| Notebook                                        | GitHub                                                                            | Colab                                                                                                                                                                                                          |
-| ----------------------------------------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| AUPIMO basics                                   | [701a_aupimo](/notebooks/700_metrics/701a_aupimo.ipynb)                           | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701a_aupimo.ipynb)              |
-| AUPIMO representative samples and visualization | [701b_aupimo_advanced_i](/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb)     | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb)   |
-| PIMO curve and integration bounds               | [701c_aupimo_advanced_ii](/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb)  |
-| (AU)PIMO of a random model                      | [701d_aupimo_advanced_iii](/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb) |
-| AUPIMO load/save, statistical comparison        | [701e_aupimo_advanced_iv](/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb)  |
+| Notebook                                        | GitHub                                                                 | Colab                                                                                                                                                                                                                   |
+| ----------------------------------------------- | ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AUPIMO basics                                   | [701a_aupimo](700_metrics/701a_aupimo.ipynb)                           | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/700_metrics/701a_aupimo.ipynb)              |
+| AUPIMO representative samples and visualization | [701b_aupimo_advanced_i](700_metrics/701b_aupimo_advanced_i.ipynb)     | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/700_metrics/701b_aupimo_advanced_i.ipynb)   |
+| PIMO curve and integration bounds               | [701c_aupimo_advanced_ii](700_metrics/701c_aupimo_advanced_ii.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/700_metrics/701c_aupimo_advanced_ii.ipynb)  |
+| (AU)PIMO of a random model                      | [701d_aupimo_advanced_iii](700_metrics/701d_aupimo_advanced_iii.ipynb) | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/700_metrics/701d_aupimo_advanced_iii.ipynb) |
+| AUPIMO load/save, statistical comparison        | [701e_aupimo_advanced_iv](700_metrics/701e_aupimo_advanced_iv.ipynb)   | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/openvinotoolkit/anomalib/blob/main/examples/notebooks/700_metrics/701e_aupimo_advanced_iv.ipynb)  |
diff --git a/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb b/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb
deleted file mode 100644
index ca7b97e67c..0000000000
--- a/notebooks/500_use_cases/501_dobot/501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb
+++ /dev/null
@@ -1,722 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Simulation of production line with defects\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In this notebook we will train a Anomalib model using the Anomalib API and our own dataset. This notebook is also part of the Dobot series notebooks.\n",
-    "\n",
-    "### Use case\n",
-    "\n",
-    "Using the [Dobot Magician](https://www.dobot.cc/dobot-magician/product-overview.html) we could simulate a production line system. Imagine we have a cubes factory and they need to know when a defect piece appear in the process. We know very well what is the aspecto of the normal cubes. Defects are coming no often and we need to put those defect cubes out of the production line.\n",
-    "\n",
-    "\"drawing\"\n",
-    "\n",
-    "| Class    | Yellow cube                                                                                                                                           | Red cube                                                                                                                                              | Green cube                                                                                                                                            | Inferencing using Anomalib                                                                                                                            |\n",
-    "| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |\n",
-    "| Normal   | \"drawing\" | \"drawing\" | \"drawing\" | \"drawing\" |\n",
-    "| Abnormal | \"drawing\" | \"drawing\" | \"drawing\" | \"drawing\" |\n",
-    "\n",
-    "Using Anomalib we are expecting to see this result.\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Installing Anomalib\n",
-    "\n",
-    "To install anomalib with the required dependencies, please follow the steps under `Install from source` [on GitHub](https://github.com/openvinotoolkit/anomalib?tab=readme-ov-file#-installation)."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Imports\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:35.855912923Z",
-     "start_time": "2024-01-12T16:55:30.140865729Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "\"\"\"501a_training_a_model_with_cubes_from_a_robotic_arm.ipynb.\"\"\"\n",
-    "\n",
-    "from pathlib import Path\n",
-    "\n",
-    "from anomalib.data.utils import read_image\n",
-    "from anomalib.deploy import OpenVINOInferencer"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Download dataset and Robot API/Driver\n",
-    "\n",
-    "We should prepare the folder to save the dataset and the Dobot API and drivers. To download the dataset and the Dobot API and drivers we will use anomalib's `download_and_extract` utility function.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:40.293464182Z",
-     "start_time": "2024-01-12T16:55:35.850186281Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "cubes.zip: 6.99MB [00:01, 5.86MB/s]                            \n",
-      "dobot_api.zip: 3.69MB [00:00, 5.43MB/s]                            \n"
-     ]
-    }
-   ],
-   "source": [
-    "from anomalib.data.utils import DownloadInfo, download_and_extract\n",
-    "\n",
-    "dataset_download_info = DownloadInfo(\n",
-    "    name=\"cubes.zip\",\n",
-    "    url=\"https://github.com/openvinotoolkit/anomalib/releases/download/dobot/cubes.zip\",\n",
-    "    hashsum=\"182ce0a48dabf452bf9a6aeb83132466088e30ed7a5c35d7d3a10a9fc11daac4\",\n",
-    ")\n",
-    "api_download_info = DownloadInfo(\n",
-    "    name=\"dobot_api.zip\",\n",
-    "    url=\"https://github.com/openvinotoolkit/anomalib/releases/download/dobot/dobot_api.zip\",\n",
-    "    hashsum=\"eb79bb9c6346be1628a0fe5e1196420dcc4e122ab1aa0d5abbc82f63236f0527\",\n",
-    ")\n",
-    "download_and_extract(root=Path.cwd(), info=dataset_download_info)\n",
-    "download_and_extract(root=Path.cwd(), info=api_download_info)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Dataset: Cubes\n",
-    "\n",
-    "Prepare your own dataset for normal and defect pieces.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:40.725983993Z",
-     "start_time": "2024-01-12T16:55:40.274675101Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dict_keys(['image_path', 'label', 'image'])\n"
-     ]
-    }
-   ],
-   "source": [
-    "from anomalib import TaskType\n",
-    "from anomalib.data import Folder\n",
-    "\n",
-    "datamodule = Folder(\n",
-    "    name=\"cubes\",\n",
-    "    root=Path.cwd() / \"cubes\",\n",
-    "    normal_dir=\"normal\",\n",
-    "    abnormal_dir=\"abnormal\",\n",
-    "    normal_split_ratio=0.2,\n",
-    "    image_size=(256, 256),\n",
-    "    train_batch_size=32,\n",
-    "    eval_batch_size=32,\n",
-    "    task=TaskType.CLASSIFICATION,\n",
-    ")\n",
-    "datamodule.setup()\n",
-    "\n",
-    "i, data = next(enumerate(datamodule.val_dataloader()))\n",
-    "print(data.keys())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:40.734861023Z",
-     "start_time": "2024-01-12T16:55:40.727834331Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "torch.Size([32, 3, 256, 256])\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Check image size\n",
-    "print(data[\"image\"].shape)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model\n",
-    "\n",
-    "`anomalib` supports a wide range of unsupervised anomaly detection models. The table in this [link](https://anomalib.readthedocs.io/en/latest/markdown/guides/reference/models/image/index.html) shows the list of models currently supported by `anomalib` library.\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Prepare the Model\n",
-    "\n",
-    "We will use Padim model for this use case, which could be imported from `anomalib.models`.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:41.184026691Z",
-     "start_time": "2024-01-12T16:55:40.731669374Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from anomalib.models import Padim\n",
-    "\n",
-    "model = Padim(\n",
-    "    backbone=\"resnet18\",\n",
-    "    layers=[\"layer1\", \"layer2\", \"layer3\"],\n",
-    ")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Training\n",
-    "\n",
-    "Now that we set up the datamodule and model, we could now train the model.\n",
-    "\n",
-    "The final component to train the model is `Engine` object, which handles train/test/predict/export pipeline. Let's create the engine object to train the model.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:45.425314142Z",
-     "start_time": "2024-01-12T16:55:41.180954949Z"
-    },
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/djameln/miniconda3/envs/anomalibv1source/lib/python3.10/site-packages/torchmetrics/utilities/prints.py:36: UserWarning: Metric `PrecisionRecallCurve` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n",
-      "  warnings.warn(*args, **kwargs)\n",
-      "GPU available: True (cuda), used: True\n",
-      "TPU available: False, using: 0 TPU cores\n",
-      "IPU available: False, using: 0 IPUs\n",
-      "HPU available: False, using: 0 HPUs\n",
-      "`Trainer(val_check_interval=1.0)` was configured so validation will run at the end of the training epoch..\n",
-      "You are using a CUDA device ('NVIDIA GeForce RTX 3090') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n",
-      "/home/djameln/miniconda3/envs/anomalibv1source/lib/python3.10/site-packages/torchmetrics/utilities/prints.py:36: UserWarning: Metric `ROC` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n",
-      "  warnings.warn(*args, **kwargs)\n",
-      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n",
-      "/home/djameln/miniconda3/envs/anomalibv1source/lib/python3.10/site-packages/lightning/pytorch/core/optimizer.py:180: `LightningModule.configure_optimizers` returned `None`, this fit will run with no optimizer\n",
-      "\n",
-      "  | Name                  | Type                     | Params\n",
-      "-------------------------------------------------------------------\n",
-      "0 | model                 | PadimModel               | 2.8 M \n",
-      "1 | _transform            | Compose                  | 0     \n",
-      "2 | normalization_metrics | MinMax                   | 0     \n",
-      "3 | image_threshold       | F1AdaptiveThreshold      | 0     \n",
-      "4 | pixel_threshold       | F1AdaptiveThreshold      | 0     \n",
-      "5 | image_metrics         | AnomalibMetricCollection | 0     \n",
-      "6 | pixel_metrics         | AnomalibMetricCollection | 0     \n",
-      "-------------------------------------------------------------------\n",
-      "2.8 M     Trainable params\n",
-      "0         Non-trainable params\n",
-      "2.8 M     Total params\n",
-      "11.131    Total estimated model params size (MB)\n"
-     ]
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "cd7082c9791c4745a28c995a0f50abc8",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Training: |          | 0/? [00:00┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃        Test metric        ┃       DataLoader 0        ┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│        image_AUROC        │            1.0            │\n",
-       "└───────────────────────────┴───────────────────────────┘\n",
-       "\n"
-      ],
-      "text/plain": [
-       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
-       "┃\u001b[1m \u001b[0m\u001b[1m       Test metric       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      DataLoader 0       \u001b[0m\u001b[1m \u001b[0m┃\n",
-       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
-       "│\u001b[36m \u001b[0m\u001b[36m       image_AUROC       \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m           1.0           \u001b[0m\u001b[35m \u001b[0m│\n",
-       "└───────────────────────────┴───────────────────────────┘\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Validation\n",
-    "test_results = engine.test(model=model, datamodule=datamodule)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:48.906878137Z",
-     "start_time": "2024-01-12T16:55:46.673514722Z"
-    },
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/djameln/miniconda3/envs/anomalibv1source/lib/python3.10/site-packages/torch/onnx/_internal/jit_utils.py:307: UserWarning: Constant folding - Only steps=1 can be constant folded for opset >= 10 onnx::Slice op. Constant folding not applied. (Triggered internally at ../torch/csrc/jit/passes/onnx/constant_fold.cpp:179.)\n",
-      "  _C._jit_pass_onnx_node_shape_type_inference(node, params_dict, opset_version)\n",
-      "/home/djameln/miniconda3/envs/anomalibv1source/lib/python3.10/site-packages/torch/onnx/utils.py:702: UserWarning: Constant folding - Only steps=1 can be constant folded for opset >= 10 onnx::Slice op. Constant folding not applied. (Triggered internally at ../torch/csrc/jit/passes/onnx/constant_fold.cpp:179.)\n",
-      "  _C._jit_pass_onnx_graph_shape_type_inference(\n",
-      "/home/djameln/miniconda3/envs/anomalibv1source/lib/python3.10/site-packages/torch/onnx/utils.py:1209: UserWarning: Constant folding - Only steps=1 can be constant folded for opset >= 10 onnx::Slice op. Constant folding not applied. (Triggered internally at ../torch/csrc/jit/passes/onnx/constant_fold.cpp:179.)\n",
-      "  _C._jit_pass_onnx_graph_shape_type_inference(\n"
-     ]
-    }
-   ],
-   "source": [
-    "from anomalib.deploy import ExportType\n",
-    "\n",
-    "# Exporting model to OpenVINO\n",
-    "openvino_model_path = engine.export(\n",
-    "    model=model,\n",
-    "    export_type=ExportType.OPENVINO,\n",
-    "    export_root=str(Path.cwd()),\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For optimization and quantization process, we are using a seamless integration with [NNCF Library](https://github.com/openvinotoolkit/nncf) in the backend of Anomalib. Select one of the following options for optimization or quantization. Replace the openvino_model_path line above in order to export the optimized/quantized model:\n",
-    "\n",
-    "```\n",
-    "# Exporting optimized/quantized models\n",
-    "\n",
-    "# Post Training Quantization\n",
-    "openvino_model_path = engine.export(\n",
-    "    model, \n",
-    "    ExportType.OPENVINO, \n",
-    "    str(Path.cwd()) + \"_optimized\", \n",
-    "    compression_type=CompressionType.INT8_PTQ, \n",
-    "    datamodule=datamodule\n",
-    "    )\n",
-    "\n",
-    "# Accuracy-Control Quantization\n",
-    "openvino_model_path=engine.export(\n",
-    "    model, \n",
-    "    ExportType.OPENVINO, \n",
-    "    str(Path.cwd()) + \"_optimized\", \n",
-    "    compression_type=CompressionType.INT8_ACQ, \n",
-    "    datamodule=datamodule, \n",
-    "    metric=\"F1Score\"\n",
-    "    )\n",
-    "\n",
-    "# Weight Compression\n",
-    "openvino_model_path=engine.export(\n",
-    "    model, \n",
-    "    ExportType.OPENVINO, \n",
-    "    str(Path.cwd()) + \"_WEIGHTS\", \n",
-    "    compression_type=CompressionType.FP16, \n",
-    "    datamodule=datamodule\n",
-    "    )\n",
-    "```"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## OpenVINO Inference\n",
-    "\n",
-    "Now that we trained and tested a model, we could check a single inference result using OpenVINO inferencer object. This will demonstrate how a trained model could be used for inference.\n"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Load a Test Image\n",
-    "\n",
-    "Let's read an image from the test set and perform inference using OpenVINO inferencer.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:49.107125004Z",
-     "start_time": "2024-01-12T16:55:48.908620452Z"
-    },
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from matplotlib import pyplot as plt\n",
-    "\n",
-    "image_path = \"./cubes/abnormal/input_20230210134059.jpg\"\n",
-    "image = read_image(path=\"./cubes/abnormal/input_20230210134059.jpg\")\n",
-    "plt.imshow(image)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Load the OpenVINO Model\n",
-    "\n",
-    "By default, the output files are saved into `results` directory. Let's check where the OpenVINO model is stored.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:49.109896590Z",
-     "start_time": "2024-01-12T16:55:49.107381700Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "True True\n"
-     ]
-    }
-   ],
-   "source": [
-    "metadata_path = openvino_model_path.parent / \"metadata.json\"\n",
-    "print(openvino_model_path.exists(), metadata_path.exists())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:49.447048687Z",
-     "start_time": "2024-01-12T16:55:49.110849785Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "inferencer = OpenVINOInferencer(\n",
-    "    path=openvino_model_path,  # Path to the OpenVINO IR model.\n",
-    "    metadata=metadata_path,  # Path to the metadata file.\n",
-    "    device=\"CPU\",  # We would like to run it on an Intel CPU.\n",
-    ")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Perform Inference\n",
-    "\n",
-    "Predicting an image using OpenVINO inferencer is as simple as calling `predict` method.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:49.489524314Z",
-     "start_time": "2024-01-12T16:55:49.447882511Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(480, 640, 3)\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(image.shape)\n",
-    "predictions = inferencer.predict(image=image)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "where `predictions` contain any relevant information regarding the task type. For example, predictions for a segmentation model could contain image, anomaly maps, predicted scores, labels or masks.\n",
-    "\n",
-    "### Visualizing Inference Results\n",
-    "\n",
-    "`anomalib` provides a number of tools to visualize the inference results. Let's visualize the inference results using the `Visualizer` method.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:49.577270470Z",
-     "start_time": "2024-01-12T16:55:49.489434931Z"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from PIL import Image\n",
-    "\n",
-    "from anomalib.utils.visualization.image import ImageVisualizer, VisualizationMode\n",
-    "\n",
-    "visualizer = ImageVisualizer(mode=VisualizationMode.FULL, task=TaskType.CLASSIFICATION)\n",
-    "output_image = visualizer.visualize_image(predictions)\n",
-    "Image.fromarray(output_image)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Since `predictions` contain a number of information, we could specify which information we want to visualize. For example, if we want to visualize the predicted mask and the segmentation results, we could specify the task type as `TaskType.SEGMENTATION`, which would produce the following visualization.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-01-12T16:55:49.691819697Z",
-     "start_time": "2024-01-12T16:55:49.583066408Z"
-    }
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "visualizer = ImageVisualizer(mode=VisualizationMode.FULL, task=TaskType.SEGMENTATION)\n",
-    "output_image = visualizer.visualize_image(predictions)\n",
-    "Image.fromarray(output_image)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "anomalib",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.13"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "ae223df28f60859a2f400fae8b3a1034248e0a469f5599fd9a89c32908ed7a84"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/pyproject.toml b/pyproject.toml
index 5d72ebd91b..5d28759b15 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -264,7 +264,7 @@ notice-rgx = """
 """
 
 [tool.ruff.lint.per-file-ignores]
-"notebooks/**/*" = ["CPY001"]
+"examples/notebooks/**/*" = ["CPY001"]
 
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
 # MYPY CONFIGURATION.                                                         #
diff --git a/src/anomalib/data/datamodules/base/image.py b/src/anomalib/data/datamodules/base/image.py
index a2e163a3bd..330319f625 100644
--- a/src/anomalib/data/datamodules/base/image.py
+++ b/src/anomalib/data/datamodules/base/image.py
@@ -10,7 +10,7 @@
     Create a datamodule from a config file::
 
         >>> from anomalib.data import AnomalibDataModule
-        >>> data_config = "configs/data/mvtec.yaml"
+        >>> data_config = "examples/configs/data/mvtec.yaml"
         >>> datamodule = AnomalibDataModule.from_config(config_path=data_config)
 
     Override config with additional arguments::
@@ -422,7 +422,7 @@ def from_config(
         Example:
             Load from config file::
 
-                >>> config_path = "configs/data/mvtec.yaml"
+                >>> config_path = "examples/configs/data/mvtec.yaml"
                 >>> datamodule = AnomalibDataModule.from_config(config_path)
 
             Override config values::
diff --git a/src/anomalib/data/datamodules/base/video.py b/src/anomalib/data/datamodules/base/video.py
index 3e86d4f09b..5e37a0a5c8 100644
--- a/src/anomalib/data/datamodules/base/video.py
+++ b/src/anomalib/data/datamodules/base/video.py
@@ -10,7 +10,7 @@
     Create a video datamodule from a config file::
 
         >>> from anomalib.data import AnomalibVideoDataModule
-        >>> data_config = "configs/data/ucsd_ped.yaml"
+        >>> data_config = "examples/configs/data/ucsd_ped.yaml"
         >>> datamodule = AnomalibVideoDataModule.from_config(config_path=data_config)
 """
 
diff --git a/src/anomalib/models/components/base/anomalib_module.py b/src/anomalib/models/components/base/anomalib_module.py
index a0251c4e64..58e323e9a7 100644
--- a/src/anomalib/models/components/base/anomalib_module.py
+++ b/src/anomalib/models/components/base/anomalib_module.py
@@ -435,13 +435,13 @@ def from_config(
             ValueError: If instantiated model is not AnomalibModule
 
         Example:
-            >>> model = AnomalibModule.from_config("configs/model/patchcore.yaml")
+            >>> model = AnomalibModule.from_config("examples/configs/model/patchcore.yaml")
             >>> isinstance(model, AnomalibModule)
             True
 
             Override config values:
             >>> model = AnomalibModule.from_config(
-            ...     "configs/model/patchcore.yaml",
+            ...     "examples/configs/model/patchcore.yaml",
             ...     model__backbone="resnet18"
             ... )
         """
diff --git a/src/anomalib/models/image/__init__.py b/src/anomalib/models/image/__init__.py
index 388c6002a7..9290f3a0fb 100644
--- a/src/anomalib/models/image/__init__.py
+++ b/src/anomalib/models/image/__init__.py
@@ -5,12 +5,19 @@
 
 Example:
     >>> from anomalib.models.image import Padim, Patchcore
-    >>> # Initialize a model
+    >>> from anomalib.data import MVTec  # doctest: +SKIP
+    >>> from anomalib.engine import Engine  # doctest: +SKIP
+
+    >>> # Initialize model and data
+    >>> datamodule = MVTec()  # doctest: +SKIP
     >>> model = Padim()  # doctest: +SKIP
-    >>> # Train on normal images
-    >>> model.fit(["normal1.jpg", "normal2.jpg"])  # doctest: +SKIP
+    >>> # Train using the Engine
+
+    >>> engine = Engine()  # doctest: +SKIP
+    >>> engine.fit(model=model, datamodule=datamodule)  # doctest: +SKIP
+
     >>> # Get predictions
-    >>> predictions = model.predict("test.jpg")  # doctest: +SKIP
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)  # doctest: +SKIP
 
 Available Models:
     - :class:`Cfa`: Contrastive Feature Aggregation
diff --git a/src/anomalib/models/image/cfa/__init__.py b/src/anomalib/models/image/cfa/__init__.py
index 962612f974..9a61ce668a 100644
--- a/src/anomalib/models/image/cfa/__init__.py
+++ b/src/anomalib/models/image/cfa/__init__.py
@@ -11,13 +11,20 @@
 Paper: https://arxiv.org/abs/2206.04325
 
 Example:
+    >>> from anomalib.data import MVTec
     >>> from anomalib.models.image import Cfa
-    >>> # Initialize the model
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and data
+    >>> datamodule = MVTec()
     >>> model = Cfa()
-    >>> # Train on normal samples
-    >>> model.fit(normal_samples)
-    >>> # Get anomaly predictions
-    >>> predictions = model.predict(test_samples)
+
+    >>> # Train using the Engine
+    >>> engine = Engine()
+    >>> engine.fit(model=model, datamodule=datamodule)
+
+    >>> # Get predictions
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)
 """
 
 # Copyright (C) 2022-2024 Intel Corporation
diff --git a/src/anomalib/models/image/padim/lightning_model.py b/src/anomalib/models/image/padim/lightning_model.py
index 242cd309e7..fb50ccd38a 100644
--- a/src/anomalib/models/image/padim/lightning_model.py
+++ b/src/anomalib/models/image/padim/lightning_model.py
@@ -12,14 +12,24 @@
 Paper: https://arxiv.org/abs/2011.08785
 
 Example:
+    >>> from anomalib.data import MVTec
     >>> from anomalib.models.image.padim import Padim
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and data
+    >>> datamodule = MVTec()
     >>> model = Padim(
     ...     backbone="resnet18",
     ...     layers=["layer1", "layer2", "layer3"],
     ...     pre_trained=True
     ... )
-    >>> model.fit()
-    >>> prediction = model(image)
+
+    >>> # Train using the Engine
+    >>> engine = Engine()
+    >>> engine.fit(model=model, datamodule=datamodule)
+
+    >>> # Get predictions
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)
 
 See Also:
     - :class:`anomalib.models.image.padim.torch_model.PadimModel`:
@@ -74,14 +84,21 @@ class Padim(MemoryBankMixin, AnomalibModule):
             result images. Defaults to ``True``.
 
     Example:
-        >>> from anomalib.models.image.padim import Padim
+        >>> from anomalib.models import Padim
+        >>> from anomalib.data import MVTec
+        >>> from anomalib.engine import Engine
+
+        >>> # Initialize model and data
+        >>> datamodule = MVTec()
         >>> model = Padim(
         ...     backbone="resnet18",
         ...     layers=["layer1", "layer2", "layer3"],
         ...     pre_trained=True
         ... )
-        >>> model.fit()
-        >>> prediction = model(image)
+
+        >>> engine = Engine()
+        >>> engine.train(model=model, datamodule=datamodule)
+        >>> predictions = engine.predict(model=model, datamodule=datamodule)
 
     Note:
         The model does not require training in the traditional sense. It fits
diff --git a/src/anomalib/models/image/patchcore/__init__.py b/src/anomalib/models/image/patchcore/__init__.py
index 1d716b53f0..b0462cd0e1 100644
--- a/src/anomalib/models/image/patchcore/__init__.py
+++ b/src/anomalib/models/image/patchcore/__init__.py
@@ -10,14 +10,24 @@
 high performance while maintaining interpretability through localization maps.
 
 Example:
-    >>> from anomalib.models.image.patchcore import Patchcore
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Patchcore
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and data
+    >>> datamodule = MVTec()
     >>> model = Patchcore(
     ...     backbone="wide_resnet50_2",
     ...     layers=["layer2", "layer3"],
     ...     coreset_sampling_ratio=0.1
     ... )
-    >>> model.fit()
-    >>> prediction = model(image)
+
+    >>> # Train using the Engine
+    >>> engine = Engine()
+    >>> engine.fit(model=model, datamodule=datamodule)
+
+    >>> # Get predictions
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)
 
 Paper: https://arxiv.org/abs/2106.08265
 """
diff --git a/src/anomalib/models/image/patchcore/lightning_model.py b/src/anomalib/models/image/patchcore/lightning_model.py
index bd8f9da4f7..b2f950ab9e 100644
--- a/src/anomalib/models/image/patchcore/lightning_model.py
+++ b/src/anomalib/models/image/patchcore/lightning_model.py
@@ -10,14 +10,24 @@
 performance while maintaining interpretability through localization maps.
 
 Example:
-    >>> from anomalib.models.image.patchcore import Patchcore
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.models import Patchcore
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and data
+    >>> datamodule = MVTec()
     >>> model = Patchcore(
     ...     backbone="wide_resnet50_2",
     ...     layers=["layer2", "layer3"],
     ...     coreset_sampling_ratio=0.1
     ... )
-    >>> model.fit()
-    >>> prediction = model(image)
+
+    >>> # Train using the Engine
+    >>> engine = Engine()
+    >>> engine.fit(model=model, datamodule=datamodule)
+
+    >>> # Get predictions
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)
 
 Paper: https://arxiv.org/abs/2106.08265
 
@@ -86,14 +96,24 @@ class Patchcore(MemoryBankMixin, AnomalibModule):
             Defaults to ``True``.
 
     Example:
-        >>> from anomalib.models.image.patchcore import Patchcore
+        >>> from anomalib.data import MVTec
+        >>> from anomalib.models import Patchcore
+        >>> from anomalib.engine import Engine
+
+        >>> # Initialize model and data
+        >>> datamodule = MVTec()
         >>> model = Patchcore(
         ...     backbone="wide_resnet50_2",
         ...     layers=["layer2", "layer3"],
         ...     coreset_sampling_ratio=0.1
         ... )
-        >>> model.fit()
-        >>> predictions = model(image)
+
+        >>> # Train using the Engine
+        >>> engine = Engine()
+        >>> engine.fit(model=model, datamodule=datamodule)
+
+        >>> # Get predictions
+        >>> predictions = engine.predict(model=model, datamodule=datamodule)
 
     Notes:
         The model requires no optimization/backpropagation as it uses a pretrained
diff --git a/src/anomalib/models/image/reverse_distillation/__init__.py b/src/anomalib/models/image/reverse_distillation/__init__.py
index 616c06c4f8..b17976a977 100644
--- a/src/anomalib/models/image/reverse_distillation/__init__.py
+++ b/src/anomalib/models/image/reverse_distillation/__init__.py
@@ -11,10 +11,20 @@
 - A scoring mechanism based on reconstruction error
 
 Example:
-    >>> from anomalib.models.image import ReverseDistillation
+    >>> from anomalib.models import ReverseDistillation
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and data
+    >>> datamodule = MVTec()
     >>> model = ReverseDistillation()
-    >>> model.fit(train_dataloader)
-    >>> predictions = model.predict(test_dataloader)
+
+    >>> # Train using the Engine
+    >>> engine = Engine()
+    >>> engine.fit(model=model, datamodule=datamodule)
+
+    >>> # Get predictions
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)
 
 See Also:
     - :class:`anomalib.models.image.reverse_distillation.lightning_model.ReverseDistillation`:
diff --git a/src/anomalib/models/image/reverse_distillation/lightning_model.py b/src/anomalib/models/image/reverse_distillation/lightning_model.py
index 9436549568..4153601362 100644
--- a/src/anomalib/models/image/reverse_distillation/lightning_model.py
+++ b/src/anomalib/models/image/reverse_distillation/lightning_model.py
@@ -10,13 +10,23 @@
 - A scoring mechanism based on reconstruction error
 
 Example:
-    >>> from anomalib.models.image import ReverseDistillation
+    >>> from anomalib.models import ReverseDistillation
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and data
+    >>> datamodule = MVTec()
     >>> model = ReverseDistillation(
     ...     backbone="wide_resnet50_2",
     ...     layers=["layer1", "layer2", "layer3"]
     ... )
-    >>> model.fit(train_dataloader)
-    >>> predictions = model.predict(test_dataloader)
+
+    >>> # Train using the Engine
+    >>> engine = Engine()
+    >>> engine.fit(model=model, datamodule=datamodule)
+
+    >>> # Get predictions
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)
 
 See Also:
     - :class:`ReverseDistillation`: Lightning implementation of the model
diff --git a/src/anomalib/models/image/vlm_ad/__init__.py b/src/anomalib/models/image/vlm_ad/__init__.py
index f13d6c46d9..271ab257a4 100644
--- a/src/anomalib/models/image/vlm_ad/__init__.py
+++ b/src/anomalib/models/image/vlm_ad/__init__.py
@@ -6,12 +6,19 @@
 
 Example:
     >>> from anomalib.models.image import VlmAd
-    >>> model = VlmAd(  # doctest: +SKIP
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and data
+    >>> datamodule = MVTec()
+    >>> model = VlmAd(
     ...     backend="chatgpt",
     ...     model_name="gpt-4-vision-preview"
     ... )
-    >>> model.fit(["normal1.jpg", "normal2.jpg"])  # doctest: +SKIP
-    >>> prediction = model.predict("test.jpg")  # doctest: +SKIP
+
+    >>> # Predict using the Engine
+    >>> engine = Engine()
+    >>> engine.predict(model=model, datamodule=datamodule)  # doctest: +SKIP
 
 See Also:
     - :class:`VlmAd`: Main model class for VLM-based anomaly detection
diff --git a/src/anomalib/models/image/vlm_ad/lightning_model.py b/src/anomalib/models/image/vlm_ad/lightning_model.py
index 92a52a7c75..57e3a76be4 100644
--- a/src/anomalib/models/image/vlm_ad/lightning_model.py
+++ b/src/anomalib/models/image/vlm_ad/lightning_model.py
@@ -11,13 +11,18 @@
 
 Example:
     >>> from anomalib.models.image import VlmAd
+    >>> from anomalib.data import MVTec
+    >>> from anomalib.engine import Engine
+
     >>> model = VlmAd(  # doctest: +SKIP
     ...     model="gpt-4-vision-preview",
     ...     api_key="YOUR_API_KEY",
     ...     k_shot=3
     ... )
-    >>> model.fit(["normal1.jpg", "normal2.jpg"])  # doctest: +SKIP
-    >>> prediction = model.predict("test.jpg")  # doctest: +SKIP
+    >>> datamodule = MVTec()
+
+    >>> engine = Engine()
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)  # doctest: +SKIP
 
 See Also:
     - :class:`VlmAd`: Main model class for VLM-based anomaly detection
diff --git a/src/anomalib/models/image/winclip/__init__.py b/src/anomalib/models/image/winclip/__init__.py
index 86f2b72691..a7e0799b51 100644
--- a/src/anomalib/models/image/winclip/__init__.py
+++ b/src/anomalib/models/image/winclip/__init__.py
@@ -4,10 +4,20 @@
 CLIP embeddings and a sliding window approach to detect anomalies in images.
 
 Example:
-    >>> from anomalib.models.image import WinClip
-    >>> model = WinClip()  # doctest: +SKIP
-    >>> model.fit(["normal1.jpg", "normal2.jpg"])  # doctest: +SKIP
-    >>> prediction = model.predict("test.jpg")  # doctest: +SKIP
+    >>> from anomalib.models import WinClip
+    >>> from anomalib.data import Visa
+    >>> from anomalib.engine import Engine
+
+    >>> # Initialize model and data
+    >>> datamodule = Visa()
+    >>> model = WinClip()
+
+    >>> # Validate using the Engine
+    >>> engine = Engine()
+    >>> engine.validate(model=model, datamodule=datamodule)
+
+    >>> # Get predictions
+    >>> predictions = engine.predict(model=model, datamodule=datamodule)
 
 See Also:
     - :class:`WinClip`: Main model class for WinCLIP-based anomaly detection
diff --git a/src/anomalib/visualization/image/functional.py b/src/anomalib/visualization/image/functional.py
index 558e55613e..396d897959 100644
--- a/src/anomalib/visualization/image/functional.py
+++ b/src/anomalib/visualization/image/functional.py
@@ -37,7 +37,7 @@
 
 import torch
 import torch.nn.functional as F  # noqa: N812
-from PIL import Image, ImageDraw, ImageEnhance, ImageFont
+from PIL import Image, ImageDraw, ImageEnhance, ImageFilter, ImageFont
 from torchvision.transforms.functional import to_pil_image
 
 logger = logging.getLogger(__name__)
@@ -554,6 +554,46 @@ def visualize_mask(
         - ``"contour"`` mode uses edge detection to find mask boundaries
         - ``"fill"`` mode creates a semi-transparent overlay using the specified color
     """
+    # Convert torch.Tensor to PIL Image if necessary
+    if isinstance(mask, torch.Tensor):
+        if mask.dtype == torch.bool:
+            mask = mask.to(torch.uint8) * 255
+        mask = to_pil_image(mask)
+
+    if not isinstance(mask, Image.Image):
+        msg = "Mask must be a PIL Image or PyTorch tensor"
+        raise TypeError(msg)
+
+    # Ensure mask is in binary mode
+    mask = mask.convert("L")
+    if mode in {"binary", "L", "1"}:
+        return mask
+
+    # Create a background image
+    background = Image.new("RGBA", mask.size, background_color)
+
+    match mode:
+        case "contour":
+            # Find edges of the mask
+            edges = mask.filter(ImageFilter.FIND_EDGES)
+
+            # Create a colored version of the edges
+            colored_edges = Image.new("RGBA", mask.size, (*color, 255))
+            colored_edges.putalpha(edges)
+
+            # Composite the colored edges onto the background
+            return Image.alpha_composite(background, colored_edges)
+
+        case "fill":
+            # Create a solid color image for the overlay
+            overlay = Image.new("RGBA", mask.size, (*color, int(255 * alpha)))
+
+            # Use the mask to blend the overlay with the background
+            return Image.composite(overlay, background, mask)
+
+        case _:
+            msg = f"Invalid mode: {mode}. Allowed modes are 'contour', 'binary', or 'fill'."
+            raise ValueError(msg)
 
 
 def visualize_gt_mask(
diff --git a/src/anomalib/visualization/image/item_visualizer.py b/src/anomalib/visualization/image/item_visualizer.py
index 305230bb5a..a0b76e9a92 100644
--- a/src/anomalib/visualization/image/item_visualizer.py
+++ b/src/anomalib/visualization/image/item_visualizer.py
@@ -1,4 +1,31 @@
-"""ImageItem visualizer."""
+"""ImageItem visualization module.
+
+This module provides utilities for visualizing ``ImageItem`` objects, which contain
+images and their associated anomaly detection results. The key components include:
+
+    - Functions for visualizing individual fields (image, masks, anomaly maps)
+    - Support for overlaying multiple fields
+    - Configurable visualization parameters
+    - Text annotation capabilities
+
+Example:
+    >>> from anomalib.data import ImageItem
+    >>> from anomalib.visualization.image.item_visualizer import visualize_image_item
+    >>> # Create an ImageItem
+    >>> item = ImageItem(image=img, pred_mask=mask)
+    >>> # Generate visualization
+    >>> vis_result = visualize_image_item(item)
+
+The module ensures consistent visualization by:
+    - Providing standardized field configurations
+    - Supporting flexible overlay options
+    - Handling text annotations
+    - Maintaining consistent output formats
+
+Note:
+    All visualization functions preserve the input image format and dimensions
+    unless explicitly specified in the configuration.
+"""
 
 # Copyright (C) 2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
@@ -49,39 +76,53 @@ def visualize_image_item(
     overlay_fields_config: dict[str, dict[str, Any]] = DEFAULT_OVERLAY_FIELDS_CONFIG,
     text_config: dict[str, Any] = DEFAULT_TEXT_CONFIG,
 ) -> Image.Image | None:
-    """Visualizes specified fields of an ImageItem with configurable options.
+    """Visualize specified fields of an ``ImageItem`` with configurable options.
 
-    This function creates visualizations for individual fields and overlays of an ImageItem.
-    It supports customization of field visualization, overlay composition, and text annotations.
+    This function creates visualizations for individual fields and overlays of an
+    ``ImageItem``. It supports customization of field visualization, overlay
+    composition, and text annotations.
 
     Args:
-        item: An ImageItem instance containing the data to visualize.
-        fields: A list of field names to visualize individually. If None, no individual
-            fields are visualized.
-        overlay_fields: A list of tuples, each containing a base field and a list of
-            fields to overlay on it. If None, no overlays are created.
-        field_size: A tuple (width, height) specifying the size of each visualized field.
-        fields_config: A dictionary of field-specific visualization configurations.
+        item: An ``ImageItem`` instance containing the data to visualize.
+        fields: A list of field names to visualize individually. If ``None``, no
+            individual fields are visualized.
+        overlay_fields: A list of tuples, each containing a base field and a list
+            of fields to overlay on it. If ``None``, no overlays are created.
+        field_size: A tuple ``(width, height)`` specifying the size of each
+            visualized field.
+        fields_config: A dictionary of field-specific visualization
+            configurations.
         overlay_fields_config: A dictionary of overlay-specific configurations.
         text_config: A dictionary of text annotation configurations.
 
     Returns:
-        A PIL Image containing the visualized fields and overlays, or None if no
-        valid fields to visualize.
+        A PIL ``Image`` containing the visualized fields and overlays, or
+        ``None`` if no valid fields to visualize.
 
     Raises:
-        AttributeError: If a specified field doesn't exist in the ImageItem.
+        AttributeError: If a specified field doesn't exist in the ``ImageItem``.
         ValueError: If an invalid configuration is provided.
 
     Examples:
         Basic usage with default settings:
-        >>> item = ImageItem(image_path="image.jpg", gt_mask=mask, pred_mask=pred, anomaly_map=amap)
-        >>> result = visualize_image_item(item, fields=["image", "gt_mask", "pred_mask", "anomaly_map"])
+
+        >>> item = ImageItem(
+        ...     image_path="image.jpg",
+        ...     gt_mask=mask,
+        ...     pred_mask=pred,
+        ...     anomaly_map=amap
+        ... )
+        >>> result = visualize_image_item(
+        ...     item,
+        ...     fields=["image", "gt_mask", "pred_mask", "anomaly_map"]
+        ... )
 
         Visualizing specific fields:
+
         >>> result = visualize_image_item(item, fields=["image", "anomaly_map"])
 
         Creating an overlay:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["image"],
@@ -89,6 +130,7 @@ def visualize_image_item(
         ... )
 
         Multiple overlays:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     overlay_fields=[
@@ -99,6 +141,7 @@ def visualize_image_item(
         ... )
 
         Customizing field visualization:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["image", "anomaly_map"],
@@ -108,6 +151,7 @@ def visualize_image_item(
         ... )
 
         Adjusting overlay transparency:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     overlay_fields=[("image", ["gt_mask", "pred_mask"])],
@@ -118,6 +162,7 @@ def visualize_image_item(
         ... )
 
         Customizing text annotations:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["image", "gt_mask"],
@@ -130,6 +175,7 @@ def visualize_image_item(
         ... )
 
         Disabling text annotations:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["image", "gt_mask"],
@@ -137,6 +183,7 @@ def visualize_image_item(
         ... )
 
         Combining multiple customizations:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["image", "gt_mask", "pred_mask"],
@@ -157,7 +204,12 @@ def visualize_image_item(
         ... )
 
         Handling missing fields gracefully:
-        >>> item_no_pred = ImageItem(image_path="image.jpg", gt_mask=mask, anomaly_map=amap)
+
+        >>> item_no_pred = ImageItem(
+        ...     image_path="image.jpg",
+        ...     gt_mask=mask,
+        ...     anomaly_map=amap
+        ... )
         >>> result = visualize_image_item(
         ...     item_no_pred,
         ...     fields=["image", "gt_mask", "pred_mask", "anomaly_map"]
@@ -165,6 +217,7 @@ def visualize_image_item(
         # This will visualize all available fields, skipping 'pred_mask'
 
         Custom ordering of fields and overlays:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["anomaly_map", "image", "gt_mask"],
@@ -178,6 +231,7 @@ def visualize_image_item(
         Different masking strategies:
 
         1. Binary mask visualization:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["gt_mask", "pred_mask"],
@@ -188,6 +242,7 @@ def visualize_image_item(
         ... )
 
         2. Contour mask visualization:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["gt_mask", "pred_mask"],
@@ -198,6 +253,7 @@ def visualize_image_item(
         ... )
 
         3. Filled mask visualization:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["gt_mask", "pred_mask"],
@@ -208,6 +264,7 @@ def visualize_image_item(
         ... )
 
         4. Mixed masking strategies:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["image"],
@@ -219,6 +276,7 @@ def visualize_image_item(
         ... )
 
         5. Combining masking strategies with anomaly map:
+
         >>> result = visualize_image_item(
         ...     item,
         ...     fields=["image", "anomaly_map"],
@@ -234,14 +292,17 @@ def visualize_image_item(
 
     Note:
         - The function preserves the order of fields as specified in the input.
-        - If a field is not available in the ImageItem, it will be skipped without raising an error.
-        - The function uses default configurations if not provided, which can be overridden
-          by passing custom configurations.
-        - For mask visualization, the 'mode' parameter in fields_config or overlay_fields_config
-          determines how the mask is displayed:
-            * 'binary': Shows the mask as a black and white image
-            * 'contour': Displays only the contours of the mask
-            * 'fill': Fills the mask area with a specified color and transparency
+        - If a field is not available in the ``ImageItem``, it will be skipped
+          without raising an error.
+        - The function uses default configurations if not provided, which can be
+          overridden by passing custom configurations.
+        - For mask visualization, the ``mode`` parameter in ``fields_config`` or
+          ``overlay_fields_config`` determines how the mask is displayed:
+
+          * ``'binary'``: Shows the mask as a black and white image
+          * ``'contour'``: Displays only the contours of the mask
+          * ``'fill'``: Fills the mask area with a specified color and
+            transparency
     """
     fields_config = {**DEFAULT_FIELDS_CONFIG, **(fields_config or {})}
     overlay_fields_config = {**DEFAULT_OVERLAY_FIELDS_CONFIG, **(overlay_fields_config or {})}
diff --git a/tests/conftest.py b/tests/conftest.py
index c2709ad275..b2cfe0606d 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -17,7 +17,7 @@
 
 
 def _dataset_names() -> list[str]:
-    return [str(path.stem) for path in Path("configs/data").glob("*.yaml")]
+    return [str(path.stem) for path in Path("examples/configs/data").glob("*.yaml")]
 
 
 @pytest.fixture(scope="session")
diff --git a/tests/unit/data/datamodule/depth/test_folder_3d.py b/tests/unit/data/datamodule/depth/test_folder_3d.py
index 9deec32b9c..79a5a1be80 100644
--- a/tests/unit/data/datamodule/depth/test_folder_3d.py
+++ b/tests/unit/data/datamodule/depth/test_folder_3d.py
@@ -43,7 +43,7 @@ def datamodule(dataset_path: Path) -> Folder3D:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/folder_3d.yaml"
+        return "examples/configs/data/folder_3d.yaml"
 
     @staticmethod
     def test_datamodule_from_config(fxt_data_config_path: str) -> None:
diff --git a/tests/unit/data/datamodule/depth/test_mvtec_3d.py b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
index f07266c56a..7601dbf42c 100644
--- a/tests/unit/data/datamodule/depth/test_mvtec_3d.py
+++ b/tests/unit/data/datamodule/depth/test_mvtec_3d.py
@@ -36,4 +36,4 @@ def datamodule(dataset_path: Path) -> MVTec3D:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/mvtec_3d.yaml"
+        return "examples/configs/data/mvtec_3d.yaml"
diff --git a/tests/unit/data/datamodule/image/test_btech.py b/tests/unit/data/datamodule/image/test_btech.py
index 6dcb7969a5..cac296b82c 100644
--- a/tests/unit/data/datamodule/image/test_btech.py
+++ b/tests/unit/data/datamodule/image/test_btech.py
@@ -36,4 +36,4 @@ def datamodule(dataset_path: Path) -> BTech:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/btech.yaml"
+        return "examples/configs/data/btech.yaml"
diff --git a/tests/unit/data/datamodule/image/test_datumaro.py b/tests/unit/data/datamodule/image/test_datumaro.py
index 9b527bd864..a65895520d 100644
--- a/tests/unit/data/datamodule/image/test_datumaro.py
+++ b/tests/unit/data/datamodule/image/test_datumaro.py
@@ -33,4 +33,4 @@ def datamodule(dataset_path: Path) -> Datumaro:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/datumaro.yaml"
+        return "examples/configs/data/datumaro.yaml"
diff --git a/tests/unit/data/datamodule/image/test_folder.py b/tests/unit/data/datamodule/image/test_folder.py
index 9c32239008..466ddd1e09 100644
--- a/tests/unit/data/datamodule/image/test_folder.py
+++ b/tests/unit/data/datamodule/image/test_folder.py
@@ -46,4 +46,4 @@ def datamodule(dataset_path: Path) -> Folder:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/folder.yaml"
+        return "examples/configs/data/folder.yaml"
diff --git a/tests/unit/data/datamodule/image/test_kolektor.py b/tests/unit/data/datamodule/image/test_kolektor.py
index b0456c05fd..460be89217 100644
--- a/tests/unit/data/datamodule/image/test_kolektor.py
+++ b/tests/unit/data/datamodule/image/test_kolektor.py
@@ -35,4 +35,4 @@ def datamodule(dataset_path: Path) -> Kolektor:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/kolektor.yaml"
+        return "examples/configs/data/kolektor.yaml"
diff --git a/tests/unit/data/datamodule/image/test_mvtec.py b/tests/unit/data/datamodule/image/test_mvtec.py
index 537fa9c4e0..b0ff74d86c 100644
--- a/tests/unit/data/datamodule/image/test_mvtec.py
+++ b/tests/unit/data/datamodule/image/test_mvtec.py
@@ -35,4 +35,4 @@ def datamodule(dataset_path: Path) -> MVTec:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/mvtec.yaml"
+        return "examples/configs/data/mvtec.yaml"
diff --git a/tests/unit/data/datamodule/image/test_visa.py b/tests/unit/data/datamodule/image/test_visa.py
index 5f3968b531..3d9d9f2d47 100644
--- a/tests/unit/data/datamodule/image/test_visa.py
+++ b/tests/unit/data/datamodule/image/test_visa.py
@@ -36,4 +36,4 @@ def datamodule(dataset_path: Path) -> Visa:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/visa.yaml"
+        return "examples/configs/data/visa.yaml"
diff --git a/tests/unit/data/datamodule/video/test_avenue.py b/tests/unit/data/datamodule/video/test_avenue.py
index e7c3e8546e..e263ca772a 100644
--- a/tests/unit/data/datamodule/video/test_avenue.py
+++ b/tests/unit/data/datamodule/video/test_avenue.py
@@ -44,4 +44,4 @@ def datamodule(dataset_path: Path, clip_length_in_frames: int) -> Avenue:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/avenue.yaml"
+        return "examples/configs/data/avenue.yaml"
diff --git a/tests/unit/data/datamodule/video/test_shanghaitech.py b/tests/unit/data/datamodule/video/test_shanghaitech.py
index dfee8ca519..a0ae534d5f 100644
--- a/tests/unit/data/datamodule/video/test_shanghaitech.py
+++ b/tests/unit/data/datamodule/video/test_shanghaitech.py
@@ -44,4 +44,4 @@ def datamodule(dataset_path: Path, clip_length_in_frames: int) -> ShanghaiTech:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/shanghaitech.yaml"
+        return "examples/configs/data/shanghaitech.yaml"
diff --git a/tests/unit/data/datamodule/video/test_ucsdped.py b/tests/unit/data/datamodule/video/test_ucsdped.py
index f55347c3f2..46bb328d79 100644
--- a/tests/unit/data/datamodule/video/test_ucsdped.py
+++ b/tests/unit/data/datamodule/video/test_ucsdped.py
@@ -43,4 +43,4 @@ def datamodule(dataset_path: Path, clip_length_in_frames: int) -> UCSDped:
     @staticmethod
     def fxt_data_config_path() -> str:
         """Return the path to the test data config."""
-        return "configs/data/ucsd_ped.yaml"
+        return "examples/configs/data/ucsd_ped.yaml"
diff --git a/tests/unit/models/components/base/test_anomaly_module.py b/tests/unit/models/components/base/test_anomaly_module.py
index 0c522998ae..d3290d078d 100644
--- a/tests/unit/models/components/base/test_anomaly_module.py
+++ b/tests/unit/models/components/base/test_anomaly_module.py
@@ -14,7 +14,7 @@
 @pytest.fixture(scope="class")
 def model_config_folder_path() -> str:
     """Fixture that returns model config folder path."""
-    return "configs/model"
+    return "examples/configs/model"
 
 
 class TestAnomalibModule:
diff --git a/tox.ini b/tox.ini
index c6ddd8f753..b7da26d212 100644
--- a/tox.ini
+++ b/tox.ini
@@ -16,7 +16,8 @@ passenv = ftp_proxy
 basepython = py310
 deps =
     pre-commit
-commands = pre-commit run --all-files
+commands =
+    pre-commit run --all-files
 
 [testenv:pre-merge-py{38,39,310}]
 passenv = {[testenv]deps}
@@ -42,9 +43,9 @@ commands =
         {posargs}
 
     ; 2. Test Jupyter Notebooks.
-    pytest -v --tb=auto --nbmake notebooks \
-        --ignore=notebooks/400_openvino \
-        --ignore=notebooks/500_use_cases/501_dobot
+    pytest -v --tb=auto --nbmake examples/notebooks \
+        --ignore=examples/notebooks/400_openvino \
+        --ignore=examples/notebooks/500_use_cases/501_dobot
 
 [testenv:trivy-scan]
 basepython = py310