MATCH: Multi-View Anomaly Detection

• MATCH is a multi-view anomaly detection method that uses Flow Matching to estimate likelihoods and score anomalies from defect-free data.
• The method extracts multi-scale features via a pretrained WideResNet50 and conditions on both time and view index using learned embeddings.
• MATCH achieves state-of-the-art segmentation and detection performance on industrial benchmarks while operating efficiently on consumer-level hardware.

MATCH is a multi-view anomaly detection method for industrial objects that is based on Flow Matching (FM). It is designed for semi-supervised anomaly detection from defect-free data and targets object-, image-, and pixel-level detection in multi-view image data, where an object is anomalous if any view exhibits a defect. The method uses the ODE formulation of Flow Matching to estimate likelihoods and derive anomaly scores, while conditioning the model on both time and view index. It was introduced as the first multi-view anomaly detection method based on Flow Matching and was evaluated on Real-IAD and MANTA-Tiny, where it achieved state-of-the-art performance in anomaly detection and segmentation while remaining usable on consumer-level hardware (Kruse et al., 23 Jun 2026).

1. Problem setting and design rationale

Industrial anomaly detection often relies on defect-free training data and must identify deviations at inference time. MATCH is formulated for multi-view anomaly detection, motivated by the observation that a single camera often misses anomalies that appear only from particular viewpoints. This is especially relevant for complex objects, occlusions, and subtle defects. In the Real-IAD benchmark, each object is seen from five views per object, and object-level anomaly detection is defined by a max-over-views decision rule: an object is anomalous if any view exhibits a defect (Kruse et al., 23 Jun 2026).

The method is explicitly multi-level. At the pixel level, it produces anomaly segmentation maps. At the image level, it produces per-view anomaly scores. At the object level, it aggregates image-wise scores across all views. The architecture is built to operate on multi-scale latent features extracted from multiple viewpoints, but it does not use explicit geometric alignment or cross-view registration. Instead, views are processed independently and conditioned through a learned embedding of the view index, and multi-view information is aggregated at scoring time via a max-over-views operator.

A central design choice is the use of Flow Matching rather than conventional normalizing flows. The paper positions this choice as a response to the architectural constraints of many RealNVP-based flows on high-dimensional image features. MATCH uses Flow Matching to transform normal features toward a standard Gaussian, and then interprets the Gaussian-space representation as an anomaly score. This supports density estimation while retaining architectural flexibility for multi-scale feature processing.

2. Architecture and multi-view representation learning

MATCH uses a frozen WideResNet50 pretrained on ImageNet as feature encoder. Features are extracted from its first three layers, yielding latent maps of sizes $(256 \times 64 \times 64)$, $(512 \times 32 \times 32)$, and $(1024 \times 16 \times 16)$ (Kruse et al., 23 Jun 2026). These maps are spatially aligned by downsampling the higher-resolution maps to the lowest-resolution map’s spatial size and concatenating them in a bottleneck.

The bottleneck uses GroupNorm and ResNet-style bottleneck blocks to distill the representation. Time conditioning is provided by a sinusoidal positional encoding of the scalar time $t$ followed by a small MLP. The view index $v$ is also embedded through a learned embedding and MLP. Time and view embeddings are added both to the bottleneck and to each decoder stage. This conditioning is integral to the FM formulation because the model learns a time-dependent velocity field and must also distinguish the viewpoint from which the features were extracted.

The decoder has three heads, each reconstructing per-scale outputs matching the spatial sizes of the original features. The overall architecture is inspired by Reverse Distillation (RD4AD), but the training objective is Flow Matching rather than a reconstruction or student-teacher objective. The method therefore combines multi-scale feature processing, explicit time conditioning, and explicit view conditioning within a single ODE-based density-estimation framework.

The model is trained one model per object class, which is typical in industrial anomaly detection. Images are resized to $256 \times 256$ before feature extraction. The decoder layers $D_i$ contain $3$, $4$, and $6$ blocks, respectively, the base width is $(512 \times 32 \times 32)$0, training runs for $(512 \times 32 \times 32)$1 epochs with batch size $(512 \times 32 \times 32)$2, and optimization uses AdamW with $(512 \times 32 \times 32)$3, $(512 \times 32 \times 32)$4, and weight decay $(512 \times 32 \times 32)$5. No gradient clipping or scaling is needed.

3. Flow Matching formulation

MATCH adopts Optimal Transport Conditional Flow Matching (OT-CFM). It learns a time-dependent velocity field $(512 \times 32 \times 32)$6 that moves features from the data distribution $(512 \times 32 \times 32)$7 toward a standard Gaussian base distribution $(512 \times 32 \times 32)$8. The ODE formulation is

$(512 \times 32 \times 32)$9

and the paper also writes the flow solution $(1024 \times 16 \times 16)$0 satisfying

$(1024 \times 16 \times 16)$1

The evolving density satisfies the continuity equation

$(1024 \times 16 \times 16)$2

and the instantaneous change-of-variables relation is

$(1024 \times 16 \times 16)$3

The specific OT-CFM path used by MATCH is linear between Gaussian noise $(1024 \times 16 \times 16)$4 and real data $(1024 \times 16 \times 16)$5:

$(1024 \times 16 \times 16)$6

with $(1024 \times 16 \times 16)$7 and $(1024 \times 16 \times 16)$8. The loss is the regression objective

$(1024 \times 16 \times 16)$9

In this formulation, the target velocity is simply $t$0 along the straight-line path. This makes training a regression problem rather than requiring ODE solution during training. The paper identifies this as one of the practical advantages of Flow Matching in the anomaly-detection setting.

At inference, MATCH integrates the ODE from $t$1 to $t$2, which is the density-estimation direction, to map real features $t$3 into Gaussian-space features $t$4. Inference uses a simple Euler solver with step size $t$5, giving $t$6 steps total. Ablation on ODE solvers showed that Midpoint, RK4, and Dopri5 gave nearly identical AUROC but substantially lower FPS, so Euler was preferred for the speed/accuracy trade-off (Kruse et al., 23 Jun 2026).

4. Likelihood estimation and anomaly scoring

The exact log-density expression would be

$t$7

However, MATCH omits the divergence term $t$8 at inference. The paper states that computing this term is expensive, although unbiased estimators such as Hutchinson’s trace can approximate it. Ablation studies showed essentially identical detection and segmentation performance without the divergence term, while throughput improved dramatically. On Real-IAD with an RTX 3090, the no-divergence setting achieved $t$9 FPS with $v$0 GB memory and I-AUROC $v$1, compared with $v$2 FPS and $v$3 GB for Hutchinson $v$4, and $v$5 FPS and $v$6 GB for Hutchinson $v$7, both with I-AUROC $v$8. The divergence contributed only about $v$9 to the score magnitude in the reported measurement (Kruse et al., 23 Jun 2026).

Omitting divergence yields the surrogate anomaly score

$256 \times 256$0

where $256 \times 256$1 is the feature dimensionality. The paper interprets this, up to an additive constant, as a squared Mahalanobis distance to $256 \times 256$2.

MATCH computes anomaly scores at three levels. For pixel-level segmentation, it computes per-scale maps $256 \times 256$3 by applying $256 \times 256$4 along the channel dimension of each decoded feature map, resizes them to full image resolution, and sums them:

$256 \times 256$5

For image-level detection, it uses only the last two scale maps:

$256 \times 256$6

The image score is the maximum spatial value in $256 \times 256$7. For object-level scoring across $256 \times 256$8 views, MATCH takes the maximum image-wise score over views:

$256 \times 256$9

This scoring scheme aligns the role of different feature scales with the two tasks: all scales contribute to segmentation, whereas higher-level scales dominate image-level detection.

5. Training, inference, and empirical performance

The inference pipeline processes each view independently. For each view, the model extracts multiscale features $D_i$0 from WideResNet50, initializes $D_i$1 at $D_i$2, performs $D_i$3 Euler steps with step size $D_i$4 to obtain Gaussian-space features $D_i$5, computes per-scale anomaly maps $D_i$6, then derives the segmentation map $D_i$7, the image detection map $D_i$8, and the image score by spatial max. Object-level scoring is then computed by max aggregation across views (Kruse et al., 23 Jun 2026).

The reported headline results are strongest on segmentation while remaining strong on detection. On Real-IAD, which contains $D_i$9 categories, about $3$0k normal images, about $3$1k anomalous images, and five views per object, MATCH achieved:

Dataset	I-AUROC	S-AUROC	P-AUROC	P-AUPRO	P-AP
Real-IAD	$3$2	$3$3	$3$4	$3$5	$3$6

On Real-IAD, the paper highlights comparison points against Multi-Flow and RD4AD. Multi-Flow achieved I-AUROC $3$7, S-AUROC $3$8, and P-AUPRO $3$9, while RD4AD achieved P-AUROC $4$0, P-AUPRO $4$1, and P-AP $4$2. MATCH exceeded Multi-Flow in detection and substantially in segmentation metrics, and improved all three reported segmentation metrics over RD4AD (Kruse et al., 23 Jun 2026).

On MANTA-Tiny, MATCH is reported as the first method to comprehensively evaluate popular anomaly detection methods on that benchmark. It achieved best overall segmentation metrics, with P-AUPRO $4$3 and P-AUROC $4$4, outperforming RD4AD’s $4$5 and $4$6, respectively. Its image-level I-AUROC on MANTA-Tiny was $4$7, which was competitive but below SimpleNet’s $4$8. The paper attributes this gap to the higher variance in defect types and tiny anomalies in MANTA-Tiny. It also reports that training on MANTA-Tiny and testing on the full MANTA test split, which is about $4$9 identical, yielded stable performance.

Ablations further supported the methodological choices. Performance improved with model width up to about $6$0. The paper states that the gains are due to the FM formulation rather than parameter count alone, since RD4AD matched in capacity underperformed in I-AUROC. Euler solver was preferred over Midpoint, RK4, and Dopri5 because AUROC remained nearly identical while throughput was higher.

6. Practical constraints, limitations, and relation to prior anomaly detection methods

MATCH was evaluated using a single consumer GPU, specifically an RTX 3090. With Euler integration and no divergence term, it reached $6$1 FPS and used $6$2 GB of memory. The paper explicitly frames this as satisfying latency requirements of real production scenarios and as supporting real-time usability on consumer-level hardware (Kruse et al., 23 Jun 2026).

Several limitations and failure cases are noted. Very large anomalies that are subtle in color or texture may be only partially segmented because of data ambiguity. Some anomalies are globally defined rather than locally defined, such as duplicate caps on a capsule, and local segmentation may miss these global cues. False positives can arise from rare normal patterns that are insufficiently covered in training, such as small natural spots. Lighting artifacts or non-object regions can also trigger false positives. The paper suggests that object segmentation pre-processing, improved data coverage, explicit 3D priors, multi-view correspondences, or depth constraints could help address these issues.

Within the anomaly-detection literature, the method is positioned against memory- or kNN-based density estimators such as PatchCore, PaDiM, and SPADE; against normalizing-flow methods such as DifferNet, CFLOW/CSFlow, FastFlow, and PyramidFlow; against student-teacher or reconstruction methods such as RD4AD, DSR, and SimpleNet; and against diffusion or score-based anomaly detection methods. The paper’s central claim in this comparison is methodological rather than taxonomic: Flow Matching allows general, non-invertible architectures to parameterize velocity fields, trains through a simple regression objective without solving the ODE during training, and handles high-dimensional latent features robustly. This suggests a specific role for MATCH within industrial anomaly detection: a density-estimation method that combines multi-scale feature modeling, explicit multi-view conditioning, and practical inference speed without the inference cost usually associated with exact likelihood computation.