💻 computer science

Continual Visual Anomaly Detection on the Edge: Benchmark and Efficient Solutions

This paper introduces the first comprehensive benchmark for continual visual anomaly detection on resource-constrained edge devices and proposes Tiny-Dinomaly, a highly efficient model that significantly reduces memory and computational costs while improving detection performance, alongside optimized versions of PatchCore and PaDiM.

Original authors: Manuel Barusco, Francesco Borsatti, David Petrovic, Davide Dalle Pezze, Gian Antonio Susto

Published 2026-04-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Manuel Barusco, Francesco Borsatti, David Petrovic, Davide Dalle Pezze, Gian Antonio Susto

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are the head of security for a massive, ever-changing factory. Your job is to spot defective products on a conveyor belt. In the past, you had a giant, super-smart security guard (a powerful AI) sitting in a huge, air-conditioned server room. This guard had access to every single product ever made, infinite memory, and unlimited coffee to stay awake. It worked great, but it was slow, expensive, and couldn't move with the factory.

Now, the factory wants to move the security guard right onto the assembly line. But there's a catch: the guard has to fit inside a tiny, battery-powered backpack (an Edge Device). They also have a new rule: every week, a new type of product arrives (like switching from inspecting nuts to inspecting cables), and the guard must learn this new job without forgetting how to inspect the old ones. This is called Continual Learning.

This paper is like a massive "Consumer Reports" guide for finding the perfect security guard for this tiny, evolving factory.

The Problem: The "Amnesia" vs. "Backpack" Dilemma

Most current security guards are either:

The Brains: Super smart but huge. They need a whole server room to fit. If you shrink them to fit in a backpack, they lose their brains.
The Amnesiacs: They can fit in a backpack, but if you teach them a new product, they immediately forget how to spot defects in the old products.

The authors asked: Can we find a guard that is small enough for a backpack, smart enough to spot tiny scratches, and has a memory good enough to remember everything it's ever learned?

The Solution: A New "Benchmark" (The Report Card)

The researchers created a giant test track. They took 7 different types of security guards (AI models) and tried them out with 3 different sizes of backpacks (lightweight computer chips). They tested them on two famous "training grounds" (datasets) full of industrial products.

They measured three things:

How small is the backpack? (Memory Footprint)
How fast does the guard think? (Inference Cost)
How good is the guard at finding defects? (Performance)

The Star Players (The New Solutions)

1. Tiny-Dinomaly: The "Mini-Master"

The original "Dinomaly" guard was a genius but weighed 560 MB (like a heavy suitcase). It was too big for the backpack.

The Fix: The authors built Tiny-Dinomaly. They swapped the giant brain for a tiny, efficient one called "DeiT-Tiny."
The Magic: Instead of just making it smaller, they realized that a smaller brain actually helped! Because the tiny brain couldn't memorize every single detail perfectly, it was forced to focus on the essence of what "normal" looks like. This made it surprisingly better at spotting weird anomalies.
The Result: It's 13 times smaller and 20 times faster than the original, but it actually got better at finding pixel-level defects (like a tiny scratch). It's like replacing a heavy tank with a nimble ninja who is actually more accurate.

2. PatchCoreCL++: The "Smart Librarian"

The original "PatchCore" guard kept a library of photos of every normal product it had ever seen. When a new product arrived, it added a new shelf.

The Problem: As the factory grew, the library got huge. To check a new item, the guard had to walk down every single aisle to find a match. This was slow and took up too much space.
The Fix: They created PatchCoreCL++.
- Smarter Shelving: Instead of reorganizing the whole library every time a new product arrived, they just cut off the bottom of the list (the least important photos).
- The ID Badge: Before checking the library, the guard now takes a quick "ID photo" of the item to guess which aisle it belongs to. It only walks down that one aisle.
The Result: It's 12 times faster at checking items and saves massive amounts of space, making it perfect for the edge.

3. PaDiM-Lite MultiModal: The "Specialized Note-Taker"

This guard uses a complex mathematical formula (a Gaussian distribution) to describe what "normal" looks like.

The Problem: The original formula was too heavy for the backpack. The "Lite" version was too simple and forgot things.
The Fix: They created a hybrid. They kept the "specialized note-taking" for each product type (so it doesn't forget) but simplified the math to just the most important numbers.
The Result: It strikes the perfect balance, offering high accuracy without the memory explosion of the original heavy version.

Key Takeaways for the Real World

Size Matters, but Smarts Matter More: You don't need a supercomputer to do this job. By swapping heavy computer chips for lightweight ones (like MobileNet or MCUNet), you can save 85% of the space and power with almost no loss in quality.
You Don't Need a Giant Memory: To remember the past, you don't need to store thousands of old photos. Keeping just 40 samples (a tiny handful) of old products is enough to stop the guard from forgetting. It's like remembering the gist of a story rather than memorizing every word.
The "One-Size-Fits-All" Myth is Dead: There is no single "best" guard.
- If you need speed and have a tiny battery, use MCUNet with PaSTe.
- If you need maximum accuracy for tiny scratches and have a bit more space, use Tiny-Dinomaly.
- If you need to detect which product you are looking at first, use PatchCoreCL++.

The Bottom Line

This paper proves that we can finally put "smart" industrial inspection systems right on the factory floor, on small, cheap devices, without needing a cloud connection. We can have a security guard that learns new jobs on the fly, never forgets its old ones, and fits in your pocket. It's a huge step toward making factories smarter, faster, and more private.

1. Problem Statement

Visual Anomaly Detection (VAD) is critical for industrial inspection and healthcare but faces two major, often conflicting, challenges in real-world deployment:

Edge Deployment: Real-world systems require low-latency, energy-efficient, and privacy-preserving operation on devices with severe constraints on memory and compute power.
Continual Learning (CL): Industrial environments are dynamic; new product categories are introduced over time. Models must adapt to these evolving data distributions without "catastrophic forgetting" (losing knowledge of previous categories).

The Gap: Existing research typically addresses these challenges in isolation. Continual learning methods assume unlimited server-side resources (large replay buffers, expensive updates), while edge-optimized VAD models assume static data distributions. There is a lack of comprehensive benchmarks or solutions that jointly optimize for efficiency (memory/compute) and adaptability (continual learning) on edge devices.

2. Methodology

The authors propose a comprehensive benchmark and three specific architectural solutions to address the joint constraints of edge deployment and continual learning.

A. The Benchmark Framework

Scope: Evaluated 7 VAD models (PatchCore, PaDiM, CFA, STFPM, SimpleNet, PaSTe, Dinomaly) across 6 backbone architectures (including lightweight options like MobileNet, MCUNet, PhiNet, and DeiT-Tiny).
Datasets: MVTec AD and VisA, covering a wide range of industrial inspection scenarios.
Continual Learning Protocol: A class-incremental setting where the model learns one object category at a time.
Strategies:
- Replay: The primary CL strategy used, tested with buffer sizes of 40 and 100 samples (approx. 5MB and 15MB) to simulate edge constraints.
- Baselines: Compared against Fine-Tuning (lower bound, suffers forgetting) and Joint Training (upper bound, ideal performance).

B. Proposed Solutions

1. Tiny-Dinomaly

Concept: A lightweight adaptation of the Dinomaly model (based on DINO foundation models).
Architecture: Replaces the heavy DINOv2 ViT-L/14 backbone (307M parameters) with DeiT-Tiny (5M parameters).
Mechanism: Utilizes a frozen encoder and a trainable transformer decoder. It employs Noisy Bottleneck, Linear Attention, and Loose Reconstruction to prevent the decoder from overfitting (identity mapping).
Key Insight: The smaller capacity of the DeiT-Tiny encoder naturally acts as a regularizer, making it harder for the decoder to reconstruct unseen anomalies, thereby improving pixel-level localization without explicit heavy constraints.

2. PatchCoreCL++

Problem: Standard PatchCoreCL requires re-running the $k$ -center algorithm to compress memory banks for every new task ( $O(S^2)$ complexity) and compares test images against all task memory banks during inference ( $O(K)$ complexity).
Solution:
- Training: Replaces $k$ -center recompression with a prefix-based truncation strategy. Based on the "farthest-first traversal" property, the least representative samples (at the end of the list) are simply discarded, reducing update cost to $O(1)$ .
- Inference: Introduces prototype-based task identification. Instead of scoring against all banks, the system identifies the task using a single nearest-prototype lookup, then scores only against that specific memory bank. This reduces inference cost from $O(K \cdot |M|)$ to $O(K + |M|)$ .

3. PaDiM-CL Variants (UniModal & MultiModal)

Correction: The authors identified a statistical bias in the original PaDiM-CL (from [1]), which used uniform weighting for tasks regardless of sample size. They proposed PaDiM-CL UniModal with a mathematically correct weighted fusion of means and covariances (using the parallel axis theorem).
Efficiency: Introduced PaDiM-CL-Lite MultiModal. Instead of storing full covariance matrices ( $O(d^2)$ ) for every task, it stores only diagonal variance vectors ( $O(d)$ ). This drastically reduces memory growth from quadratic to linear with respect to feature dimension, making multimodal continual learning feasible on edge devices.

3. Key Contributions

First Comprehensive Benchmark: Established the first systematic evaluation of VAD models under the joint constraints of edge deployment and continual learning, analyzing trade-offs between memory, compute, and performance.
Tiny-Dinomaly: A new state-of-the-art lightweight model that achieves 13× smaller memory footprint and 20× lower computational cost than the original Dinomaly, while improving Pixel F1 by 5 percentage points.
Algorithmic Optimizations:
- PatchCoreCL++: Reduces inference cost by 12× and eliminates the quadratic training update cost.
- PaDiM-CL-Lite MultiModal: Solves the memory explosion problem of multimodal continual learning, offering the best accuracy-memory trade-off in the PaDiM family.
Statistical Correction: Fixed a systematic bias in existing PaDiM-CL implementations, significantly improving baseline performance.

4. Results

Performance vs. Efficiency:
- Tiny-Dinomaly and PaSTe emerged as the top performers for pixel-level localization. Tiny-Dinomaly achieved a Pixel F1 of 0.45 with only 3.39 GFLOPs and 50.87 MB memory.
- PatchCoreCL++ achieved the highest Image-level F1 (0.96) while reducing inference cost from 49.16 GFLOPs to 4.15 GFLOPs (MobileNet backbone).
- PaDiM-CL-Lite MultiModal achieved a Pixel F1 of 0.41 with only 46.67 MB memory, outperforming the full-covariance UniModal variant (0.34 F1, 98 MB).
Backbone Analysis:
- MobileNet generally provided the highest accuracy but higher memory usage.
- MCUNet offered the best efficiency-to-performance ratio, suitable for strict latency constraints.
- PhiNet was a middle ground but lagged in detection accuracy.
Replay Buffer Size: A buffer of 40 samples (~5 MB) was found to capture the majority of continual learning benefits. Increasing to 100 samples yielded marginal gains, and beyond that, returns diminished rapidly. This suggests edge devices can operate with very small replay buffers.

5. Significance

This work bridges the gap between theoretical continual learning and practical edge deployment. It demonstrates that:

High-performance VAD on edge devices is feasible without sacrificing adaptability.
Structural regularization (using smaller encoders like DeiT-Tiny) can outperform explicit architectural constraints designed for larger models.
Algorithmic efficiency (e.g., prototype-based inference, diagonal covariance) is as critical as model compression for enabling lifelong learning on resource-constrained hardware.

The proposed solutions (Tiny-Dinomaly, PatchCoreCL++, PaDiM-CL-Lite) provide a toolkit for deploying adaptive, privacy-preserving industrial inspection systems on commodity hardware, moving beyond the "static server" paradigm.