add app

.devcontainer/devcontainer.json

@@ -0,0 +1,56 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.187.0/containers/docker-existing-dockerfile
+{
+	"name": "Anomalib Development Environment",
+	// Sets the run context to one level up instead of the .devcontainer folder.
+	"context": "..",
+	// Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
+	"dockerFile": "../Dockerfile",
+	// Set *default* container specific settings.json values on container create.
+	"settings": {
+		"python.pythonPath": "/opt/conda/bin/python",
+		"python.formatting.provider": "black",
+		"editor.formatOnSave": true,
+		"python.formatting.blackArgs": [
+			"--line-length",
+			"120"
+		],
+		"editor.codeActionsOnSave": {
+			"source.organizeImports": true
+		},
+		"python.linting.enabled": true,
+		"python.linting.flake8Enabled": true,
+		"python.linting.flake8Args": [
+			"--max-line-length=120"
+		],
+		"python.testing.cwd": ".",
+		"python.linting.lintOnSave": true,
+		"python.testing.unittestEnabled": false,
+		"python.testing.nosetestsEnabled": false,
+		"python.testing.pytestEnabled": true,
+		"python.testing.pytestArgs": [
+			"tests"
+		]
+	},
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"ms-python.python",
+		"njpwerner.autodocstring",
+		"streetsidesoftware.code-spell-checker",
+		"eamodio.gitlens",
+		"littlefoxteam.vscode-python-test-adapter"
+	],
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+	// Uncomment the next line to run commands after the container is created - for example installing curl.
+	// "postCreateCommand": "apt-get update && apt-get install -y curl",
+	// Uncomment when using a ptrace-based debugger like C++, Go, and Rust
+	"runArgs": [
+		"--gpus=all",
+		"--shm-size=20g"
+	]
+	// Uncomment to use the Docker CLI from inside the container. See https://aka.ms/vscode-remote/samples/docker-from-docker.
+	// "mounts": [ "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind" ],
+	// Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root.
+	// "remoteUser": "vscode"
+}

.dockerignore

@@ -0,0 +1,13 @@
+*.dot
+.idea
+.pytest_cache
+.tox
+.vscode
+__pycache__
+{toxworkdir}
+datasets/
+embeddings/
+lightning_logs/
+lightning_test/
+papers/
+results/

.gitattributes

@@ -25,3 +25,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zstandard filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,35 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+- A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+- A clear and concise description of what you expected to happen.
+
+**Screenshots**
+- If applicable, add screenshots to help explain your problem.
+
+**Hardware and Software Configuration**
+- OS: [Ubuntu, OD]
+- NVIDIA Driver Version [470.57.02]
+- CUDA Version [e.g. 11.4]
+- CUDNN Version [e.g. v11.4.120]
+- OpenVINO Version [Optional e.g. v2021.4.2]
+
+
+**Additional context**
+- Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+  - A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+  - A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+  - A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+  - Add any other context or screenshots about the feature request here.

.github/pull_request_template.md

@@ -0,0 +1,22 @@
+# Description
+
+- Provide a summary of the modification as well as the issue that has been resolved. List any dependencies that this modification necessitates.
+
+- Fixes # (issue)
+
+## Changes
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] This change requires a documentation update
+
+## Checklist
+
+- [ ] My code follows the [pre-commit style and check guidelines](https://openvinotoolkit.github.io/anomalib/guides/using_pre_commit.html#pre-commit-hooks) of this project.
+- [ ] I have performed a self-review of my code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing tests pass locally with my changes

.github/workflows/docs.yml

@@ -0,0 +1,66 @@
+name: Build Docs
+
+on:
+  push:
+    branches: [development]
+    paths-ignore:
+      - ".github/**" # Ignore changes towards the .github directory
+  workflow_dispatch: # run on request (no need for PR)
+
+jobs:
+  Build-and-Publish-Documentation:
+    runs-on: [docs]
+    steps:
+      - name: CHECKOUT REPOSITORY
+        uses: actions/checkout@v2
+      - name: Install requirements
+        run: |
+          pip install -r requirements/base.txt
+          pip install -r requirements/dev.txt
+          pip install -r requirements/openvino.txt
+      - name: Build and Commit Docs
+        run: |
+          pip install -r requirements/docs.txt
+          cd docs
+          make html
+      - name: Create gh-pages branch
+        run: |
+          echo ::set-output name=SOURCE_NAME::${GITHUB_REF#refs/*/}
+          echo ::set-output name=SOURCE_BRANCH::${GITHUB_REF#refs/heads/}
+          echo ::set-output name=SOURCE_TAG::${GITHUB_REF#refs/tags/}
+
+          existed_in_remote=$(git ls-remote --heads origin gh-pages)
+
+          if [[ -z ${existed_in_remote} ]]; then
+            echo "Creating gh-pages branch"
+            git config --local user.email "[email protected]"
+            git config --local user.name "GitHub Action"
+            git checkout --orphan gh-pages
+            git reset --hard
+            touch .nojekyll
+            git add .nojekyll
+            git commit -m "Initializing gh-pages branch"
+            git push origin gh-pages
+            git checkout ${{steps.branch_name.outputs.SOURCE_NAME}}
+            echo "Created gh-pages branch"
+          else
+            echo "Branch gh-pages already exists"
+          fi
+      - name: Commit docs to gh-pages branch
+        run: |
+          git fetch
+          git checkout gh-pages
+          mkdir -p /tmp/docs_build
+          cp -r docs/build/html/* /tmp/docs_build/
+          rm -rf ./*
+          cp -r /tmp/docs_build/* ./
+          rm -rf /tmp/docs_build
+          git config --local user.email "[email protected]"
+          git config --local user.name "GitHub Action"
+          git add .
+          git commit -m "Update documentation" -a || true
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: gh-pages

.github/workflows/nightly.yml

@@ -0,0 +1,29 @@
+name: Nightly-regression Test
+
+on:
+  workflow_dispatch: # run on request (no need for PR)
+  schedule:
+    - cron: "0 0 * * *"
+
+jobs:
+  Tox:
+    runs-on: [self-hosted, linux, x64]
+    strategy:
+      max-parallel: 1
+    if: github.ref == 'refs/heads/development'
+    steps:
+      - name: Print GPU status
+        run: nvidia-smi
+      - name: CHECKOUT REPOSITORY
+        uses: actions/checkout@v2
+      - name: Install Tox
+        run: pip install tox
+      - name: Coverage
+        run: |
+          export ANOMALIB_DATASET_PATH=/media/data1/datasets/
+          tox -e nightly
+      - name: Upload coverage result
+        uses: actions/upload-artifact@v2
+        with:
+          name: coverage
+          path: .tox/coverage.xml

.github/workflows/pre_merge.yml

@@ -0,0 +1,32 @@
+name: Pre-merge Checks
+
+on:
+  push:
+    branches: [development, master]
+  pull_request:
+  workflow_dispatch: # run on request (no need for PR)
+
+jobs:
+  Tox:
+    runs-on: [self-hosted, linux, x64]
+    strategy:
+      max-parallel: 1
+    steps:
+      - name: Print GPU status
+        run: nvidia-smi
+      - name: CHECKOUT REPOSITORY
+        uses: actions/checkout@v2
+      - name: Install Tox
+        run: pip install tox
+      - name: Code quality checks
+        run: tox -e black,isort,flake8,pylint,mypy,pydocstyle
+      - name: Coverage
+        run: |
+          export ANOMALIB_DATASET_PATH=/media/data1/datasets/
+          export CUDA_VISIBLE_DEVICES=3
+          tox -e pre_merge
+      - name: Upload coverage result
+        uses: actions/upload-artifact@v2
+        with:
+          name: coverage
+          path: .tox/coverage.xml

.gitignore

@@ -0,0 +1,173 @@
+# Project related
+datasets
+!anomalib/datasets
+!tests/pre_merge/datasets
+results
+!anomalib/core/results
+
+backup.py
+train.ipynb
+
+# VENV
+.python-version
+.anomalib
+.toxbase
+
+# IDE
+.vscode
+.idea
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/build/
+docs/source/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+
+# Documentations
+docs/source/generated
+docs/source/api
+docs/source/models
+docs/build/
+docs/source/_build/
+
+# Misc
+.DS_Store
+
+# logs
+wandb/
+lightning_logs/

.pre-commit-config.yaml

@@ -0,0 +1,70 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.4.0
+    hooks:
+      # list of supported hooks: https://pre-commit.com/hooks.html
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+      - id: debug-statements
+      - id: detect-private-key
+
+  # python code formatting
+  - repo: https://github.com/psf/black
+    rev: 22.3.0
+    hooks:
+      - id: black
+        args: [--line-length, "120"]
+
+  # python import sorting
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.8.0
+    hooks:
+      - id: isort
+        args: ["--profile", "black"]
+
+  # yaml formatting
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v2.3.0
+    hooks:
+      - id: prettier
+        types: [yaml]
+
+  # python code analysis
+  - repo: https://github.com/PyCQA/flake8
+    rev: 3.9.2
+    hooks:
+      - id: flake8
+        args: [--config=tox.ini]
+        exclude: "tests|anomalib/models/components/freia"
+
+  # python linting
+  - repo: local
+    hooks:
+      - id: pylint
+        name: pylint
+        entry: pylint --score=no --rcfile=tox.ini
+        language: system
+        types: [python]
+        exclude: "tests|docs|anomalib/models/components/freia"
+
+  # python static type checking
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: "v0.910"
+    hooks:
+      - id: mypy
+        args: [--config-file=tox.ini]
+        additional_dependencies: [types-PyYAML]
+        exclude: "tests|anomalib/models/components/freia"
+
+  - repo: https://github.com/PyCQA/pydocstyle
+    rev: 6.1.1
+    hooks:
+      - id: pydocstyle
+        name: pydocstyle
+        entry: pydocstyle
+        language: python
+        types: [python]
+        args: [--config=tox.ini]
+        exclude: "tests|docs|anomalib/models/components/freia"

CHANGELOG.md

@@ -0,0 +1,152 @@
+# Changelog
+
+## v.0.3.0
+### What's Changed
+* 🛠 ⚠️ Fix configs to properly use pytorch-lightning==1.6 with GPU by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/234
+* 🛠 Fix `get_version` in `setup.py` to avoid hard-coding version. by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/229
+* 🐞 Fix image loggers by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/233
+* Configurable metrics by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/230
+* Make OpenVINO throughput optional in benchmarking by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/239
+* 🔨 Minor fix: Ensure docs build runs only on isea-server by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/245
+* 🏷  Rename `--model_config_path` to `config` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/246
+* Revert "🏷  Rename `--model_config_path` to `config`" by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/247
+* ➕ Add `--model_config_path` deprecation warning to `inference.py` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/248
+* Add console logger by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/241
+* Add segmentation mask to inference output by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/242
+* 🛠 Fix broken mvtec link, and split url to fit to 120 by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/264
+* 🛠  Fix mask filenames in folder dataset by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/249
+
+
+**Full Changelog**: https://github.com/openvinotoolkit/anomalib/compare/v0.2.6...v0.3.0
+## v.0.2.6
+### What's Changed
+* ✏️ Add `torchtext==0.9.1` to support Kaggle environments. by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/165
+* 🛠 Fix `KeyError:'label'` in classification folder dataset by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/175
+* 📝 Added MVTec license to the repo by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/177
+* load best model from checkpoint by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/195
+* Replace `SaveToCSVCallback` with PL `CSVLogger` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/198
+* WIP Refactor test by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/197
+* 🔧 Dockerfile enhancements by @LukasBommes in https://github.com/openvinotoolkit/anomalib/pull/172
+* 🛠 Fix visualization issue for fully defected images by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/194
+* ✨ Add hpo search using `wandb` by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/82
+* Separate train and validation transformations by @alexriedel1 in https://github.com/openvinotoolkit/anomalib/pull/168
+* 🛠 Fix docs workflow by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/200
+* 🔄 CFlow: Switch soft permutation to false by default to speed up training. by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/201
+* Return only `image`, `path` and `label` for classification tasks in `Mvtec` and `Btech` datasets. by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/196
+* 🗑 Remove `freia` as dependency and include it in `anomalib/models/components` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/174
+* Visualizer show classification and segmentation by @alexriedel1 in https://github.com/openvinotoolkit/anomalib/pull/178
+* ↗️ Bump up `pytorch-lightning` version to `1.6.0` or higher by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/193
+* 🛠 Refactor DFKDE model by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/207
+* 🛠 Minor fixes: Update callbacks to AnomalyModule by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/208
+* 🛠 Minor update: Update pre-commit docs by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/206
+* ✨ Directory streaming by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/210
+* ✏️ Updated documentation for development on Docker by @LukasBommes in https://github.com/openvinotoolkit/anomalib/pull/217
+* 🏷 Fix Mac M1 dependency conflicts by @dreaquil in https://github.com/openvinotoolkit/anomalib/pull/158
+* 🐞 Set tiling off in pathcore to correctly reproduce the stats. by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/222
+* 🐞fix support for non-square images by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/204
+* Allow specifying feature layer and pool factor in DFM by @nahuja-intel in https://github.com/openvinotoolkit/anomalib/pull/215
+* 📝 Add GANomaly metrics to readme by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/224
+* ↗️ Bump the version to 0.2.6 by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/223
+* ���� 🛠 Fix inconsistent benchmarking throughput/time by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/221
+* assign test split for folder dataset by @alexriedel1 in https://github.com/openvinotoolkit/anomalib/pull/220
+* 🛠 Refactor model implementations by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/225
+
+## New Contributors
+* @LukasBommes made their first contribution in https://github.com/openvinotoolkit/anomalib/pull/172
+* @dreaquil made their first contribution in https://github.com/openvinotoolkit/anomalib/pull/158
+* @nahuja-intel made their first contribution in https://github.com/openvinotoolkit/anomalib/pull/215
+
+**Full Changelog**: https://github.com/openvinotoolkit/anomalib/compare/v.0.2.5...v0.2.6
+## v.0.2.5
+### What's Changed
+* Bugfix: fix random val/test split issue by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/48
+* Fix Readmes by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/46
+* Updated changelog by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/49
+* add distinction between image and pixel threshold in postprocessor by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/50
+* Fix docstrings by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/22
+* Fix networkx requirement by @LeonidBeynenson in https://github.com/openvinotoolkit/anomalib/pull/52
+* Add min-max normalization by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/53
+* Change hardcoded dataset path to environ variable by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/51
+* Added cflow algorithm by @blakshma in https://github.com/openvinotoolkit/anomalib/pull/47
+* perform metric computation on cpu by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/64
+* Fix Inferencer by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/60
+* Updated readme for cflow and change default config to reflect results by @blakshma in https://github.com/openvinotoolkit/anomalib/pull/68
+* Fixed issue with model loading by @blakshma in https://github.com/openvinotoolkit/anomalib/pull/69
+* Docs/sa/fix readme by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/71
+* Updated coreset subsampling method to improve accuracy by @blakshma in https://github.com/openvinotoolkit/anomalib/pull/73
+* Revert "Updated coreset subsampling method to improve accuracy" by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/79
+* Replace `SupportIndex` with `int` by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/76
+* Added reference to official CFLOW repo by @blakshma in https://github.com/openvinotoolkit/anomalib/pull/81
+* Fixed issue with k_greedy method by @blakshma in https://github.com/openvinotoolkit/anomalib/pull/80
+* Fix Mix Data type issue on inferencer by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/77
+* Create CODE_OF_CONDUCT.md by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/86
+* ✨ Add GANomaly by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/70
+* Reorder auc only when needed by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/91
+* Bump up the pytorch lightning to master branch due to vulnurability issues by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/55
+* 🚀 CI: Nightly Build by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/66
+* Refactor by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/87
+* Benchmarking Script by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/17
+* 🐞 Fix tensor detach and gpu count issues in benchmarking script by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/100
+* Return predicted masks in predict step by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/103
+* Add Citation to the Readme by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/106
+* Nightly build by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/104
+* c_idx cast to LongTensor in random sparse projection by @alexriedel1 in https://github.com/openvinotoolkit/anomalib/pull/113
+* Update Nightly by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/126
+* Updated logos by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/131
+* Add third-party-programs.txt file and update license by @LeonidBeynenson in https://github.com/openvinotoolkit/anomalib/pull/132
+* 🔨 Increase inference + openvino support by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/122
+* Fix/da/image size bug by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/135
+* Fix/da/image size bug by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/140
+* optimize compute_anomaly_score by using torch native funcrtions by @alexriedel1 in https://github.com/openvinotoolkit/anomalib/pull/141
+* Fix IndexError in adaptive threshold computation by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/146
+* Feature/data/btad by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/120
+* Update for nncf_task by @AlexanderDokuchaev in https://github.com/openvinotoolkit/anomalib/pull/145
+* fix non-adaptive thresholding bug by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/152
+* Calculate feature map shape patchcore by @alexriedel1 in https://github.com/openvinotoolkit/anomalib/pull/148
+* Add `transform_config` to the main `config.yaml` file. by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/156
+* Add Custom Dataset Training Support by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/154
+* Added extension as an option when saving the result images. by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/162
+* Update `anomalib` version and requirements by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/163
+
+## New Contributors
+* @LeonidBeynenson made their first contribution in https://github.com/openvinotoolkit/anomalib/pull/52
+* @blakshma made their first contribution in https://github.com/openvinotoolkit/anomalib/pull/47
+* @alexriedel1 made their first contribution in https://github.com/openvinotoolkit/anomalib/pull/113
+* @AlexanderDokuchaev made their first contribution in https://github.com/openvinotoolkit/anomalib/pull/145
+
+**Full Changelog**: https://github.com/openvinotoolkit/anomalib/compare/v.0.2.4...v.0.2.5
+## v.0.2.4
+### What's Changed
+* Bump up the version to 0.2.4 by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/45
+* fix heatmap color scheme by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/44
+
+**Full Changelog**: https://github.com/openvinotoolkit/anomalib/compare/v.0.2.3...v.0.2.4
+
+## v.0.2.3
+### What's Changed
+* Address docs build failing issue by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/39
+* Fix docs pipeline 📄 by @ashwinvaidya17 in https://github.com/openvinotoolkit/anomalib/pull/41
+* Feature/dick/anomaly score normalization by @djdameln in https://github.com/openvinotoolkit/anomalib/pull/35
+* Shuffle train dataloader by @samet-akcay in https://github.com/openvinotoolkit/anomalib/pull/42
+
+
+**Full Changelog**: https://github.com/openvinotoolkit/anomalib/compare/v0.2.2...v.0.2.3
+
+## v0.2.0 Pre-release (2021-12-15)
+### What's Changed
+* Address compatibility issues with OTE, that are caused by the legacy code. by @samet-akcay in [#24](https://github.com/openvinotoolkit/anomalib/pull/24)
+* Initial docs string by @ashwinvaidya17 in [#9](https://github.com/openvinotoolkit/anomalib/pull/9)
+* Load model did not work correctly as DFMModel did not inherit by @ashwinvaidya17 in [#5](https://github.com/openvinotoolkit/anomalib/pull/5)
+* Refactor/samet/data by @samet-akcay in [#8](https://github.com/openvinotoolkit/anomalib/pull/8)
+* Delete make.bat by @samet-akcay in [#11](https://github.com/openvinotoolkit/anomalib/pull/11)
+* TorchMetrics by @djdameln in [#7](https://github.com/openvinotoolkit/anomalib/pull/7)
+* ONNX node naming by @djdameln in [#13](https://github.com/openvinotoolkit/anomalib/pull/13)
+* Add FPS counter to `TimerCallback` by @ashwinvaidya17 in [#12](https://github.com/openvinotoolkit/anomalib/pull/12)
+
+
+## Contributors
+* @ashwinvaidya17
+* @djdameln
+* @samet-akcay
+
+**Full Changelog**: https://github.com/openvinotoolkit/anomalib/commits/v0.2.0

CITATION.cff

@@ -0,0 +1,92 @@
+# This CITATION.cff file was generated with cffinit.
+# Visit https://bit.ly/cffinit to generate yours today!
+
+cff-version: 1.2.0
+title: "Anomalib: A Deep Learning Library for Anomaly Detection"
+message: "If you use this library and love it, cite the software and the paper \U0001F917"
+authors:
+  - given-names: Samet
+    family-names: Akcay
+    email: [email protected]
+    affiliation: Intel
+  - given-names: Dick
+    family-names: Ameln
+    email: [email protected]
+    affiliation: Intel
+  - given-names: Ashwin
+    family-names: Vaidya
+    email: [email protected]
+    affiliation: Intel
+  - given-names: Barath
+    family-names: Lakshmanan
+    email: [email protected]
+    affiliation: Intel
+  - given-names: Nilesh
+    family-names: Ahuja
+    email: [email protected]
+    affiliation: Intel
+  - given-names: Utku
+    family-names: Genc
+    email: [email protected]
+    affiliation: Intel
+version: 0.2.6
+doi: https://doi.org/10.48550/arXiv.2202.08341
+date-released: 2022-02-18
+references:
+  - type: article
+    authors:
+      - given-names: Samet
+        family-names: Akcay
+        email: [email protected]
+        affiliation: Intel
+      - given-names: Dick
+        family-names: Ameln
+        email: [email protected]
+        affiliation: Intel
+      - given-names: Ashwin
+        family-names: Vaidya
+        email: [email protected]
+        affiliation: Intel
+      - given-names: Barath
+        family-names: Lakshmanan
+        email: [email protected]
+        affiliation: Intel
+      - given-names: Nilesh
+        family-names: Ahuja
+        email: [email protected]
+        affiliation: Intel
+      - given-names: Utku
+        family-names: Genc
+        email: [email protected]
+        affiliation: Intel
+    title: "Anomalib: A Deep Learning Library for Anomaly Detection"
+    year: 2022
+    journal: ArXiv
+    doi: https://doi.org/10.48550/arXiv.2202.08341
+    url: https://arxiv.org/abs/2202.08341
+
+abstract: >-
+  This paper introduces anomalib, a novel library for
+  unsupervised anomaly detection and localization.
+  With reproducibility and modularity in mind, this
+  open-source library provides algorithms from the
+  literature and a set of tools to design custom
+  anomaly detection algorithms via a plug-and-play
+  approach. Anomalib comprises state-of-the-art
+  anomaly detection algorithms that achieve top
+  performance on the benchmarks and that can be used
+  off-the-shelf. In addition, the library provides
+  components to design custom algorithms that could
+  be tailored towards specific needs. Additional
+  tools, including experiment trackers, visualizers,
+  and hyper-parameter optimizers, make it simple to
+  design and implement anomaly detection models. The
+  library also supports OpenVINO model optimization
+  and quantization for real-time deployment. Overall,
+  anomalib is an extensive library for the design,
+  implementation, and deployment of unsupervised
+  anomaly detection models from data to the edge.
+keywords:
+  - Unsupervised Anomaly detection
+  - Unsupervised Anomaly localization
+license: Apache-2.0

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[Intel Integrity Line](https://secure.ethicspoint.com/domain/media/en/gui/31244/index.html).
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -0,0 +1,64 @@
+# Contributing to Anomalib
+We welcome your input! 👐
+
+We want to make it as simple and straightforward as possible to contribute to this project, whether it is a:
+
+- Bug Report
+- Discussion
+- Feature Request
+- Creating a Pull Request (PR)
+- Becoming a maintainer
+
+
+## Bug Report
+We use GitHub issues to track the bugs. Report a bug by using our Bug Report Template in [Issues](https://github.com/openvinotoolkit/anomalib/issues/new?assignees=&labels=&template=bug_report.md).
+
+
+## Discussion
+We enabled [GitHub Discussions](https://github.com/openvinotoolkit/anomalib/discussions/) in anomalib to welcome the community to ask questions and/or propose ideas/solutions. This will not only provide a medium to the community to discuss about anomalib but also help us de-clutter [Issues](https://github.com/openvinotoolkit/anomalib/issues/new?assignees=&labels=&template=bug_report.md).
+
+
+## Feature Request
+We utilize GitHub issues to track the feature requests as well. If you are certain regarding the feature you are interested and have a solid proposal, you could then create the feature request by using our [Feature Request Template](https://github.com/openvinotoolkit/anomalib/issues/new?assignees=&labels=&template=feature_request.md) in Issues. If it's still in an idea phase, you could then discuss that with the community in our [Discussion](https://github.com/openvinotoolkit/anomalib/discussions/categories/ideas).
+
+
+## Development & PRs
+We actively welcome your pull requests:
+
+  1. Fork the repo and create your branch from [`development`](https://github.com/openvinotoolkit/anomalib/tree/development).
+  2. If you've added code that should be tested, add tests.
+  3. If you've changed APIs, update the documentation.
+  4. Ensure the test suite passes.
+  5. Make sure your code lints.
+  6. Make sure you own the code you're submitting or that you obtain it from a source with an appropriate license.
+  7. Issue that pull request!
+
+To setup the development environment, you will need to install development requirements.
+```
+pip install -r requirements/dev.txt
+```
+
+To enforce consistency within the repo, we use several formatters, linters, and style- and type checkers:
+
+| Tool   | Function                   | Documentation                           |
+| ------ | -------------------------- | --------------------------------------- |
+| Black  | Code formatting            | https://black.readthedocs.io/en/stable/ |
+| isort  | Organize import statements | https://pycqa.github.io/isort/          |
+| Flake8 | Code style                 | https://flake8.pycqa.org/en/latest/     |
+| Pylint | Linting                    | http://pylint.pycqa.org/en/latest/      |
+| MyPy   | Type checking              | https://mypy.readthedocs.io/en/stable/  |
+
+Instead of running each of these tools manually, we automatically run them before each commit and after each merge request. To achieve this we use pre-commit hooks and tox. Every developer is expected to use pre-commit hooks to make sure that their code remains free of typing and linting issues, and complies with the coding style requirements. When an MR is submitted, tox will be automatically invoked from the CI pipeline in Gitlab to check if the code quality is up to standard. Developers can also run tox locally before making an MR, though this is not strictly necessary since pre-commit hooks should be sufficient to prevent code quality issues. More detailed explanations of how to work with these tools is given in the respective guides:
+
+- Pre-commit hooks: [Pre-commit hooks guide](https://openvinotoolkit.github.io/anomalib/guides/using_pre_commit.html#pre-commit-hooks)
+- Tox: [Using Tox](https://openvinotoolkit.github.io/anomalib/guides/using_tox.html#using-tox)
+
+In rare cases it might be desired to ignore certain errors or warnings for a particular part of your code. Flake8, Pylint and MyPy allow disabling specific errors for a line or block of code. The instructions for this can be found in the the documentations of each of these tools. Please make sure to only ignore errors/warnings when absolutely necessary, and always add a comment in your code stating why you chose to ignore it.
+
+
+## License
+You accept that your contributions will be licensed under the [Apache-2.0 License](https://choosealicense.com/licenses/apache-2.0/) if you contribute to this repository. If this is a concern, please notify the maintainers.
+
+
+## References
+This document was adapted from [here](https://gist.github.com/briandk/3d2e8b3ec8daf5a27a62).

Dockerfile

@@ -0,0 +1,38 @@
+#########################################################
+## Python Environment with CUDA
+#########################################################
+
+FROM nvidia/cuda:11.4.0-devel-ubuntu20.04 AS python_base_cuda
+LABEL MAINTAINER="Anomalib Development Team"
+
+# Update system and install wget
+RUN apt-get update && DEBIAN_FRONTEND="noninteractive" apt-get install -y wget ffmpeg libpython3.8 git sudo
+
+# Install Conda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda.sh --quiet && \
+    bash ~/miniconda.sh -b -p /opt/conda
+ENV PATH "/opt/conda/bin:${PATH}"
+RUN conda install python=3.8
+
+
+#########################################################
+## Anomalib Development Env
+#########################################################
+
+FROM python_base_cuda as anomalib_development_env
+
+# Install all anomalib requirements
+COPY ./requirements/base.txt /tmp/anomalib/requirements/base.txt
+RUN pip install -r /tmp/anomalib/requirements/base.txt
+
+COPY ./requirements/openvino.txt /tmp/anomalib/requirements/openvino.txt
+RUN pip install -r /tmp/anomalib/requirements/openvino.txt
+
+# Install other requirements related to development
+COPY ./requirements/dev.txt /tmp/anomalib/requirements/dev.txt
+RUN pip install -r /tmp/anomalib/requirements/dev.txt
+
+# Install anomalib
+COPY . /anomalib
+WORKDIR /anomalib
+RUN pip install -e .

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (C) 2020-2021 Intel Corporation
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MANIFEST.in

@@ -0,0 +1 @@
+recursive-include requirements *

README copy.md

@@ -0,0 +1,253 @@
+<div align="center">
+
+<img src="docs/source/images/logos/anomalib-wide-blue.png" width="600px">
+
+**A library for benchmarking, developing and deploying deep learning anomaly detection algorithms**
+___
+
+[Key Features](#key-features) •
+[Getting Started](#getting-started) •
+[Docs](https://openvinotoolkit.github.io/anomalib) •
+[License](https://github.com/openvinotoolkit/anomalib/blob/development/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-2021.4.2-purple)]()
+[![black](https://img.shields.io/badge/code%20style-black-000000.svg)]()
+[![Nightly-regression Test](https://github.com/openvinotoolkit/anomalib/actions/workflows/nightly.yml/badge.svg)](https://github.com/openvinotoolkit/anomalib/actions/workflows/nightly.yml)
+[![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)
+[![Build Docs](https://github.com/openvinotoolkit/anomalib/actions/workflows/docs.yml/badge.svg)](https://github.com/openvinotoolkit/anomalib/actions/workflows/docs.yml)
+
+</div>
+
+___
+
+## 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 image-based anomaly detection, where the goal of the algorithm is to identify anomalous images, or anomalous pixel regions within images in a dataset. Anomalib is constantly updated with new algorithms and training/inference extensions, so keep checking!
+
+![Sample Image](./docs/source/images/readme.png)
+
+**Key features:**
+
+- The largest public collection of ready-to-use deep learning anomaly detection algorithms and benchmark datasets.
+- [**PyTorch Lightning**](https://www.pytorchlightning.ai/) based model implementations to reduce boilerplate code and limit the implementation efforts to the bare essentials.
+- All models can be exported to [**OpenVINO**](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html) Intermediate Representation (IR) for accelerated inference on intel hardware.
+- A set of [inference tools](#inference) for quick and easy deployment of the standard or custom anomaly detection models.
+
+___
+
+## Getting Started
+
+To get an overview of all the devices where `anomalib` as been tested thoroughly, look at the [Supported Hardware](https://openvinotoolkit.github.io/anomalib/#supported-hardware) section in the documentation.
+
+### PyPI Install
+
+You can get started with `anomalib` by just using pip.
+
+```bash
+pip install anomalib
+```
+
+### Local Install
+It is highly recommended to use virtual environment when installing anomalib. For instance, with [anaconda](https://www.anaconda.com/products/individual), `anomalib` could be installed as,
+
+```bash
+yes | conda create -n anomalib_env python=3.8
+conda activate anomalib_env
+git clone https://github.com/openvinotoolkit/anomalib.git
+cd anomalib
+pip install -e .
+```
+
+## Training
+
+By default [`python tools/train.py`](https://gitlab-icv.inn.intel.com/algo_rnd_team/anomaly/-/blob/development/train.py)
+runs [PADIM](https://arxiv.org/abs/2011.08785) model on `leather` category from the [MVTec AD](https://www.mvtec.com/company/research/datasets/mvtec-ad) [(CC BY-NC-SA 4.0)](https://creativecommons.org/licenses/by-nc-sa/4.0/)  dataset.
+
+```bash
+python tools/train.py    # Train PADIM on MVTec AD leather
+```
+
+Training a model on a specific dataset and category requires further configuration. Each model has its own configuration
+file, [`config.yaml`](https://gitlab-icv.inn.intel.com/algo_rnd_team/anomaly/-/blob/development/padim/anomalib/models/padim/config.yaml)
+, which contains data, model and training configurable parameters. To train a specific model on a specific dataset and
+category, the config file is to be provided:
+
+```bash
+python tools/train.py --config <path/to/model/config.yaml>
+```
+
+For example, to train [PADIM](anomalib/models/padim) you can use
+
+```bash
+python tools/train.py --config anomalib/models/padim/config.yaml
+```
+
+Note that `--model_config_path` will be deprecated in `v0.2.8` and removed
+in `v0.2.9`.
+
+Alternatively, a model name could also be provided as an argument, where the scripts automatically finds the corresponding config file.
+
+```bash
+python tools/train.py --model padim
+```
+
+where the currently available models are:
+
+- [CFlow](anomalib/models/cflow)
+- [PatchCore](anomalib/models/patchcore)
+- [PADIM](anomalib/models/padim)
+- [STFPM](anomalib/models/stfpm)
+- [DFM](anomalib/models/dfm)
+- [DFKDE](anomalib/models/dfkde)
+- [GANomaly](anomalib/models/ganomaly)
+
+### Custom Dataset
+It is also possible to train on a custom folder dataset. To do so, `data` section in `config.yaml` is to be modified as follows:
+```yaml
+dataset:
+  name: <name-of-the-dataset>
+  format: folder
+  path: <path/to/folder/dataset>
+  normal: normal # name of the folder containing normal images.
+  abnormal: abnormal # name of the folder containing abnormal images.
+  task: segmentation # classification or segmentation
+  mask: <path/to/mask/annotations> #optional
+  extensions: null
+  split_ratio: 0.2  # ratio of the normal images that will be used to create a test split
+  seed: 0
+  image_size: 256
+  train_batch_size: 32
+  test_batch_size: 32
+  num_workers: 8
+  transform_config: null
+  create_validation_set: true
+  tiling:
+    apply: false
+    tile_size: null
+    stride: null
+    remove_border_count: 0
+    use_random_tiling: False
+    random_tile_count: 16
+```
+## Inference
+
+Anomalib contains several tools that can be used to perform inference with a trained model. The script in [`tools/inference`](tools/inference.py) contains an example of how the inference tools can be used to generate a prediction for an input image.
+
+If the specified weight path points to a PyTorch Lightning checkpoint file (`.ckpt`), inference will run in PyTorch. If the path points to an ONNX graph (`.onnx`) or OpenVINO IR (`.bin` or `.xml`), inference will run in OpenVINO.
+
+The following command can be used to run inference from the command line:
+
+```bash
+python tools/inference.py \
+    --config <path/to/model/config.yaml> \
+    --weight_path <path/to/weight/file> \
+    --image_path <path/to/image>
+```
+
+As a quick example:
+
+```bash
+python tools/inference.py \
+    --config anomalib/models/padim/config.yaml \
+    --weight_path results/padim/mvtec/bottle/weights/model.ckpt \
+    --image_path datasets/MVTec/bottle/test/broken_large/000.png
+```
+
+If you want to run OpenVINO model, ensure that `openvino` `apply` is set to `True` in the respective model `config.yaml`.
+
+```yaml
+optimization:
+  openvino:
+    apply: true
+```
+
+Example OpenVINO Inference:
+
+```bash
+python tools/inference.py \
+    --config  \
+    anomalib/models/padim/config.yaml  \
+    --weight_path  \
+    results/padim/mvtec/bottle/compressed/compressed_model.xml  \
+    --image_path  \
+    datasets/MVTec/bottle/test/broken_large/000.png  \
+    --meta_data  \
+    results/padim/mvtec/bottle/compressed/meta_data.json
+```
+
+> Ensure that you provide path to `meta_data.json` if you want the normalization to be applied correctly.
+
+___
+
+## Datasets
+`anomalib` supports MVTec AD [(CC BY-NC-SA 4.0)](https://creativecommons.org/licenses/by-nc-sa/4.0/) and BeanTech [(CC-BY-SA)](https://creativecommons.org/licenses/by-sa/4.0/legalcode) for benchmarking and `folder` for custom dataset training/inference.
+
+### [MVTec AD Dataset](https://www.mvtec.com/company/research/datasets/mvtec-ad)
+MVTec AD dataset is one of the main benchmarks for anomaly detection, and is released under the
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License [(CC BY-NC-SA 4.0)](https://creativecommons.org/licenses/by-nc-sa/4.0/).
+
+### Image-Level AUC
+
+| Model         |                    |    Avg    |  Carpet   |   Grid    | Leather |   Tile    |   Wood    | Bottle  |   Cable   |  Capsule  | Hazelnut | Metal Nut |   Pill    |   Screw   | Toothbrush | Transistor |  Zipper   |
+| ------------- | ------------------ | :-------: | :-------: | :-------: | :-----: | :-------: | :-------: | :-----: | :-------: | :-------: | :------: | :-------: | :-------: | :-------: | :--------: | :--------: | :-------: |
+| **PatchCore** | **Wide ResNet-50** | **0.980** |   0.984   |   0.959   |  1.000  | **1.000** |   0.989   |  1.000  | **0.990** | **0.982** |  1.000   |   0.994   |   0.924   |   0.960   |   0.933    | **1.000**  |   0.982   |
+| PatchCore     | ResNet-18          |   0.973   |   0.970   |   0.947   |  1.000  |   0.997   |   0.997   |  1.000  |   0.986   |   0.965   |  1.000   |   0.991   |   0.916   | **0.943** |   0.931    |   0.996    |   0.953   |
+| CFlow         | Wide ResNet-50     |   0.962   |   0.986   |   0.962   | **1.0** |   0.999   | **0.993** | **1.0** |   0.893   |   0.945   | **1.0**  | **0.995** |   0.924   |   0.908   |   0.897    |   0.943    | **0.984** |
+| PaDiM         | Wide ResNet-50     |   0.950   | **0.995** |   0.942   |   1.0   |   0.974   | **0.993** |  0.999  |   0.878   |   0.927   |  0.964   |   0.989   | **0.939** |   0.845   |   0.942    |   0.976    |   0.882   |
+| PaDiM         | ResNet-18          |   0.891   |   0.945   |   0.857   |  0.982  |   0.950   |   0.976   |  0.994  |   0.844   |   0.901   |  0.750   |   0.961   |   0.863   |   0.759   |   0.889    |   0.920    |   0.780   |
+| STFPM         | Wide ResNet-50     |   0.876   |   0.957   |   0.977   |  0.981  |   0.976   |   0.939   |  0.987  |   0.878   |   0.732   |  0.995   |   0.973   |   0.652   |   0.825   |    0.5     |   0.875    |   0.899   |
+| STFPM         | ResNet-18          |   0.893   |   0.954   | **0.982** |  0.989  |   0.949   |   0.961   |  0.979  |   0.838   |   0.759   |  0.999   |   0.956   |   0.705   |   0.835   | **0.997**  |   0.853    |   0.645   |
+| DFM           | Wide ResNet-50     |   0.891   |   0.978   |   0.540   |  0.979  |   0.977   |   0.974   |  0.990  |   0.891   |   0.931   |  0.947   |   0.839   |   0.809   |   0.700   |   0.911    |   0.915    |   0.981   |
+| DFM           | ResNet-18          |   0.894   |   0.864   |   0.558   |  0.945  |   0.984   |   0.946   |  0.994  |   0.913   |   0.871   |  0.979   |   0.941   |   0.838   |   0.761   |    0.95    |   0.911    |   0.949   |
+| DFKDE         | Wide ResNet-50     |   0.774   |   0.708   |   0.422   |  0.905  |   0.959   |   0.903   |  0.936  |   0.746   |   0.853   |  0.736   |   0.687   |   0.749   |   0.574   |   0.697    |   0.843    |   0.892   |
+| DFKDE         | ResNet-18          |   0.762   |   0.646   |   0.577   |  0.669  |   0.965   |   0.863   |  0.951  |   0.751   |   0.698   |  0.806   |   0.729   |   0.607   |   0.694   |   0.767    |   0.839    |   0.866   |
+| GANomaly      |                    |   0.421   |   0.203   |   0.404   |  0.413  |   0.408   |   0.744   |  0.251  |   0.457   |   0.682   |  0.537   |   0.270   |   0.472   |   0.231   |   0.372    |   0.440    |   0.434   |
+
+### Pixel-Level AUC
+
+| Model         |                    |    Avg    |  Carpet   |   Grid    |  Leather  |   Tile    |   Wood    |  Bottle   |   Cable   |  Capsule  | Hazelnut  | Metal Nut |   Pill    |   Screw   | Toothbrush | Transistor |  Zipper   |
+| ------------- | ------------------ | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :--------: | :--------: | :-------: |
+| **PatchCore** | **Wide ResNet-50** | **0.980** |   0.988   |   0.968   |   0.991   |   0.961   |   0.934   |   0.984   | **0.988** | **0.988** |   0.987   | **0.989** |   0.980   | **0.989** |   0.988    | **0.981**  |   0.983   |
+| PatchCore     | ResNet-18          |   0.976   |   0.986   |   0.955   |   0.990   |   0.943   |   0.933   |   0.981   |   0.984   |   0.986   |   0.986   |   0.986   |   0.974   |   0.991   |   0.988    |   0.974    |   0.983   |
+| CFlow         | Wide ResNet-50     |   0.971   |   0.986   |   0.968   |   0.993   | **0.968** |   0.924   |   0.981   |   0.955   | **0.988** | **0.990** |   0.982   | **0.983** |   0.979   |   0.985    |   0.897    |   0.980   |
+| PaDiM         | Wide ResNet-50     |   0.979   | **0.991** |   0.970   |   0.993   |   0.955   | **0.957** | **0.985** |   0.970   | **0.988** |   0.985   |   0.982   |   0.966   |   0.988   | **0.991**  |   0.976    | **0.986** |
+| PaDiM         | ResNet-18          |   0.968   |   0.984   |   0.918   | **0.994** |   0.934   |   0.947   |   0.983   |   0.965   |   0.984   |   0.978   |   0.970   |   0.957   |   0.978   |   0.988    |   0.968    |   0.979   |
+| STFPM         | Wide ResNet-50     |   0.903   |   0.987   | **0.989** |   0.980   |   0.966   |   0.956   |   0.966   |   0.913   |   0.956   |   0.974   |   0.961   |   0.946   |   0.988   |   0.178    |   0.807    |   0.980   |
+| STFPM         | ResNet-18          |   0.951   |   0.986   |   0.988   |   0.991   |   0.946   |   0.949   |   0.971   |   0.898   |   0.962   |   0.981   |   0.942   |   0.878   |   0.983   |   0.983    |   0.838    |   0.972   |
+
+### Image F1 Score
+
+| Model         |                    |    Avg    |  Carpet   |   Grid    |  Leather  |   Tile    |   Wood    |  Bottle   |   Cable   |  Capsule  | Hazelnut  | Metal Nut |   Pill    |   Screw   | Toothbrush | Transistor |  Zipper   |
+| ------------- | ------------------ | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: | :--------: | :--------: | :-------: |
+| **PatchCore** | **Wide ResNet-50** | **0.976** |   0.971   |   0.974   | **1.000** | **1.000** |   0.967   | **1.000** |   0.968   | **0.982** | **1.000** |   0.984   |   0.940   |   0.943   |   0.938    | **1.000**  | **0.979** |
+| PatchCore     | ResNet-18          |   0.970   |   0.949   |   0.946   | **1.000** |   0.98    | **0.992** | **1.000** | **0.978** |   0.969   | **1.000** | **0.989** |   0.940   |   0.932   |   0.935    |   0.974    |   0.967   |
+| CFlow         | Wide ResNet-50     |   0.944   |   0.972   |   0.932   |  **1.0**  |   0.988   |   0.967   |  **1.0**  |   0.832   |   0.939   |  **1.0**  |   0.979   |   0.924   | **0.971** |   0.870    |   0.818    |   0.967   |
+| PaDiM         | Wide ResNet-50     |   0.951   | **0.989** |   0.930   |  **1.0**  |   0.960   |   0.983   |   0.992   |   0.856   | **0.982** |   0.937   |   0.978   | **0.946** |   0.895   |   0.952    |   0.914    |   0.947   |
+| PaDiM         | ResNet-18          |   0.916   |   0.930   |   0.893   |   0.984   |   0.934   |   0.952   |   0.976   |   0.858   |   0.960   |   0.836   |   0.974   |   0.932   |   0.879   |   0.923    |   0.796    |   0.915   |
+| STFPM         | Wide ResNet-50     |   0.926   |   0.973   |   0.973   |   0.974   |   0.965   |   0.929   |   0.976   |   0.853   |   0.920   |   0.972   |   0.974   |   0.922   |   0.884   |   0.833    |   0.815    |   0.931   |
+| STFPM         | ResNet-18          |   0.932   |   0.961   | **0.982** |   0.989   |   0.930   |   0.951   |   0.984   |   0.819   |   0.918   |   0.993   |   0.973   |   0.918   |   0.887   | **0.984**  |   0.790    |   0.908   |
+| DFM           | Wide ResNet-50     |   0.918   |   0.960   |   0.844   |   0.990   |   0.970   |   0.959   |   0.976   |   0.848   |   0.944   |   0.913   |   0.912   |   0.919   |   0.859   |   0.893    |   0.815    |   0.961   |
+| DFM           | ResNet-18          |   0.919   |   0.895   |   0.844   |   0.926   |   0.971   |   0.948   |   0.977   |   0.874   |   0.935   |   0.957   |   0.958   |   0.921   |   0.874   |   0.933    |   0.833    |   0.943   |
+| DFKDE         | Wide ResNet-50     |   0.875   |   0.907   |   0.844   |   0.905   |   0.945   |   0.914   |   0.946   |   0.790   |   0.914   |   0.817   |   0.894   |   0.922   |   0.855   |   0.845    |   0.722    |   0.910   |
+| DFKDE         | ResNet-18          |   0.872   |   0.864   |   0.844   |   0.854   |   0.960   |   0.898   |   0.942   |   0.793   |   0.908   |   0.827   |   0.894   |   0.916   |   0.859   |   0.853    |   0.756    |   0.916   |
+| GANomaly      |                    |   0.834   |   0.864   |   0.844   |   0.852   |   0.836   |   0.863   |   0.863   |   0.760   |   0.905   |   0.777   |   0.894   |   0.916   |   0.853   |   0.833    |   0.571    |   0.881   |
+
+## Reference
+If you use this library and love it, use this to cite it 🤗
+```
+@misc{anomalib,
+      title={Anomalib: A Deep Learning Library for Anomaly Detection},
+      author={Samet Akcay and
+              Dick Ameln and
+              Ashwin Vaidya and
+              Barath Lakshmanan and
+              Nilesh Ahuja and
+              Utku Genc},
+      year={2022},
+      eprint={2202.08341},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV}
+}
+```

anomalib/__init__.py

@@ -0,0 +1,17 @@
+"""Anomalib library for research and benchmarking."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+__version__ = "0.3.0"

anomalib/config/__init__.py

@@ -0,0 +1,23 @@
+"""Utilities for parsing model configuration."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from .config import (
+    get_configurable_parameters,
+    update_input_size_config,
+    update_nncf_config,
+)
+
+__all__ = ["get_configurable_parameters", "update_nncf_config", "update_input_size_config"]

anomalib/config/config.py

@@ -0,0 +1,170 @@
+"""Get configurable parameters."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+# TODO: This would require a new design.
+# TODO: https://jira.devtools.intel.com/browse/IAAALD-149
+
+from pathlib import Path
+from typing import List, Optional, Union
+from warnings import warn
+
+from omegaconf import DictConfig, ListConfig, OmegaConf
+
+
+def update_input_size_config(config: Union[DictConfig, ListConfig]) -> Union[DictConfig, ListConfig]:
+    """Update config with image size as tuple, effective input size and tiling stride.
+
+    Convert integer image size parameters into tuples, calculate the effective input size based on image size
+    and crop size, and set tiling stride if undefined.
+
+    Args:
+        config (Union[DictConfig, ListConfig]): Configurable parameters object
+
+    Returns:
+        Union[DictConfig, ListConfig]: Configurable parameters with updated values
+    """
+    # handle image size
+    if isinstance(config.dataset.image_size, int):
+        config.dataset.image_size = (config.dataset.image_size,) * 2
+
+    config.model.input_size = config.dataset.image_size
+
+    if "tiling" in config.dataset.keys() and config.dataset.tiling.apply:
+        if isinstance(config.dataset.tiling.tile_size, int):
+            config.dataset.tiling.tile_size = (config.dataset.tiling.tile_size,) * 2
+        if config.dataset.tiling.stride is None:
+            config.dataset.tiling.stride = config.dataset.tiling.tile_size
+
+    return config
+
+
+def update_nncf_config(config: Union[DictConfig, ListConfig]) -> Union[DictConfig, ListConfig]:
+    """Set the NNCF input size based on the value of the crop_size parameter in the configurable parameters object.
+
+    Args:
+        config (Union[DictConfig, ListConfig]): Configurable parameters of the current run.
+
+    Returns:
+        Union[DictConfig, ListConfig]: Updated configurable parameters in DictConfig object.
+    """
+    crop_size = config.dataset.image_size
+    sample_size = (crop_size, crop_size) if isinstance(crop_size, int) else crop_size
+    if "optimization" in config.keys():
+        if "nncf" in config.optimization.keys():
+            config.optimization.nncf.input_info.sample_size = [1, 3, *sample_size]
+            if config.optimization.nncf.apply:
+                if "update_config" in config.optimization.nncf:
+                    return OmegaConf.merge(config, config.optimization.nncf.update_config)
+    return config
+
+
+def update_multi_gpu_training_config(config: Union[DictConfig, ListConfig]) -> Union[DictConfig, ListConfig]:
+    """Updates the config to change learning rate based on number of gpus assigned.
+
+    Current behaviour is to ensure only ddp accelerator is used.
+
+    Args:
+        config (Union[DictConfig, ListConfig]): Configurable parameters for the current run
+
+    Raises:
+        ValueError: If unsupported accelerator is passed
+
+    Returns:
+        Union[DictConfig, ListConfig]: Updated config
+    """
+    # validate accelerator
+    if config.trainer.accelerator is not None:
+        if config.trainer.accelerator.lower() != "ddp":
+            if config.trainer.accelerator.lower() in ("dp", "ddp_spawn", "ddp2"):
+                warn(
+                    f"Using accelerator {config.trainer.accelerator.lower()} is discouraged. "
+                    f"Please use one of [null, ddp]. Setting accelerator to ddp"
+                )
+                config.trainer.accelerator = "ddp"
+            else:
+                raise ValueError(
+                    f"Unsupported accelerator found: {config.trainer.accelerator}. Should be one of [null, ddp]"
+                )
+    # Increase learning rate
+    # since pytorch averages the gradient over devices, the idea is to
+    # increase the learning rate by the number of devices
+    if "lr" in config.model:
+        # Number of GPUs can either be passed as gpus: 2 or gpus: [0,1]
+        n_gpus: Union[int, List] = 1
+        if "trainer" in config and "gpus" in config.trainer:
+            n_gpus = config.trainer.gpus
+        lr_scaler = n_gpus if isinstance(n_gpus, int) else len(n_gpus)
+        config.model.lr = config.model.lr * lr_scaler
+    return config
+
+
+def get_configurable_parameters(
+    model_name: Optional[str] = None,
+    config_path: Optional[Union[Path, str]] = None,
+    weight_file: Optional[str] = None,
+    config_filename: Optional[str] = "config",
+    config_file_extension: Optional[str] = "yaml",
+) -> Union[DictConfig, ListConfig]:
+    """Get configurable parameters.
+
+    Args:
+        model_name: Optional[str]:  (Default value = None)
+        config_path: Optional[Union[Path, str]]:  (Default value = None)
+        weight_file: Path to the weight file
+        config_filename: Optional[str]:  (Default value = "config")
+        config_file_extension: Optional[str]:  (Default value = "yaml")
+
+    Returns:
+        Union[DictConfig, ListConfig]: Configurable parameters in DictConfig object.
+    """
+    if model_name is None and config_path is None:
+        raise ValueError(
+            "Both model_name and model config path cannot be None! "
+            "Please provide a model name or path to a config file!"
+        )
+
+    if config_path is None:
+        config_path = Path(f"anomalib/models/{model_name}/{config_filename}.{config_file_extension}")
+
+    config = OmegaConf.load(config_path)
+
+    # Dataset Configs
+    if "format" not in config.dataset.keys():
+        config.dataset.format = "mvtec"
+
+    config = update_input_size_config(config)
+
+    # Project Configs
+    project_path = Path(config.project.path) / config.model.name / config.dataset.name
+    if config.dataset.format.lower() in ("btech", "mvtec"):
+        project_path = project_path / config.dataset.category
+
+    (project_path / "weights").mkdir(parents=True, exist_ok=True)
+    (project_path / "images").mkdir(parents=True, exist_ok=True)
+    config.project.path = str(project_path)
+    # loggers should write to results/model/dataset/category/ folder
+    config.trainer.default_root_dir = str(project_path)
+
+    if weight_file:
+        config.model.weight_file = weight_file
+
+    config = update_nncf_config(config)
+
+    # thresholding
+    if "pixel_default" not in config.model.threshold.keys():
+        config.model.threshold.pixel_default = config.model.threshold.image_default
+
+    return config

anomalib/data/__init__.py

@@ -0,0 +1,104 @@
+"""Anomalib Datasets."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from typing import Union
+
+from omegaconf import DictConfig, ListConfig
+from pytorch_lightning import LightningDataModule
+
+from .btech import BTechDataModule
+from .folder import FolderDataModule
+from .inference import InferenceDataset
+from .mvtec import MVTecDataModule
+
+
+def get_datamodule(config: Union[DictConfig, ListConfig]) -> LightningDataModule:
+    """Get Anomaly Datamodule.
+
+    Args:
+        config (Union[DictConfig, ListConfig]): Configuration of the anomaly model.
+
+    Returns:
+        PyTorch Lightning DataModule
+    """
+    datamodule: LightningDataModule
+
+    if config.dataset.format.lower() == "mvtec":
+        datamodule = MVTecDataModule(
+            # TODO: Remove config values. IAAALD-211
+            root=config.dataset.path,
+            category=config.dataset.category,
+            image_size=(config.dataset.image_size[0], config.dataset.image_size[1]),
+            train_batch_size=config.dataset.train_batch_size,
+            test_batch_size=config.dataset.test_batch_size,
+            num_workers=config.dataset.num_workers,
+            seed=config.project.seed,
+            task=config.dataset.task,
+            transform_config_train=config.dataset.transform_config.train,
+            transform_config_val=config.dataset.transform_config.val,
+            create_validation_set=config.dataset.create_validation_set,
+        )
+    elif config.dataset.format.lower() == "btech":
+        datamodule = BTechDataModule(
+            # TODO: Remove config values. IAAALD-211
+            root=config.dataset.path,
+            category=config.dataset.category,
+            image_size=(config.dataset.image_size[0], config.dataset.image_size[1]),
+            train_batch_size=config.dataset.train_batch_size,
+            test_batch_size=config.dataset.test_batch_size,
+            num_workers=config.dataset.num_workers,
+            seed=config.project.seed,
+            task=config.dataset.task,
+            transform_config_train=config.dataset.transform_config.train,
+            transform_config_val=config.dataset.transform_config.val,
+            create_validation_set=config.dataset.create_validation_set,
+        )
+    elif config.dataset.format.lower() == "folder":
+        datamodule = FolderDataModule(
+            root=config.dataset.path,
+            normal_dir=config.dataset.normal_dir,
+            abnormal_dir=config.dataset.abnormal_dir,
+            task=config.dataset.task,
+            normal_test_dir=config.dataset.normal_test_dir,
+            mask_dir=config.dataset.mask,
+            extensions=config.dataset.extensions,
+            split_ratio=config.dataset.split_ratio,
+            seed=config.dataset.seed,
+            image_size=(config.dataset.image_size[0], config.dataset.image_size[1]),
+            train_batch_size=config.dataset.train_batch_size,
+            test_batch_size=config.dataset.test_batch_size,
+            num_workers=config.dataset.num_workers,
+            transform_config_train=config.dataset.transform_config.train,
+            transform_config_val=config.dataset.transform_config.val,
+            create_validation_set=config.dataset.create_validation_set,
+        )
+    else:
+        raise ValueError(
+            "Unknown dataset! \n"
+            "If you use a custom dataset make sure you initialize it in"
+            "`get_datamodule` in `anomalib.data.__init__.py"
+        )
+
+    return datamodule
+
+
+__all__ = [
+    "get_datamodule",
+    "BTechDataModule",
+    "FolderDataModule",
+    "InferenceDataset",
+    "MVTecDataModule",
+]

anomalib/data/btech.py

@@ -0,0 +1,453 @@
+"""BTech Dataset.
+
+This script contains PyTorch Lightning DataModule for the BTech dataset.
+
+If the dataset is not on the file system, the script downloads and
+extracts the dataset and create PyTorch data objects.
+"""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+import logging
+import shutil
+import zipfile
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
+from urllib.request import urlretrieve
+
+import albumentations as A
+import cv2
+import numpy as np
+import pandas as pd
+from pandas.core.frame import DataFrame
+from pytorch_lightning.core.datamodule import LightningDataModule
+from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
+from torch import Tensor
+from torch.utils.data import DataLoader
+from torch.utils.data.dataset import Dataset
+from torchvision.datasets.folder import VisionDataset
+from tqdm import tqdm
+
+from anomalib.data.inference import InferenceDataset
+from anomalib.data.utils import DownloadProgressBar, read_image
+from anomalib.data.utils.split import (
+    create_validation_set_from_test_set,
+    split_normal_images_in_train_set,
+)
+from anomalib.pre_processing import PreProcessor
+
+logger = logging.getLogger(__name__)
+
+
+def make_btech_dataset(
+    path: Path,
+    split: Optional[str] = None,
+    split_ratio: float = 0.1,
+    seed: int = 0,
+    create_validation_set: bool = False,
+) -> DataFrame:
+    """Create BTech samples by parsing the BTech data file structure.
+
+    The files are expected to follow the structure:
+        path/to/dataset/split/category/image_filename.png
+        path/to/dataset/ground_truth/category/mask_filename.png
+
+    Args:
+        path (Path): Path to dataset
+        split (str, optional): Dataset split (ie., either train or test). Defaults to None.
+        split_ratio (float, optional): Ratio to split normal training images and add to the
+            test set in case test set doesn't contain any normal images.
+            Defaults to 0.1.
+        seed (int, optional): Random seed to ensure reproducibility when splitting. Defaults to 0.
+        create_validation_set (bool, optional): Boolean to create a validation set from the test set.
+            BTech dataset does not contain a validation set. Those wanting to create a validation set
+            could set this flag to ``True``.
+
+    Example:
+        The following example shows how to get training samples from BTech 01 category:
+
+        >>> root = Path('./BTech')
+        >>> category = '01'
+        >>> path = root / category
+        >>> path
+        PosixPath('BTech/01')
+
+        >>> samples = make_btech_dataset(path, split='train', split_ratio=0.1, seed=0)
+        >>> samples.head()
+           path     split label image_path                  mask_path                     label_index
+        0  BTech/01 train 01    BTech/01/train/ok/105.bmp BTech/01/ground_truth/ok/105.png      0
+        1  BTech/01 train 01    BTech/01/train/ok/017.bmp BTech/01/ground_truth/ok/017.png      0
+        ...
+
+    Returns:
+        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+    """
+    samples_list = [
+        (str(path),) + filename.parts[-3:] for filename in path.glob("**/*") if filename.suffix in (".bmp", ".png")
+    ]
+    if len(samples_list) == 0:
+        raise RuntimeError(f"Found 0 images in {path}")
+
+    samples = pd.DataFrame(samples_list, columns=["path", "split", "label", "image_path"])
+    samples = samples[samples.split != "ground_truth"]
+
+    # Create mask_path column
+    samples["mask_path"] = (
+        samples.path
+        + "/ground_truth/"
+        + samples.label
+        + "/"
+        + samples.image_path.str.rstrip("png").str.rstrip(".")
+        + ".png"
+    )
+
+    # Modify image_path column by converting to absolute path
+    samples["image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.image_path
+
+    # Split the normal images in training set if test set doesn't
+    # contain any normal images. This is needed because AUC score
+    # cannot be computed based on 1-class
+    if sum((samples.split == "test") & (samples.label == "ok")) == 0:
+        samples = split_normal_images_in_train_set(samples, split_ratio, seed)
+
+    # Good images don't have mask
+    samples.loc[(samples.split == "test") & (samples.label == "ok"), "mask_path"] = ""
+
+    # Create label index for normal (0) and anomalous (1) images.
+    samples.loc[(samples.label == "ok"), "label_index"] = 0
+    samples.loc[(samples.label != "ok"), "label_index"] = 1
+    samples.label_index = samples.label_index.astype(int)
+
+    if create_validation_set:
+        samples = create_validation_set_from_test_set(samples, seed=seed)
+
+    # Get the data frame for the split.
+    if split is not None and split in ["train", "val", "test"]:
+        samples = samples[samples.split == split]
+        samples = samples.reset_index(drop=True)
+
+    return samples
+
+
+class BTech(VisionDataset):
+    """BTech PyTorch Dataset."""
+
+    def __init__(
+        self,
+        root: Union[Path, str],
+        category: str,
+        pre_process: PreProcessor,
+        split: str,
+        task: str = "segmentation",
+        seed: int = 0,
+        create_validation_set: bool = False,
+    ) -> None:
+        """Btech Dataset class.
+
+        Args:
+            root: Path to the BTech dataset
+            category: Name of the BTech category.
+            pre_process: List of pre_processing object containing albumentation compose.
+            split: 'train', 'val' or 'test'
+            task: ``classification`` or ``segmentation``
+            seed: seed used for the random subset splitting
+            create_validation_set: Create a validation subset in addition to the train and test subsets
+
+        Examples:
+            >>> from anomalib.data.btech import BTech
+            >>> from anomalib.data.transforms import PreProcessor
+            >>> pre_process = PreProcessor(image_size=256)
+            >>> dataset = BTech(
+            ...     root='./datasets/BTech',
+            ...     category='leather',
+            ...     pre_process=pre_process,
+            ...     task="classification",
+            ...     is_train=True,
+            ... )
+            >>> dataset[0].keys()
+            dict_keys(['image'])
+
+            >>> dataset.split = "test"
+            >>> dataset[0].keys()
+            dict_keys(['image', 'image_path', 'label'])
+
+            >>> dataset.task = "segmentation"
+            >>> dataset.split = "train"
+            >>> dataset[0].keys()
+            dict_keys(['image'])
+
+            >>> dataset.split = "test"
+            >>> dataset[0].keys()
+            dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
+
+            >>> dataset[0]["image"].shape, dataset[0]["mask"].shape
+            (torch.Size([3, 256, 256]), torch.Size([256, 256]))
+        """
+        super().__init__(root)
+        self.root = Path(root) if isinstance(root, str) else root
+        self.category: str = category
+        self.split = split
+        self.task = task
+
+        self.pre_process = pre_process
+
+        self.samples = make_btech_dataset(
+            path=self.root / category,
+            split=self.split,
+            seed=seed,
+            create_validation_set=create_validation_set,
+        )
+
+    def __len__(self) -> int:
+        """Get length of the dataset."""
+        return len(self.samples)
+
+    def __getitem__(self, index: int) -> Dict[str, Union[str, Tensor]]:
+        """Get dataset item for the index ``index``.
+
+        Args:
+            index (int): Index to get the item.
+
+        Returns:
+            Union[Dict[str, Tensor], Dict[str, Union[str, Tensor]]]: Dict of image tensor during training.
+                Otherwise, Dict containing image path, target path, image tensor, label and transformed bounding box.
+        """
+        item: Dict[str, Union[str, Tensor]] = {}
+
+        image_path = self.samples.image_path[index]
+        image = read_image(image_path)
+
+        pre_processed = self.pre_process(image=image)
+        item = {"image": pre_processed["image"]}
+
+        if self.split in ["val", "test"]:
+            label_index = self.samples.label_index[index]
+
+            item["image_path"] = image_path
+            item["label"] = label_index
+
+            if self.task == "segmentation":
+                mask_path = self.samples.mask_path[index]
+
+                # Only Anomalous (1) images has masks in BTech dataset.
+                # Therefore, create empty mask for Normal (0) images.
+                if label_index == 0:
+                    mask = np.zeros(shape=image.shape[:2])
+                else:
+                    mask = cv2.imread(mask_path, flags=0) / 255.0
+
+                pre_processed = self.pre_process(image=image, mask=mask)
+
+                item["mask_path"] = mask_path
+                item["image"] = pre_processed["image"]
+                item["mask"] = pre_processed["mask"]
+
+        return item
+
+
+class BTechDataModule(LightningDataModule):
+    """BTechDataModule Lightning Data Module."""
+
+    def __init__(
+        self,
+        root: str,
+        category: str,
+        # TODO: Remove default values. IAAALD-211
+        image_size: Optional[Union[int, Tuple[int, int]]] = None,
+        train_batch_size: int = 32,
+        test_batch_size: int = 32,
+        num_workers: int = 8,
+        task: str = "segmentation",
+        transform_config_train: Optional[Union[str, A.Compose]] = None,
+        transform_config_val: Optional[Union[str, A.Compose]] = None,
+        seed: int = 0,
+        create_validation_set: bool = False,
+    ) -> None:
+        """Instantiate BTech Lightning Data Module.
+
+        Args:
+            root: Path to the BTech dataset
+            category: Name of the BTech category.
+            image_size: Variable to which image is resized.
+            train_batch_size: Training batch size.
+            test_batch_size: Testing batch size.
+            num_workers: Number of workers.
+            task: ``classification`` or ``segmentation``
+            transform_config_train: Config for pre-processing during training.
+            transform_config_val: Config for pre-processing during validation.
+            seed: seed used for the random subset splitting
+            create_validation_set: Create a validation subset in addition to the train and test subsets
+
+        Examples
+            >>> from anomalib.data import BTechDataModule
+            >>> datamodule = BTechDataModule(
+            ...     root="./datasets/BTech",
+            ...     category="leather",
+            ...     image_size=256,
+            ...     train_batch_size=32,
+            ...     test_batch_size=32,
+            ...     num_workers=8,
+            ...     transform_config_train=None,
+            ...     transform_config_val=None,
+            ... )
+            >>> datamodule.setup()
+
+            >>> i, data = next(enumerate(datamodule.train_dataloader()))
+            >>> data.keys()
+            dict_keys(['image'])
+            >>> data["image"].shape
+            torch.Size([32, 3, 256, 256])
+
+            >>> i, data = next(enumerate(datamodule.val_dataloader()))
+            >>> data.keys()
+            dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
+            >>> data["image"].shape, data["mask"].shape
+            (torch.Size([32, 3, 256, 256]), torch.Size([32, 256, 256]))
+        """
+        super().__init__()
+
+        self.root = root if isinstance(root, Path) else Path(root)
+        self.category = category
+        self.dataset_path = self.root / self.category
+        self.transform_config_train = transform_config_train
+        self.transform_config_val = transform_config_val
+        self.image_size = image_size
+
+        if self.transform_config_train is not None and self.transform_config_val is None:
+            self.transform_config_val = self.transform_config_train
+
+        self.pre_process_train = PreProcessor(config=self.transform_config_train, image_size=self.image_size)
+        self.pre_process_val = PreProcessor(config=self.transform_config_val, image_size=self.image_size)
+
+        self.train_batch_size = train_batch_size
+        self.test_batch_size = test_batch_size
+        self.num_workers = num_workers
+
+        self.create_validation_set = create_validation_set
+        self.task = task
+        self.seed = seed
+
+        self.train_data: Dataset
+        self.test_data: Dataset
+        if create_validation_set:
+            self.val_data: Dataset
+        self.inference_data: Dataset
+
+    def prepare_data(self) -> None:
+        """Download the dataset if not available."""
+        if (self.root / self.category).is_dir():
+            logger.info("Found the dataset.")
+        else:
+            zip_filename = self.root.parent / "btad.zip"
+
+            logger.info("Downloading the BTech dataset.")
+            with DownloadProgressBar(unit="B", unit_scale=True, miniters=1, desc="BTech") as progress_bar:
+                urlretrieve(
+                    url="https://avires.dimi.uniud.it/papers/btad/btad.zip",
+                    filename=zip_filename,
+                    reporthook=progress_bar.update_to,
+                )  # nosec
+
+            logger.info("Extracting the dataset.")
+            with zipfile.ZipFile(zip_filename, "r") as zip_file:
+                zip_file.extractall(self.root.parent)
+
+            logger.info("Renaming the dataset directory")
+            shutil.move(src=str(self.root.parent / "BTech_Dataset_transformed"), dst=str(self.root))
+
+            # NOTE: Each BTech category has different image extension as follows
+            #       | Category | Image | Mask |
+            #       |----------|-------|------|
+            #       | 01       | bmp   | png  |
+            #       | 02       | png   | png  |
+            #       | 03       | bmp   | bmp  |
+            # To avoid any conflict, the following script converts all the extensions to png.
+            # This solution works fine, but it's also possible to properly ready the bmp and
+            # png filenames from categories in `make_btech_dataset` function.
+            logger.info("Convert the bmp formats to png to have consistent image extensions")
+            for filename in tqdm(self.root.glob("**/*.bmp"), desc="Converting bmp to png"):
+                image = cv2.imread(str(filename))
+                cv2.imwrite(str(filename.with_suffix(".png")), image)
+                filename.unlink()
+
+            logger.info("Cleaning the tar file")
+            zip_filename.unlink()
+
+    def setup(self, stage: Optional[str] = None) -> None:
+        """Setup train, validation and test data.
+
+        BTech dataset uses BTech dataset structure, which is the reason for
+        using `anomalib.data.btech.BTech` class to get the dataset items.
+
+        Args:
+          stage: Optional[str]:  Train/Val/Test stages. (Default value = None)
+
+        """
+        logger.info("Setting up train, validation, test and prediction datasets.")
+        if stage in (None, "fit"):
+            self.train_data = BTech(
+                root=self.root,
+                category=self.category,
+                pre_process=self.pre_process_train,
+                split="train",
+                task=self.task,
+                seed=self.seed,
+                create_validation_set=self.create_validation_set,
+            )
+
+        if self.create_validation_set:
+            self.val_data = BTech(
+                root=self.root,
+                category=self.category,
+                pre_process=self.pre_process_val,
+                split="val",
+                task=self.task,
+                seed=self.seed,
+                create_validation_set=self.create_validation_set,
+            )
+
+        self.test_data = BTech(
+            root=self.root,
+            category=self.category,
+            pre_process=self.pre_process_val,
+            split="test",
+            task=self.task,
+            seed=self.seed,
+            create_validation_set=self.create_validation_set,
+        )
+
+        if stage == "predict":
+            self.inference_data = InferenceDataset(
+                path=self.root, image_size=self.image_size, transform_config=self.transform_config_val
+            )
+
+    def train_dataloader(self) -> TRAIN_DATALOADERS:
+        """Get train dataloader."""
+        return DataLoader(self.train_data, shuffle=True, batch_size=self.train_batch_size, num_workers=self.num_workers)
+
+    def val_dataloader(self) -> EVAL_DATALOADERS:
+        """Get validation dataloader."""
+        dataset = self.val_data if self.create_validation_set else self.test_data
+        return DataLoader(dataset=dataset, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers)
+
+    def test_dataloader(self) -> EVAL_DATALOADERS:
+        """Get test dataloader."""
+        return DataLoader(self.test_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers)
+
+    def predict_dataloader(self) -> EVAL_DATALOADERS:
+        """Get predict dataloader."""
+        return DataLoader(
+            self.inference_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers
+        )

anomalib/data/folder.py

@@ -0,0 +1,540 @@
+"""Custom Folder Dataset.
+
+This script creates a custom dataset from a folder.
+"""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+import logging
+import warnings
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
+
+import albumentations as A
+import cv2
+import numpy as np
+from pandas.core.frame import DataFrame
+from pytorch_lightning.core.datamodule import LightningDataModule
+from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
+from torch import Tensor
+from torch.utils.data import DataLoader, Dataset
+from torchvision.datasets.folder import IMG_EXTENSIONS
+
+from anomalib.data.inference import InferenceDataset
+from anomalib.data.utils import read_image
+from anomalib.data.utils.split import (
+    create_validation_set_from_test_set,
+    split_normal_images_in_train_set,
+)
+from anomalib.pre_processing import PreProcessor
+
+logger = logging.getLogger(__name__)
+
+
+def _check_and_convert_path(path: Union[str, Path]) -> Path:
+    """Check an input path, and convert to Pathlib object.
+
+    Args:
+        path (Union[str, Path]): Input path.
+
+    Returns:
+        Path: Output path converted to pathlib object.
+    """
+    if not isinstance(path, Path):
+        path = Path(path)
+    return path
+
+
+def _prepare_files_labels(
+    path: Union[str, Path], path_type: str, extensions: Optional[Tuple[str, ...]] = None
+) -> Tuple[list, list]:
+    """Return a list of filenames and list corresponding labels.
+
+    Args:
+        path (Union[str, Path]): Path to the directory containing images.
+        path_type (str): Type of images in the provided path ("normal", "abnormal", "normal_test")
+        extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the
+            directory.
+
+    Returns:
+        List, List: Filenames of the images provided in the paths, labels of the images provided in the paths
+    """
+    path = _check_and_convert_path(path)
+    if extensions is None:
+        extensions = IMG_EXTENSIONS
+
+    if isinstance(extensions, str):
+        extensions = (extensions,)
+
+    filenames = [f for f in path.glob(r"**/*") if f.suffix in extensions and not f.is_dir()]
+    if len(filenames) == 0:
+        raise RuntimeError(f"Found 0 {path_type} images in {path}")
+
+    labels = [path_type] * len(filenames)
+
+    return filenames, labels
+
+
+def make_dataset(
+    normal_dir: Union[str, Path],
+    abnormal_dir: Union[str, Path],
+    normal_test_dir: Optional[Union[str, Path]] = None,
+    mask_dir: Optional[Union[str, Path]] = None,
+    split: Optional[str] = None,
+    split_ratio: float = 0.2,
+    seed: int = 0,
+    create_validation_set: bool = True,
+    extensions: Optional[Tuple[str, ...]] = None,
+):
+    """Make Folder Dataset.
+
+    Args:
+        normal_dir (Union[str, Path]): Path to the directory containing normal images.
+        abnormal_dir (Union[str, Path]): Path to the directory containing abnormal images.
+        normal_test_dir (Optional[Union[str, Path]], optional): Path to the directory containing
+            normal images for the test dataset. Normal test images will be a split of `normal_dir`
+            if `None`. Defaults to None.
+        mask_dir (Optional[Union[str, Path]], optional): Path to the directory containing
+            the mask annotations. Defaults to None.
+        split (Optional[str], optional): Dataset split (ie., either train or test). Defaults to None.
+        split_ratio (float, optional): Ratio to split normal training images and add to the
+            test set in case test set doesn't contain any normal images.
+            Defaults to 0.2.
+        seed (int, optional): Random seed to ensure reproducibility when splitting. Defaults to 0.
+        create_validation_set (bool, optional):Boolean to create a validation set from the test set.
+            Those wanting to create a validation set could set this flag to ``True``.
+        extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the
+            directory.
+
+    Returns:
+        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+    """
+
+    filenames = []
+    labels = []
+    dirs = {"normal": normal_dir, "abnormal": abnormal_dir}
+
+    if normal_test_dir:
+        dirs = {**dirs, **{"normal_test": normal_test_dir}}
+
+    for dir_type, path in dirs.items():
+        filename, label = _prepare_files_labels(path, dir_type, extensions)
+        filenames += filename
+        labels += label
+
+    samples = DataFrame({"image_path": filenames, "label": labels})
+
+    # Create label index for normal (0) and abnormal (1) images.
+    samples.loc[(samples.label == "normal") | (samples.label == "normal_test"), "label_index"] = 0
+    samples.loc[(samples.label == "abnormal"), "label_index"] = 1
+    samples.label_index = samples.label_index.astype(int)
+
+    # If a path to mask is provided, add it to the sample dataframe.
+    if mask_dir is not None:
+        mask_dir = _check_and_convert_path(mask_dir)
+        samples["mask_path"] = ""
+        for index, row in samples.iterrows():
+            if row.label_index == 1:
+                samples.loc[index, "mask_path"] = str(mask_dir / row.image_path.name)
+
+    # Ensure the pathlib objects are converted to str.
+    # This is because torch dataloader doesn't like pathlib.
+    samples = samples.astype({"image_path": "str"})
+
+    # Create train/test split.
+    # By default, all the normal samples are assigned as train.
+    #   and all the abnormal samples are test.
+    samples.loc[(samples.label == "normal"), "split"] = "train"
+    samples.loc[(samples.label == "abnormal") | (samples.label == "normal_test"), "split"] = "test"
+
+    if not normal_test_dir:
+        samples = split_normal_images_in_train_set(
+            samples=samples, split_ratio=split_ratio, seed=seed, normal_label="normal"
+        )
+
+    # If `create_validation_set` is set to True, the test set is split into half.
+    if create_validation_set:
+        samples = create_validation_set_from_test_set(samples, seed=seed, normal_label="normal")
+
+    # Get the data frame for the split.
+    if split is not None and split in ["train", "val", "test"]:
+        samples = samples[samples.split == split]
+        samples = samples.reset_index(drop=True)
+
+    return samples
+
+
+class FolderDataset(Dataset):
+    """Folder Dataset."""
+
+    def __init__(
+        self,
+        normal_dir: Union[Path, str],
+        abnormal_dir: Union[Path, str],
+        split: str,
+        pre_process: PreProcessor,
+        normal_test_dir: Optional[Union[Path, str]] = None,
+        split_ratio: float = 0.2,
+        mask_dir: Optional[Union[Path, str]] = None,
+        extensions: Optional[Tuple[str, ...]] = None,
+        task: Optional[str] = None,
+        seed: int = 0,
+        create_validation_set: bool = False,
+    ) -> None:
+        """Create Folder Folder Dataset.
+
+        Args:
+            normal_dir (Union[str, Path]): Path to the directory containing normal images.
+            abnormal_dir (Union[str, Path]): Path to the directory containing abnormal images.
+            split (Optional[str], optional): Dataset split (ie., either train or test). Defaults to None.
+            pre_process (Optional[PreProcessor], optional): Image Pro-processor to apply transform.
+                Defaults to None.
+            normal_test_dir (Optional[Union[str, Path]], optional): Path to the directory containing
+                normal images for the test dataset. Defaults to None.
+            split_ratio (float, optional): Ratio to split normal training images and add to the
+                test set in case test set doesn't contain any normal images.
+                Defaults to 0.2.
+            mask_dir (Optional[Union[str, Path]], optional): Path to the directory containing
+                the mask annotations. Defaults to None.
+            extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the
+                directory.
+            task (Optional[str], optional): Task type. (classification or segmentation) Defaults to None.
+            seed (int, optional): Random seed to ensure reproducibility when splitting. Defaults to 0.
+            create_validation_set (bool, optional):Boolean to create a validation set from the test set.
+                Those wanting to create a validation set could set this flag to ``True``.
+
+        Raises:
+            ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is
+                provided, `task` should be set to `segmentation`.
+
+        """
+        self.split = split
+
+        if task == "segmentation" and mask_dir is None:
+            warnings.warn(
+                "Segmentation task is requested, but mask directory is not provided. "
+                "Classification is to be chosen if mask directory is not provided."
+            )
+            self.task = "classification"
+
+        if task == "classification" and mask_dir:
+            warnings.warn(
+                "Classification task is requested, but mask directory is provided. "
+                "Segmentation task is to be chosen if mask directory is provided."
+            )
+            self.task = "segmentation"
+
+        if task is None or mask_dir is None:
+            self.task = "classification"
+        else:
+            self.task = task
+
+        self.pre_process = pre_process
+        self.samples = make_dataset(
+            normal_dir=normal_dir,
+            abnormal_dir=abnormal_dir,
+            normal_test_dir=normal_test_dir,
+            mask_dir=mask_dir,
+            split=split,
+            split_ratio=split_ratio,
+            seed=seed,
+            create_validation_set=create_validation_set,
+            extensions=extensions,
+        )
+
+    def __len__(self) -> int:
+        """Get length of the dataset."""
+        return len(self.samples)
+
+    def __getitem__(self, index: int) -> Dict[str, Union[str, Tensor]]:
+        """Get dataset item for the index ``index``.
+
+        Args:
+            index (int): Index to get the item.
+
+        Returns:
+            Union[Dict[str, Tensor], Dict[str, Union[str, Tensor]]]: Dict of image tensor during training.
+                Otherwise, Dict containing image path, target path, image tensor, label and transformed bounding box.
+        """
+        item: Dict[str, Union[str, Tensor]] = {}
+
+        image_path = self.samples.image_path[index]
+        image = read_image(image_path)
+
+        pre_processed = self.pre_process(image=image)
+        item = {"image": pre_processed["image"]}
+
+        if self.split in ["val", "test"]:
+            label_index = self.samples.label_index[index]
+
+            item["image_path"] = image_path
+            item["label"] = label_index
+
+            if self.task == "segmentation":
+                mask_path = self.samples.mask_path[index]
+
+                # Only Anomalous (1) images has masks in MVTec AD dataset.
+                # Therefore, create empty mask for Normal (0) images.
+                if label_index == 0:
+                    mask = np.zeros(shape=image.shape[:2])
+                else:
+                    mask = cv2.imread(mask_path, flags=0) / 255.0
+
+                pre_processed = self.pre_process(image=image, mask=mask)
+
+                item["mask_path"] = mask_path
+                item["image"] = pre_processed["image"]
+                item["mask"] = pre_processed["mask"]
+
+        return item
+
+
+class FolderDataModule(LightningDataModule):
+    """Folder Lightning Data Module."""
+
+    def __init__(
+        self,
+        root: Union[str, Path],
+        normal_dir: str = "normal",
+        abnormal_dir: str = "abnormal",
+        task: str = "classification",
+        normal_test_dir: Optional[Union[Path, str]] = None,
+        mask_dir: Optional[Union[Path, str]] = None,
+        extensions: Optional[Tuple[str, ...]] = None,
+        split_ratio: float = 0.2,
+        seed: int = 0,
+        image_size: Optional[Union[int, Tuple[int, int]]] = None,
+        train_batch_size: int = 32,
+        test_batch_size: int = 32,
+        num_workers: int = 8,
+        transform_config_train: Optional[Union[str, A.Compose]] = None,
+        transform_config_val: Optional[Union[str, A.Compose]] = None,
+        create_validation_set: bool = False,
+    ) -> None:
+        """Folder Dataset PL Datamodule.
+
+        Args:
+            root (Union[str, Path]): Path to the root folder containing normal and abnormal dirs.
+            normal_dir (str, optional): Name of the directory containing normal images.
+                Defaults to "normal".
+            abnormal_dir (str, optional): Name of the directory containing abnormal images.
+                Defaults to "abnormal".
+            task (str, optional): Task type. Could be either classification or segmentation.
+                Defaults to "classification".
+            normal_test_dir (Optional[Union[str, Path]], optional): Path to the directory containing
+                normal images for the test dataset. Defaults to None.
+            mask_dir (Optional[Union[str, Path]], optional): Path to the directory containing
+                the mask annotations. Defaults to None.
+            extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the
+                directory. Defaults to None.
+            split_ratio (float, optional): Ratio to split normal training images and add to the
+                test set in case test set doesn't contain any normal images.
+                Defaults to 0.2.
+            seed (int, optional): Random seed to ensure reproducibility when splitting. Defaults to 0.
+            image_size (Optional[Union[int, Tuple[int, int]]], optional): Size of the input image.
+                Defaults to None.
+            train_batch_size (int, optional): Training batch size. Defaults to 32.
+            test_batch_size (int, optional): Test batch size. Defaults to 32.
+            num_workers (int, optional): Number of workers. Defaults to 8.
+            transform_config_train (Optional[Union[str, A.Compose]], optional): Config for pre-processing
+                during training.
+                Defaults to None.
+            transform_config_val (Optional[Union[str, A.Compose]], optional): Config for pre-processing
+                during validation.
+                Defaults to None.
+            create_validation_set (bool, optional):Boolean to create a validation set from the test set.
+                Those wanting to create a validation set could set this flag to ``True``.
+
+        Examples:
+            Assume that we use Folder Dataset for the MVTec/bottle/broken_large category. We would do:
+            >>> from anomalib.data import FolderDataModule
+            >>> datamodule = FolderDataModule(
+            ...     root="./datasets/MVTec/bottle/test",
+            ...     normal="good",
+            ...     abnormal="broken_large",
+            ...     image_size=256
+            ... )
+            >>> datamodule.setup()
+            >>> i, data = next(enumerate(datamodule.train_dataloader()))
+            >>> data["image"].shape
+            torch.Size([16, 3, 256, 256])
+
+            >>> i, test_data = next(enumerate(datamodule.test_dataloader()))
+            >>> test_data.keys()
+            dict_keys(['image'])
+
+            We could also create a Folder DataModule for datasets containing mask annotations.
+            The dataset expects that mask annotation filenames must be same as the original filename.
+            To this end, we modified mask filenames in MVTec AD bottle category.
+            Now we could try folder data module using the mvtec bottle broken large category
+            >>> datamodule = FolderDataModule(
+            ...     root="./datasets/bottle/test",
+            ...     normal="good",
+            ...     abnormal="broken_large",
+            ...     mask_dir="./datasets/bottle/ground_truth/broken_large",
+            ...     image_size=256
+            ... )
+
+            >>> i , train_data = next(enumerate(datamodule.train_dataloader()))
+            >>> train_data.keys()
+            dict_keys(['image'])
+            >>> train_data["image"].shape
+            torch.Size([16, 3, 256, 256])
+
+            >>> i, test_data = next(enumerate(datamodule.test_dataloader()))
+            dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
+            >>> print(test_data["image"].shape, test_data["mask"].shape)
+            torch.Size([24, 3, 256, 256]) torch.Size([24, 256, 256])
+
+            By default, Folder Data Module does not create a validation set. If a validation set
+            is needed it could be set as follows:
+
+            >>> datamodule = FolderDataModule(
+            ...     root="./datasets/bottle/test",
+            ...     normal="good",
+            ...     abnormal="broken_large",
+            ...     mask_dir="./datasets/bottle/ground_truth/broken_large",
+            ...     image_size=256,
+            ...     create_validation_set=True,
+            ... )
+
+            >>> i, val_data = next(enumerate(datamodule.val_dataloader()))
+            >>> val_data.keys()
+            dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
+            >>> print(val_data["image"].shape, val_data["mask"].shape)
+            torch.Size([12, 3, 256, 256]) torch.Size([12, 256, 256])
+
+            >>> i, test_data = next(enumerate(datamodule.test_dataloader()))
+            >>> print(test_data["image"].shape, test_data["mask"].shape)
+            torch.Size([12, 3, 256, 256]) torch.Size([12, 256, 256])
+
+        """
+        super().__init__()
+
+        self.root = _check_and_convert_path(root)
+        self.normal_dir = self.root / normal_dir
+        self.abnormal_dir = self.root / abnormal_dir
+        self.normal_test = normal_test_dir
+        if normal_test_dir:
+            self.normal_test = self.root / normal_test_dir
+        self.mask_dir = mask_dir
+        self.extensions = extensions
+        self.split_ratio = split_ratio
+
+        if task == "classification" and mask_dir is not None:
+            raise ValueError(
+                "Classification type is set but mask_dir provided. "
+                "If mask_dir is provided task type must be segmentation. "
+                "Check your configuration."
+            )
+        self.task = task
+        self.transform_config_train = transform_config_train
+        self.transform_config_val = transform_config_val
+        self.image_size = image_size
+
+        if self.transform_config_train is not None and self.transform_config_val is None:
+            self.transform_config_val = self.transform_config_train
+
+        self.pre_process_train = PreProcessor(config=self.transform_config_train, image_size=self.image_size)
+        self.pre_process_val = PreProcessor(config=self.transform_config_val, image_size=self.image_size)
+
+        self.train_batch_size = train_batch_size
+        self.test_batch_size = test_batch_size
+        self.num_workers = num_workers
+
+        self.create_validation_set = create_validation_set
+        self.seed = seed
+
+        self.train_data: Dataset
+        self.test_data: Dataset
+        if create_validation_set:
+            self.val_data: Dataset
+        self.inference_data: Dataset
+
+    def setup(self, stage: Optional[str] = None) -> None:
+        """Setup train, validation and test data.
+
+        Args:
+          stage: Optional[str]:  Train/Val/Test stages. (Default value = None)
+
+        """
+        logger.info("Setting up train, validation, test and prediction datasets.")
+        if stage in (None, "fit"):
+            self.train_data = FolderDataset(
+                normal_dir=self.normal_dir,
+                abnormal_dir=self.abnormal_dir,
+                normal_test_dir=self.normal_test,
+                split="train",
+                split_ratio=self.split_ratio,
+                mask_dir=self.mask_dir,
+                pre_process=self.pre_process_train,
+                extensions=self.extensions,
+                task=self.task,
+                seed=self.seed,
+                create_validation_set=self.create_validation_set,
+            )
+
+        if self.create_validation_set:
+            self.val_data = FolderDataset(
+                normal_dir=self.normal_dir,
+                abnormal_dir=self.abnormal_dir,
+                normal_test_dir=self.normal_test,
+                split="val",
+                split_ratio=self.split_ratio,
+                mask_dir=self.mask_dir,
+                pre_process=self.pre_process_val,
+                extensions=self.extensions,
+                task=self.task,
+                seed=self.seed,
+                create_validation_set=self.create_validation_set,
+            )
+
+        self.test_data = FolderDataset(
+            normal_dir=self.normal_dir,
+            abnormal_dir=self.abnormal_dir,
+            split="test",
+            normal_test_dir=self.normal_test,
+            split_ratio=self.split_ratio,
+            mask_dir=self.mask_dir,
+            pre_process=self.pre_process_val,
+            extensions=self.extensions,
+            task=self.task,
+            seed=self.seed,
+            create_validation_set=self.create_validation_set,
+        )
+
+        if stage == "predict":
+            self.inference_data = InferenceDataset(
+                path=self.root, image_size=self.image_size, transform_config=self.transform_config_val
+            )
+
+    def train_dataloader(self) -> TRAIN_DATALOADERS:
+        """Get train dataloader."""
+        return DataLoader(self.train_data, shuffle=True, batch_size=self.train_batch_size, num_workers=self.num_workers)
+
+    def val_dataloader(self) -> EVAL_DATALOADERS:
+        """Get validation dataloader."""
+        dataset = self.val_data if self.create_validation_set else self.test_data
+        return DataLoader(dataset=dataset, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers)
+
+    def test_dataloader(self) -> EVAL_DATALOADERS:
+        """Get test dataloader."""
+        return DataLoader(self.test_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers)
+
+    def predict_dataloader(self) -> EVAL_DATALOADERS:
+        """Get predict dataloader."""
+        return DataLoader(
+            self.inference_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers
+        )

anomalib/data/inference.py

@@ -0,0 +1,67 @@
+"""Inference Dataset."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from pathlib import Path
+from typing import Any, Optional, Tuple, Union
+
+import albumentations as A
+from torch.utils.data.dataset import Dataset
+
+from anomalib.data.utils import get_image_filenames, read_image
+from anomalib.pre_processing import PreProcessor
+
+
+class InferenceDataset(Dataset):
+    """Inference Dataset to perform prediction."""
+
+    def __init__(
+        self,
+        path: Union[str, Path],
+        pre_process: Optional[PreProcessor] = None,
+        image_size: Optional[Union[int, Tuple[int, int]]] = None,
+        transform_config: Optional[Union[str, A.Compose]] = None,
+    ) -> None:
+        """Inference Dataset to perform prediction.
+
+        Args:
+            path (Union[str, Path]): Path to an image or image-folder.
+            pre_process (Optional[PreProcessor], optional): Pre-Processing transforms to
+                pre-process the input dataset. Defaults to None.
+            image_size (Optional[Union[int, Tuple[int, int]]], optional): Target image size
+                to resize the original image. Defaults to None.
+            transform_config (Optional[Union[str, A.Compose]], optional): Configuration file
+                parse the albumentation transforms. Defaults to None.
+        """
+        super().__init__()
+
+        self.image_filenames = get_image_filenames(path)
+
+        if pre_process is None:
+            self.pre_process = PreProcessor(transform_config, image_size)
+        else:
+            self.pre_process = pre_process
+
+    def __len__(self) -> int:
+        """Get the number of images in the given path."""
+        return len(self.image_filenames)
+
+    def __getitem__(self, index: int) -> Any:
+        """Get the image based on the `index`."""
+        image_filename = self.image_filenames[index]
+        image = read_image(path=image_filename)
+        pre_processed = self.pre_process(image=image)
+
+        return pre_processed

anomalib/data/mvtec.py

@@ -0,0 +1,457 @@
+"""MVTec AD Dataset (CC BY-NC-SA 4.0).
+
+Description:
+    This script contains PyTorch Dataset, Dataloader and PyTorch
+        Lightning DataModule for the MVTec AD dataset.
+
+    If the dataset is not on the file system, the script downloads and
+        extracts the dataset and create PyTorch data objects.
+
+License:
+    MVTec AD dataset is released under the Creative Commons
+    Attribution-NonCommercial-ShareAlike 4.0 International License
+    (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/).
+
+Reference:
+    - Paul Bergmann, Kilian Batzner, Michael Fauser, David Sattlegger, Carsten Steger:
+      The MVTec Anomaly Detection Dataset: A Comprehensive Real-World Dataset for
+      Unsupervised Anomaly Detection; in: International Journal of Computer Vision
+      129(4):1038-1059, 2021, DOI: 10.1007/s11263-020-01400-4.
+
+    - Paul Bergmann, Michael Fauser, David Sattlegger, Carsten Steger: MVTec AD —
+      A Comprehensive Real-World Dataset for Unsupervised Anomaly Detection;
+      in: IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR),
+      9584-9592, 2019, DOI: 10.1109/CVPR.2019.00982.
+"""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+import logging
+import tarfile
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
+from urllib.request import urlretrieve
+
+import albumentations as A
+import cv2
+import numpy as np
+import pandas as pd
+from pandas.core.frame import DataFrame
+from pytorch_lightning.core.datamodule import LightningDataModule
+from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
+from torch import Tensor
+from torch.utils.data import DataLoader
+from torch.utils.data.dataset import Dataset
+from torchvision.datasets.folder import VisionDataset
+
+from anomalib.data.inference import InferenceDataset
+from anomalib.data.utils import DownloadProgressBar, read_image
+from anomalib.data.utils.split import (
+    create_validation_set_from_test_set,
+    split_normal_images_in_train_set,
+)
+from anomalib.pre_processing import PreProcessor
+
+logger = logging.getLogger(__name__)
+
+
+def make_mvtec_dataset(
+    path: Path,
+    split: Optional[str] = None,
+    split_ratio: float = 0.1,
+    seed: int = 0,
+    create_validation_set: bool = False,
+) -> DataFrame:
+    """Create MVTec AD samples by parsing the MVTec AD data file structure.
+
+    The files are expected to follow the structure:
+        path/to/dataset/split/category/image_filename.png
+        path/to/dataset/ground_truth/category/mask_filename.png
+
+    This function creates a dataframe to store the parsed information based on the following format:
+    |---|---------------|-------|---------|---------------|---------------------------------------|-------------|
+    |   | path          | split | label   | image_path    | mask_path                             | label_index |
+    |---|---------------|-------|---------|---------------|---------------------------------------|-------------|
+    | 0 | datasets/name |  test |  defect |  filename.png | ground_truth/defect/filename_mask.png | 1           |
+    |---|---------------|-------|---------|---------------|---------------------------------------|-------------|
+
+    Args:
+        path (Path): Path to dataset
+        split (str, optional): Dataset split (ie., either train or test). Defaults to None.
+        split_ratio (float, optional): Ratio to split normal training images and add to the
+            test set in case test set doesn't contain any normal images.
+            Defaults to 0.1.
+        seed (int, optional): Random seed to ensure reproducibility when splitting. Defaults to 0.
+        create_validation_set (bool, optional): Boolean to create a validation set from the test set.
+            MVTec AD dataset does not contain a validation set. Those wanting to create a validation set
+            could set this flag to ``True``.
+
+    Example:
+        The following example shows how to get training samples from MVTec AD bottle category:
+
+        >>> root = Path('./MVTec')
+        >>> category = 'bottle'
+        >>> path = root / category
+        >>> path
+        PosixPath('MVTec/bottle')
+
+        >>> samples = make_mvtec_dataset(path, split='train', split_ratio=0.1, seed=0)
+        >>> samples.head()
+           path         split label image_path                           mask_path                   label_index
+        0  MVTec/bottle train good MVTec/bottle/train/good/105.png MVTec/bottle/ground_truth/good/105_mask.png 0
+        1  MVTec/bottle train good MVTec/bottle/train/good/017.png MVTec/bottle/ground_truth/good/017_mask.png 0
+        2  MVTec/bottle train good MVTec/bottle/train/good/137.png MVTec/bottle/ground_truth/good/137_mask.png 0
+        3  MVTec/bottle train good MVTec/bottle/train/good/152.png MVTec/bottle/ground_truth/good/152_mask.png 0
+        4  MVTec/bottle train good MVTec/bottle/train/good/109.png MVTec/bottle/ground_truth/good/109_mask.png 0
+
+    Returns:
+        DataFrame: an output dataframe containing samples for the requested split (ie., train or test)
+    """
+    samples_list = [(str(path),) + filename.parts[-3:] for filename in path.glob("**/*.png")]
+    if len(samples_list) == 0:
+        raise RuntimeError(f"Found 0 images in {path}")
+
+    samples = pd.DataFrame(samples_list, columns=["path", "split", "label", "image_path"])
+    samples = samples[samples.split != "ground_truth"]
+
+    # Create mask_path column
+    samples["mask_path"] = (
+        samples.path
+        + "/ground_truth/"
+        + samples.label
+        + "/"
+        + samples.image_path.str.rstrip("png").str.rstrip(".")
+        + "_mask.png"
+    )
+
+    # Modify image_path column by converting to absolute path
+    samples["image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.image_path
+
+    # Split the normal images in training set if test set doesn't
+    # contain any normal images. This is needed because AUC score
+    # cannot be computed based on 1-class
+    if sum((samples.split == "test") & (samples.label == "good")) == 0:
+        samples = split_normal_images_in_train_set(samples, split_ratio, seed)
+
+    # Good images don't have mask
+    samples.loc[(samples.split == "test") & (samples.label == "good"), "mask_path"] = ""
+
+    # Create label index for normal (0) and anomalous (1) images.
+    samples.loc[(samples.label == "good"), "label_index"] = 0
+    samples.loc[(samples.label != "good"), "label_index"] = 1
+    samples.label_index = samples.label_index.astype(int)
+
+    if create_validation_set:
+        samples = create_validation_set_from_test_set(samples, seed=seed)
+
+    # Get the data frame for the split.
+    if split is not None and split in ["train", "val", "test"]:
+        samples = samples[samples.split == split]
+        samples = samples.reset_index(drop=True)
+
+    return samples
+
+
+class MVTec(VisionDataset):
+    """MVTec AD PyTorch Dataset."""
+
+    def __init__(
+        self,
+        root: Union[Path, str],
+        category: str,
+        pre_process: PreProcessor,
+        split: str,
+        task: str = "segmentation",
+        seed: int = 0,
+        create_validation_set: bool = False,
+    ) -> None:
+        """Mvtec AD Dataset class.
+
+        Args:
+            root: Path to the MVTec AD dataset
+            category: Name of the MVTec AD category.
+            pre_process: List of pre_processing object containing albumentation compose.
+            split: 'train', 'val' or 'test'
+            task: ``classification`` or ``segmentation``
+            seed: seed used for the random subset splitting
+            create_validation_set: Create a validation subset in addition to the train and test subsets
+
+        Examples:
+            >>> from anomalib.data.mvtec import MVTec
+            >>> from anomalib.data.transforms import PreProcessor
+            >>> pre_process = PreProcessor(image_size=256)
+            >>> dataset = MVTec(
+            ...     root='./datasets/MVTec',
+            ...     category='leather',
+            ...     pre_process=pre_process,
+            ...     task="classification",
+            ...     is_train=True,
+            ... )
+            >>> dataset[0].keys()
+            dict_keys(['image'])
+
+            >>> dataset.split = "test"
+            >>> dataset[0].keys()
+            dict_keys(['image', 'image_path', 'label'])
+
+            >>> dataset.task = "segmentation"
+            >>> dataset.split = "train"
+            >>> dataset[0].keys()
+            dict_keys(['image'])
+
+            >>> dataset.split = "test"
+            >>> dataset[0].keys()
+            dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
+
+            >>> dataset[0]["image"].shape, dataset[0]["mask"].shape
+            (torch.Size([3, 256, 256]), torch.Size([256, 256]))
+        """
+        super().__init__(root)
+        self.root = Path(root) if isinstance(root, str) else root
+        self.category: str = category
+        self.split = split
+        self.task = task
+
+        self.pre_process = pre_process
+
+        self.samples = make_mvtec_dataset(
+            path=self.root / category,
+            split=self.split,
+            seed=seed,
+            create_validation_set=create_validation_set,
+        )
+
+    def __len__(self) -> int:
+        """Get length of the dataset."""
+        return len(self.samples)
+
+    def __getitem__(self, index: int) -> Dict[str, Union[str, Tensor]]:
+        """Get dataset item for the index ``index``.
+
+        Args:
+            index (int): Index to get the item.
+
+        Returns:
+            Union[Dict[str, Tensor], Dict[str, Union[str, Tensor]]]: Dict of image tensor during training.
+                Otherwise, Dict containing image path, target path, image tensor, label and transformed bounding box.
+        """
+        item: Dict[str, Union[str, Tensor]] = {}
+
+        image_path = self.samples.image_path[index]
+        image = read_image(image_path)
+
+        pre_processed = self.pre_process(image=image)
+        item = {"image": pre_processed["image"]}
+
+        if self.split in ["val", "test"]:
+            label_index = self.samples.label_index[index]
+
+            item["image_path"] = image_path
+            item["label"] = label_index
+
+            if self.task == "segmentation":
+                mask_path = self.samples.mask_path[index]
+
+                # Only Anomalous (1) images has masks in MVTec AD dataset.
+                # Therefore, create empty mask for Normal (0) images.
+                if label_index == 0:
+                    mask = np.zeros(shape=image.shape[:2])
+                else:
+                    mask = cv2.imread(mask_path, flags=0) / 255.0
+
+                pre_processed = self.pre_process(image=image, mask=mask)
+
+                item["mask_path"] = mask_path
+                item["image"] = pre_processed["image"]
+                item["mask"] = pre_processed["mask"]
+
+        return item
+
+
+class MVTecDataModule(LightningDataModule):
+    """MVTec AD Lightning Data Module."""
+
+    def __init__(
+        self,
+        root: str,
+        category: str,
+        # TODO: Remove default values. IAAALD-211
+        image_size: Optional[Union[int, Tuple[int, int]]] = None,
+        train_batch_size: int = 32,
+        test_batch_size: int = 32,
+        num_workers: int = 8,
+        task: str = "segmentation",
+        transform_config_train: Optional[Union[str, A.Compose]] = None,
+        transform_config_val: Optional[Union[str, A.Compose]] = None,
+        seed: int = 0,
+        create_validation_set: bool = False,
+    ) -> None:
+        """Mvtec AD Lightning Data Module.
+
+        Args:
+            root: Path to the MVTec AD dataset
+            category: Name of the MVTec AD category.
+            image_size: Variable to which image is resized.
+            train_batch_size: Training batch size.
+            test_batch_size: Testing batch size.
+            num_workers: Number of workers.
+            task: ``classification`` or ``segmentation``
+            transform_config_train: Config for pre-processing during training.
+            transform_config_val: Config for pre-processing during validation.
+            seed: seed used for the random subset splitting
+            create_validation_set: Create a validation subset in addition to the train and test subsets
+
+        Examples
+            >>> from anomalib.data import MVTecDataModule
+            >>> datamodule = MVTecDataModule(
+            ...     root="./datasets/MVTec",
+            ...     category="leather",
+            ...     image_size=256,
+            ...     train_batch_size=32,
+            ...     test_batch_size=32,
+            ...     num_workers=8,
+            ...     transform_config_train=None,
+            ...     transform_config_val=None,
+            ... )
+            >>> datamodule.setup()
+
+            >>> i, data = next(enumerate(datamodule.train_dataloader()))
+            >>> data.keys()
+            dict_keys(['image'])
+            >>> data["image"].shape
+            torch.Size([32, 3, 256, 256])
+
+            >>> i, data = next(enumerate(datamodule.val_dataloader()))
+            >>> data.keys()
+            dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask'])
+            >>> data["image"].shape, data["mask"].shape
+            (torch.Size([32, 3, 256, 256]), torch.Size([32, 256, 256]))
+        """
+        super().__init__()
+
+        self.root = root if isinstance(root, Path) else Path(root)
+        self.category = category
+        self.dataset_path = self.root / self.category
+        self.transform_config_train = transform_config_train
+        self.transform_config_val = transform_config_val
+        self.image_size = image_size
+
+        if self.transform_config_train is not None and self.transform_config_val is None:
+            self.transform_config_val = self.transform_config_train
+
+        self.pre_process_train = PreProcessor(config=self.transform_config_train, image_size=self.image_size)
+        self.pre_process_val = PreProcessor(config=self.transform_config_val, image_size=self.image_size)
+
+        self.train_batch_size = train_batch_size
+        self.test_batch_size = test_batch_size
+        self.num_workers = num_workers
+
+        self.create_validation_set = create_validation_set
+        self.task = task
+        self.seed = seed
+
+        self.train_data: Dataset
+        self.test_data: Dataset
+        if create_validation_set:
+            self.val_data: Dataset
+        self.inference_data: Dataset
+
+    def prepare_data(self) -> None:
+        """Download the dataset if not available."""
+        if (self.root / self.category).is_dir():
+            logger.info("Found the dataset.")
+        else:
+            self.root.mkdir(parents=True, exist_ok=True)
+
+            logger.info("Downloading the Mvtec AD dataset.")
+            url = "https://www.mydrive.ch/shares/38536/3830184030e49fe74747669442f0f282/download/420938113-1629952094"
+            dataset_name = "mvtec_anomaly_detection.tar.xz"
+            with DownloadProgressBar(unit="B", unit_scale=True, miniters=1, desc="MVTec AD") as progress_bar:
+                urlretrieve(
+                    url=f"{url}/{dataset_name}",
+                    filename=self.root / dataset_name,
+                    reporthook=progress_bar.update_to,
+                )
+
+            logger.info("Extracting the dataset.")
+            with tarfile.open(self.root / dataset_name) as tar_file:
+                tar_file.extractall(self.root)
+
+            logger.info("Cleaning the tar file")
+            (self.root / dataset_name).unlink()
+
+    def setup(self, stage: Optional[str] = None) -> None:
+        """Setup train, validation and test data.
+
+        Args:
+          stage: Optional[str]:  Train/Val/Test stages. (Default value = None)
+
+        """
+        logger.info("Setting up train, validation, test and prediction datasets.")
+        if stage in (None, "fit"):
+            self.train_data = MVTec(
+                root=self.root,
+                category=self.category,
+                pre_process=self.pre_process_train,
+                split="train",
+                task=self.task,
+                seed=self.seed,
+                create_validation_set=self.create_validation_set,
+            )
+
+        if self.create_validation_set:
+            self.val_data = MVTec(
+                root=self.root,
+                category=self.category,
+                pre_process=self.pre_process_val,
+                split="val",
+                task=self.task,
+                seed=self.seed,
+                create_validation_set=self.create_validation_set,
+            )
+
+        self.test_data = MVTec(
+            root=self.root,
+            category=self.category,
+            pre_process=self.pre_process_val,
+            split="test",
+            task=self.task,
+            seed=self.seed,
+            create_validation_set=self.create_validation_set,
+        )
+
+        if stage == "predict":
+            self.inference_data = InferenceDataset(
+                path=self.root, image_size=self.image_size, transform_config=self.transform_config_val
+            )
+
+    def train_dataloader(self) -> TRAIN_DATALOADERS:
+        """Get train dataloader."""
+        return DataLoader(self.train_data, shuffle=True, batch_size=self.train_batch_size, num_workers=self.num_workers)
+
+    def val_dataloader(self) -> EVAL_DATALOADERS:
+        """Get validation dataloader."""
+        dataset = self.val_data if self.create_validation_set else self.test_data
+        return DataLoader(dataset=dataset, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers)
+
+    def test_dataloader(self) -> EVAL_DATALOADERS:
+        """Get test dataloader."""
+        return DataLoader(self.test_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers)
+
+    def predict_dataloader(self) -> EVAL_DATALOADERS:
+        """Get predict dataloader."""
+        return DataLoader(
+            self.inference_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers
+        )

anomalib/data/utils/__init__.py

@@ -0,0 +1,20 @@
+"""Helper utilities for data."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from .download import DownloadProgressBar
+from .image import get_image_filenames, read_image
+
+__all__ = ["get_image_filenames", "read_image", "DownloadProgressBar"]

anomalib/data/utils/download.py

@@ -0,0 +1,195 @@
+"""Helper to show progress bars with `urlretrieve`.
+
+Based on https://stackoverflow.com/a/53877507
+"""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+import io
+from typing import Dict, Iterable, Optional, Union
+
+from tqdm import tqdm
+
+
+class DownloadProgressBar(tqdm):
+    """Create progress bar for urlretrieve. Subclasses `tqdm`.
+
+    For information about the parameters in constructor, refer to `tqdm`'s documentation.
+
+    Args:
+        iterable (Optional[Iterable]): Iterable to decorate with a progressbar.
+                            Leave blank to manually manage the updates.
+        desc (Optional[str]): Prefix for the progressbar.
+        total (Optional[Union[int, float]]): The number of expected iterations. If unspecified,
+                                            len(iterable) is used if possible. If float("inf") or as a last
+                                            resort, only basic progress statistics are displayed
+                                            (no ETA, no progressbar).
+                                            If `gui` is True and this parameter needs subsequent updating,
+                                            specify an initial arbitrary large positive number,
+                                            e.g. 9e9.
+        leave (Optional[bool]): upon termination of iteration. If `None`, will leave only if `position` is `0`.
+        file (Optional[Union[io.TextIOWrapper, io.StringIO]]): Specifies where to output the progress messages
+                                                            (default: sys.stderr). Uses `file.write(str)` and
+                                                            `file.flush()` methods.  For encoding, see
+                                                            `write_bytes`.
+        ncols (Optional[int]): The width of the entire output message. If specified,
+                            dynamically resizes the progressbar to stay within this bound.
+                            If unspecified, attempts to use environment width. The
+                            fallback is a meter width of 10 and no limit for the counter and
+                            statistics. If 0, will not print any meter (only stats).
+        mininterval (Optional[float]): Minimum progress display update interval [default: 0.1] seconds.
+        maxinterval (Optional[float]): Maximum progress display update interval [default: 10] seconds.
+                                    Automatically adjusts `miniters` to correspond to `mininterval`
+                                    after long display update lag. Only works if `dynamic_miniters`
+                                    or monitor thread is enabled.
+        miniters (Optional[Union[int, float]]): Minimum progress display update interval, in iterations.
+                                            If 0 and `dynamic_miniters`, will automatically adjust to equal
+                                            `mininterval` (more CPU efficient, good for tight loops).
+                                            If > 0, will skip display of specified number of iterations.
+                                            Tweak this and `mininterval` to get very efficient loops.
+                                            If your progress is erratic with both fast and slow iterations
+                                            (network, skipping items, etc) you should set miniters=1.
+        use_ascii (Optional[Union[bool, str]]): If unspecified or False, use unicode (smooth blocks) to fill
+                                        the meter. The fallback is to use ASCII characters " 123456789#".
+        disable (Optional[bool]): Whether to disable the entire progressbar wrapper
+                                    [default: False]. If set to None, disable on non-TTY.
+        unit (Optional[str]): String that will be used to define the unit of each iteration
+                            [default: it].
+        unit_scale (Union[bool, int, float]): If 1 or True, the number of iterations will be reduced/scaled
+                            automatically and a metric prefix following the
+                            International System of Units standard will be added
+                            (kilo, mega, etc.) [default: False]. If any other non-zero
+                            number, will scale `total` and `n`.
+        dynamic_ncols (Optional[bool]): If set, constantly alters `ncols` and `nrows` to the
+                                        environment (allowing for window resizes) [default: False].
+        smoothing (Optional[float]): Exponential moving average smoothing factor for speed estimates
+                                    (ignored in GUI mode). Ranges from 0 (average speed) to 1
+                                    (current/instantaneous speed) [default: 0.3].
+        bar_format (Optional[str]):  Specify a custom bar string formatting. May impact performance.
+                                    [default: '{l_bar}{bar}{r_bar}'], where
+                                    l_bar='{desc}: {percentage:3.0f}%|' and
+                                    r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, '
+                                    '{rate_fmt}{postfix}]'
+                                    Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt,
+                                    percentage, elapsed, elapsed_s, ncols, nrows, desc, unit,
+                                    rate, rate_fmt, rate_noinv, rate_noinv_fmt,
+                                    rate_inv, rate_inv_fmt, postfix, unit_divisor,
+                                    remaining, remaining_s, eta.
+                                    Note that a trailing ": " is automatically removed after {desc}
+                                    if the latter is empty.
+        initial (Optional[Union[int, float]]): The initial counter value. Useful when restarting a progress
+                                            bar [default: 0]. If using float, consider specifying `{n:.3f}`
+                                            or similar in `bar_format`, or specifying `unit_scale`.
+        position (Optional[int]): Specify the line offset to print this bar (starting from 0)
+                                    Automatic if unspecified.
+                                    Useful to manage multiple bars at once (eg, from threads).
+        postfix (Optional[Dict]): Specify additional stats to display at the end of the bar.
+                                    Calls `set_postfix(**postfix)` if possible (dict).
+        unit_divisor (Optional[float]): [default: 1000], ignored unless `unit_scale` is True.
+        write_bytes (Optional[bool]): If (default: None) and `file` is unspecified,
+                                    bytes will be written in Python 2. If `True` will also write
+                                    bytes. In all other cases will default to unicode.
+        lock_args (Optional[tuple]): Passed to `refresh` for intermediate output
+                                    (initialisation, iterating, and updating).
+                                    nrows (Optional[int]): The screen height. If specified, hides nested bars
+                                    outside this bound. If unspecified, attempts to use environment height.
+                                    The fallback is 20.
+        colour (Optional[str]): Bar colour (e.g. 'green', '#00ff00').
+        delay (Optional[float]): Don't display until [default: 0] seconds have elapsed.
+        gui (Optional[bool]): WARNING: internal parameter - do not use.
+                                Use tqdm.gui.tqdm(...) instead. If set, will attempt to use
+                                matplotlib animations for a graphical output [default: False].
+
+
+    Example:
+        >>> with DownloadProgressBar(unit='B', unit_scale=True, miniters=1, desc=url.split('/')[-1]) as p_bar:
+        >>>         urllib.request.urlretrieve(url, filename=output_path, reporthook=p_bar.update_to)
+    """
+
+    def __init__(
+        self,
+        iterable: Optional[Iterable] = None,
+        desc: Optional[str] = None,
+        total: Optional[Union[int, float]] = None,
+        leave: Optional[bool] = True,
+        file: Optional[Union[io.TextIOWrapper, io.StringIO]] = None,
+        ncols: Optional[int] = None,
+        mininterval: Optional[float] = 0.1,
+        maxinterval: Optional[float] = 10.0,
+        miniters: Optional[Union[int, float]] = None,
+        use_ascii: Optional[Union[bool, str]] = None,
+        disable: Optional[bool] = False,
+        unit: Optional[str] = "it",
+        unit_scale: Optional[Union[bool, int, float]] = False,
+        dynamic_ncols: Optional[bool] = False,
+        smoothing: Optional[float] = 0.3,
+        bar_format: Optional[str] = None,
+        initial: Optional[Union[int, float]] = 0,
+        position: Optional[int] = None,
+        postfix: Optional[Dict] = None,
+        unit_divisor: Optional[float] = 1000,
+        write_bytes: Optional[bool] = None,
+        lock_args: Optional[tuple] = None,
+        nrows: Optional[int] = None,
+        colour: Optional[str] = None,
+        delay: Optional[float] = 0,
+        gui: Optional[bool] = False,
+        **kwargs
+    ):
+        super().__init__(
+            iterable=iterable,
+            desc=desc,
+            total=total,
+            leave=leave,
+            file=file,
+            ncols=ncols,
+            mininterval=mininterval,
+            maxinterval=maxinterval,
+            miniters=miniters,
+            ascii=use_ascii,
+            disable=disable,
+            unit=unit,
+            unit_scale=unit_scale,
+            dynamic_ncols=dynamic_ncols,
+            smoothing=smoothing,
+            bar_format=bar_format,
+            initial=initial,
+            position=position,
+            postfix=postfix,
+            unit_divisor=unit_divisor,
+            write_bytes=write_bytes,
+            lock_args=lock_args,
+            nrows=nrows,
+            colour=colour,
+            delay=delay,
+            gui=gui,
+            **kwargs
+        )
+        self.total: Optional[Union[int, float]]
+
+    def update_to(self, chunk_number: int = 1, max_chunk_size: int = 1, total_size=None):
+        """Progress bar hook for tqdm.
+
+        The implementor does not have to bother about passing parameters to this as it gets them from urlretrieve.
+        However the context needs a few parameters. Refer to the example.
+
+        Args:
+            chunk_number (int, optional): The current chunk being processed. Defaults to 1.
+            max_chunk_size (int, optional): Maximum size of each chunk. Defaults to 1.
+            total_size ([type], optional): Total download size. Defaults to None.
+        """
+        if total_size is not None:
+            self.total = total_size
+        self.update(chunk_number * max_chunk_size - self.n)

anomalib/data/utils/image.py

@@ -0,0 +1,91 @@
+"""Image Utils."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+import math
+from pathlib import Path
+from typing import List, Union
+
+import cv2
+import numpy as np
+import torch.nn.functional as F
+from torch import Tensor
+from torchvision.datasets.folder import IMG_EXTENSIONS
+
+
+def get_image_filenames(path: Union[str, Path]) -> List[str]:
+    """Get image filenames.
+
+    Args:
+        path (Union[str, Path]): Path to image or image-folder.
+
+    Returns:
+        List[str]: List of image filenames
+
+    """
+    image_filenames: List[str]
+
+    if isinstance(path, str):
+        path = Path(path)
+
+    if path.is_file() and path.suffix in IMG_EXTENSIONS:
+        image_filenames = [str(path)]
+
+    if path.is_dir():
+        image_filenames = [str(p) for p in path.glob("**/*") if p.suffix in IMG_EXTENSIONS]
+
+    if len(image_filenames) == 0:
+        raise ValueError(f"Found 0 images in {path}")
+
+    return image_filenames
+
+
+def read_image(path: Union[str, Path]) -> np.ndarray:
+    """Read image from disk in RGB format.
+
+    Args:
+        path (str, Path): path to the image file
+
+    Example:
+        >>> image = read_image("test_image.jpg")
+
+    Returns:
+        image as numpy array
+    """
+    path = path if isinstance(path, str) else str(path)
+    image = cv2.imread(path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    return image
+
+
+def pad_nextpow2(batch: Tensor) -> Tensor:
+    """Compute required padding from input size and return padded images.
+
+    Finds the largest dimension and computes a square image of dimensions that are of the power of 2.
+    In case the image dimension is odd, it returns the image with an extra padding on one side.
+
+    Args:
+        batch (Tensor): Input images
+
+    Returns:
+        batch: Padded batch
+    """
+    # find the largest dimension
+    l_dim = 2 ** math.ceil(math.log(max(*batch.shape[-2:]), 2))
+    padding_w = [math.ceil((l_dim - batch.shape[-2]) / 2), math.floor((l_dim - batch.shape[-2]) / 2)]
+    padding_h = [math.ceil((l_dim - batch.shape[-1]) / 2), math.floor((l_dim - batch.shape[-1]) / 2)]
+    padded_batch = F.pad(batch, pad=[*padding_h, *padding_w])
+    return padded_batch

anomalib/data/utils/split.py

@@ -0,0 +1,94 @@
+"""Dataset Split Utils.
+
+This module contains function in regards to splitting normal images in training set,
+and creating validation sets from test sets.
+
+These function are useful
+    - when the test set does not contain any normal images.
+    - when the dataset doesn't have a validation set.
+"""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+import random
+
+from pandas.core.frame import DataFrame
+
+
+def split_normal_images_in_train_set(
+    samples: DataFrame, split_ratio: float = 0.1, seed: int = 0, normal_label: str = "good"
+) -> DataFrame:
+    """Split normal images in train set.
+
+        This function splits the normal images in training set and assigns the
+        values to the test set. This is particularly useful especially when the
+        test set does not contain any normal images.
+
+        This is important because when the test set doesn't have any normal images,
+        AUC computation fails due to having single class.
+
+    Args:
+        samples (DataFrame): Dataframe containing dataset info such as filenames, splits etc.
+        split_ratio (float, optional): Train-Test normal image split ratio. Defaults to 0.1.
+        seed (int, optional): Random seed to ensure reproducibility. Defaults to 0.
+        normal_label (str): Name of the normal label. For MVTec AD, for instance, this is normal_label.
+
+    Returns:
+        DataFrame: Output dataframe where the part of the training set is assigned to test set.
+    """
+
+    if seed > 0:
+        random.seed(seed)
+
+    normal_train_image_indices = samples.index[(samples.split == "train") & (samples.label == normal_label)].to_list()
+    num_normal_train_images = len(normal_train_image_indices)
+    num_normal_valid_images = int(num_normal_train_images * split_ratio)
+
+    indices_to_split_from_train_set = random.sample(population=normal_train_image_indices, k=num_normal_valid_images)
+    samples.loc[indices_to_split_from_train_set, "split"] = "test"
+
+    return samples
+
+
+def create_validation_set_from_test_set(samples: DataFrame, seed: int = 0, normal_label: str = "good") -> DataFrame:
+    """Craete Validation Set from Test Set.
+
+    This function creates a validation set from test set by splitting both
+    normal and abnormal samples to two.
+
+    Args:
+        samples (DataFrame): Dataframe containing dataset info such as filenames, splits etc.
+        seed (int, optional): Random seed to ensure reproducibility. Defaults to 0.
+        normal_label (str): Name of the normal label. For MVTec AD, for instance, this is normal_label.
+    """
+
+    if seed > 0:
+        random.seed(seed)
+
+    # Split normal images.
+    normal_test_image_indices = samples.index[(samples.split == "test") & (samples.label == normal_label)].to_list()
+    num_normal_valid_images = len(normal_test_image_indices) // 2
+
+    indices_to_sample = random.sample(population=normal_test_image_indices, k=num_normal_valid_images)
+    samples.loc[indices_to_sample, "split"] = "val"
+
+    # Split abnormal images.
+    abnormal_test_image_indices = samples.index[(samples.split == "test") & (samples.label != normal_label)].to_list()
+    num_abnormal_valid_images = len(abnormal_test_image_indices) // 2
+
+    indices_to_sample = random.sample(population=abnormal_test_image_indices, k=num_abnormal_valid_images)
+    samples.loc[indices_to_sample, "split"] = "val"
+
+    return samples

anomalib/deploy/__init__.py

@@ -0,0 +1,20 @@
+"""Functions for Inference and model deployment."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from .inferencers import OpenVINOInferencer, TorchInferencer
+from .optimize import export_convert, get_model_metadata
+
+__all__ = ["OpenVINOInferencer", "TorchInferencer", "export_convert", "get_model_metadata"]

anomalib/deploy/inferencers/__init__.py

@@ -0,0 +1,21 @@
+"""Inferencers for Torch and OpenVINO."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from .base import Inferencer
+from .openvino import OpenVINOInferencer
+from .torch import TorchInferencer
+
+__all__ = ["Inferencer", "TorchInferencer", "OpenVINOInferencer"]

anomalib/deploy/inferencers/base.py

@@ -0,0 +1,204 @@
+"""Base Inferencer for Torch and OpenVINO."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union, cast
+
+import cv2
+import numpy as np
+from omegaconf import DictConfig, OmegaConf
+from skimage.morphology import dilation
+from skimage.segmentation import find_boundaries
+from torch import Tensor
+
+from anomalib.data.utils import read_image
+from anomalib.post_processing import compute_mask, superimpose_anomaly_map
+from anomalib.post_processing.normalization.cdf import normalize as normalize_cdf
+from anomalib.post_processing.normalization.cdf import standardize
+from anomalib.post_processing.normalization.min_max import (
+    normalize as normalize_min_max,
+)
+
+
+class Inferencer(ABC):
+    """Abstract class for the inference.
+
+    This is used by both Torch and OpenVINO inference.
+    """
+
+    @abstractmethod
+    def load_model(self, path: Union[str, Path]):
+        """Load Model."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def pre_process(self, image: np.ndarray) -> Union[np.ndarray, Tensor]:
+        """Pre-process."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def forward(self, image: Union[np.ndarray, Tensor]) -> Union[np.ndarray, Tensor]:
+        """Forward-Pass input to model."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def post_process(
+        self, predictions: Union[np.ndarray, Tensor], meta_data: Optional[Dict]
+    ) -> Tuple[np.ndarray, float]:
+        """Post-Process."""
+        raise NotImplementedError
+
+    def predict(
+        self,
+        image: Union[str, np.ndarray, Path],
+        superimpose: bool = True,
+        meta_data: Optional[dict] = None,
+        overlay_mask: bool = False,
+    ) -> Tuple[np.ndarray, float]:
+        """Perform a prediction for a given input image.
+
+        The main workflow is (i) pre-processing, (ii) forward-pass, (iii) post-process.
+
+        Args:
+            image (Union[str, np.ndarray]): Input image whose output is to be predicted.
+                It could be either a path to image or numpy array itself.
+
+            superimpose (bool): If this is set to True, output predictions
+                will be superimposed onto the original image. If false, `predict`
+                method will return the raw heatmap.
+
+            overlay_mask (bool): If this is set to True, output segmentation mask on top of image.
+
+        Returns:
+            np.ndarray: Output predictions to be visualized.
+        """
+        if meta_data is None:
+            if hasattr(self, "meta_data"):
+                meta_data = getattr(self, "meta_data")
+            else:
+                meta_data = {}
+        if isinstance(image, (str, Path)):
+            image_arr: np.ndarray = read_image(image)
+        else:  # image is already a numpy array. Kept for mypy compatibility.
+            image_arr = image
+        meta_data["image_shape"] = image_arr.shape[:2]
+
+        processed_image = self.pre_process(image_arr)
+        predictions = self.forward(processed_image)
+        anomaly_map, pred_scores = self.post_process(predictions, meta_data=meta_data)
+
+        # Overlay segmentation mask using raw predictions
+        if overlay_mask and meta_data is not None:
+            image_arr = self._superimpose_segmentation_mask(meta_data, anomaly_map, image_arr)
+
+        if superimpose is True:
+            anomaly_map = superimpose_anomaly_map(anomaly_map, image_arr)
+
+        return anomaly_map, pred_scores
+
+    def _superimpose_segmentation_mask(self, meta_data: dict, anomaly_map: np.ndarray, image: np.ndarray):
+        """Superimpose segmentation mask on top of image.
+
+        Args:
+            meta_data (dict): Metadata of the image which contains the image size.
+            anomaly_map (np.ndarray): Anomaly map which is used to extract segmentation mask.
+            image (np.ndarray): Image on which segmentation mask is to be superimposed.
+
+        Returns:
+            np.ndarray: Image with segmentation mask superimposed.
+        """
+        pred_mask = compute_mask(anomaly_map, 0.5)  # assumes predictions are normalized.
+        image_height = meta_data["image_shape"][0]
+        image_width = meta_data["image_shape"][1]
+        pred_mask = cv2.resize(pred_mask, (image_width, image_height))
+        boundaries = find_boundaries(pred_mask)
+        outlines = dilation(boundaries, np.ones((7, 7)))
+        image[outlines] = [255, 0, 0]
+        return image
+
+    def __call__(self, image: np.ndarray) -> Tuple[np.ndarray, float]:
+        """Call predict on the Image.
+
+        Args:
+            image (np.ndarray): Input Image
+
+        Returns:
+            np.ndarray: Output predictions to be visualized
+        """
+        return self.predict(image)
+
+    def _normalize(
+        self,
+        anomaly_maps: Union[Tensor, np.ndarray],
+        pred_scores: Union[Tensor, np.float32],
+        meta_data: Union[Dict, DictConfig],
+    ) -> Tuple[Union[np.ndarray, Tensor], float]:
+        """Applies normalization and resizes the image.
+
+        Args:
+            anomaly_maps (Union[Tensor, np.ndarray]): Predicted raw anomaly map.
+            pred_scores (Union[Tensor, np.float32]): Predicted anomaly score
+            meta_data (Dict): Meta data. Post-processing step sometimes requires
+                additional meta data such as image shape. This variable comprises such info.
+
+        Returns:
+            Tuple[Union[np.ndarray, Tensor], float]: Post processed predictions that are ready to be visualized and
+                predicted scores.
+
+
+        """
+
+        # min max normalization
+        if "min" in meta_data and "max" in meta_data:
+            anomaly_maps = normalize_min_max(
+                anomaly_maps, meta_data["pixel_threshold"], meta_data["min"], meta_data["max"]
+            )
+            pred_scores = normalize_min_max(
+                pred_scores, meta_data["image_threshold"], meta_data["min"], meta_data["max"]
+            )
+
+        # standardize pixel scores
+        if "pixel_mean" in meta_data.keys() and "pixel_std" in meta_data.keys():
+            anomaly_maps = standardize(
+                anomaly_maps, meta_data["pixel_mean"], meta_data["pixel_std"], center_at=meta_data["image_mean"]
+            )
+            anomaly_maps = normalize_cdf(anomaly_maps, meta_data["pixel_threshold"])
+
+        # standardize image scores
+        if "image_mean" in meta_data.keys() and "image_std" in meta_data.keys():
+            pred_scores = standardize(pred_scores, meta_data["image_mean"], meta_data["image_std"])
+            pred_scores = normalize_cdf(pred_scores, meta_data["image_threshold"])
+
+        return anomaly_maps, float(pred_scores)
+
+    def _load_meta_data(
+        self, path: Optional[Union[str, Path]] = None
+    ) -> Union[DictConfig, Dict[str, Union[float, np.ndarray, Tensor]]]:
+        """Loads the meta data from the given path.
+
+        Args:
+            path (Optional[Union[str, Path]], optional): Path to JSON file containing the metadata.
+                If no path is provided, it returns an empty dict. Defaults to None.
+
+        Returns:
+            Union[DictConfig, Dict]: Dictionary containing the metadata.
+        """
+        meta_data: Union[DictConfig, Dict[str, Union[float, np.ndarray, Tensor]]] = {}
+        if path is not None:
+            config = OmegaConf.load(path)
+            meta_data = cast(DictConfig, config)
+        return meta_data

anomalib/deploy/inferencers/openvino.py

@@ -0,0 +1,149 @@
+"""This module contains inference-related abstract class and its Torch and OpenVINO implementations."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from importlib.util import find_spec
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
+
+import cv2
+import numpy as np
+from omegaconf import DictConfig, ListConfig
+
+from anomalib.pre_processing import PreProcessor
+
+from .base import Inferencer
+
+if find_spec("openvino") is not None:
+    from openvino.inference_engine import (  # type: ignore  # pylint: disable=no-name-in-module
+        IECore,
+    )
+
+
+class OpenVINOInferencer(Inferencer):
+    """OpenVINO implementation for the inference.
+
+    Args:
+        config (DictConfig): Configurable parameters that are used
+            during the training stage.
+        path (Union[str, Path]): Path to the openvino onnx, xml or bin file.
+        meta_data_path (Union[str, Path], optional): Path to metadata file. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        config: Union[DictConfig, ListConfig],
+        path: Union[str, Path, Tuple[bytes, bytes]],
+        meta_data_path: Union[str, Path] = None,
+    ):
+        self.config = config
+        self.input_blob, self.output_blob, self.network = self.load_model(path)
+        self.meta_data = super()._load_meta_data(meta_data_path)
+
+    def load_model(self, path: Union[str, Path, Tuple[bytes, bytes]]):
+        """Load the OpenVINO model.
+
+        Args:
+            path (Union[str, Path, Tuple[bytes, bytes]]): Path to the onnx or xml and bin files
+                                                        or tuple of .xml and .bin data as bytes.
+
+        Returns:
+            [Tuple[str, str, ExecutableNetwork]]: Input and Output blob names
+                together with the Executable network.
+        """
+        ie_core = IECore()
+        # If tuple of bytes is passed
+
+        if isinstance(path, tuple):
+            network = ie_core.read_network(model=path[0], weights=path[1], init_from_buffer=True)
+        else:
+            path = path if isinstance(path, Path) else Path(path)
+            if path.suffix in (".bin", ".xml"):
+                if path.suffix == ".bin":
+                    bin_path, xml_path = path, path.with_suffix(".xml")
+                elif path.suffix == ".xml":
+                    xml_path, bin_path = path, path.with_suffix(".bin")
+                network = ie_core.read_network(xml_path, bin_path)
+            elif path.suffix == ".onnx":
+                network = ie_core.read_network(path)
+            else:
+                raise ValueError(f"Path must be .onnx, .bin or .xml file. Got {path.suffix}")
+
+        input_blob = next(iter(network.input_info))
+        output_blob = next(iter(network.outputs))
+        executable_network = ie_core.load_network(network=network, device_name="CPU")
+
+        return input_blob, output_blob, executable_network
+
+    def pre_process(self, image: np.ndarray) -> np.ndarray:
+        """Pre process the input image by applying transformations.
+
+        Args:
+            image (np.ndarray): Input image.
+
+        Returns:
+            np.ndarray: pre-processed image.
+        """
+        config = self.config.transform if "transform" in self.config.keys() else None
+        image_size = tuple(self.config.dataset.image_size)
+        pre_processor = PreProcessor(config, image_size)
+        processed_image = pre_processor(image=image)["image"]
+
+        if len(processed_image.shape) == 3:
+            processed_image = np.expand_dims(processed_image, axis=0)
+
+        if processed_image.shape[-1] == 3:
+            processed_image = processed_image.transpose(0, 3, 1, 2)
+
+        return processed_image
+
+    def forward(self, image: np.ndarray) -> np.ndarray:
+        """Forward-Pass input tensor to the model.
+
+        Args:
+            image (np.ndarray): Input tensor.
+
+        Returns:
+            np.ndarray: Output predictions.
+        """
+        return self.network.infer(inputs={self.input_blob: image})
+
+    def post_process(
+        self, predictions: np.ndarray, meta_data: Optional[Union[Dict, DictConfig]] = None
+    ) -> Tuple[np.ndarray, float]:
+        """Post process the output predictions.
+
+        Args:
+            predictions (np.ndarray): Raw output predicted by the model.
+            meta_data (Dict, optional): Meta data. Post-processing step sometimes requires
+                additional meta data such as image shape. This variable comprises such info.
+                Defaults to None.
+
+        Returns:
+            np.ndarray: Post processed predictions that are ready to be visualized.
+        """
+        if meta_data is None:
+            meta_data = self.meta_data
+
+        predictions = predictions[self.output_blob]
+        anomaly_map = predictions.squeeze()
+        pred_score = anomaly_map.reshape(-1).max()
+
+        anomaly_map, pred_score = self._normalize(anomaly_map, pred_score, meta_data)
+
+        if "image_shape" in meta_data and anomaly_map.shape != meta_data["image_shape"]:
+            anomaly_map = cv2.resize(anomaly_map, meta_data["image_shape"])
+
+        return anomaly_map, float(pred_score)

anomalib/deploy/inferencers/torch.py

@@ -0,0 +1,164 @@
+"""This module contains Torch inference implementations."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
+
+import cv2
+import numpy as np
+import torch
+from omegaconf import DictConfig, ListConfig
+from torch import Tensor
+
+from anomalib.deploy.optimize import get_model_metadata
+from anomalib.models import get_model
+from anomalib.models.components import AnomalyModule
+from anomalib.pre_processing import PreProcessor
+
+from .base import Inferencer
+
+
+class TorchInferencer(Inferencer):
+    """PyTorch implementation for the inference.
+
+    Args:
+        config (DictConfig): Configurable parameters that are used
+            during the training stage.
+        model_source (Union[str, Path, AnomalyModule]): Path to the model ckpt file or the Anomaly model.
+        meta_data_path (Union[str, Path], optional): Path to metadata file. If none, it tries to load the params
+                from the model state_dict. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        config: Union[DictConfig, ListConfig],
+        model_source: Union[str, Path, AnomalyModule],
+        meta_data_path: Union[str, Path] = None,
+    ):
+        self.config = config
+        if isinstance(model_source, AnomalyModule):
+            self.model = model_source
+        else:
+            self.model = self.load_model(model_source)
+
+        self.meta_data = self._load_meta_data(meta_data_path)
+
+    def _load_meta_data(self, path: Optional[Union[str, Path]] = None) -> Union[Dict, DictConfig]:
+        """Load metadata from file or from model state dict.
+
+        Args:
+            path (Optional[Union[str, Path]], optional): Path to metadata file. If none, it tries to load the params
+                from the model state_dict. Defaults to None.
+
+        Returns:
+            Dict: Dictionary containing the meta_data.
+        """
+        meta_data: Union[DictConfig, Dict[str, Union[float, Tensor, np.ndarray]]]
+        if path is None:
+            meta_data = get_model_metadata(self.model)
+        else:
+            meta_data = super()._load_meta_data(path)
+        return meta_data
+
+    def load_model(self, path: Union[str, Path]) -> AnomalyModule:
+        """Load the PyTorch model.
+
+        Args:
+            path (Union[str, Path]): Path to model ckpt file.
+
+        Returns:
+            (AnomalyModule): PyTorch Lightning model.
+        """
+        model = get_model(self.config)
+        model.load_state_dict(torch.load(path)["state_dict"])
+        model.eval()
+        return model
+
+    def pre_process(self, image: np.ndarray) -> Tensor:
+        """Pre process the input image by applying transformations.
+
+        Args:
+            image (np.ndarray): Input image
+
+        Returns:
+            Tensor: pre-processed image.
+        """
+        config = self.config.transform if "transform" in self.config.keys() else None
+        image_size = tuple(self.config.dataset.image_size)
+        pre_processor = PreProcessor(config, image_size)
+        processed_image = pre_processor(image=image)["image"]
+
+        if len(processed_image) == 3:
+            processed_image = processed_image.unsqueeze(0)
+
+        return processed_image
+
+    def forward(self, image: Tensor) -> Tensor:
+        """Forward-Pass input tensor to the model.
+
+        Args:
+            image (Tensor): Input tensor.
+
+        Returns:
+            Tensor: Output predictions.
+        """
+        return self.model(image)
+
+    def post_process(
+        self, predictions: Tensor, meta_data: Optional[Union[Dict, DictConfig]] = None
+    ) -> Tuple[np.ndarray, float]:
+        """Post process the output predictions.
+
+        Args:
+            predictions (Tensor): Raw output predicted by the model.
+            meta_data (Dict, optional): Meta data. Post-processing step sometimes requires
+                additional meta data such as image shape. This variable comprises such info.
+                Defaults to None.
+
+        Returns:
+            np.ndarray: Post processed predictions that are ready to be visualized.
+        """
+        if meta_data is None:
+            meta_data = self.meta_data
+
+        if isinstance(predictions, Tensor):
+            anomaly_map = predictions
+            pred_score = anomaly_map.reshape(-1).max()
+        else:
+            # NOTE: Patchcore `forward`` returns heatmap and score.
+            #   We need to add the following check to ensure the variables
+            #   are properly assigned. Without this check, the code
+            #   throws an error regarding type mismatch torch vs np.
+            if isinstance(predictions[1], (Tensor)):
+                anomaly_map, pred_score = predictions
+                pred_score = pred_score.detach()
+            else:
+                anomaly_map, pred_score = predictions
+                pred_score = pred_score.detach().numpy()
+
+        anomaly_map = anomaly_map.squeeze()
+
+        anomaly_map, pred_score = self._normalize(anomaly_map, pred_score, meta_data)
+
+        if isinstance(anomaly_map, Tensor):
+            anomaly_map = anomaly_map.detach().cpu().numpy()
+
+        if "image_shape" in meta_data and anomaly_map.shape != meta_data["image_shape"]:
+            image_height = meta_data["image_shape"][0]
+            image_width = meta_data["image_shape"][1]
+            anomaly_map = cv2.resize(anomaly_map, (image_width, image_height))
+
+        return anomaly_map, float(pred_score)

anomalib/deploy/optimize.py

@@ -0,0 +1,89 @@
+"""Utilities for optimization and OpenVINO conversion."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Tuple, Union
+
+import numpy as np
+import torch
+from torch import Tensor
+
+from anomalib.models.components import AnomalyModule
+
+
+def get_model_metadata(model: AnomalyModule) -> Dict[str, Tensor]:
+    """Get meta data related to normalization from model.
+
+    Args:
+        model (AnomalyModule): Anomaly model which contains metadata related to normalization.
+
+    Returns:
+        Dict[str, Tensor]: metadata
+    """
+    meta_data = {}
+    cached_meta_data = {
+        "image_threshold": model.image_threshold.cpu().value,
+        "pixel_threshold": model.pixel_threshold.cpu().value,
+        "pixel_mean": model.training_distribution.pixel_mean.cpu(),
+        "image_mean": model.training_distribution.image_mean.cpu(),
+        "pixel_std": model.training_distribution.pixel_std.cpu(),
+        "image_std": model.training_distribution.image_std.cpu(),
+        "min": model.min_max.min.cpu(),
+        "max": model.min_max.max.cpu(),
+    }
+    # Remove undefined values by copying in a new dict
+    for key, val in cached_meta_data.items():
+        if not np.isinf(val).all():
+            meta_data[key] = val
+    del cached_meta_data
+    return meta_data
+
+
+def export_convert(
+    model: AnomalyModule,
+    input_size: Union[List[int], Tuple[int, int]],
+    onnx_path: Union[str, Path],
+    export_path: Union[str, Path],
+):
+    """Export the model to onnx format and convert to OpenVINO IR.
+
+    Args:
+        model (AnomalyModule): Model to convert.
+        input_size (Union[List[int], Tuple[int, int]]): Image size used as the input for onnx converter.
+        onnx_path (Union[str, Path]): Path to output onnx model.
+        export_path (Union[str, Path]): Path to exported OpenVINO IR.
+    """
+    height, width = input_size
+    torch.onnx.export(
+        model.model,
+        torch.zeros((1, 3, height, width)).to(model.device),
+        onnx_path,
+        opset_version=11,
+        input_names=["input"],
+        output_names=["output"],
+    )
+    optimize_command = "mo --input_model " + str(onnx_path) + " --output_dir " + str(export_path)
+    os.system(optimize_command)
+    with open(Path(export_path) / "meta_data.json", "w", encoding="utf-8") as metadata_file:
+        meta_data = get_model_metadata(model)
+        # Convert metadata from torch
+        for key, value in meta_data.items():
+            if isinstance(value, Tensor):
+                meta_data[key] = value.numpy().tolist()
+        json.dump(meta_data, metadata_file, ensure_ascii=False, indent=4)

anomalib/models/__init__.py

@@ -0,0 +1,75 @@
+"""Load Anomaly Model."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+import os
+from importlib import import_module
+from typing import List, Union
+
+from omegaconf import DictConfig, ListConfig
+from torch import load
+
+from anomalib.models.components import AnomalyModule
+
+# TODO(AlexanderDokuchaev): Workaround of wrapping by NNCF.
+#                           Can't not wrap `spatial_softmax2d` if use import_module.
+from anomalib.models.padim.lightning_model import PadimLightning  # noqa: F401
+
+
+def get_model(config: Union[DictConfig, ListConfig]) -> AnomalyModule:
+    """Load model from the configuration file.
+
+    Works only when the convention for model naming is followed.
+
+    The convention for writing model classes is
+    `anomalib.models.<model_name>.model.<Model_name>Lightning`
+    `anomalib.models.stfpm.model.StfpmLightning`
+
+    and for OpenVINO
+    `anomalib.models.<model-name>.model.<Model_name>OpenVINO`
+    `anomalib.models.stfpm.model.StfpmOpenVINO`
+
+    Args:
+        config (Union[DictConfig, ListConfig]): Config.yaml loaded using OmegaConf
+
+    Raises:
+        ValueError: If unsupported model is passed
+
+    Returns:
+        AnomalyModule: Anomaly Model
+    """
+    openvino_model_list: List[str] = ["stfpm"]
+    torch_model_list: List[str] = ["padim", "stfpm", "dfkde", "dfm", "patchcore", "cflow", "ganomaly"]
+    model: AnomalyModule
+
+    if "openvino" in config.keys() and config.openvino:
+        if config.model.name in openvino_model_list:
+            module = import_module(f"anomalib.models.{config.model.name}.model")
+            model = getattr(module, f"{config.model.name.capitalize()}OpenVINO")
+        else:
+            raise ValueError(f"Unknown model {config.model.name} for OpenVINO model!")
+    else:
+        if config.model.name in torch_model_list:
+            module = import_module(f"anomalib.models.{config.model.name}")
+            model = getattr(module, f"{config.model.name.capitalize()}Lightning")
+        else:
+            raise ValueError(f"Unknown model {config.model.name}!")
+
+    model = model(config)
+
+    if "init_weights" in config.keys() and config.init_weights:
+        model.load_state_dict(load(os.path.join(config.project.path, config.init_weights))["state_dict"], strict=False)
+
+    return model

anomalib/models/cflow/README.md

@@ -0,0 +1,49 @@
+# Real-Time  Unsupervised Anomaly Detection via Conditional Normalizing Flows
+
+This is the implementation of the [CFLOW-AD](https://arxiv.org/pdf/2107.12571v1.pdf) paper. This code is modified form of the [official repository](https://github.com/gudovskiy/cflow-ad).
+
+Model Type: Segmentation
+
+## Description
+
+CFLOW model is based on a conditional normalizing flow framework adopted for anomaly detection with localization. It consists of a discriminatively pretrained encoder followed by a multi-scale generative decoders. The encoder extracts features with multi-scale pyramid pooling to capture both global and local semantic information with the growing from top to bottom receptive fields. Pooled features are processed by a set of decoders to explicitly estimate likelihood of the encoded features. The estimated multi-scale likelyhoods are upsampled to input size and added up to produce the anomaly map.
+
+## Architecture
+
+![CFlow Architecture](../../../docs/source/images/cflow/architecture.jpg "CFlow Architecture")
+
+## Usage
+
+`python tools/train.py --model cflow`
+
+## Benchmark
+
+All results gathered with seed `42`.
+
+## [MVTec AD Dataset](https://www.mvtec.com/company/research/datasets/mvtec-ad)
+
+### Image-Level AUC
+
+|                |  Avg  | Carpet | Grid  | Leather | Tile  | Wood  | Bottle | Cable | Capsule | Hazelnut | Metal Nut | Pill  | Screw | Toothbrush | Transistor | Zipper |
+| -------------- | :---: | :----: | :---: | :-----: | :---: | :---: | :----: | :---: | :-----: | :------: | :-------: | :---: | :---: | :--------: | :--------: | :----: |
+| Wide ResNet-50 | 0.962 | 0.986  | 0.962 |   1.0   | 0.999 | 0.993 |   1.0  | 0.893 |  0.945  |   1.0    |   0.995   | 0.924 | 0.908 |   0.897    |   0.943    | 0.984  |
+
+### Pixel-Level AUC
+
+|                |  Avg  | Carpet | Grid  | Leather | Tile  | Wood  | Bottle | Cable | Capsule | Hazelnut | Metal Nut | Pill  | Screw | Toothbrush | Transistor | Zipper |
+| -------------- | :---: | :----: | :---: | :-----: | :---: | :---: | :----: | :---: | :-----: | :------: | :-------: | :---: | :---: | :--------: | :--------: | :----: |
+| Wide ResNet-50 | 0.971 | 0.986  | 0.968 |  0.993  | 0.968 | 0.924 | 0.981  | 0.955 |  0.988  |   0.990  |   0.982   | 0.983 | 0.979 |   0.985    |   0.897    | 0.980  |
+
+### Image F1 Score
+
+|                |  Avg  | Carpet | Grid  | Leather | Tile  | Wood  | Bottle | Cable | Capsule | Hazelnut | Metal Nut | Pill  | Screw | Toothbrush | Transistor | Zipper |
+| -------------- | :---: | :----: | :---: | :-----: | :---: | :---: | :----: | :---: | :-----: | :------: | :-------: | :---: | :---: | :--------: | :--------: | :----: |
+| Wide ResNet-50 | 0.944 |  0.972 | 0.932 |  1.000  | 0.988 | 0.967 | 1.000  | 0.832 |  0.939  |  1.000   |   0.979   | 0.924 | 0.971 |   0.870    |   0.818    | 0.967  |
+
+### Sample Results
+
+![Sample Result 1](../../../docs/source/images/cflow/results/0.png "Sample Result 1")
+
+![Sample Result 2](../../../docs/source/images/cflow/results/1.png "Sample Result 2")
+
+![Sample Result 3](../../../docs/source/images/cflow/results/2.png "Sample Result 3")

anomalib/models/cflow/__init__.py

@@ -0,0 +1,19 @@
+"""Real-Time  Unsupervised Anomaly Detection via Conditional Normalizing Flows."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from .lightning_model import CflowLightning
+
+__all__ = ["CflowLightning"]

anomalib/models/cflow/anomaly_map.py

@@ -0,0 +1,97 @@
+"""Anomaly Map Generator for CFlow model implementation."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from typing import List, Tuple, Union, cast
+
+import torch
+import torch.nn.functional as F
+from omegaconf import ListConfig
+from torch import Tensor
+
+
+class AnomalyMapGenerator:
+    """Generate Anomaly Heatmap."""
+
+    def __init__(
+        self,
+        image_size: Union[ListConfig, Tuple],
+        pool_layers: List[str],
+    ):
+        self.distance = torch.nn.PairwiseDistance(p=2, keepdim=True)
+        self.image_size = image_size if isinstance(image_size, tuple) else tuple(image_size)
+        self.pool_layers: List[str] = pool_layers
+
+    def compute_anomaly_map(
+        self, distribution: Union[List[Tensor], List[List]], height: List[int], width: List[int]
+    ) -> Tensor:
+        """Compute the layer map based on likelihood estimation.
+
+        Args:
+          distribution: Probability distribution for each decoder block
+          height: blocks height
+          width: blocks width
+
+        Returns:
+          Final Anomaly Map
+
+        """
+
+        test_map: List[Tensor] = []
+        for layer_idx in range(len(self.pool_layers)):
+            test_norm = torch.tensor(distribution[layer_idx], dtype=torch.double)  # pylint: disable=not-callable
+            test_norm -= torch.max(test_norm)  # normalize likelihoods to (-Inf:0] by subtracting a constant
+            test_prob = torch.exp(test_norm)  # convert to probs in range [0:1]
+            test_mask = test_prob.reshape(-1, height[layer_idx], width[layer_idx])
+            # upsample
+            test_map.append(
+                F.interpolate(
+                    test_mask.unsqueeze(1), size=self.image_size, mode="bilinear", align_corners=True
+                ).squeeze()
+            )
+        # score aggregation
+        score_map = torch.zeros_like(test_map[0])
+        for layer_idx in range(len(self.pool_layers)):
+            score_map += test_map[layer_idx]
+        score_mask = score_map
+        # invert probs to anomaly scores
+        anomaly_map = score_mask.max() - score_mask
+
+        return anomaly_map
+
+    def __call__(self, **kwargs: Union[List[Tensor], List[int], List[List]]) -> Tensor:
+        """Returns anomaly_map.
+
+        Expects `distribution`, `height` and 'width' keywords to be passed explicitly
+
+        Example
+        >>> anomaly_map_generator = AnomalyMapGenerator(image_size=tuple(hparams.model.input_size),
+        >>>        pool_layers=pool_layers)
+        >>> output = self.anomaly_map_generator(distribution=dist, height=height, width=width)
+
+        Raises:
+            ValueError: `distribution`, `height` and 'width' keys are not found
+
+        Returns:
+            torch.Tensor: anomaly map
+        """
+        if not ("distribution" in kwargs and "height" in kwargs and "width" in kwargs):
+            raise KeyError(f"Expected keys `distribution`, `height` and `width`. Found {kwargs.keys()}")
+
+        # placate mypy
+        distribution: List[Tensor] = cast(List[Tensor], kwargs["distribution"])
+        height: List[int] = cast(List[int], kwargs["height"])
+        width: List[int] = cast(List[int], kwargs["width"])
+        return self.compute_anomaly_map(distribution, height, width)

anomalib/models/cflow/config.yaml

@@ -0,0 +1,101 @@
+dataset:
+  name: mvtec #options: [mvtec, btech, folder]
+  format: mvtec
+  path: ./datasets/MVTec
+  category: bottle
+  task: segmentation
+  image_size: 256
+  train_batch_size: 16
+  test_batch_size: 16
+  inference_batch_size: 16
+  fiber_batch_size: 64
+  num_workers: 8
+  transform_config:
+    train: null
+    val: null
+  create_validation_set: false
+
+model:
+  name: cflow
+  backbone: wide_resnet50_2
+  layers:
+    - layer2
+    - layer3
+    - layer4
+  decoder: freia-cflow
+  condition_vector: 128
+  coupling_blocks: 8
+  clamp_alpha: 1.9
+  soft_permutation: false
+  lr: 0.0001
+  early_stopping:
+    patience: 2
+    metric: pixel_AUROC
+    mode: max
+  normalization_method: min_max # options: [null, min_max, cdf]
+  threshold:
+    image_default: 0
+    pixel_default: 0
+    adaptive: true
+
+metrics:
+  image:
+    - F1Score
+    - AUROC
+  pixel:
+    - F1Score
+    - AUROC
+
+project:
+  seed: 0
+  path: ./results
+  log_images_to: [local]
+  logger: false # options: [tensorboard, wandb, csv] or combinations.
+
+# PL Trainer Args. Don't add extra parameter here.
+trainer:
+  accelerator: auto # <"cpu", "gpu", "tpu", "ipu", "hpu", "auto">
+  accumulate_grad_batches: 1
+  amp_backend: native
+  auto_lr_find: false
+  auto_scale_batch_size: false
+  auto_select_gpus: false
+  benchmark: false
+  check_val_every_n_epoch: 1
+  default_root_dir: null
+  detect_anomaly: false
+  deterministic: false
+  enable_checkpointing: true
+  enable_model_summary: true
+  enable_progress_bar: true
+  fast_dev_run: false
+  gpus: null # Set automatically
+  gradient_clip_val: 0
+  ipus: null
+  limit_predict_batches: 1.0
+  limit_test_batches: 1.0
+  limit_train_batches: 1.0
+  limit_val_batches: 1.0
+  log_every_n_steps: 50
+  log_gpu_memory: null
+  max_epochs: 50
+  max_steps: -1
+  max_time: null
+  min_epochs: null
+  min_steps: null
+  move_metrics_to_cpu: false
+  multiple_trainloader_mode: max_size_cycle
+  num_nodes: 1
+  num_processes: 1
+  num_sanity_val_steps: 0
+  overfit_batches: 0.0
+  plugins: null
+  precision: 32
+  profiler: null
+  reload_dataloaders_every_n_epochs: 0
+  replace_sampler_ddp: true
+  strategy: null
+  sync_batchnorm: false
+  tpu_cores: null
+  track_grad_norm: -1
+  val_check_interval: 1.0

anomalib/models/cflow/lightning_model.py

@@ -0,0 +1,161 @@
+"""CFLOW: Real-Time  Unsupervised Anomaly Detection via Conditional Normalizing Flows.
+
+https://arxiv.org/pdf/2107.12571v1.pdf
+"""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+import logging
+
+import einops
+import torch
+import torch.nn.functional as F
+from pytorch_lightning.callbacks import EarlyStopping
+from torch import optim
+
+from anomalib.models.cflow.torch_model import CflowModel
+from anomalib.models.cflow.utils import get_logp, positional_encoding_2d
+from anomalib.models.components import AnomalyModule
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["CflowLightning"]
+
+
+class CflowLightning(AnomalyModule):
+    """PL Lightning Module for the CFLOW algorithm."""
+
+    def __init__(self, hparams):
+        super().__init__(hparams)
+        logger.info("Initializing Cflow Lightning model.")
+
+        self.model: CflowModel = CflowModel(hparams)
+        self.loss_val = 0
+        self.automatic_optimization = False
+
+    def configure_callbacks(self):
+        """Configure model-specific callbacks."""
+        early_stopping = EarlyStopping(
+            monitor=self.hparams.model.early_stopping.metric,
+            patience=self.hparams.model.early_stopping.patience,
+            mode=self.hparams.model.early_stopping.mode,
+        )
+        return [early_stopping]
+
+    def configure_optimizers(self) -> torch.optim.Optimizer:
+        """Configures optimizers for each decoder.
+
+        Returns:
+            Optimizer: Adam optimizer for each decoder
+        """
+        decoders_parameters = []
+        for decoder_idx in range(len(self.model.pool_layers)):
+            decoders_parameters.extend(list(self.model.decoders[decoder_idx].parameters()))
+
+        optimizer = optim.Adam(
+            params=decoders_parameters,
+            lr=self.hparams.model.lr,
+        )
+        return optimizer
+
+    def training_step(self, batch, _):  # pylint: disable=arguments-differ
+        """Training Step of CFLOW.
+
+        For each batch, decoder layers are trained with a dynamic fiber batch size.
+        Training step is performed manually as multiple training steps are involved
+            per batch of input images
+
+        Args:
+          batch: Input batch
+          _: Index of the batch.
+
+        Returns:
+          Loss value for the batch
+
+        """
+        opt = self.optimizers()
+        self.model.encoder.eval()
+
+        images = batch["image"]
+        activation = self.model.encoder(images)
+        avg_loss = torch.zeros([1], dtype=torch.float64).to(images.device)
+
+        height = []
+        width = []
+        for layer_idx, layer in enumerate(self.model.pool_layers):
+            encoder_activations = activation[layer].detach()  # BxCxHxW
+
+            batch_size, dim_feature_vector, im_height, im_width = encoder_activations.size()
+            image_size = im_height * im_width
+            embedding_length = batch_size * image_size  # number of rows in the conditional vector
+
+            height.append(im_height)
+            width.append(im_width)
+            # repeats positional encoding for the entire batch 1 C H W to B C H W
+            pos_encoding = einops.repeat(
+                positional_encoding_2d(self.model.condition_vector, im_height, im_width).unsqueeze(0),
+                "b c h w-> (tile b) c h w",
+                tile=batch_size,
+            ).to(images.device)
+            c_r = einops.rearrange(pos_encoding, "b c h w -> (b h w) c")  # BHWxP
+            e_r = einops.rearrange(encoder_activations, "b c h w -> (b h w) c")  # BHWxC
+            perm = torch.randperm(embedding_length)  # BHW
+            decoder = self.model.decoders[layer_idx].to(images.device)
+
+            fiber_batches = embedding_length // self.model.fiber_batch_size  # number of fiber batches
+            assert fiber_batches > 0, "Make sure we have enough fibers, otherwise decrease N or batch-size!"
+
+            for batch_num in range(fiber_batches):  # per-fiber processing
+                opt.zero_grad()
+                if batch_num < (fiber_batches - 1):
+                    idx = torch.arange(
+                        batch_num * self.model.fiber_batch_size, (batch_num + 1) * self.model.fiber_batch_size
+                    )
+                else:  # When non-full batch is encountered batch_num * N will go out of bounds
+                    idx = torch.arange(batch_num * self.model.fiber_batch_size, embedding_length)
+                # get random vectors
+                c_p = c_r[perm[idx]]  # NxP
+                e_p = e_r[perm[idx]]  # NxC
+                # decoder returns the transformed variable z and the log Jacobian determinant
+                p_u, log_jac_det = decoder(e_p, [c_p])
+                #
+                decoder_log_prob = get_logp(dim_feature_vector, p_u, log_jac_det)
+                log_prob = decoder_log_prob / dim_feature_vector  # likelihood per dim
+                loss = -F.logsigmoid(log_prob)
+                self.manual_backward(loss.mean())
+                opt.step()
+                avg_loss += loss.sum()
+
+        return {"loss": avg_loss}
+
+    def validation_step(self, batch, _):  # pylint: disable=arguments-differ
+        """Validation Step of CFLOW.
+
+            Similar to the training step, encoder features
+            are extracted from the CNN for each batch, and anomaly
+            map is computed.
+
+        Args:
+          batch: Input batch
+          _: Index of the batch.
+
+        Returns:
+          Dictionary containing images, anomaly maps, true labels and masks.
+          These are required in `validation_epoch_end` for feature concatenation.
+
+        """
+        batch["anomaly_maps"] = self.model(batch["image"])
+
+        return batch

anomalib/models/cflow/torch_model.py

@@ -0,0 +1,130 @@
+"""PyTorch model for CFlow model implementation."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from typing import List, Union
+
+import einops
+import torch
+import torchvision
+from omegaconf import DictConfig, ListConfig
+from torch import nn
+
+from anomalib.models.cflow.anomaly_map import AnomalyMapGenerator
+from anomalib.models.cflow.utils import cflow_head, get_logp, positional_encoding_2d
+from anomalib.models.components import FeatureExtractor
+
+
+class CflowModel(nn.Module):
+    """CFLOW: Conditional Normalizing Flows."""
+
+    def __init__(self, hparams: Union[DictConfig, ListConfig]):
+        super().__init__()
+
+        self.backbone = getattr(torchvision.models, hparams.model.backbone)
+        self.fiber_batch_size = hparams.dataset.fiber_batch_size
+        self.condition_vector: int = hparams.model.condition_vector
+        self.dec_arch = hparams.model.decoder
+        self.pool_layers = hparams.model.layers
+
+        self.encoder = FeatureExtractor(backbone=self.backbone(pretrained=True), layers=self.pool_layers)
+        self.pool_dims = self.encoder.out_dims
+        self.decoders = nn.ModuleList(
+            [
+                cflow_head(
+                    condition_vector=self.condition_vector,
+                    coupling_blocks=hparams.model.coupling_blocks,
+                    clamp_alpha=hparams.model.clamp_alpha,
+                    n_features=pool_dim,
+                    permute_soft=hparams.model.soft_permutation,
+                )
+                for pool_dim in self.pool_dims
+            ]
+        )
+
+        # encoder model is fixed
+        for parameters in self.encoder.parameters():
+            parameters.requires_grad = False
+
+        self.anomaly_map_generator = AnomalyMapGenerator(
+            image_size=tuple(hparams.model.input_size), pool_layers=self.pool_layers
+        )
+
+    def forward(self, images):
+        """Forward-pass images into the network to extract encoder features and compute probability.
+
+        Args:
+          images: Batch of images.
+
+        Returns:
+          Predicted anomaly maps.
+
+        """
+
+        self.encoder.eval()
+        self.decoders.eval()
+        with torch.no_grad():
+            activation = self.encoder(images)
+
+        distribution = [torch.Tensor(0).to(images.device) for _ in self.pool_layers]
+
+        height: List[int] = []
+        width: List[int] = []
+        for layer_idx, layer in enumerate(self.pool_layers):
+            encoder_activations = activation[layer]  # BxCxHxW
+
+            batch_size, dim_feature_vector, im_height, im_width = encoder_activations.size()
+            image_size = im_height * im_width
+            embedding_length = batch_size * image_size  # number of rows in the conditional vector
+
+            height.append(im_height)
+            width.append(im_width)
+            # repeats positional encoding for the entire batch 1 C H W to B C H W
+            pos_encoding = einops.repeat(
+                positional_encoding_2d(self.condition_vector, im_height, im_width).unsqueeze(0),
+                "b c h w-> (tile b) c h w",
+                tile=batch_size,
+            ).to(images.device)
+            c_r = einops.rearrange(pos_encoding, "b c h w -> (b h w) c")  # BHWxP
+            e_r = einops.rearrange(encoder_activations, "b c h w -> (b h w) c")  # BHWxC
+            decoder = self.decoders[layer_idx].to(images.device)
+
+            # Sometimes during validation, the last batch E / N is not a whole number. Hence we need to add 1.
+            # It is assumed that during training that E / N is a whole number as no errors were discovered during
+            # testing. In case it is observed in the future, we can use only this line and ensure that FIB is at
+            # least 1 or set `drop_last` in the dataloader to drop the last non-full batch.
+            fiber_batches = embedding_length // self.fiber_batch_size + int(
+                embedding_length % self.fiber_batch_size > 0
+            )
+
+            for batch_num in range(fiber_batches):  # per-fiber processing
+                if batch_num < (fiber_batches - 1):
+                    idx = torch.arange(batch_num * self.fiber_batch_size, (batch_num + 1) * self.fiber_batch_size)
+                else:  # When non-full batch is encountered batch_num+1 * N will go out of bounds
+                    idx = torch.arange(batch_num * self.fiber_batch_size, embedding_length)
+                c_p = c_r[idx]  # NxP
+                e_p = e_r[idx]  # NxC
+                # decoder returns the transformed variable z and the log Jacobian determinant
+                with torch.no_grad():
+                    p_u, log_jac_det = decoder(e_p, [c_p])
+                #
+                decoder_log_prob = get_logp(dim_feature_vector, p_u, log_jac_det)
+                log_prob = decoder_log_prob / dim_feature_vector  # likelihood per dim
+                distribution[layer_idx] = torch.cat((distribution[layer_idx], log_prob))
+
+        output = self.anomaly_map_generator(distribution=distribution, height=height, width=width)
+        self.decoders.train()
+
+        return output.to(images.device)

anomalib/models/cflow/utils.py

@@ -0,0 +1,125 @@
+"""Helper functions for CFlow implementation."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+import logging
+import math
+
+import numpy as np
+import torch
+from torch import nn
+
+from anomalib.models.components.freia.framework import SequenceINN
+from anomalib.models.components.freia.modules import AllInOneBlock
+
+logger = logging.getLogger(__name__)
+
+
+def get_logp(dim_feature_vector: int, p_u: torch.Tensor, logdet_j: torch.Tensor) -> torch.Tensor:
+    """Returns the log likelihood estimation.
+
+    Args:
+        dim_feature_vector (int): Dimensions of the condition vector
+        p_u (torch.Tensor): Random variable u
+        logdet_j (torch.Tensor): log of determinant of jacobian returned from the invertable decoder
+
+    Returns:
+        torch.Tensor: Log probability
+    """
+    ln_sqrt_2pi = -np.log(np.sqrt(2 * np.pi))  # ln(sqrt(2*pi))
+    logp = dim_feature_vector * ln_sqrt_2pi - 0.5 * torch.sum(p_u**2, 1) + logdet_j
+    return logp
+
+
+def positional_encoding_2d(condition_vector: int, height: int, width: int) -> torch.Tensor:
+    """Creates embedding to store relative position of the feature vector using sine and cosine functions.
+
+    Args:
+        condition_vector (int): Length of the condition vector
+        height (int): H of the positions
+        width (int): W of the positions
+
+    Raises:
+        ValueError: Cannot generate encoding with conditional vector length not as multiple of 4
+
+    Returns:
+        torch.Tensor: condition_vector x HEIGHT x WIDTH position matrix
+    """
+    if condition_vector % 4 != 0:
+        raise ValueError(f"Cannot use sin/cos positional encoding with odd dimension (got dim={condition_vector})")
+    pos_encoding = torch.zeros(condition_vector, height, width)
+    # Each dimension use half of condition_vector
+    condition_vector = condition_vector // 2
+    div_term = torch.exp(torch.arange(0.0, condition_vector, 2) * -(math.log(1e4) / condition_vector))
+    pos_w = torch.arange(0.0, width).unsqueeze(1)
+    pos_h = torch.arange(0.0, height).unsqueeze(1)
+    pos_encoding[0:condition_vector:2, :, :] = (
+        torch.sin(pos_w * div_term).transpose(0, 1).unsqueeze(1).repeat(1, height, 1)
+    )
+    pos_encoding[1:condition_vector:2, :, :] = (
+        torch.cos(pos_w * div_term).transpose(0, 1).unsqueeze(1).repeat(1, height, 1)
+    )
+    pos_encoding[condition_vector::2, :, :] = (
+        torch.sin(pos_h * div_term).transpose(0, 1).unsqueeze(2).repeat(1, 1, width)
+    )
+    pos_encoding[condition_vector + 1 :: 2, :, :] = (
+        torch.cos(pos_h * div_term).transpose(0, 1).unsqueeze(2).repeat(1, 1, width)
+    )
+    return pos_encoding
+
+
+def subnet_fc(dims_in: int, dims_out: int):
+    """Subnetwork which predicts the affine coefficients.
+
+    Args:
+        dims_in (int): input dimensions
+        dims_out (int): output dimensions
+
+    Returns:
+        nn.Sequential: Feed-forward subnetwork
+    """
+    return nn.Sequential(nn.Linear(dims_in, 2 * dims_in), nn.ReLU(), nn.Linear(2 * dims_in, dims_out))
+
+
+def cflow_head(
+    condition_vector: int, coupling_blocks: int, clamp_alpha: float, n_features: int, permute_soft: bool = False
+) -> SequenceINN:
+    """Create invertible decoder network.
+
+    Args:
+        condition_vector (int): length of the condition vector
+        coupling_blocks (int): number of coupling blocks to build the decoder
+        clamp_alpha (float): clamping value to avoid exploding values
+        n_features (int): number of decoder features
+        permute_soft (bool): Whether to sample the permutation matrix :math:`R` from :math:`SO(N)`,
+            or to use hard permutations instead. Note, ``permute_soft=True`` is very slow
+            when working with >512 dimensions.
+
+    Returns:
+        SequenceINN: decoder network block
+    """
+    coder = SequenceINN(n_features)
+    logger.info("CNF coder: %d", n_features)
+    for _ in range(coupling_blocks):
+        coder.append(
+            AllInOneBlock,
+            cond=0,
+            cond_shape=(condition_vector,),
+            subnet_constructor=subnet_fc,
+            affine_clamping=clamp_alpha,
+            global_affine_type="SOFTPLUS",
+            permute_soft=permute_soft,
+        )
+    return coder

anomalib/models/components/__init__.py

@@ -0,0 +1,32 @@
+"""Components used within the models."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from .base import AnomalyModule, DynamicBufferModule
+from .dimensionality_reduction import PCA, SparseRandomProjection
+from .feature_extractors import FeatureExtractor
+from .sampling import KCenterGreedy
+from .stats import GaussianKDE, MultiVariateGaussian
+
+__all__ = [
+    "AnomalyModule",
+    "DynamicBufferModule",
+    "PCA",
+    "SparseRandomProjection",
+    "FeatureExtractor",
+    "KCenterGreedy",
+    "GaussianKDE",
+    "MultiVariateGaussian",
+]

anomalib/models/components/base/__init__.py

@@ -0,0 +1,20 @@
+"""Base classes for all anomaly components."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from .anomaly_module import AnomalyModule
+from .dynamic_module import DynamicBufferModule
+
+__all__ = ["AnomalyModule", "DynamicBufferModule"]

anomalib/models/components/base/anomaly_module.py

@@ -0,0 +1,181 @@
+"""Base Anomaly Module for Training Task."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from abc import ABC
+from typing import Any, List, Optional, Union
+
+import pytorch_lightning as pl
+from omegaconf import DictConfig, ListConfig
+from pytorch_lightning.callbacks.base import Callback
+from torch import Tensor, nn
+
+from anomalib.utils.metrics import (
+    AdaptiveThreshold,
+    AnomalyScoreDistribution,
+    MinMax,
+    get_metrics,
+)
+
+
+class AnomalyModule(pl.LightningModule, ABC):
+    """AnomalyModule to train, validate, predict and test images.
+
+    Acts as a base class for all the Anomaly Modules in the library.
+
+    Args:
+        params (Union[DictConfig, ListConfig]): Configuration
+    """
+
+    def __init__(self, params: Union[DictConfig, ListConfig]):
+
+        super().__init__()
+        # Force the type for hparams so that it works with OmegaConfig style of accessing
+        self.hparams: Union[DictConfig, ListConfig]  # type: ignore
+        self.save_hyperparameters(params)
+        self.loss: Tensor
+        self.callbacks: List[Callback]
+
+        self.image_threshold = AdaptiveThreshold(self.hparams.model.threshold.image_default).cpu()
+        self.pixel_threshold = AdaptiveThreshold(self.hparams.model.threshold.pixel_default).cpu()
+
+        self.training_distribution = AnomalyScoreDistribution().cpu()
+        self.min_max = MinMax().cpu()
+
+        self.model: nn.Module
+
+        # metrics
+        self.image_metrics, self.pixel_metrics = get_metrics(self.hparams)
+        self.image_metrics.set_threshold(self.hparams.model.threshold.image_default)
+        self.pixel_metrics.set_threshold(self.hparams.model.threshold.pixel_default)
+
+    def forward(self, batch):  # pylint: disable=arguments-differ
+        """Forward-pass input tensor to the module.
+
+        Args:
+            batch (Tensor): Input Tensor
+
+        Returns:
+            Tensor: Output tensor from the model.
+        """
+        return self.model(batch)
+
+    def validation_step(self, batch, batch_idx) -> dict:  # type: ignore  # pylint: disable=arguments-differ
+        """To be implemented in the subclasses."""
+        raise NotImplementedError
+
+    def predict_step(self, batch: Any, batch_idx: int, _dataloader_idx: Optional[int] = None) -> Any:
+        """Step function called during :meth:`~pytorch_lightning.trainer.trainer.Trainer.predict`.
+
+        By default, it calls :meth:`~pytorch_lightning.core.lightning.LightningModule.forward`.
+        Override to add any processing logic.
+
+        Args:
+            batch (Tensor): Current batch
+            batch_idx (int): Index of current batch
+            _dataloader_idx (int): Index of the current dataloader
+
+        Return:
+            Predicted output
+        """
+        outputs = self.validation_step(batch, batch_idx)
+        self._post_process(outputs)
+        outputs["pred_labels"] = outputs["pred_scores"] >= self.image_threshold.value
+        if "anomaly_maps" in outputs.keys():
+            outputs["pred_masks"] = outputs["anomaly_maps"] >= self.pixel_threshold.value
+        return outputs
+
+    def test_step(self, batch, _):  # pylint: disable=arguments-differ
+        """Calls validation_step for anomaly map/score calculation.
+
+        Args:
+          batch (Tensor): Input batch
+          _: Index of the batch.
+
+        Returns:
+          Dictionary containing images, features, true labels and masks.
+          These are required in `validation_epoch_end` for feature concatenation.
+        """
+        return self.validation_step(batch, _)
+
+    def validation_step_end(self, val_step_outputs):  # pylint: disable=arguments-differ
+        """Called at the end of each validation step."""
+        self._outputs_to_cpu(val_step_outputs)
+        self._post_process(val_step_outputs)
+        return val_step_outputs
+
+    def test_step_end(self, test_step_outputs):  # pylint: disable=arguments-differ
+        """Called at the end of each test step."""
+        self._outputs_to_cpu(test_step_outputs)
+        self._post_process(test_step_outputs)
+        return test_step_outputs
+
+    def validation_epoch_end(self, outputs):
+        """Compute threshold and performance metrics.
+
+        Args:
+          outputs: Batch of outputs from the validation step
+        """
+        if self.hparams.model.threshold.adaptive:
+            self._compute_adaptive_threshold(outputs)
+        self._collect_outputs(self.image_metrics, self.pixel_metrics, outputs)
+        self._log_metrics()
+
+    def test_epoch_end(self, outputs):
+        """Compute and save anomaly scores of the test set.
+
+        Args:
+            outputs: Batch of outputs from the validation step
+        """
+        self._collect_outputs(self.image_metrics, self.pixel_metrics, outputs)
+        self._log_metrics()
+
+    def _compute_adaptive_threshold(self, outputs):
+        self._collect_outputs(self.image_threshold, self.pixel_threshold, outputs)
+        self.image_threshold.compute()
+        if "mask" in outputs[0].keys() and "anomaly_maps" in outputs[0].keys():
+            self.pixel_threshold.compute()
+        else:
+            self.pixel_threshold.value = self.image_threshold.value
+
+        self.image_metrics.set_threshold(self.image_threshold.value.item())
+        self.pixel_metrics.set_threshold(self.pixel_threshold.value.item())
+
+    def _collect_outputs(self, image_metric, pixel_metric, outputs):
+        for output in outputs:
+            image_metric.cpu()
+            image_metric.update(output["pred_scores"], output["label"].int())
+            if "mask" in output.keys() and "anomaly_maps" in output.keys():
+                pixel_metric.cpu()
+                pixel_metric.update(output["anomaly_maps"].flatten(), output["mask"].flatten().int())
+
+    def _post_process(self, outputs):
+        """Compute labels based on model predictions."""
+        if "pred_scores" not in outputs and "anomaly_maps" in outputs:
+            outputs["pred_scores"] = (
+                outputs["anomaly_maps"].reshape(outputs["anomaly_maps"].shape[0], -1).max(dim=1).values
+            )
+
+    def _outputs_to_cpu(self, output):
+        # for output in outputs:
+        for key, value in output.items():
+            if isinstance(value, Tensor):
+                output[key] = value.cpu()
+
+    def _log_metrics(self):
+        """Log computed performance metrics."""
+        self.log_dict(self.image_metrics)
+        if self.pixel_metrics.update_called:
+            self.log_dict(self.pixel_metrics)

anomalib/models/components/base/dynamic_module.py

@@ -0,0 +1,63 @@
+"""Dynamic Buffer Module."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from abc import ABC
+
+from torch import Tensor, nn
+
+
+class DynamicBufferModule(ABC, nn.Module):
+    """Torch module that allows loading variables from the state dict even in the case of shape mismatch."""
+
+    def get_tensor_attribute(self, attribute_name: str) -> Tensor:
+        """Get attribute of the tensor given the name.
+
+        Args:
+            attribute_name (str): Name of the tensor
+
+        Raises:
+            ValueError: `attribute_name` is not a torch Tensor
+
+        Returns:
+            Tensor: Tensor attribute
+        """
+        attribute = self.__getattr__(attribute_name)
+        if isinstance(attribute, Tensor):
+            return attribute
+
+        raise ValueError(f"Attribute with name '{attribute_name}' is not a torch Tensor")
+
+    def _load_from_state_dict(self, state_dict: dict, prefix: str, *args):
+        """Resizes the local buffers to match those stored in the state dict.
+
+        Overrides method from parent class.
+
+        Args:
+          state_dict (dict): State dictionary containing weights
+          prefix (str): Prefix of the weight file.
+          *args:
+        """
+        persistent_buffers = {k: v for k, v in self._buffers.items() if k not in self._non_persistent_buffers_set}
+        local_buffers = {k: v for k, v in persistent_buffers.items() if v is not None}
+
+        for param in local_buffers.keys():
+            for key in state_dict.keys():
+                if key.startswith(prefix) and key[len(prefix) :].split(".")[0] == param:
+                    if not local_buffers[param].shape == state_dict[key].shape:
+                        attribute = self.get_tensor_attribute(param)
+                        attribute.resize_(state_dict[key].shape)
+
+        super()._load_from_state_dict(state_dict, prefix, *args)

anomalib/models/components/dimensionality_reduction/__init__.py

@@ -0,0 +1,20 @@
+"""Algorithms for decomposition and dimensionality reduction."""
+
+# Copyright (C) 2020 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+from .pca import PCA
+from .random_projection import SparseRandomProjection
+
+__all__ = ["PCA", "SparseRandomProjection"]