WorksComputer Science
Robust Deep Prototype Classifiers via Lipschitz Training
Abstract
Robustness and interpretability are interrelated and desirable properties of machine learning models. A model that changes its prediction under imperceptible perturbations behaves inconsistently with human-recognizable features and, hence, is not interpretable. Prototype-based classifiers such as Generalized Learning Vector Quantization address both at once. They are interpretable by construction because they make the decision by comparing the input to the prototypical example; and their hypothesis margin yields a closed form robustness certificate. However, on high-dimensional data, these shallow models need deep embedding networks to achieve high accuracy, and this voids the robustness certificate. The margin is a statement about distances in the embedding space, and an unconstrained network can map an arbitrarily small input perturbation to arbitrarily large attacks in the embedding space. We close this gap with a theorem: if the embedding network is locally L-Lipschitz around a point, and the classifier is ε-robust around its embedding, then the full model is ε/L-robust in the input space. Based on this, we propose a Lipschitz training scheme to achieve L-Lipschitz properties for embedding networks. We evaluate three classification heads (linear, linear Support Vector Machine, and GLVQ) crossed with two embedding networks (standard and Lipschitz-constrained) on MNIST, CIFAR-10, and Imagenette-160, under FGS, PGD and C&W attacks. The evaluation results show that combining a prototype-based head with a Lipschitz-constrained embedding provides the strongest robustness. This suggests that the Lipschitz constraint provides an additional robustness benefit in addition to the advantage provided by the prototype-based head. Since the Lipschitz constraint is enforced by sampling rather than by construction, the reported robustness is empirical rather than certified.
Introduction
Machine learning systems have achieved remarkable breakthroughs in recent years, enabling applications across a wide range of domains, including medical imaging, computer vision, autonomous driving, and security monitoring. In these safety-critical applications, erroneous predictions or decisions can have potentially catastrophic consequences [Zhou et al.(2022)Zhou, Liu, Ye, Zhu, Zhou, and Yu]. Therefore, such applications demand not only accurate predictions but robustness and interpretability [5 )Göpfert, Artelt, Wersing, and Hammer] ()Carlini, Athalye, Papernot, Brendel, Rauber, Tsipras, Goodfellow, Madry, and Kurakin, Göpfert et al. 2020b); robust in the sense that decisions should remain stable under small changes in the input that a human would consider insignificant [45 )Xu, Ma, Liu, Deb, Liu, Tang, and Jain] ()Szegedy, Zaremba, Sutskever, Bruna, Erhan, Goodfellow, and Fergus, Goodfellow et al. 2014; )Goodfellow, Shlens, and Szegedy, Xu et al. 2020); and interpretable in the sense that users should be able to understand why a particular decision was made [Gunning et al.(2019)Gunning, Stefik, Choi, Miller, Stumpf, and Yang, Xu et al.(2019)Xu, Uszkoreit, Du, Fan, Zhao, and Zhu, Biehl et al.(2016)Biehl, Hammer, and Villmann], to assess the system before deployment and to diagnose potential failures afterwards. High accuracy on a test set alone does not guarantee either of these properties.
Szegedy et al. [45 )Szegedy, Zaremba, Sutskever, Bruna, Erhan, Goodfellow, and Fergus] were among the first to demonstrate this gap. They showed that small, often imperceptible changes to the input can completely change a network’s prediction, and that such changes often transfer between independently trained models. Over the past decade, researchers have confirmed that even models with excellent accuracy on clean data can be reduced to near-zero accuracy under white-box attacks [31] (Goodfellow et al. 2014; )Goodfellow, Shlens, and Szegedy, Madry et al. 2017). Vulnerability to adversarial attacks can also indicate a lack of interpretability, as the model may rely on features that are not meaningful or recognizable to humans. Therefore, robustness and interpretability are closely connected rather than being distinct goals. Both assess whether the model makes decisions based on features that humans can understand and recognize. This connection is the main focus of this paper.
Two main defense approaches (adversarial training and Lipschitz-based methods) have been proposed in the literature, each with its own strengths and drawbacks. Adversarial training adds adversarial examples into the training data and remains the most effective empirical defense [31 )Zhang, Yu, Jiao, Xing, El Ghaoui, and Jordan] ()Madry, Makelov, Schmidt, Tsipras, and Vladu, Zhang et al. 2019). However, this approach requires an inner optimization at every training step, trades clean accuracy for robustness [46 )Zhang, Yu, Jiao, Xing, El Ghaoui, and Jordan] ()Tsipras, Santurkar, Engstrom, Turner, and Madry, Zhang et al. 2019), and provides no formal guarantees: robustness is only certified against the attacks that were actually tested. Lipschitz-based methods, on the other hand, bound how much the model can amplify input differences, providing an attack-independent guarantee [22 )Hoffman, Roberts, and Yaidal] (Fazlyab et al. 2019; )Fazlyab, Robey, Hassani, Morari, and Pappas, Virmaux and Scaman 2018). Yet a Lipschitz bound alone is not a defense. In fact, the most Lipschitz-stable model is the constant function, which is useless for prediction [59]. Therefore, we propose to combine a Lipschitz constraint for a deep embedding network with the robustness guarantees of shallow classification models.
Prototype-based classifiers are such intrinsically robust classification models—and they additionally offer interpretability as a bonus. A nearest prototype classifier assigns an input to the class of its closest prototype. Thus, its decisions are interpretable as long as the prototypes themselves are interpretable [2 )Davoodi, Mohammadi-zehsamakosh, and Komeili] ()Biehl, Hammer, and Villmann, Davoodi et al. 2023). Since the decision depends solely on distances to a fixed set of prototypes, the distance to the decision boundary can be calculated in closed form. This distance, known as the hypothesis margin [8 )Crammer, Gilad-bachrach, Navot, and Tishby], was originally introduced to derive generalization bounds for Learning Vector Quantization (LVQ)—a specific family of prototype-based classifiers [8 )Hammer, Strickert, and Villmann] ()Crammer, Gilad-bachrach, Navot, and Tishby, Hammer et al. 2005). Saralajew et al. [Saralajew et al.(2020b)Saralajew, Holdijk, and Villmann] later showed that it also yields an adversarial robustness guarantee. Subsequent work has tightened these bounds further and has shown that prototype classifiers can be competitive with certified neural networks [49], while empirical studies report that GLVQ models are robust even before any explicit certification [Saralajew et al.(2020a)Saralajew, Holdijk, Rees, and Villmann].
The challenge, however, is that LVQ operates on distances in the input space, where the Euclidean distance is not meaningful for image data [Khalid and Paaßen()]. The common solution is a hybrid approach: train a deep network that embeds inputs nonlinearly, and then use prototype-based decisions in this embedding space [7 )Snell, Swersky, and Zemel] ()Chen, Li, Tao, Barnett, Rudin, and Su, Li et al. 2018; )Li, Liu, Chen, and Rudin, Snell et al. 2017). While this approach improves accuracy, it implicitly compromises the formal robustness guarantee. The certificate of a nearest prototype classifier is only valid in the space where the prototypes live. However, an unconstrained embedding network can map an arbitrarily small input change to an arbitrarily large change in the embedding space [26]. Therefore, a certified radius in the embedding space does not provide information regarding robustness in the original input space—unless we have a guarantee that distances in the embedding space are bounded by distances in the input space, which is precisely what a Lipschitz constraint does. As illustrated in Figure 1 (compare the top-left and top-right panels), without a Lipschitz constraint, small changes in the input space can result in large changes in the embedding space, invalidating the robustness guarantee.
Figure 1. Top Left: An adversarial attack of size from point . Top right: In embedding space, the attack is enlarged to size , violating Lipschitz continuity. Bottom: With Lipschitz training, the classification boundary shifts such that the attack fails because is now upper-bounded by .
Our approach is a combination of prototype-based classification and Lipschitz bounds to achieve better adversarial robustness for deep prototype classifiers. In more detail, our main contributions are:
A composition theorem (Theorem 1) that transfers local -robustness guarantees in the embedding space to the input space using -Lipschitz continuity of the deep embedding network, yielding a radius of around each correctly classified point.
A Lipschitz loss and corresponding training scheme which enhances the Lipschitz continuity of deep embedding networks by sampling Gaussian noise around the training data during training and punishes violations of the desired Lipschitz constant . Because sampling Gaussian noise is cheap, this is substantially cheaper than adversarial training [31 )Madry, Makelov, Schmidt, Tsipras, and Vladu] and less restrictive than a global Lipschitz bound.
An evaluation on three data sets (MNIST, CIFAR-10, and Imagenette-160) using three classifiers (linear, linear SVM, and GLVQ) and two embedding networks (standard and Lipschitz-constrained) under three adversarial attacks (FGSM, PGD, and C&W),
This paper is an extension of the conference contribution ESANN [26]. The present paper extends it in four ways: evaluation on three benchmarks instead of one, a sensitivity analysis over the Lipschitz training hyperparameters, the addition of the Carlini–Wagner (C&W) attacks and Projected Gradient Descent (PGD) attacks, and a measurement of residual constraint-violation rates that qualifies the transferred radius as empirical.
Background and Related Work
This section reviews the prior work on which our contribution builds, focusing on two properties of machine learning models: adversarial robustness – the stability of a model’s prediction under small input perturbations [45 )Szegedy, Zaremba, Sutskever, Bruna, Erhan, Goodfellow, and Fergus] – and interpretability – the extent to which a human can understand the model’s decision process [3].
Adversarial perturbations, defined as imperceptible changes to the input that flip a model’s prediction, reveal both a security flaw and a fundamental failure of interpretability, as the model’s internal representations diverge from human perception [52 )Göpfert, Artelt, Wersing, and Hammer] ()Xu, Ma, Liu, Deb, Liu, Tang, and Jain, Zhou et al. 2022; )Zhou, Liu, Ye, Zhu, Zhou, and Yu, Göpfert et al. 2020b). Even systems that achieve state-of-the-art accuracy can be successfully attacked, suffering substantial drops in performance [5 )Ilievski, Hammer, van Harmelen, Paassen, Saralajew, Schmid, Biehl, Bolognesi, Dong, Gashteovski, Hitzler, Marra, Minervini, Mundt, Ngomo, Oltramari, Pasi, Saribatur, Serafini, Shawe-Taylor, Shwartz, Skitalinskaya, Stachl, van de Ven, and Villmann] ()Carlini, Athalye, Papernot, Brendel, Rauber, Tsipras, Goodfellow, Madry, and Kurakin, Ilievski et al. 2025).
This phenomenon was first systematically studied by Szegedy et al. who demonstrated that small, often imperceptible perturbations can cause misclassification and may transfer between independently trained models [45 )Szegedy, Zaremba, Sutskever, Bruna, Erhan, Goodfellow, and Fergus]. Formally, given a classifier with parameters , an input-label pair , and a loss function , an adversarial example is found by solving the inner maximization problem [31 )Szegedy, Zaremba, Sutskever, Bruna, Erhan, Goodfellow, and Fergus] ()Madry, Makelov, Schmidt, Tsipras, and Vladu, Szegedy et al. 2013):
where is an adversarial perturbation, constrained to an -norm ball of radius [Goodfellow et al.(2014)Goodfellow, Shlens, and Szegedy, Madry et al.(2017)Madry, Makelov, Schmidt, Tsipras, and Vladu]. Such perturbations are commonly constrained using , , or norms [4]. Based on the level of access to the target model, attacks are typically categorized as white-box, where the adversary has full access to the model parameters and gradients, or black-box, where attacks rely on transferability without direct access [Yuan et al.(2019)Yuan, He, Zhu, and Li, Chakraborty et al.(2021)Chakraborty, Alam, Dey, Chattopadhyay, and Mukhopadhyay, Papernot et al.(2017)Papernot, McDaniel, Goodfellow, Jha, Celik, and Swami]. Since white-box attacks provide direct access to the model’s vulnerabilities [Yuan et al.(2019)Yuan, He, Zhu, and Li], they represent the most challenging threat scenario and are the focus of rigorous robustness evaluation.
Among white-box attacks, the fast gradient sign method (FGSM) [Goodfellow et al.(2014)Goodfellow, Shlens, and Szegedy] is a single-step attack that perturbs the input by in the direction of the sign of the loss gradient. It is computationally efficient and serves as a lower bound on attack strength; a model that fails against FGSM cannot be considered robust in any meaningful sense. Projected gradient descent (PGD) [31 )Madry, Makelov, Schmidt, Tsipras, and Vladu] extends this to a multi-step first-order adversary and is substantially stronger than single-step variants [31 )Shafahi, Najibi, Ghiasi, Xu, Dickerson, Studer, Davis, Taylor, and Goldstein] ()Madry, Makelov, Schmidt, Tsipras, and Vladu, Dong et al. 2018; )Dong, Liao, Pang, Su, Zhu, Hu, and Li, Shafahi et al. 2019). Madry et al. [Madry et al. [31] argue that PGD with random restarts approximates the strongest first-order adversary, establishing it as the standard reference attack for robustness. Beyond FGSM and PGD, the Carlini & Wagner (C&W) attack [4] formulates adversarial example generation as an optimization problem that jointly minimizes the perturbation norm and a surrogate of the classification margin under , , or constraints. This attack achieves 100% success on both distilled and undistilled networks, revealing that defensive distillation, previously claimed to reduce attack success to 0.5%, provides little real security benefit [4]. Other notable attacks include DeepFool [33 )Moosavi-Dezfooli, Fawzi, and Frossard], which searches for the minimal perturbation crossing the decision boundary by iteratively linearizing it; saliency-guided attacks such as JSMA, which target sparsity [Papernot et al.(2016)Papernot, McDaniel, Jha, Fredrikson, Celik, and Swami]; and AutoAttack [9], a parameter-free ensemble of four complementary attacks designed for reliable robustness evaluation. Croce and Hein [9] showed that published defenses frequently report inflated robustness: across 49 deterministic defenses, AutoAttack obtained lower robust accuracy than originally reported in all but one case, with drops exceeding 10 percentage points in 13 cases and by more than 30 percentage points in eight [9].
The design of effective defense mechanisms against adversarial perturbations must navigate a trade-off: improving robustness against adversarial perturbations often reduces accuracy on clean data [Zhang et al.(2019)Zhang, Yu, Jiao, Xing, El Ghaoui, and Jordan]. Moreover, training robust classifiers is computationally expensive and does not provide formal guarantees. Despite these costs, robustly trained models learn feature representations that are more closely aligned with human-perceptible features [46 )Tsipras, Santurkar, Engstrom, Turner, and Madry], suggesting that robustness and interpretability are interrelated.
To enhance adversarial robustness, numerous defense strategies have been proposed, ranging from adversarial training [Goodfellow et al.(2014)Goodfellow, Shlens, and Szegedy, Madry et al.(2017)Madry, Makelov, Schmidt, Tsipras, and Vladu] to regularization techniques [36]. Adversarial training, which augments the training set with adversarial examples, has emerged as one of the most effective empirical defenses. Zhang et al. [Zhang et al.(2019)Zhang, Yu, Jiao, Xing, El Ghaoui, and Jordan] formalized the robustness–accuracy trade-off through TRADES, which achieves a theoretically principled balance between standard accuracy and adversarial robustness, winning first place in the NeurIPS 2018 Adversarial Vision Challenge and surpassing the runner-up by 11.41% in mean perturbation distance. However, adversarial training is computationally expensive and does not provide formal guarantees.
Lipschitz theory instead offers guarantees that hold independently of any particular attack [59]: the Lipschitz constant upper-bounds the amplification of input differences and is thus a direct measure of perturbation sensitivity [Fazlyab et al.(2019)Fazlyab, Robey, Hassani, Morari, and Pappas, Virmaux and Scaman(2018)]. This motivates constraining during training via Jacobian or spectral norm regularization [Zhao et al.(2021)Zhao, Zhang, Zhang, Wu, Jin, Zhou, Jin, Dou, and Yan, Yoshida and Miyato(2017)], input-gradient regularization [15], or weight-matrix conditioning [Feng et al.(2025)Feng, Lin, Gao, and Wei]. For instance, Hoffman et al. [22 )Hoffman, Roberts, and Yaida] approximate local Lipschitz constraints by penalizing the Jacobian norm via random projection (a computationally efficient estimator of local sensitivity), without generating adversarial perturbations. The framework has two well-known limitations. First, the most Lipschitz-stable model is the constant function with , which is useless for prediction [59]. Second, computing exactly is NP-hard even for two-layer networks [48]; consequently, all practical estimators must trade tightness against scalability [Fazlyab et al.(2019)Fazlyab, Robey, Hassani, Morari, and Pappas]. Furthermore, Ross and Doshi-Velez [36] found that penalizing input-gradient norms improves robustness to transferred adversarial examples while simultaneously making input gradients more interpretable as explanations. Specifically, human evaluators rated the resulting misclassifications as more plausible than those of other defended models, suggesting a strong fundamental connection between robustness and interpretability [47 )Vadillo, Santana, and Lozano]. Some intrinsically interpretable models also provide robustness guarantees. Prototype-based models perform classification by comparing input data points to prototypical examples for each class, which makes them ininterpretable by construction: as long as the prototypes themselves are interpretable, so are the decisions [2 )Davoodi, Mohammadizadehsamakosh, and Komeili] ()Biehl, Hammer, and Villmann, Davoodi et al. 2023). Formally, a nearest prototype classifier assigns an input data point to the label of the closest prototype from a learned, finite set of prototypes under a dissimilarity [Saralajew et al.(2020b)Saralajew, Holdijk, and Villmann]. Learning Vector Quantization (LVQ) [27] is the foundational nearest prototype classifier; Generalized LVQ (GLVQ) [40] replaces the heuristic update with a differentiable cost function, and further extensions either learn the metric itself [20 )Schneider, Biehl, and Hammer] (), Schneider et al. 2009) or introduce probabilistic variants [42]. The connection between prototype models and robustness is structural rather than incidental. Crammer et al. [8 )Crammer, Gilad-bachrach, Navot, and Tishby] showed that LVQ-type learning maximizes a hypothesis margin, and Hammer et al. [Hammer et al.(2005)Hammer, Strickert, and Villmann] derived corresponding generalization bounds that depend on this margin rather than on input dimensionality. Because the decision of a nearest prototype classifier depends only on distances to a finite prototype set, the distance from a point to the decision boundary can be computed in closed form, yielding a robustness certificate rather than an empirical estimate. Saralajew et al. [Saralajew et al.(2020b)Saralajew, Holdijk, and Villmann] made this explicit, showing that the hypothesis margin of nearest prototype classifiers is a tight lower bound on adversarial perturbation size and can be computed in constant time for seminorm-induced dissimilarities. GLVQ trained with triplet losses automatically maximizes this margin, certifying an entire test set in roughly the time required by randomized smoothing for a single CIFAR-10 sample. Voráček and Hein [49] extended this analysis, demonstrating that -PNPC (Provably Adversarially Robust Nearest Prototype Classifier) achieves the best certified -robust accuracy on MNIST among deterministic certifiers, outperforming Saralajew et al.’s -GLVQ by approximately 6% robust accuracy at . On CIFAR-10 under the LPIPS perceptual metric, their Perceptual-PNPC reaches 80.3% clean accuracy with 40.5% certified robust accuracy, compared to 71.6% clean and only 9.8% empirical robust accuracy for an adversarially trained ResNet-50 baseline. Empirically, Saralajew et al. [Saralajew et al.(2020a)Saralajew, Holdijk, Rees, and Villmann] found that GLVQ and its tangent-distance variant GTLVQ exhibit high base robustness without any adversarial training, and that adversarial examples against these models resemble semantically meaningful interpolations towards the target class rather than arbitrary noise.
This connection between margin and robustness is not unique to prototype-based classifiers. The linear Support Vector Machine (SVM) is a classic maximum-margin classifier, and its robustness properties have been extensively studied [32 )Dakhale, Satwik, Kumar, Narayana, Bhurane, and Kothari] (), Dakhale et al. 2023). Inspired by these results, Elsayed et al. [32] proposed a margin-maximization objective for deep neural networks, demonstrating that it enhances robustness to adversarial perturbations by promoting a larger geometric margin. This approach effectively extends the classical SVM margin-maximization principle to the deep learning setting. Yu et al. [Yu et al.(2019)Yu, Amizadeh, Kim, Pagnoni, Chun, Weimer, and Interlandi] further showed that classical machine learning pipelines, including SVMs, can be integrated into neural network architectures and jointly optimized through backpropagation. Their findings highlight the flexibility of SVM-based approaches within modern deep learning frameworks. Motivated by this, we include a linear SVM as an additional baseline alongside linear and GLVQ classifiers, enabling a direct comparison between a conventional maximum-margin classifier and the prototype-based GLVQ approach. Related studies investigating margin-based robustness in non-parametric and nearest-neighbor classifiers have reported similar findings [50 )Wang, Jha,] and Chaudhuri, Yang et al. [53]Yang, Rashtchian, Wang, and Chaudhuri].
Unfortunately, shallow classifiers such as GLVQ or SVM tend to struggle in highly nonlinear settings such as image data, where the Euclidean distance in input space is uninformative for class discrimination [Khalid and Paassen()], a phenomenon consistent with the accuracy–interpretability trade-off described in the XAI literature [Gunning et al.(2019)Gunning, Stefik, Choi, Miller, Stumpf, and Yang, Xu et al.(2019)Xu, Uszkoreit, Du, Fan, Zhao, and Zhu]. This has motivated hybrid architectures that use a deep neural network to perform a nonlinear embedding while retaining prototype-based decisions in the embedding space. Examples are Prototypical Networks [44 )Snell, Swersky, and Zemel], autoencoder-plus-prototype-layer models whose prototypes decode back to the input space [30 )Li, Liu, Chen, and Rudin], ProtoPNet and its part-prototype descendants [7 )Chen, Li, Tao, Barnett, Rudin, and Su], classification-by-components [Saralajew et al.(2019)Saralajew, Holdijk, Rees, Asan, and Villmann], and prototype–rule hybrids [1]. These hybrid models improve classification performance but lose robustness guarantees, because the certificate of a nearest prototype classifier is only valid in the space where the prototypes are defined: the embedding space [26, 2 )Biehl, Hammer, and Villmann]. An unconstrained embedding network can map an arbitrarily small input perturbation to an arbitrarily large embedding displacement, so a certified radius in provides no information regarding robustness in unless the embedding network’s sensitivity is itself bounded. Bounding the embedding network’s sensitivity is, therefore, the starting point for our method.
Methodology
Our goal is to leverage the interpretability and robustness advantages of prototype-based models when combined with deep embedding networks for pre-processing. We first establish the theoretical foundation of our method before describing our proposed algorithm for Lipschitz training.
Adversarial Robustness
Assume a deep neural network , which maps input data from some input space to an -dimensional embedding space . Further, assume that the input space is equipped with some metric and the embedding space with some metric . Finally, assume that we have trained a classifier which maps data in the embedding space to one of labels.
The core challenge we try to address is that a deep neural network may yield an embedding space that improves classification accuracy but breaks adversarial robustness. Points that are close in the input space may be suddenly far apart in the embedding space. Hence, even if the classifier is adversarially robust in the embedding space, this does not guarantee adversarial robustness in the input space (see Figure 1, top). Our core argument is straightforward: Lipschitz-continuity limits how much distances in the input space can be stretched in the embedding space (see Figure 1, bottom). Hence, a robust classifier in the embedding space, in combination with a deep network that satisfies the Lipschitz property, yields a robust classifier in the input space.
To make our argument precise, we first introduce a formal definition of (local) adversarial robustness.
Definition 1. Let be some set, let be some classifier for some , and let be a metric on . Further, let and with . We say
that is locally -robust around (with respect to metric ) if and only if for all with we have .
For the purpose of our argument, we assume that this property holds point-wise for all correctly classified points, in particular for the held-out points used for robustness evaluation. It is important to note that the robustness radius is not a fixed constant but depends on the input point . For a nearest prototype classifier such as GLVQ, the certified radius around a correctly classified point is half the distance from to the decision boundary [8] induced by the closest correct and closest incorrect prototype. Let denote the distance between and . Saralajew et al. [Saralajew et al. (2020b)] show that the hypothesis margin at can be obtained in constant time during the inference step as:
where and denote the closest prototype of the correct class and any incorrect class, respectively. This quantity lower-bounds the sample margin and hence the norm of any adversarial perturbation that changes the predicted label, with the bound being tight. The notion originates with Crammer et al. [Crammer et al. [8], who introduced the hypothesis margin to derive generalization bounds for LVQ under the norm. The certificate applies only to correctly classified points; for misclassified points, the signed margin of [Saralajew et al. (2020b)] is negative, and no radius is guaranteed.
Despite the robustness certificates of LVQ models, it is easy to construct a case where an LVQ model loses its robustness when combined with a deep embedding model. The certificate in Eq. (2) is a statement about distances in the embedding space . If is unconstrained, an input perturbation of arbitrarily small norm in can be mapped to a distance larger than in , so the robustness guarantee in , by itself, carries no information about robustness in . Therefore, we also need Lipschitz continuity.
Lipschitz continuity
To ensure that robustness guarantees in the embedding space translate to robustness guarantees for a deep prototype classifier (including a deep embedding model), we require (local) Lipschitz continuity as a second ingredient.
Definition 2. Let and be sets, let , let be a metric on , and let be a metric on . Further, let and let with . We say that is locally -Lipschitz-continuous around (with respect to metrics and ) if and only if for all we obtain
It follows that the local robustness of a classifier , combined with the local Lipschitz continuity of an embedding model , implies the local robustness of combined with .
Theorem 1. Let and be sets, let , let for some , let be a metric on , and let be a metric on . Further, let , and with and . Then it holds: if is locally -Lipschitz around (w.r.t. metrics and ) and is locally -robust around (w.r.t. metric ), then (defined as ) is -robust around with respect to .
Proof. Consider any with . Then, because is -Lipschitz around with respect to and . Hence, because is -robust around w.r.t. .
Here and are the metrics on and ; the squaring in Equation (4) applies inside the Lipschitz loss only, so that larger violations are punished more strongly.
While this theorem is, admittedly, somewhat trivial, it is highly useful for our purpose. The theorem implies that we can leverage the robustness and interpretability properties of GLVQ models in combination with deep networks if the deep networks are Lipschitz continuous with sufficiently small . Hence, we devise a training method that encourages this Lipschitz property.
Lipschitz Training
Our goal is to construct a training scheme which ensures that a deep neural network is locally -Lipschitz-continuous for some desired around all training data points . To achieve this goal, our core strategy is quite simple: For each training data point , we sample one neighbor by adding Gaussian random noise to . Then, we punish violations of the Lipschitz property by imposing the loss following loss:
where,
and where denotes the hinge loss/the rectified linear unit and denotes the multivariate Gaussian density.
For training, the Lipschitz loss (4) is added to the regular classification loss of the classifier. In our case, we train a deep embedding network with a final linear layer for classification using the cross-entropy loss
where is the Lipschitz weight, controlling the strength of the Lipschitz loss relative to the cross-entropy loss.
The loss is then minimized via standard deep learning optimizers, such as Adam.
Hyperparameters: Lipschitz training depends on three hyperparameters, each playing a distinct role.
The hyperparameter is the desired upper bound on the Lipschitz constant of the embedding network . As established in Theorem 1, if is -Lipschitz and the classifier is -robust in the embedding space, then the composed classifier is -robust in the input space. Thus, enters the robustness radius directly through the factor . It may, therefore, appear tempting to set as low as possible to achieve the best possible robustness bound. However, imposing tighter Lipschitz continuity on also means that distances within the embedding space shrink, which in turn reduces the distances from which the hypothesis margin in Equation (2) is computed. The radius that Theorem 1 transfers to the input space is therefore a ratio of two quantities that both shrink as shrinks, so it does not simply grow as . Conversely, a larger relaxes the constraint, potentially improving accuracy but weakening the robustness guarantee. The choice of should therefore be guided by the desired perturbation budget in the input space.
The second hyperparameter is the Lipschitz weight , which controls how strongly violations are penalized relative to the classification loss. The higher is, the more the Lipschitz loss is weighted and the fewer violations of the Lipschitz loss are expected. However, higher may also hurt classification accuracy (especially on non-attacked data) because the classification loss has less influence on training. can thus be used to navigate the accuracy-robustness tradeoff.
The third hyperparameter is the standard deviation of the isotropic, zero-mean Gaussian noise from which the neighbor for each training sample is generated. Lower values mean that neighbors are samples more closely to the training data, higher values mean that neighbors are farther away. We generally recommend to base on the expected strength of adversarial attacks.
All three hyperparameters are also investigated experimentally and discussed in § 4.4.
Computational Efficiency: In terms of computational efficiency, Lipschitz training is releatively cheap. For every training point in a mini-batch, we sample a single neighbor via Gaussian noise. Thus, the asymptotic training efficiency remains unchanged. Lipschitz training compares particularly favorably to adversarial training [31 )Madry, Makelov, Schmidt, Tsipras, and Vladu], where needs to be generated via projected gradient descent, which requires an inner maximization involving several forward and backward passes for every single training data point during training.
Lack of theoretical guarantees: We acknowledge that Lipschitz training does not guarantee a certain Lipschitz constant but only punishes violations of the desired constant for the distance between a training sample and the sampled neighbor . If the Lipschitz loss (4) becomes zero during training, does hold for the training data because then for all pairs. Further, we recommend to re-sample the neighbors in each mini-batch, thus providing a more comprehensive stochastic sampling in each direction. If training would continue indefinitely under infinitely strong weight , local -Lipschitz continuity would eventually result. In practice, though, the effective Lipschitz constant of will be higher than . We investigate the empiric effectiveness of Lipschitz training in much more detail in the next section.
Classification Heads
After training the embedding network , we use one of three classification heads for inference. By “classification head”, we mean the final layer that maps the embedding to a class prediction.
Linear: The standard linear+softmax layer with cross-entropy loss serves as our baseline and is used during the first training stage.
Linear SVM: We extract the embeddings of the training fold with the embedding network frozen and fit a linear SVM on these fixed feature vectors using scikit-learn’s LinearSVC (, one-vs-rest). Since the decision function of a linear SVM, , has the same form as a linear layer, the learned and are copied into a linear layer on top of the frozen embedding network [Yu et al. (2019)Yu, Amizadeh, Kim, Pagnoni, Chun, Weimer, and Interlandi], so that the same gradient-based attacks apply as for the other heads. This head provides a maximum-margin classifier in the embedding space but lacks interpretability.
Generalized Learning Vector Quantization (GLVQ): A prototype-based model to achieve interpretable classification. The prototypes are initialized in the input space and then mapped into by the embedding network , rather than being free vectors in . This keeps them interpretable as images throughout training and guarantees that they lie on the image of , which makes the distances in embedding space and input space comparable between prototypes and data. The optimization of the prototypes occurs via Adam on the GLVQ loss [40]. However, in contrast to regular GLVQ, because the prototypes live in , the GLVQ loss needs to be propagated through the embedding network . Still, the parameters of remain frozen at this stage.
Because both GLVQ and SVM are maximum margin classifiers, we assume that they are locally -robust, such that the Lipschitz-continuous embedding network combined with GLVQ or SVM should be -robust, following Theorem 1. We will test this hypothesis experimentally.
Summary of Training Procedure
In summary, training proceeds in two stages. Stage 1: Lipschitz Embedding Training. We train the embedding network jointly with a linear (+softmax) classification head, minimizing Eq. (6). This step (hopefully) yields a locally -Lipschitz continuous embedding network .
Stage 2: Freeze and Fit Classifier Heads. After Stage 1, we freeze the embedding network , keeping it in evaluation mode and setting requires_grad = False. The linear head is not re-trained: we keep the one obtained in Stage 1. Only the SVM and the GLVQ prototypes are fitted, both on top of the frozen embedding, ensuring that all three heads share identical features and differ only in the decision rule.
Experimental Setup and Datasets
Our primary objective is to test whether a Lipschitz-constrained embedding network combined with a maximum-margin classifier (GLVQ or SVM) achieves higher adversarial robustness than all baseline combinations. Specifically, we aim to:
isolate the effect of the Lipschitz loss by comparing standard and Lipschitz-constrained embedding networks with the same classification head;
isolate the effect of the classification head by comparing Linear, SVM, and GLVQ heads on the same frozen embedding; and
demonstrate that the proposed Lipschitz-GLVQ model achieves enhanced robustness compared to all baselines, as measured by standard adversarial attacks.
We evaluate the proposed scheme on three image classification benchmarks of increasing difficulty and resolution. Our aim is not to reach state-of-the-art clean accuracy but to investigate the effect of the Lipschitz loss: within each dataset, every model shares the same embedding network architecture, the same optimization budget, and the same data splits, so that differences in adversarial accuracy can be attributed to the Lipschitz loss and to the choice of classification head rather than to model capacity or tuning.
Datasets
The detailed description of all three datasets is given below:
MNIST
The first benchmark is MNIST [29 )LeCun, Cortes, and Burges], consisting of gray-scale images ( input features) with raw pixel values in . The images are loaded with transforms.ToTensor(), which maps them to ; no further channel normalization is applied. The torchvision.datasets release contains samples ( train, test) evenly distributed over ten digit classes (–). The class distribution is approximately, but not exactly, uniform.
CIFAR-10
The second benchmark is CIFAR-10 [28] (accessed via PyTorch), described by its authors as “60000 32x32 color images in 10 classes, with 6000 images per class”, split into training and test images. The images are normalized with the channel mean and standard deviation computed on that split.
Imagenette
The third benchmark is Imagenette [23], described by Howard et al. as “a subset of 10 easily classified classes from Imagenet”. We use the imagenette-160 release with its predefined train / val directory structure (Imagenette-1601), and resize all images to pixels to keep the embedding network architecture consistent with the CIFAR-10 setting. We use the images in the train directory, which are normalized with the channel mean and standard deviation computed on that split.
Model Architecture and Feature Extraction
Embedding network: We consider image classification with a convolutional neural network (CNN) for feature extraction. Detailed descriptions for each dataset and its respective settings for the CNN embedding network are provided in Table 1. The same embedding network architecture is used for both the standard (unregularized) models and the Lipschitz-constrained models, ensuring that any differences in performance can be attributed solely to the Lipschitz loss rather than architectural variations. These architectures were chosen to be lightweight and representative of typical CNNs for each dataset. A systematic hyperparameter search over network architectures was outside the scope of this paper, and other architectures may yield better performance.
| MNIST | CIFAR-10 | Imagenette-160 | |
| Classes | 10 | 10 | 10 |
| Samples used (train) | 60, 000 | 50, 000 | 9, 469 |
| Native resolution | variable (resized to ) | ||
| Input to the network | |||
| Pixel range | |||
| Channel normalization | none | split mean/std | split mean/std |
| Convolutional layers | 2 | 3 | 3 |
| Batch normalization | no | yes | yes |
| Activation | ReLU | ReLU | ReLU |
| Pooling | max | max | max |
| Dropout | 0.0 | 0.5 | 0.5 |
| Embedding dim() | 16 | 64 | 64 |
Table 1. Datasets, input pre-processing and network parameters. The pixel range refers to the values after ToTensor and before channel normalization.
Models’ Architecture: We compare six models, obtained by crossing three classification heads (linear, SVM, and GLVQ) with two training schemes for the embedding network (with and without the Lipschitz loss), as listed in Table 2. The training procedure consists of two stages. The embedding network is first trained end-to-end together with a linear (+softmax) head, with the Lipschitz loss of Eq. (6) in the Lipschitz-constrained setting and without it in the baseline setting, and is then frozen, as shown in Figure 2. The SVM and GLVQ heads are subsequently fitted on top of this frozen embedding. Under this design, any difference between Linear and Lipschitz-Linear can be attributed to the Lipschitz loss alone, and any difference between Lipschitz-Linear and Lipschitz-GLVQ is caused by the classification head alone. Consequently, this setup allows us to isolate the effect of the Lipschitz loss from that of the classification head. We expect that the two Lipschitz variants with a margin-based heads (Lipschitz-SVM and Lipschitz-GLVQ) will gain substantial adversarial robustness, as they combine adversarial robustness in the embedding space (due to maximum margin properties) with the Lipschitz continuity of the embedding network. The added value of Lipschitz-GLVQ over Lipschitz-SVM should only lie in additional interpretability due to the prototype-based classification scheme.
| Model | Embedding Net | Classification head | Interpretable? |
| LINEAR | standard | linear+softmax layer, cross-entropy loss | no |
| SVM | standard | linear SVM (, one-vs-rest) fitted on the frozen embedding and converted into an equivalent linear layer so that gradient-based attacks apply | no |
| GLVQ | standard | one prototype per class, GLVQ cost with the sigmoid link; only the prototypes are updated | yes |
| Lipschitz_Linear | Lipschitz | as LINEAR | no |
| Lipschitz_SVM | Lipschitz | as SVM | no |
| Lipschitz_GLVQ | Lipschitz | as GLVQ | yes |
Table 2. The six models compared on every dataset. All heads within each configuration share the same frozen embedding network.

Figure 2. The proposed architecture where the Lipschitz loss is applied to the embedding network (CNN) , which is then frozen; after that, the classification head classifies in the embedding space .
Training Protocol
The following training details apply to all experiments. Models were trained for 50 epochs on all three datasets to ensure that no model receives a larger optimization budget than another. The batch sizes are 32 for MNIST, 128 for CIFAR-10, and 64 for Imagenette-160. For GLVQ, we use one prototype per class, as described in § 3.4. The prototypes are the only parameters updated during GLVQ training: the embedding network is frozen, and the optimizer is constructed over the prototypes only. Prototypes are initialized as one randomly drawn training image per class and are updated directly in input space, so that they remain interpretable as images. The embedding networks and linear heads are trained jointly in Stage 1 with an Adam optimizer (lr , weight decay ) for 50 epochs; the GLVQ prototypes are trained with a separate Adam instance at the same learning rate. The SVM is fitted with scikit-learn rather than by gradient descent, as described in § 3.4. The remaining hyper-parameter settings are listed in Table 3.
| MNIST | CIFAR-10 | Imagenette | |
| Epochs | 50 | 50 | 50 |
| Batch size | 32 | 128 | 64 |
| Optimiser | Adam, lr = , weight decay | Adam, lr = , weight decay | Adam, lr = , weight decay |
| Cross-validation folds | 5 | 5 | 5 |
| Prototypes per class | 1 | 1 | 1 |
| Embedding dimension | 16 | 64 | 64 |
| Lipschitz loss | |||
| Neighborhood mean | 0 | 0 | 0 |
| Neighborhood std. dev. | 0.1 | 0.03 | 0.03 |
| Lipschitz constant | 0.032 | 0.032 | 0.032 |
| Lipschitz weight | 10 | 10 | 10 |
| Attack parameters | |||
| FGSM/PGD budget | [0, 0.4], 41 pts | [0, 0.0667], 35 pts | [0, 0.0667], 35 pts |
| Evaluation batch size | 200 | 200 | 200 |
| PGD steps | 40 | 20 | 20 |
| PGD random restarts | 1 | 1 | 1 |
| C&W binary-search steps | 9 | 9 | 9 |
| C&W optimisation steps | 1000 | 1000 | 1000 |
| C&W initial constant | 1 | 1 | 1 |
| C&W confidence | 0 | 0 | 0 |
Table 3. Training hyperparameters per dataset.
Lipschitz Hyperparameter Selection
As discussed previously in § 3, Lipschitz training has three hyperparameters: the desired Lipschitz constant , the Lipschitz weight , and the neighborhood standard deviation . We selected these values on a held-out portion of the training split (using only the official training split), keeping them fixed across all cross-validation folds.
Lipschitz constant . As discussed in § 3, has two opposing effects. On the one hand, Theorem 1 certifies a radius of in input space, so a smaller (if actually achieved) means a larger guaranteed radius. On the other hand, a smaller constrains the embedding network more strongly, which may cost clean accuracy. The choice of therefore has to be made empirically. We tested (see Figure 7). Values of left the constraint inactive, while produced no additional robustness gain. We therefore chose as a conservative operating point, balancing robustness with (unattacked) classification accuracy.
Figure 7. Effect of target Lipschitz constant at fixed . Larger leaves the hinge slack and the Lipschitz loss inactive.
Lipschitz weight . is purely an optimization-side quantity; it weighs the Lipschitz loss versus the classification loss. We tested (see Figure 6). Higher values reduce the rate of violations against the Lipschitz constraint but cost clean accuracy (i.e. accuracy without adversarial attacks) on CIFAR-10 and Imagenette-160 (Table 5). We selected as the default Lipschitz weight.
Figure 6. Effect of Lipschitz weight at fixed , over 50 epochs. Solid curves: weighted Lipschitz loss (left, log axis). Dashed: classification loss (right axis).
| Dataset | Violation | Mean stretch ratio | Clean accuracy (%) | |
| MNIST | 1 | 0.867 | 0.049 | 98.47 |
| 5 | 0.410 | 0.032 | 98.33 | |
| 10 | 0.252 | 0.028 | 98.32 | |
| 20 | 0.147 | 0.025 | 98.13 | |
| 50 | 0.070 | 0.023 | 98.21 | |
| 100 | 0.041 | 0.021 | 98.08 | |
| CIFAR-10 | 1 | 1.000 | 0.200 | 78.12 |
| 5 | 0.988 | 0.107 | 77.17 | |
| 10 | 0.952 | 0.081 | 75.54 | |
| 20 | 0.839 | 0.061 | 73.56 | |
| 50 | 0.590 | 0.043 | 70.17 | |
| 100 | 0.401 | 0.034 | 67.00 | |
| Imagenette-160 | 1 | 0.983 | 0.103 | 76.36 |
| 5 | 0.770 | 0.054 | 72.31 | |
| 10 | 0.551 | 0.041 | 66.49 | |
| 20 | 0.334 | 0.031 | 56.11 | |
| 50 | 0.189 | 0.026 | 40.09 | |
| 100 | 0.131 | 0.023 | 30.69 |
Table 5. How strictly the Lipschitz constraint is enforced as the weight varies, at fixed . Two quantities measure this on the same sampled training pairs: “violation” counts the fraction of pairs for which the constraint of Eq. (4) is not satisfied, while “mean stretch ratio” reports by how much the embedding is stretched on those pairs. Values are taken at the final training epoch and averaged over 5 folds.
Neighborhood standard deviation . The parameter fixes the radius at which neighbors are sampled during training for testing violations of the Lipschitz condition. To effectively check the Lipschitz constraints for small distances where adversarial attacks are expected, should be of the same order as the largest attack budget evaluated on that dataset. Guided by this, we swept and selected for MNIST and for CIFAR-10 and Imagenette-160, which are the smallest values at which the Lipschitz loss remains clearly active throughout training; § 5.2 discusses this sweep in detail.
Evaluation Protocol
All experiments use 5-fold cross-validation over the training split, with folds generated by a shuffled KFold split under a fixed seed. In each fold, all six models are trained on four folds, and the held-out fold is used for both clean and adversarial evaluation. All results are averaged over the five folds and reported as the mean one standard deviation. All hyperparameters were fixed before running any experiments (see § 4.4).
Implementation details
The Lipschitz loss is computed on the same mini-batch as the classification loss, using the pre-logit embedding. As discussed above, the SVM and GLVQ classification heads are fitted on top of the frozen embedding network; therefore, the Lipschitz loss plays no role in their training. Mini-batches are drawn by reshuffling the training fold at the start of every epoch. Perturbed samples used for the Lipschitz loss are not clipped to the valid pixel range, since the local Lipschitz condition is meant to hold in the ambient space and clipping would bias the sampled neighborhood at the boundary of . In addition to optimization and hyper-parameter tuning, a crucial implementation detail concerns the handling of input normalization. Because the networks operate on channel-normalized inputs while perturbation budgets are only meaningful in raw pixel units, every attack follows the same three-step convention: the image is un-normalized into raw pixel space, the adversarial attack is applied in pixel space, enforcing the attack budget as well as the bounds of the pixel range . Finally, the result is re-normalized before being fed to the model. As loss functions for adversarial attacks, cross-entropy is used for Linear and SVM classifiers and the GLVQ loss for GLVQ models. For the Lipschitz-GLVQ model, the attack uses the classification part of the cost only, without the Lipschitz loss term, since the Lipschitz loss is not part of the decision rule and including it would provide the attacker with a gradient that does not correspond to the model’s predictions.
In preliminary experiments with , we mistakenly included the Lipschitz loss in the loss that was attacked. Because the Lipschitz loss directly works against adversarial attacks, this made the adversarial robustness appear much better than it actually was. Therefore, we caution other researchers against this mistake.
Attack schemes and robustness evaluation
We evaluate the adversarial robustness by measuring the accuracy under FGSM [Goodfellow et al.(2014)Goodfellow, Shlens, and Szegedy], PGD [31 )Madry, Makelov, Schmidt, Tsipras, and Vladu], and C&W attacks [4]. All three types of attack are computed on the held-out fold of the current cross-validation split. FGSM and PGD are run across a wide range of attack strengths (in line with the robustness curve proposal of [Göpfert et al.(2020a)Göpfert, Göpfert, and Hammer]), namely in steps of 0.01 for MNIST, and for , i.e. , for CIFAR-10 and Imagenette-160. Regarding the attack configurations, FGSM and PGD are both attacks. PGD uses steps with step size and a random start inside the -ball, while the C&W attack uses a confidence of , binary-search steps over the trade-off constant, and optimization steps per search step. The values of , , , and the number of random restarts are listed in Table 3. The C&W attack is unbounded and is reported as a mean distortion rather than as an accuracy curve.
Experimental Results
We evaluate our approach on MNIST, CIFAR-10, and Imagenette-160 discussed in § 4.1. For each dataset, we compare six models: three heads (Linear, SVM, GLVQ) crossed with two embedding networks (standard and Lipschitz-constrained) (see § 3). Our goal is to separate the effect of the Lipschitz loss from the effect of the classification head. We report clean accuracy and adversarial accuracy under FGSM, PGD, and C&W attacks. Unless stated otherwise, all results use and Lipschitz weight (§ 4.4). All curves reported in Figure 3a – Figure 5c are the means over 5-fold cross-validation, with error bars representing the standard deviation across folds.
Figure 3. MNIST robustness. (3a,3b) Accuracy versus the attack budget . (3c) Mean distortion required to flip the label; higher is more robust.

Figure 5. Imagenette-160 robustness. (5a,5b) Accuracy versus the attack budget . (5c) Mean distortion required to flip the label; higher values indicate greater robustness.
The effect of the Lipschitz loss on clean accuracy depends strongly on the dataset (Table 4). On MNIST, the two Lipschitz models slightly exceed their unconstrained counterparts, while on CIFAR-10 the standard models lead. The Lipschitz loss gains 0.12 percentage points on MNIST and costs 2.66 on CIFAR-10, consistent with the known robustness–accuracy trade-off [46 ) Zhang, Yu, Jiao, Xing, El Ghaoui, and Jordan] () Tsipras, Santurkar, Engstrom, Turner, and Madry, Zhang et al. 2019). On Imagenette-160, the cost is largest, 8.01 points for the Linear models (65.19% vs. 73.20%), reflecting the slower convergence of the constrained embedding network under the matched 50-epoch budget, as shown by the loss curves in § 5.2.
| Model | MNIST | CIFAR-10 | Imagenette-160 |
| Linear (standard) | 98.24 0.10 | 78.97 0.49 | 73.20 2.34 |
| SVM (standard) | 98.34 0.13 | 78.79 0.60 | 78.14 1.06 |
| GLVQ (standard) | 97.82 0.16 | 79.18 0.53 | 76.40 1.15 |
| Lipschitz-Linear | 98.36 0.10 | 76.31 0.99 | 65.19 2.24 |
| Lipschitz-SVM | 98.46 0.10 | 76.82 0.93 | 68.35 1.12 |
| Lipschitz-GLVQ | 98.09 0.17 | 76.49 1.20 | 67.19 1.16 |
Table 4. Clean accuracy (%). Values are the mean standard deviation over 5 folds.
The clean accuracy (without any adversarial attack at ) of the GLVQ models are close to that of Linear and SVM on every dataset. GLVQ is 0.42 percentage points below Linear on MNIST and 1.74 points below SVM on Imagenette-160, while on CIFAR-10 the three heads are within 0.4 points of each other. Voráček and Hein [Voráček and Hein [49] similarly report 97.3% clean accuracy for -PNPC on MNIST. Zhang et al. [Zhang et al. (2019) Zhang, Yu, Jiao, Xing, El Ghaoui, and Jordan] observed a comparable trade-off on CIFAR-10, where TRADES () achieved 84.92% clean accuracy against 56.61% robust accuracy under PGD20. Our clean accuracy is well below this, as expected given our relatively small embedding network with only 64 embedding dimensions and 3 layers; we cite the comparison to situate the size of the trade-off, not to claim equality.
Adversarial Robustness
At (clean accuracy) all models achieve high accuracy. As increases, performance degrades rapidly for the standard models. Lipschitz-GLVQ achieves the highest robustness on MNIST and CIFAR-10 (Figure 3a–Figure 4c). On Imagenette-160 the picture differs: under PGD, Lipschitz-SVM is the strongest model over the range where accuracies remain substantial, with Lipschitz-GLVQ second, while under FGSM attacks, Lipschitz-GLVQ leads from onwards by a wide margin (10.8% against 3.7% at the largest budget). Among the unconstrained models, GLVQ is the most robust under FGSM attacks on all three datasets. This is likely because our embedding network already exhibits some Lipschitz continuity even without explicit training, while GLVQ’s margin-based decision rule provides a natural robustness certificate in the embedding space [Hammer et al. (2005) Hammer, Strickert, and Villmann, Saralajew et al. (2020b) Saralajew, Holdijk, and Villmann].
Figure 4. CIFAR-10 robustness. (4a,4b) Accuracy versus the attack budget . (4c) Mean distortion required to flip the label.
A key observation is that the improvement of Lipschitz-Linear and Lipschitz-SVM over their standard counterparts is strongest on MNIST. On CIFAR-10 (Figure 4a) and Imagenette-160 (Figure 5a), both also clearly outperform their unconstrained counterparts at small attack budgets. This advantage diminishes as increases, and on Imagenette-160 and under FGSM attacks on CIFAR-10, unconstrained GLVQ overtakes them at higher attack strengths.
The results on MNIST are the clearest: under FGSM attacks (Figure 3a), Lipschitz-GLVQ retains accuracy at and at . Under the stronger PGD adversary (Figure 3b), it retains at , while every unconstrained model has collapsed to near-zero by . Degradation occurs only when the images are altered so strongly that a human observer might not recognize them, which is consistent with the goal of interpretability: a model should change its prediction only when the input has changed enough to change a human’s judgment [47 )Vadillo, Santana, and Lozano]. On CIFAR-10 and Imagenette-160, however, a human observer would likely not change their predicted class even at the largest tested, so the current level of robustness is still insufficient for true interpretability, despite the significant improvement over the baseline.
The C&W results (Figure 3c, Figure 4c, Figure 5c) address the same question from a minimum-distortion perspective. On MNIST, the mean distortion needed to flip a label rises from 1.57 to 2.93 for the GLVQ pair (1.87) and from 0.91 to 1.79 for both Linear and SVM. On CIFAR-10 the two GLVQ variants are indistinguishable (0.194 against 0.194), so Lipschitz training brings no measurable C&W advantage there. On Imagenette-160, the ordering is favorable but within one standard deviation (0.387 0.414). On CIFAR-10 and Imagenette-160, both prototype models require clearly more distortion than the four linear heads; on MNIST this holds for Lipschitz-GLVQ (2.93), while standard GLVQ (1.57) sits below the two Lipschitz linear heads.
In comparison to prior work, Voráček and Hein [Voráček and Hein [49] report that -PNPC attains 96.2% certified accuracy on MNIST at , outperforming -GLVQ (94.2%) and 1-NN (95.0%). Our empirical results align with these findings, though our model is not certified in the same sense, because we enforce local Lipschitz continuity of the embedding only stochastically via training rather than proving a strict, global bound on the whole model. Saralajew et al. [Saralajew et al. (2020a)Saralajew, Holdijk, Rees, and Villmann] found that GLVQ and GTLVQ exhibit high base robustness without adversarial training, and that adversarial examples against them resemble semantically meaningful interpolations toward the target class rather than arbitrary noise; our observation that standard GLVQ beats Linear and SVM in terms of robustness supports this.
These results give partial support to our hypothesis. Lipschitz training on its own is clearly not sufficient: with a softmax head it buys almost nothing beyond MNIST, which is consistent with the observation that the most Lipschitz-stable model is the useless constant function [59]. The broader picture on the margin-based heads is more mixed than the theory would suggest. When comparing Lipschitz training to the choice of classifier, GLVQ appears to yield a clearer effect: unconstrained GLVQ already beats Linear and SVM everywhere, the SVM benefits much less from Lipschitz training compared to GLVQ, and on Imagenette-160 Lipschitz-GLVQ does not beat regular GLVQ. We return to these two discrepancies in § 6.
Hyperparameter Sensitivity Analysis
The Lipschitz loss depends on three free parameters: the desired Lipschitz constant , the weight , and the neighborhood standard deviation . Because these interact in a way that is not obvious from the loss definition alone, we visualize their effect in Figure 6, Figure 7 and Figure 8.
Figure 8. Effect of the neighborhood standard deviation at fixed and , over 50 epochs. Solid curves: weighted Lipschitz loss (left, log axis). Dashed: classification loss (right axis). Mean over 5 folds; error bars give one standard deviation across folds.
Lipschitz weight . On MNIST (Figure 6a) the weighted Lipschitz loss rises over the first 5–10 epochs, peaks, and then decays. This is the signature of the two objectives competing. At initialization, the embedding network is near-random, the embedding is compressed, and the
constraint is barely violated; as the classification loss falls, the embedding network expands the embedding to separate classes, increasing its local sensitivity. The Lipschitz loss only begins to dominate once this expansion has occurred. The curves have the same shape for all values; only their magnitude changes. Thus, controls the strength of the Lipschitz loss but does not change how the loss behaves over time. The classification-loss curves for all six are indistinguishable and converge to near zero by epoch 30, meaning that, for MNIST, can be increased without a strong impact on the final training loss. Accordingly, the test accuracy also hardly changes across different values (Table 4).
Lipschitz constant : Figure 7 shows a monotone ordering across all three datasets: the smaller the Lipschitz constant , the larger the residual Lipschitz loss at convergence.
For , the constraint has almost no effect, indicating that the regular training of already ensures that distances are never enlarged beyond this factor. For example, on MNIST (Figure 7a), when is large (0.707, 0.775, or 1), the Lipschitz loss drops below and often drops to zero and becomes unstable, with error bars varying across multiple orders of magnitude. Correspondingly, the constraint is violated on 25% of sampled pairs on MNIST and 95% on CIFAR-10 at our operating point (Table 5). In practice, the Lipschitz loss effectively vanishes, so it contributes almost no gradient and we would not expect the learned embedding to differ from the unconstrained one. We did not test this directly at these values of .
At the other extreme, the and curves are nearly identical on all three datasets. This is worth noting because punishes any distance between and , boiling down to something akin to L2 regularization on . Still, it appears that the constraint degrades gracefully toward , indicating that the models do not collapse. Clean accuracy stays high, and on MNIST the classification loss is unaffected. Likely, this stability can be effect that the classification loss and the Lipschitz loss act as opposing forces: collapsing all distances would lead to high classification loss, such that a stable tradeoff occurs. Where the tradeoff lies is, in turn, regulated by .
Two considerations govern the choice of . Theorem 1 guarantees local -robustness, so we want to be as small as possible to achieve the highest possible robustness; at the same time, a smaller constrains the embedding network more strongly and, thus, may reduce accuracy. Figure 7 shows how the Lipschitz loss develops for different . For , the Lipschitz loss collapses below and becomes erratic, so the constraint is essentially never violated and contributes almost no gradient. At the other end, the and curves nearly coincide, indicating that the Lipschitz loss saturates below 0.032 and reducing further changes nothing. Within the active range, the dashed classification-loss curves are largely unaffected by , and clean accuracy stays within one percentage point of the baseline (Table 4). We therefore adopt : the smallest value at which the Lipschitz loss is still distinguishable from the degenerate case and at which accuracy is still little affected.
Note that is not the actual Lipschitz constant of the trained embedding network. would only be the Lipschitz constant if the Lipschitz loss would reach zero for infinitely long training (i.e.: infinitely many stochastic samples across the neighborhood). Figure 7 shows a non-zero residual for every . The constraint is violated on 25% of sampled pairs on MNIST and 95% on CIFAR-10 (Table 5). To quantify how far the trained network is from the requested bound, we report the empirical stretch ratio , averaged over exactly those Gaussian neighbor pairs on which the Lipschitz loss is evaluated. We emphasize that this is not the Lipschitz constant of , which is NP-hard to compute even for two-layer networks [48]. It is a sample average over a finite set of directions and therefore a lower bound on the true constant (the maximum over all pairs can only be larger). Its mean value is 0.028 on MNIST and 0.081 on CIFAR-10, against – close on MNIST, exceeded by a factor of 2.5 on CIFAR-10. Consequently, is not a certified radius, and the robustness reported in § 5 is empirical throughout. This matters because is the degenerate limit where all points are mapped to the same constant embedding [59].
Table 5 shows that the violation rate (measured on randomly sampled Gaussian neighbors of the training points, using the same pairs the Lipschitz loss is computed on) falls monotonically with on all three datasets. This confirms that controls how strictly the constraint is enforced, and suggests that the violation rate is never driven to zero, so target is not attained everywhere in either setting. The cost differs sharply by dataset: raising from 1 to 100 reduces clean accuracy by 0.4 points on MNIST, 11 on CIFAR-10, and 46 on Imagenette-160, which is why we adopt rather than a larger value.
Neighborhood standard deviation . The third parameter controls where the constraint is sampled rather than how tightly it is enforced. If is increased, neighbors are drawn further away from the training point , so the Lipschitz condition of Eq. (4) is checked over a wider region. Figure 8 shows a monotone ordering on CIFAR-10 and Imagenette-160. The results indicate that the larger , the smaller the residual Lipschitz loss at convergence, spanning about one order of magnitude between and . This is a property of the loss rather than of the embedding network, because the term grows quadratically with the distance to the neighbor while the embedding displacement saturates. Consequently, the constraint is satisfied more often for distant neighbors, and the Lipschitz loss in Equation (4) is inactive on those neighbor pairs. A small residual at large therefore indicates that the constraint is loosely enforced. On MNIST, only is separated from the rest, and the remaining values coincide, indicating that the Lipschitz loss is insensitive to above 0.1 on this dataset. The classification loss behaves in the opposite direction on CIFAR-10 and Imagenette-160. On both of these datasets, the smallest converges most slowly, and the ordering is preserved throughout training, while on MNIST the curves are indistinguishable. We therefore select for MNIST and for CIFAR-10 and Imagenette-160, which are the smallest values at which the Lipschitz loss is still clearly active.
Discussion
The results indicate that adversarial robustness is not the consequence of a single design choice or hyperparameter. Several factors act together, and in our study the classification head emerges as the dominant one, rather than the Lipschitz loss alone. Under FGSM and PGD attacks at moderate and large budgets, the two prototype-based models (GLVQ and Lipschitz GLVQ) are more robust than the linear and SVM classifiers trained on the same frozen embedding. Standard GLVQ, without any Lipschitz loss, already outperforms both Linear and SVM under FGSM, PGD, and C&W attacks. This reproduces the observation by Saralajew et al. [Saralajew et al.(2020a)Saralajew, Holdijk, Rees, and Villmann] that GLVQ models possess a high base robustness before any explicit certification, and it is consistent with the margin-based view of these models: the decision rule of a nearest prototype classifier carries its own hypothesis margin, whereas linear+softmax classification carries none [8 )Hammer, Strickert, and Villmann] ()Crammer, Gilad-bachrach, Navot, and Tishby, Hammer et al. 2005). This gain is obtained at a cost to clean accuracy, which remains below two percentage points on all three benchmarks (Table 4), and without giving up interpretability, since the prototypes are stored in and are initialized from training images. The Lipschitz constraint plays a complementary role: it is what makes the guarantee of Theorem 1 available at all. Without a controlled value of , that is, without a bound on how much the embedding network can stretch distances in the input space, robustness guarantees in the embedding space tell us nothing about robustness in the original input space, because an unconstrained embedding network can map an arbitrarily small input perturbation to an arbitrarily large attack in the embedding space, thus exceeding the robustness guarantees. The measured effect of the Lipschitz loss on robust accuracy, however, depends strongly on the choice of classification head, even though the embedding itself is identical for all three. The improvement of Lipschitz-Linear and Lipschitz-SVM over their unconstrained counterparts is confined to MNIST. On CIFAR-10, Lipschitz-Linear and Lipschitz-SVM fail to outperform their non-Lipschitz counterparts, and on Imagenette-160 the constrained variants are marginally worse against stronger attacks. The two margin-based heads on top of the embedding model therefore do not benefit equally from the Lipschitz loss. Figure 7 also visualizes the range in which the Lipschitz loss has any effect. For , the loss falls below , indicating that the embedding network that does not stretch distances beyond that factor. So setting this large does not have any effect; the regular training of the embedding network would have ensured this Lipschitz constant anyway. By contrast, for , the Lipschitz loss remains nonzero throughout training on all three datasets. The difference between Lipschitz-GLVQ and standard GLVQ on MNIST and CIFAR-10 can thus be attributed to the effect of the Lipschitz loss. More broadly, Figure 7 indicates that the Lipschitz loss has no effect for and saturates for . Hence, we select . For this setting, the clean (i.e. not attacked) accuracy remains almost unaffected while achieving as strong robustness as possible. For example, on MNIST, where the input dimension is low and the embedding space is only 16-dimensional, Lipschitz-GLVQ retains roughly 52.9% accuracy under PGD attacks at (§ 5), an attack strength at which every unconstrained model has collapsed to zero.
Computationally, Lipschitz training is relatively cheap: it costs one additional forward pass through per mini-batch, against the several forward–backward passes per sample required by the inner maximization of adversarial training [31 )Madry, Makelov, Schmidt, Tsipras, and Vladu]. On Imagenette-160, this cheapness is partly offset by slower convergence, as the constrained embedding network reaches only 65.1% validation accuracy at 50 epochs, compared to 74.7% for the baseline.
As discussed in § 4.4, the Lipschitz constant , the Lipschitz weight , and the neighborhood width do not act independently, making hyperparameter optimization a multi-dimensional (and multi-objective; due to the accuracy-robustness tradeoff) optimization problem. Still, it is possible to characterize the different roles of , , and , and provide some guidance for reasonable settings. limits how much the embedding network may stretch a small input perturbation into a displacement in the embedding space, determines how aggressively that limit is enforced during training, and decides whether the constraint is checked only very close to the training data or over a broader region. A larger enforces the constraint more strictly and drives the violation rate down, while a larger relaxes it, so the two can effectively cancel. If is too small, the embedding network may satisfy the Lipschitz bound near the training points while remaining unconstrained further away, leaving gaps that an attack can exploit. A small therefore does not guarantee robustness if is too weak to enforce it or is too narrow to cover the relevant region, just as a large with a wide is of little use if is set so loosely that the constraint is vacuous. Only when all three are chosen in concert does the constraint provide a transferable statement about robustness. The three parameters are not tunable independently. Reporting only one without the other two is insufficient for reproducibility. Two additional observations follow. First, the architecture of the embedding network may be just as important as the Lipschitz loss. We used a small embedding network for fair comparison, not for peak performance. A larger embedding network may raise both clean and robust accuracy. On MNIST, clean accuracy is high (98%), so the model handles a wide range of attacks. On CIFAR-10 and Imagenette-160, clean accuracy is lower (around 70%). There is less room to spare, so performance drops faster. Second, the interaction differs by dataset, so a single global setting of is unlikely to be appropriate everywhere.
The behavior across datasets and attacks is not uniform. Lipschitz-GLVQ is the strongest model under FGSM attacks on all three datasets once the attack limit exceeds a small threshold. Under PGD attacks, the six models are close on MNIST at small budgets but separate sharply at larger ones, while on CIFAR-10 Lipschitz-GLVQ retains a clear advantage over the linear and SVM heads. On Imagenette-160, however, Lipschitz-SVM is the strongest model under PGD attacks over the range where accuracies remain substantial, with Lipschitz-GLVQ second. Since both are maximum-margin heads, which Theorem 1 treats alike, we take this as another instance of the SVM/GLVQ difference that needs to be explored further. The C&W results are the least consistent: on MNIST the ordering is clear, with the mean distortion of the GLVQ pair rising from 1.57 to 2.93, and on Imagenette-160 it is favorable (0.387 0.414), whereas on CIFAR-10 the two are indistinguishable (0.194 against 0.194). The C&W is also the least stable attack across runs. Between two runs on Imagenette-160, the unconstrained baselines shifted as well (Linear 0.36 0.46, SVM 0.32 0.40), although they contain no Lipschitz loss and are unaffected by and . Part of the variation therefore originates in the internal routines of the C&W attacks, rather than in the models (§ 5.2). Beyond this, is expressed in fixed input units and so covers a smaller relative region of a image than of a digit. Resolution-aware choice of would be a natural next step. Imagenette-160 also has by far the smallest training set (9,469 images), and the matched 50-epoch budget penalizes the constrained embedding network on this dataset given its slower convergence. The FGSM results on this dataset, which are stable across folds, show Lipschitz-GLVQ ahead of both linear heads, and we take those as the primary evidence.
Overall, our key results are: The combination of Lipschitz training for a deep embedding network and a GLVQ classifier on the embeddings yields a promising deep prototype classification approach. Our theory suggests that this is due to a transfer of robustness guarantees in the embedding space to the overall model, thanks to Lipschitz continuity. However, these results are complicated by the fact that Lipschitz-SVM falls short of Lipschitz-GLVQ (even though we would have expected similar results) and that GLVQ performs very similar to Lipschitz-GLVQ for some dataset-attack-combinations.
Limitations
While we hope to have substantially pushed forward the research on deep embedding networks combined with robust, shallow classifiers, we also acknowledge multiple limitations:
Local robustness is assumed by our theory, not proven. We rely on prior robustness proofs. However, the fact that Lipschitz SVM does not perform as well as Lipschitz-GLVQ indicates that this may be problematic. A deeper theoretical analysis of the difference between SVM and GLVQ robustness guarantees is required.
Lipschitz training does not guarantee a local Lipschitz bound but only punishes violations for stochastically sampled neighbors. This leaves room for future work on more effective training schemes (without losing the computational efficiency of our approach).
While empirical improvements are striking against FGSM attacks, robustness gains against stronger attacks (PGD and C&W) are more modest. Accordingly, stronger guarantees may be needed.
Our evaluation is limited to three attacks, each using a single random restart. A more comprehensive evaluation using an ensemble-based approach such as AutoAttack [9] would provide a stronger test of the observed robustness and is left for future work.
Our experiments are limited to three data sets and three classifiers. Further classifiers, especially those with robustness guarantees, could be investigated in subsequent work. Similarly, further datasets, involving more modalities than just image data, could be investigated.
Conclusion
Broadly speaking, our motivation stems from the idea that robustness and interpretability are connected by a similar underlying question: does a model only change its prediction when the input has accumulated enough evidence to support a different label? The MNIST results provide some support for this interpretation. In this setting, Lipschitz-GLVQ changes its prediction only at perturbation levels where the digit itself becomes difficult for a human to recognize. This correspondence is less clear for CIFAR-10 and Imagenette-160. For these datasets, a human observer would generally still assign the original label within the tested perturbation budgets, even though the models may already have changed their predictions. Therefore, while Lipschitz-GLVQ improves robustness on the color datasets, the improvement is not yet strong enough to fully support the proposed interpretability argument, and the intersection of robustness and interpretability remains a promising direction for future work.
References
- [1][Angelov and Soares(2020)] Plamen Angelov and Eduardo Soares. Towards deep machine reasoning: a prototype-based deep neural network with decision tree inference. pages 2092–2099, 2020. doi:10.1109/SMC42975.2020.9282812.DOI
- [2][Biehl et al.(2016)Biehl, Hammer, and Villmann] Michael Biehl, Barbara Hammer, and Thomas Villmann. Prototype-based models in machine learning. Wiley Interdisciplinary Reviews: Cognitive Science, 7(2):92–111, 2016. doi:10.1002/wcs.1378.DOI
- [3][Biran and Cotton(2017)] Or Biran and Courtenay Cotton. Explanation and justification in machine learning: A survey. In IJCAI-17 workshop on explainable AI (XAI), volume 8, pages 8–13, 2017. URL https://api.semanticscholar.org/CorpusID:3911355.
- [4][Carlini and Wagner(2017)] Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy (SP), pages 39–57. IEEE, 2017. doi:10.1109/SP.2017.49.DOI
- [5][Carlini et al.(2019)Carlini, Athalye, Papernot, Brendel, Rauber, Tsipras, Goodfellow, Madry, and Kurakin] Nicholas Carlini, Anish Athalye, Nicolas Papernot, Wieland Brendel, Jonas Rauber, Dimitris Tsipras, Ian Goodfellow, Aleksander Madry, and Alexey Kurakin. On evaluating adversarial robustness. arXiv preprint arXiv:1902.06705, 2019. doi:10.48550/arXiv.1902.06705.DOI
- [7][Chen et al.(2019)Chen, Li, Tao, Barnett, Rudin, and Su] Chaofan Chen, Oscar Li, Daniel Tao, Alina Barnett, Cynthia Rudin, and Jonathan K Su. This looks like that: deep learning for interpretable image recognition. volume 32, 2019. URL https://proceedings.neurips.cc/paper_files/paper/2019/file/adf7ee2dcf142b0e11888e72b43fcb75-Paper.pdf.
- [8][Crammer et al.(2002)Crammer, Gilad-bachrach, Navot, and Tishby] Koby Crammer, Ran Gilad-bachrach, Amir Navot, and Naftali Tishby. Margin analysis of the lvq algorithm. In S. Becker, S. Thrun, and K. Obermayer, editors, Advances in Neural Information Processing Systems, volume 15, pages 479–486. MIT Press, 2002. URL https://proceedings.neurips.cc/paper_files/paper/2002/file/bbaa9d6a1445eac881750bea6053f564-Paper.pdf.
- [9][Croce and Hein(2020)] Francesco Croce and Matthias Hein. Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks. In Proceedings of the 37th International Conference on Machine Learning (ICML), pages 2206–2216. PMLR, 2020. URL https://proceedings.mlr.press/v119/croce20b.html.arxiv.org/abs/2003.01690
- [15][Finlay and Oberman (2021)] Chris Finlay and Adam M Oberman. Scaleable input gradient regularization for adversarial robustness. Machine Learning with Applications, 3:100017, 2021. URL arXiv:2503.20454.
- [20][Hammer and Villmann (2002)] Barbara Hammer and Thomas Villmann. Generalized relevance learning vector quantization. Neural Networks, 15(8-9):1059–1068, 2002. doi:10.1016/S0893-6080(02)00079-5.DOI
- [22][Hoffman et al.(2019)Hoffman, Roberts, and Yaida] Judy Hoffman, Daniel A Roberts, and Sho Yaida. Robust learning with jacobian regularization. 2019.arxiv.org/abs/1908.02729
- [23][Howard(2019)] Jeremy Howard. Imagenette: A smaller subset of 10 easily classified classes from imagenet, March 2019. URL https://github.com/fastai/imagenette.
- [26][Khalid and Paaßen(2026)] Adia Khalid and Benjamin Paaßen. Adversarial robustness by combining prototype models with lipschitz training. In Michel Verleysen, editor, 34th European Symposium on Artificial Neural Networks, Computational Intelligence and Machine Learning (ESANN), 2026. in press.
- [27][Kohonen(1990)] Teuvo Kohonen. The self-organizing map. Proceedings of the IEEE, 78(9): 1464–1480, 1990. doi:10.1109/5.58325.DOI
- [28][Krizhevsky(2009)] Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009. URL https://api.semanticscholar.org/CorpusID:18268744.
- [29][LeCun et al.(2010)LeCun, Cortes, and Burges] Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, 2, 2010.
- [30][Li et al.(2018)Li, Liu, Chen, and Rudin] Oscar Li, Hao Liu, Chaofan Chen, and Cynthia Rudin. Deep learning for case-based reasoning through prototypes: A neural network that explains its predictions. 32(1), 2018.
- [31][Madry et al.(2017)Madry, Makelov, Schmidt, Tsipras, and Vladu] Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv:1706.06083, 2017. doi:https://doi.org/10.1609/aaai.v32i1.11771.
- [32][Matyasko and Chau(2017)] Alexander Matyasko and Lap-Pui Chau. Margin maximization for robust classification using deep learning. In 2017 International Joint Conference on Neural Networks (IJCNN), pages 300–307. IEEE, 2017. doi:10.1109/IJCNN.2017.7965869.
- [33][Moosavi-Dezfooli et al.(2016)Moosavi-Dezfooli, Fawzi, and Frossard] Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2574–2582, 2016.
- [36][Ross and Doshi-Velez (2018)] Andrew Ross and Finale Doshi-Velez. Improving the adversarial robustness and interpretability of deep neural networks by regularizing their input gradients. In Proceedings of the AAAI conference on artificial intelligence, volume 32, 2018. doi:https://doi.org/10.1609/aaai.v32i1.11504.
- [40][Sato and Yamada(1995)] Atsushi Sato and Keiji Yamada. Generalized learning vector quantization. Advances in neural information processing systems, 8, 1995. URL https://proceedings.neurips.cc/paper_files/paper/1995/file/9c3b1830513cc3b8fc4b76635d32e692-Paper.pdf.
- [42][Seo and Obermayer(2003)] Sambu Seo and Klaus Obermayer. Probabilistic learning vector quantization. Neurocomputing, 55(1-2):189–211, 2003. URL https://proceedings.neurips.cc/paper_files/paper/2018/file/d54e99a6c03704e95e6965532dec148b-Paper.pdf.pubmed.ncbi.nlm.nih.gov/12816567
- [44][Snell et al.(2017)Snell, Swersky, and Zemel] Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems, volume 30, 2017. URL https://proceedings.neurips.cc/paper_files/paper/2017/file/cb8da6767461f2812ae4290eac7cbc42-Paper.pdf.arxiv.org/abs/1703.05175
- [45][Szegedy et al.(2013)Szegedy, Zaremba, Sutskever, Bruna, Erhan, Goodfellow, and Fergus] Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.arxiv.org/abs/1312.6199
- [46][Tsipras et al.(2018)Tsipras, Santurkar, Engstrom, Turner, and Madry] Dimitris Tsipras, Shibani Santurkar, Logan Engstrom, Alexander Turner, and Aleksander Madry. Robustness may be at odds with accuracy. 2018.arxiv.org/abs/1805.12152
- [47][Vadillo et al.(2025)Vadillo, Santana, and Lozano] Jon Vadillo, Roberto Santana, and Jose A Lozano. Adversarial attacks in explainable machine learning: A survey of threats against models and humans. Wiley Interdisciplinary Reviews: Data Mining and Knowledge Discovery, 15(1):e1567, 2025. doi:https://doi.org/10.1002/widm.1567.
- [48][Virmaux and Scaman(2018)] Aladin Virmaux and Kevin Scaman. Lipschitz regularity of deep neural networks: analysis and efficient estimation. Advances in neural information processing systems, 31, 2018.
- [49][Voráček and Hein(2022)] Václav Voráček and Matthias Hein. Provably adversarially robust nearest prototype classifiers. In Proceedings of the 39th International Conference on Machine Learning (ICML), 2022. URL https://proceedings.mlr.press/v162/voracek22a.html.arxiv.org/abs/2207.07208
- [50][Wang et al.(2018)Wang, Jha, and Chaudhuri] Yizhen Wang, Somesh Jha, and Kamalika Chaudhuri. Analyzing the robustness of nearest neighbors to adversarial examples. In Proceedings of the 35th International Conference on Machine Learning (ICML), pages 5133–5142. PMLR, 2018.arxiv.org/abs/1706.03922
- [52][Xu et al.(2020)Xu, Ma, Liu, Deb, Liu, Tang, and Jain] Han Xu, Yao Ma, Hao-Chen Liu, Debayan Deb, Hui Liu, Ji-Liang Tang, and Anil K Jain. Adversarial attacks and defenses in images, graphs and text: A review. International journal of automation and computing, 17(2):151–178, 2020. doi:https://doi.org/10.1007/978-3-030-32236-6_51.
- [53][Yang et al.(2020)Yang, Rashtchian, Wang, and Chaudhuri] Yao-Yuan Yang, Cyrus Rashtchian, Yizhen Wang, and Kamalika Chaudhuri. Robustness for non-parametric classification: A generic attack and defense. In Proceedings of the 23rd International Conference on Artificial Intelligence and Statistics (AISTATS), pages 941–951. PMLR, 2020.arxiv.org/abs/1906.03310
- [59][Zühlke and Kudenko (2025)] Monty-Maximilian Zühlke and Daniel Kudenko. Adversarial robustness of neural networks from the perspective of lipschitz calculus: A survey. ACM Computing Surveys, 57(6):1–41, 2025. doi:10.1145/3648351.DOI





