[Paper] Latent Regularization in Generative Test Input Generation

Source: arXiv - 2602.15552v1

Overview

The paper explores how regularizing the latent space of a Style‑GAN can improve the generation of test inputs for deep‑learning image classifiers. By “truncating” the latent vectors—either through a clever mixing strategy or simple random clipping—the authors show they can produce test images that are more valid, diverse, and better at uncovering model bugs across MNIST, Fashion‑MNIST, and CIFAR‑10.

Key Contributions

• Latent‑space truncation for testing: Introduces two truncation strategies (latent code mixing with binary‑search optimization and random truncation) to steer a Style‑GAN toward useful test inputs.
• Comprehensive evaluation metrics: Measures generated inputs on validity (do they look like real data?), diversity (how varied are they?), and fault detection (how many misclassifications do they provoke).
• Empirical evidence across datasets: Demonstrates on three benchmark image datasets that the mixing‑based truncation consistently outperforms random truncation in all three quality dimensions.
• Practical recipe for developers: Provides a concrete workflow for integrating latent regularization into existing GAN‑based test‑generation pipelines.

Methodology

1. Base generator: The authors use a state‑of‑the‑art Style‑GAN trained on each dataset (MNIST, Fashion‑MNIST, CIFAR‑10).
2. Latent truncation strategies:
   • Random truncation: Clamp each component of the latent vector to a predefined range, effectively limiting the generator’s exploration space.
   • Latent code mixing: Combine two latent codes (one “safe” and one “exploratory”) and iteratively adjust the mixing weight using a binary‑search‑style optimizer that maximizes a fault‑detection proxy (e.g., classifier confidence drop).
3. Test‑input generation loop: For each strategy, generate a large pool of images, filter them through the target classifier, and record whether the classifier’s prediction changes (fault) and whether the image passes visual validity checks.
4. Metrics:
   • Validity: Human‑or automated perceptual checks (e.g., Fréchet Inception Distance).
   • Diversity: Pairwise feature distance in the classifier’s embedding space.
   • Fault detection: Percentage of generated images that cause misclassification.

Results & Findings

• Latent mixing consistently beats random truncation on all three metrics.
• The binary‑search optimizer converges after ~10–15 iterations, making the approach computationally cheap.
• Diversity gains indicate that the generated test set covers a broader slice of the input manifold, reducing the risk of “over‑fitting” the test suite to a narrow set of failure modes.

Practical Implications

• Automated robustness testing: Teams can plug the mixing‑based truncation into their CI pipelines to continuously generate challenging test images for vision models.
• Faster bug discovery: Higher fault‑detection rates mean fewer generated samples are needed to surface a defect, saving compute and labeling effort.
• Model‑agnostic: The method works with any classifier that provides confidence scores, so it can be applied to object detection, segmentation, or even non‑vision models that accept image‑like inputs.
• Improved data augmentation: The diverse, high‑validity samples can double as synthetic training data, potentially boosting model generalization.

Limitations & Future Work

• Scope limited to image classifiers: The study does not address other modalities (text, audio) where latent regularization may behave differently.
• Reliance on a pre‑trained GAN: Quality hinges on the underlying generator; poor GAN training could nullify the benefits.
• Binary‑search heuristic: While effective, it may not be optimal for highly non‑convex fault landscapes; exploring gradient‑based or reinforcement‑learning controllers is a natural next step.
• Human validation cost: Validity assessment still leans on perceptual metrics; integrating more robust automated quality checks would streamline adoption.

Bottom line: By intelligently constraining the latent space of a Style‑GAN, developers can generate smarter, more fault‑revealing test inputs with modest overhead—an approach that promises to tighten the feedback loop between model development and robustness assurance.

Authors

• Giorgi Merabishvili
• Oliver Weißl
• Andrea Stocco

Paper Information

• arXiv ID: 2602.15552v1
• Categories: cs.SE, cs.LG
• Published: February 17, 2026
• PDF: Download PDF