AnomaVision 🔍

High-performance visual anomaly detection. Fast, lightweight, production-ready.

AnomaVision detects defects without ever seeing defective examples during training.

Live Demo · Docs · Quickstart · Models · Tasks · Integrations · Issues · Discussions

Try AnomaVision instantly — no installation required.

The live demo runs a PaDiM model trained on MVTec bottle images and shows:

• 🌡️ Anomaly Heatmap — spatial score map highlighting defect regions
• 🖼️ Overlay — original image with anomaly contours drawn
• 🎭 Predicted Mask — binary segmentation of detected defects
• ⚡ Real-time inference — results in milliseconds on CPU

Upload your own bottle image or pick from the provided samples to see anomaly detection in action.

AnomaVision delivers visual anomaly detection optimized for production deployment. Based on PaDiM, it learns the distribution of normal images in a single forward pass — no labels, no segmentation masks, no lengthy training loops.

The result: a 15 MB model that runs at 43 FPS on CPU and 547 FPS on GPU, with higher AUROC than the existing best-in-class baseline.

⚠️ torch is hardware-specific. A plain pip install anomavision skips PyTorch entirely. Always install with an [extra] to get the right binaries for your hardware.

Don't have uv? Install it first — it's faster than pip and handles PyTorch's hardware routing correctly:

pip install uv

git clone https://github.com/DeepKnowledge1/AnomaVision.git
cd AnomaVision

# Create and activate a virtual environment
uv venv --python 3.11 .venv
source .venv/bin/activate        # Windows: .venv\Scripts\Activate.ps1

# Install with your hardware extra
uv sync --extra cpu              # CPU
uv sync --extra cu121            # CUDA 12.1

Or install from requirements.txt directly:

uv pip install -r requirements.txt

# CPU  ·  Mac, CI runners, edge devices
uv pip install "anomavision[cpu]"

# NVIDIA GPU  ·  pick your CUDA version
uv pip install "anomavision[cu118]"   # CUDA 11.8
uv pip install "anomavision[cu121]"   # CUDA 12.1
uv pip install "anomavision[cu124]"   # CUDA 12.4

If you're seeing ModuleNotFoundError: No module named 'torch', add PyTorch into your current environment:

# CPU
uv pip install torch torchvision torchaudio

# GPU (CUDA 12.1)
uv pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

python -c "import anomavision, torch; print('✅ Ready —', torch.__version__)"

AnomaVision ships a unified anomavision command — no need to run individual scripts directly.

# Train
anomavision train --config config.yml

# Detect (images or folder)
anomavision detect --config config.yml --img_path ./test_images --thresh 13.0

# Evaluate on MVTec
anomavision eval --config config.yml --enable_visualization

# Export to ONNX / TorchScript / OpenVINO / all
anomavision export --config config.yml --model model.pt --format all --precision fp16

Every command has full --help:

anomavision --help
anomavision train --help
anomavision export --help

import torch
import anomavision
from torch.utils.data import DataLoader

# --- 1. Dataset ---
# AnodetDataset reads normal images from a folder and applies preprocessing.
# You only need train/good/ — no labels, no anomalous images required.
dataset = anomavision.AnodetDataset(
    image_directory_path="./dataset/bottle/train/good",
    resize=(224, 224),     # resize before crop
    crop_size=(224, 224),  # center crop to this size
    normalize=True,        # ImageNet mean/std normalization
)
loader = DataLoader(dataset, batch_size=16)

# --- 2. Train ---
# fit() does a single forward pass — no gradient updates, no epochs.
# Fits a multivariate Gaussian at each spatial position of the feature map.
# Typical training time: under 10 seconds on CPU for ~200 images.
model = anomavision.Padim(
    backbone="resnet18",  # or "wide_resnet50" for higher accuracy
    device="cpu",         # or "cuda"
    feat_dim=100,         # number of random feature dimensions to keep
)
model.fit(loader)

# --- 3. Save ---
torch.save(model, "model.pt")                  # full model (for export or further use)
model.save_statistics("model.pth", half=True)  # stats-only (smaller, faster to load)

# --- 4. Infer ---
# scores: (batch_size,)      — scalar anomaly score per image. Higher = more anomalous.
# maps:   (batch_size, H, W) — spatial heatmap showing *where* the anomaly is.
#                              Pass directly to matplotlib.imshow() to visualize.
batch, *_ = next(iter(loader))
scores, maps = model.predict(batch)

uvicorn apps.api.fastapi_app:app --host 0.0.0.0 --port 8000

import requests

with open("image.jpg", "rb") as f:
    r = requests.post("http://localhost:8000/predict", files={"file": f})

print(r.json()["anomaly_score"])   # e.g. 14.3
print(r.json()["is_anomaly"])      # True / False

anomavision export \
  --model_data_path ./distributions/anomav_exp \
  --model model.pt \
  --format onnx \
  --precision fp16 \
  --quantize-dynamic

# stream_config.yml
stream_mode: true
stream_source:
  type: webcam
  camera_id: 0
model: model.onnx
thresh: 13.0
enable_visualization: true

anomavision detect --config stream_config.yml

# Minimal working config.yml
dataset_path:    ./dataset
class_name:      bottle

resize:          [256, 192]
crop_size:       [224, 224]
normalize:       true
norm_mean:       [0.485, 0.456, 0.406]
norm_std:        [0.229, 0.224, 0.225]

backbone:        resnet18
batch_size:      16
feat_dim:        100
layer_indices:   [0, 1, 2]
output_model:    model.pt
run_name:        exp1
model_data_path: ./distributions/anomav_exp

model:           model.onnx
device:          auto        # auto | cpu | cuda
thresh:          13.0

log_level:       INFO

# Terminal 1 — backend
uvicorn apps.api.fastapi_app:app --host 0.0.0.0 --port 8000

# Terminal 2 — UI
streamlit run apps/ui/streamlit_app.py -- --port 8000

dataset/
└── <class_name>/
    ├── train/
    │   └── good/          ← normal images only (no anomalies needed)
    └── test/
        ├── good/          ← normal test images
        └── <defect_name>/ ← anomalous test images (any subfolder name)

Key design decisions:

PaDiM needs no gradient training. Features are extracted once with a frozen ResNet. The model fits a multivariate Gaussian at each spatial location — training is a matrix decomposition, not backprop. That's why it finishes in ~8 seconds.

ModelWrapper makes the backend transparent. The same predict(batch) → (scores, maps) call works whether you loaded .pt, .onnx, .engine, or an OpenVINO directory. Every downstream caller — CLI, FastAPI, Streamlit, eval loop — uses the same interface.

Adaptive Gaussian post-processing is applied to score maps after inference. The kernel is sized relative to the image resolution, which is a key factor behind the Pixel AUROC gain over baseline.

# Clone and create environment
git clone https://github.com/DeepKnowledge1/AnomaVision.git
cd AnomaVision

uv venv --python 3.11 .venv
source .venv/bin/activate        # Windows: .venv\Scripts\Activate.ps1

# Install with dev dependencies
uv sync --extra cpu              # or --extra cu121 for GPU

# Install the package in editable mode
uv pip install -e .

# Verify CLI is working
anomavision --help

# Test
pytest tests/

# Format + lint
black . && isort . && flake8 .

Commit convention:

feat(export):  add TensorRT INT8 calibration
fix(detect):   handle empty directories
docs(api):     improve ModelWrapper examples

Types: feat · fix · docs · refactor · test · chore

PRs must pass pytest + flake8 and include doc updates if behavior changes. See docs/contributing.md.

FROM python:3.11-slim

RUN apt-get update && apt-get install -y \
    git git-lfs libsm6 libxext6 libgl1 libglib2.0-0 \
    && rm -rf /var/lib/apt/lists/*

RUN useradd -m -u 1000 user

RUN pip install --upgrade pip setuptools wheel && \
    pip install --no-cache-dir uv && \
    uv pip install --system "anomavision[cpu]"

USER user
ENV PATH="/home/user/.local/bin:/usr/local/bin:$PATH"

WORKDIR /home/user/app
COPY --chown=user . .

EXPOSE 7860
CMD ["python", "app.py"]

docker build -t anomavision .
docker run -p 7860:7860 -v $(pwd)/distributions:/home/user/app/distributions anomavision

gunicorn apps.api.fastapi_app:app \
  --workers 4 \
  --worker-class uvicorn.workers.UvicornWorker \
  --bind 0.0.0.0:8000 \
  --timeout 120

Production tip: Serve ONNX or TensorRT models — .pt inference is 2–3× slower than ONNX Runtime at batch size 1.

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

More: docs/troubleshooting.md

• Pre-trained model zoo for all 15 MVTec classes
• Few-shot adaptation (5–10 anomalous examples)
• Native TensorRT export in export.py
• Pixel-level mask in REST /predict response
• ONNX Runtime Web (browser inference via WASM)
• Helm chart for Kubernetes deployment

Request a feature →

• 🐛 Issues — bug reports
• 💡 Discussions — questions, ideas, show & tell
• 🤗 Live Demo — try it in your browser
• 📧 [email protected] — direct contact

@software{anomavision2025,
  title   = {AnomaVision: Edge-Ready Visual Anomaly Detection},
  author  = {DeepKnowledge Contributors},
  year    = {2025},
  url     = {https://github.com/DeepKnowledge1/AnomaVision},
}

Released under the MIT License. Built on Anodet — thanks to the original authors.