💻 computer science

Efficient Visual Anomaly Detection at the Edge: Enabling Real-Time Industrial Inspection on Resource-Constrained Devices

This paper proposes PatchCore-Lite and Padim-Lite, two memory-efficient and computationally optimized variants of popular Visual Anomaly Detection models, which enable real-time, private industrial inspection on resource-constrained edge devices by significantly reducing memory footprint and inference time while maintaining high performance on standard benchmarks.

Original authors: Arianna Stropeni, Fabrizio Genilotti, Francesco Borsatti, Manuel Barusco, Davide Dalle Pezze, Gian Antonio Susto

Published 2026-03-24

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Arianna Stropeni, Fabrizio Genilotti, Francesco Borsatti, Manuel Barusco, 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 running a busy factory where thousands of products roll off a conveyor belt every hour. Your job is to make sure every single item is perfect. If a bottle has a crack or a metal nut is missing a thread, it needs to be spotted immediately and removed.

In the past, factories used "Big Brain" computers in the cloud to do this inspection. They would take a photo of the product, send it over the internet to a giant server farm, wait for the server to analyze it, and then get an answer back.

The Problem:
Sending photos over the internet is slow (bad for fast conveyor belts) and risky (what if the photos contain secret factory designs?). Also, the "Big Brain" computers are expensive and require a lot of power.

The Solution:
The authors of this paper say, "Let's put the brain right on the factory floor!" They want to put a smart camera system directly on the machine (called the Edge). But here's the catch: factory machines are like old, tiny laptops. They have very little memory and weak processors. They can't handle the heavy, complex "Big Brain" software that usually does this job.

So, the team invented two new, super-lightweight versions of popular inspection software called PatchCore-Lite and PaDiM-Lite. Think of them as "Gym-Goer" versions of the original "Bodybuilder" models. They are stripped down to be fast and fit, but still strong enough to do the job.

Here is how they did it, using some fun analogies:

1. PaDiM-Lite: The "Simplified Recipe"

The original PaDiM software is like a master chef trying to write a recipe that accounts for every possible interaction between ingredients. If you have 100 ingredients, the chef calculates how ingredient #1 affects #2, #3, all the way to #100, and how #2 affects #3, and so on. It's incredibly accurate, but it takes forever to write down and requires a massive notebook.

The Lite Version:
The authors realized that for a factory floor, you don't need to know how every ingredient interacts with every other ingredient. You mostly need to know how much of each ingredient to use on its own.

The Trick: They stopped calculating the complex "cross-relationships" and just focused on the individual ingredients (the diagonal of the math matrix).
The Result: The recipe book shrunk from a heavy encyclopedia to a small notepad. The computer can read it 31% faster, and it takes up 77% less space in the machine's memory. It's like switching from a 10-course tasting menu to a quick, efficient sandwich that still tastes great.

2. PatchCore-Lite: The "Two-Step Search"

The original PatchCore software works like a librarian with a massive library of "Perfect Product" photos. When a new product comes in, the librarian has to compare it against every single photo in the library to find the closest match. If the library has 10,000 photos, that's 10,000 comparisons for every single product. On a tiny factory computer, this is too slow.

The Lite Version:
The authors introduced a clever "Two-Step Search" strategy:

Step 1 (The Rough Scan): Imagine the librarian doesn't look at the actual photos yet. Instead, they look at a compressed "index card" for each photo. These cards are tiny summaries (like a barcode). The librarian quickly scans the 10,000 index cards to find the top 500 that might be a match. This is super fast because the cards are small.
Step 2 (The Close Look): Now, the librarian only takes those top 500 candidates, opens their full photo albums, and does the detailed comparison.
The Result: Instead of opening 10,000 heavy photo albums, they only open 500. They save a massive amount of space (79% less memory) because the "index cards" take up almost no room. It's like using a search engine: you type a few keywords to narrow it down, then only click on the most relevant results.

The Bottom Line

The team tested these new "Lite" models on standard factory datasets (MVTec and VisA).

Did they work? Yes! They found defects almost as well as the heavy, slow versions.
Did they save space? Huge amounts. The memory usage dropped by nearly 80%.
Was it fast? Yes, especially for PaDiM-Lite. PatchCore-Lite was a bit slower than its "Edge" cousin because of the two-step search, but it was still fast enough for real-time use and saved so much memory that it could run on devices that previously couldn't run any of these models.

Why does this matter?
This means factories can now install smart, privacy-friendly inspection cameras directly on their machines. They don't need to send secret data to the cloud, they don't need expensive supercomputers, and they can catch defects instantly as the products fly by. It brings the "Big Brain" intelligence down to the "Little Laptop" level, making smart manufacturing accessible to everyone.

1. Problem Statement

Visual Anomaly Detection (VAD) is critical for industrial quality control but faces significant barriers when deployed on edge devices (e.g., devices located directly on production lines).

Constraints: Edge devices have limited memory, computational power, and processing capabilities compared to cloud servers.
Current Limitations: State-of-the-art VAD models (specifically PatchCore and PaDiM) are computationally expensive.
- PaDiM: Requires calculating and inverting full covariance matrices ( $O(d^3)$ complexity), which is heavy for inference and training.
- PatchCore: Relies on a large memory bank of feature vectors, requiring exhaustive nearest-neighbor searches ( $O(K \cdot d)$ ) that consume excessive memory and time.
Goal: The authors aim to adapt these high-performing models to run locally on edge devices without sacrificing too much detection accuracy, thereby enabling real-time, private, and low-latency industrial inspection.

2. Methodology

The authors propose two optimized variants of existing models, both utilizing a lightweight MobileNetV2 backbone (instead of heavy backbones like WideResNet50) to reduce the initial feature extraction cost.

A. PaDiM-Lite (Diagonal Covariance Approximation)

Original Approach: PaDiM models normal patch distributions using multivariate Gaussian distributions with full covariance matrices ( $\Sigma$ ). Anomaly scores are calculated via Mahalanobis distance, requiring matrix inversion.
Proposed Optimization: The authors assume feature dimensions are independent, replacing the full covariance matrix with a diagonal covariance matrix (essentially a variance vector).
Mathematical Shift:
- The Mahalanobis distance simplifies from a matrix-vector multiplication to an element-wise summation:
  $M(x_{ij}) = \sum_{k=1}^{d} \frac{(x_{ij,k} - \mu_{ij,k})^2}{\sigma^2_{ij,k}}$
Complexity Reduction:
- Training: Reduced from $O(d^2 \cdot N + d^3)$ to $O(d \cdot N)$ .
- Inference: Reduced from $O(d^2)$ to $O(d)$ .
- Memory: Eliminates the need to store $d \times d$ matrices, storing only $d$ -dimensional vectors.

B. PatchCore-Lite (Product Quantization & Two-Stage Search)

Original Approach: PatchCore stores a memory bank of $K$ feature vectors. Inference involves computing the Euclidean distance between a test patch and all $K$ vectors to find the nearest neighbor.
Proposed Optimization:
1. Product Quantization (PQ): The memory bank is compressed. Feature vectors are split into $m$ subspaces. Each subspace is quantized using a codebook of $V$ centroids (learned via K-means). Instead of storing full vectors, the system stores indices pointing to centroids.
2. Two-Stage Nearest Neighbor Search:
  - Stage 1 (Coarse Search): The test feature is quantized. The system computes an approximate asymmetric distance to all $K$ compressed vectors using lookup tables. It selects the top- $k$ candidates (where $k \ll K$ ).
  - Stage 2 (Fine Search): Only the top- $k$ candidates are decoded (reconstructed) from their quantized indices. Exact Euclidean distances are computed only for this small subset to determine the final anomaly score.
Complexity Reduction:
- Memory: Drastically reduced by storing indices and small codebooks instead of full float vectors.
- Computation: Reduces the search space from $O(K \cdot d)$ to $O(K \cdot m + k \cdot d)$ , where $m$ is the number of subspaces and $k$ is the candidate set size.

3. Key Contributions

PaDiM-Lite: A reformulation of PaDiM that replaces full covariance estimation with diagonal variance, reducing computational complexity from cubic/quadratic to linear ( $O(d)$ ) and significantly lowering memory usage.
PatchCore-Lite: A novel implementation using Product Quantization and a two-stage search strategy, achieving massive storage reduction (12 $\times$ in the memory bank) while maintaining high retrieval accuracy.
Comprehensive Evaluation: The methods are validated on standard industrial benchmarks (MVTec AD and VisA) with a focus on resource-constrained metrics (memory footprint, inference time, peak memory) alongside standard accuracy metrics (I-ROC, P-ROC).
Open Source: Both methods are released as part of the MoViAD library to support future research in edge-based VAD.

4. Experimental Results

The models were tested on an Intel Core i5-9600K CPU to simulate edge conditions.

Performance vs. Efficiency Trade-offs

Metric	PaDiM-Lite vs. PaDiM-Edge	PatchCore-Lite vs. PatchCore-Edge
Total Memory Reduction	77% (4.70 MB $\to$ 1.08 MB)	79% (7.05 MB $\to$ 1.49 MB)
Memory Bank Reduction	N/A (Variance vector vs. Covariance)	91% (6.10 MB $\to$ 0.54 MB)
Inference Time	31% faster (35ms $\to$ 24ms)	Slower (30ms $\to$ 130ms)
Pixel-Level Accuracy (P-ROC)	Slight drop (0.97 $\to$ 0.94 on MVTec)	Minimal drop (0.96 $\to$ 0.94 on MVTec)
Image-Level Accuracy (I-ROC)	Moderate drop (0.94 $\to$ 0.85 on MVTec)	Moderate drop (0.95 $\to$ 0.86 on MVTec)

PaDiM-Lite: Achieves the best balance for latency-critical applications. The diagonal approximation preserves spatial localization accuracy (P-ROC) while drastically cutting inference time and memory.
PatchCore-Lite: Offers the most extreme memory savings, making it ideal for devices with very tight storage constraints. However, the two-stage search introduces a latency penalty (4 $\times$ slower than the Edge baseline) due to the decoding step, though it remains feasible for many real-time scenarios.

5. Significance

Feasibility of Edge VAD: The paper demonstrates that high-performance VAD does not strictly require cloud computing. It is possible to deploy sophisticated anomaly detection models directly on resource-constrained hardware.
Privacy and Latency: By moving processing to the edge, the solution eliminates the need to transmit sensitive manufacturing data to the cloud (enhancing IP protection) and reduces latency, which is crucial for fast-moving production lines.
Scalability: The proposed methods allow industrial operators to tune the trade-off between performance and resource usage (e.g., adjusting the number of nearest neighbors $k$ in PatchCore-Lite) based on the specific hardware capabilities of their edge devices.
Future Direction: This work establishes a new baseline for "Edge-Optimized" VAD, shifting the focus from pure accuracy to efficiency-aware accuracy, which is the primary requirement for real-world industrial deployment.