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 @@
-
+
**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!
+
+
+
+
+
-
-
-
+
+ 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",
- "\n",
- "\n",
- "| Class | Yellow cube | Red cube | Green cube | Inferencing using Anomalib |\n",
- "| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |\n",
- "| Normal | | | | |\n",
- "| Abnormal | | | | |\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, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/djameln/miniconda3/envs/anomalibv1source/lib/python3.10/site-packages/lightning/pytorch/loops/optimization/automatic.py:129: `training_step` returned `None`. If this was on purpose, ignore this warning...\n"
- ]
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "5bf5b899ecb340109d4fca28c67da82e",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Validation: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "`Trainer.fit` stopped: `max_epochs=1` reached.\n"
- ]
- }
- ],
- "source": [
- "from anomalib.engine import Engine\n",
- "from anomalib.utils.normalization import NormalizationMethod\n",
- "\n",
- "engine = Engine(\n",
- " normalization=NormalizationMethod.MIN_MAX,\n",
- " threshold=\"F1AdaptiveThreshold\",\n",
- " task=TaskType.CLASSIFICATION,\n",
- " image_metrics=[\"AUROC\"],\n",
- " accelerator=\"auto\",\n",
- " check_val_every_n_epoch=1,\n",
- " devices=1,\n",
- " max_epochs=1,\n",
- " num_sanity_val_steps=0,\n",
- " val_check_interval=1.0,\n",
- ")\n",
- "\n",
- "engine.fit(model=model, datamodule=datamodule)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {
- "ExecuteTime": {
- "end_time": "2024-01-12T16:55:46.739592200Z",
- "start_time": "2024-01-12T16:55:45.426593728Z"
- }
- },
- "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",
- "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n"
- ]
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "6d530fe5f50d41dab51d8f2fefdcdb75",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Testing: | | 0/? [00:00, ?it/s]"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/html": [
- "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\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