Get Started with Anomalib: 5-Step Setup Guide (2025)

# Create a new virtual environment named 'anomalib_env'
python -m venv anomalib_env

# Activate the environment
# On Windows:
anomalib_env\Scripts\activate

# On macOS/Linux:
source anomalib_env/bin/activate

# Create a new conda environment with a specific Python version
conda create -n anomalib_env python=3.10

# Activate the environment
conda activate anomalib_env

pip install anomalib

This command will install Anomalib along with its core dependencies, including PyTorch. If you have a CUDA-enabled GPU (which is highly recommended for faster training), ensure you have a compatible version of PyTorch installed. You can check the official PyTorch website for the correct installation command.

Step 3: Understanding Datasets and Configs

Anomalib is designed to be data-centric and configuration-driven. Before you can train a model, you need to tell it what data to use and how to behave. This is handled through a dataset folder and a YAML configuration file.

The Dataset Structure

Anomalib expects a specific folder structure for your data. It's simple and intuitive. For a standard unsupervised task, you only need to provide "good" (normal) images for training. The testing set contains both normal images and anomalous ones, organized into subfolders.

Here's the structure for the famous MVTec AD dataset, which Anomalib supports out-of-the-box:

mvtec/
└── bottle/
    ├── train/
    │   └── good/
    │       ├── 000.png
    │       ├── 001.png
    │       └── ...
    ├── test/
    │   ├── good/
    │   │   ├── 000.png
    │   │   └── ...
    │   ├── broken_large/
    │   │   ├── 000.png
    │   │   └── ...
    │   └── contamination/
    │       ├── 000.png
    │       └── ...
    └── ground_truth/
        └── broken_large/
            ├── 000_mask.png
            └── ...

The key takeaway for your own custom dataset is this: place all your normal training images in a train/good folder. Your testing images go into test/good for normal samples and test/<anomaly_name> for defective samples.

The Configuration (YAML) Files

Instead of passing dozens of arguments through the command line, Anomalib uses .yaml files to define an experiment. These files are the control panel for your training job. If you installed from source, you'll find them in the configs/ directory. If not, you can find them in the GitHub repository.

Let's look at a snippet from a typical config file, like patchcore.yaml:

# src/anomalib/models/patchcore/config.yaml

dataset:
  name: mvtec
  format: mvtec
  path: ./datasets/mvtec
  category: bottle
  image_size: 256

model:
  name: patchcore
  backbone: wide_resnet50
  layers:
    - layer2
    - layer3
  coreset_sampling_ratio: 0.1

trainer:
  max_epochs: 1
  # ... other trainer settings

This file clearly defines the dataset path, the model to use (PatchCore), its specific parameters, and the training settings. You can easily duplicate and modify these files to experiment with different models or datasets.

Step 4: Running Your First Training Job

Now for the exciting part! With our environment and understanding of the structure, we can launch a training job. Anomalib provides a simple command-line interface (CLI) for this.

First, you'll need a config file and a dataset. For this example, let's assume you've downloaded the MVTec `bottle` dataset and placed it in a `datasets/mvtec` folder. You also need the `patchcore.yaml` config file.

The command to start training is:

anomalib train --model patchcore --data.path ./datasets/mvtec --data.category bottle

Alternatively, if you are using a custom YAML file:

anomalib train --config my_patchcore_config.yaml

The system will spring to life! You'll see a progress bar as the model trains and evaluates. Once finished, all the results, including model weights, logs, and performance metrics, will be saved in a structured directory, typically under results/<model_name>/<dataset_category>/.

A Quick Note: Which Model to Choose?

Anomalib offers over 15 models. Which one is right for you? Here’s a very brief comparison of three popular choices:

• PaDiM: Fast to train and offers good performance. A great starting point.
• PatchCore: Often provides state-of-the-art accuracy, but can be memory-intensive with large datasets. Excellent for high-performance needs.
• FastFlow: A normalizing flow-based model that is very fast during inference, making it suitable for real-time applications.

Start with PaDiM or PatchCore, and explore from there based on your specific accuracy and speed requirements.

Step 5: Inference and Visualizing Results

Training a model is only half the battle. The real value comes from using it to detect anomalies in new, unseen images. Anomalib has a dedicated CLI for inference.

You'll need the path to your trained model's weights (the .ckpt or .pt file) and the input image or folder you want to inspect.

anomalib infer --weights results/patchcore/mvtec/bottle/v1/weights/torch/model.pt \
             --input path/to/your/new_images/ \
             --output results/inference/

This command will run each image through the model and generate outputs. The most important output is the anomaly map, a heatmap that highlights where the model detected a deviation from the norm. Bright, hot areas on the map indicate likely anomalies.

You will find these visualized images in the specified --output directory. By inspecting these heatmaps, you can not only tell if an image is anomalous but also where the defect is located. This visual feedback is invaluable for quality control operators and for debugging your model's performance.

Conclusion: Your Journey Has Just Begun

Congratulations! You've successfully navigated the five core steps to get started with Anomalib: setting up your environment, installing the library, understanding its data and config structure, training a model, and running inference.

You now have a powerful tool at your disposal for tackling complex visual inspection challenges. The real journey starts now. I encourage you to experiment with your own custom datasets, try different models from the library, and dive into the configuration files to fine-tune your results. The world of unsupervised anomaly detection is vast, and with Anomalib, you're well-equipped to explore it.