betaFeedback

WorksComputer Science

Attack logics, not outputs: Concept-based Property Attacks for Shortcut Elimination in Neural Networks

Abstract

Deep neural networks (NNs) for computer vision are vulnerable to adversarial attacks, such that minuscule malicious changes to inputs may induce unintuitive outputs. One key approach to verify and mitigate such robustness issues is to falsify expected output behavior, which enables local robustness guarantees and adversarial training. Due to the black-box nature of NNs, current attacks only falsify a class of the final output, such as flipping from \text{stop_sign} to \neg \text{stop_sign}. In this work we argue that robustness analysis should focus more generally on logical inconsistencies in concept-level reasoning rather than solely on output misclassification. We formalize this perspective through concept-based properties, i.e., constraints over human-interpretable concepts such as \text{red} \land \text{octogonal} \implies \text{stop_sign} and study the falsification of such properties as a principled form of adversarial attack. Furthermore, an implementation of concept-based properties on already trained NNs is proposed using techniques from concept-based explainable artificial intelligence (C-XAI). For that we formally prove that attacks on concept-based properties are expected to have a reduced search space compared to simple class falsification, whilst arguably be more aligned with intuitive robustness targets. The practical effectiveness of our approach for logically informed adversarial training is shown in an empirical study across multiple models and datasets, including both vision and a security-relevant code processing task. Our results demonstrate that concept-level falsification generalizes classical adversarial attacks: Retraining on our novel attacks maintains robustness gains as compared to classical adversarial retraining whilst better eliminating semantic biases.

Introduction

Neural Networks (NNs) excel in processing subsymbolic inputs like images, and are increasingly being considered for use in safety-critical domains [47]. This makes it crucial to ensure their robust and intuitive generalization, at least around known training cases. One tool to evaluate vulnerability to malicious attacks are Adversarial Attacks (AAs): These craft inputs that induce incorrect or unexpected predictions of an NN ff, using minimal modifications to a correctly handled input xx with y=f(x)y = f(x) [57, 33, 23, 70, 72, 61, 40]. However, existing attacks solely focus on altering the model’s final output, i.e., falsify ∀x′∈Nbhd⁡(x):f(x′)=y\forall x' \in\operatorname{Nbhd}(x): f(x') = y for some neighborhood Nbhd⁡(x)\operatorname{Nbhd}(x) around xx such as an ϵ\epsilon-ball. This disregards whether the prediction still conforms to high-level, interpretable properties. Common examples of known properties are sufficient conditions, e.g., red⁡(x)∧octogonal⁡(x)⇒stop_sign⁡(x)\operatorname{red}(x) \land\operatorname{octogonal}(x) \Rightarrow\operatorname{stop\_sign}(x) in traffic sign recognition from images xx; and necessary conditions, like ¬octogonal⁡(x)⇒¬stop_sign⁡(x)\neg\operatorname{octogonal}(x) \Rightarrow\neg\operatorname{stop\_sign}(x). More general, we call rules involving unary predicates that are not available from the NN outputs concept-based properties. Rich semantic rules are known to be well suited for runtime plausibility monitoring [51, 20] and respective correction of NN outputs [20, 31, 2]. In particular, they don’t constrain the local output to be correct, but the underlying general logical reasoning locally around the sample.

One reason why falsification of such informative constraints is not considered for attack generation so far is that they require outputs for all involved predicates—not only the available final output, like stop_sign⁡\operatorname{stop\_sign}. These additional outputs however, might need a considerable amount of training data or hyperparameter tuning if added right away during the training; or, even worse, not all properties and thus not all required concepts might be known at training time due to specification gaps or later domain transfer [63]. Meanwhile, NNs automatically learn to encode task-related concepts in their intermediate outputs. For example, when trained for stop_sign⁡\operatorname{stop\_sign} recognition, the NN may implicitly learn to identify octagons, red color, and the stop_label⁡\operatorname{stop\_label}. Post-hoc supervised concept-based explainability methods [4, 16, 10, 42] can recover this information in a very sample-efficient manner with minimal additions to the NN structure. We use this as key to access concepts post-hoc.

Altogether, we propose and analyze a general AA goal —the Concept-based Property Attack (ConPAtt)—that explicitly targets falsification of symbolic concept-based properties over non-symbolic inputs. As we will show, our formulation offers a more general way to define both targeted and untargeted attacks. As opposed to classical attacks that purely change the output, our attack on ¬octogonal⁡⇒¬stop_sign⁡\neg\operatorname{octogonal} \Rightarrow\neg\operatorname{stop\_sign} can produce an image still classified as stop_sign⁡\operatorname{stop\_sign}, in which the octogonal concept is no longer recognized. This newly allows to uncover failure cases with semantically inconsistent yet high-confidence predictions that are invisible to standard attacks. A practical benefit we show empirically is that these semantic-aware adversarial examples do not only (1) achieve competitive robustness gains when used for adversarial training, but (2) are also better in eliminating semantic bias as compared to standard AA formulations. As we show, standard white-box attack techniques can still easily and efficiently be applied, producing meaningful attacks and a more constrained adversarial space as compared to traditional AAs.

Contributions. Our main contributions are:

  • We introduce ConPAtt, a general XAI-supported adversarial attack objective that targets concept-based properties rather than just NN outputs.

  • We prove that ConPAtt generalizes both classical targeted and untargeted AA formulations, but operates on a same-sized or smaller adversarial space.

  • We empirically show that ConPAtt enables semantic perturbations that achieve competitive robustness under adversarial retraining, and improved semantic bias correction in vision and language models.

Related Work

Adversarial Attacks. AAs generally search within the vicinity of an input sample xx for minimally perturbed variants x~=x+ϵ\tilde{x} = x + \epsilon that have a malicious effect on the NN’s output [27]. The perturbations can be arbitrary (digital AAs, considered here) [58, 64, 55, 62, 72, 61], or further constrained to realistic changes (physical AAs) [33, 23, 15, 34, 57, 70]. However, the minimality makes the changes often invisible or difficult to see for humans. At the methodological level, black-box approaches only require access to NN inputs and outputs [34, 57, 23, 25, 60, 70]. White-box attacks, as considered here, instead exploit NN model internals such as the gradient for a more efficient search [58, 64, 62, 33, 72, 61]. Generally, AAs can be seen as a subfield of NN verification that falsifies a continuity property [35, 56]. Thus, usual search, reachability analysis, and—most prominently—optimization techniques are applicable to find or disprove adversarial examples [27]. Regarding types of specifications beyond continuity properties, Baninajjar et al. [3] recently formally investigated local deviations between two NNs, and approaches such as Scenic [18] and VerifAI [13] demonstrate how formal specifications can be used to generate and analyze simulation-based scenarios with symbolic inputs. In contrast, our approach targets AAs on non-symbolic image inputs, which prevents the direct use of such tools but similarly requires formal specifications.

Concept-based Explainability Concept-based explainability generally aims to associate human-interpretable concepts with representations in NN latent space [32, 44, 50]. This includes understanding which concepts are relevant to the decision and to what extent [59, 42], and how these can be accurately recognized in NNs [16, 49]. If concept definitions in form of labeled samples are available at training time, ante-hoc approaches [29, 59, 68, 41, 67] can train individual neurons to activate for the concept. We here instead consider post-hoc approaches: These train a simple model to predict the concept of interest from an NN layer’s activation [28]. Other than single-neuron-associations [5, 43], or complex models [9, 69], linear models considered here [17, 28, 21, 38] pose a good tradeoff between capturing the entanglement of representations [17, 14], interpretability [28], and favorably simple representation of the concept as halfspace in the NN’s latent space.

XAI and Verification Prior work has shown that concept-based explanation methods are vulnerable to adversarial attacks. Perturbations can mislead attribution [53] and concept-based tools [39, 6], and adversarial examples significantly alter the internal concept composition of NNs [39], confirming the general fragility of interpretability methods [19]. However, these studies target concepts in isolation, without considering their joint relation to model predictions.

Beyond highlighting vulnerabilities, concept outputs have also been used for verification. Mangal et al. Mangal et al. [37] employed vision–language models to check concept-based properties. While expressive, this approach relies on semantic similarity in multimodal embeddings (e.g., CLIP [46]), which can introduce linguistic ambiguity as well as imprecision for similar terms with small visual differences, e.g., circle versus octagon. Moreover, it is restricted to the latent space of a specific layer, although simple visual concepts may predominantly appear earlier and diminish in later layers. Cheng et al. Cheng et al. [8] proposed specifications close to the output layer, but without decomposing them into underlying concepts and by employing an additional NN. Semantic losses [66, 2] like logic tensor networks [2] suggest to directly train concept-based rules into the network. These techniques, however, are only used for updating the NN, not for verification as done in [51], and not for AAs. Furthermore, they rely on concepts being direct outputs of the NN. Even further decoupling the verification from the NN’s learned representations and thus exacerbating training efforts, Xie et al. Xie et al. [65] even trained completely separate NNs for predicting the concepts. Our work also directly addresses the relationship between concepts and model outputs, a perspective that has received little attention so far [51]. However, similar to the verification testing techniques from [8, 51], we suggest to keep training and verification efforts low by using faithful explainability techniques to access concept predictions, and we newly apply the setup to AAs.

Background

Adversarial Attacks Let x∈Xx \in\mathcal{X} be a real image, y∈Yy \in\mathcal{Y} be its true label, and f ⁣:X→Yf \colon\mathcal{X} \to\mathcal{Y} be a NN. An AA seeks an adversarial example xadv:=x+ϵ∈Xx^{\mathrm{adv}} := x + \epsilon\in\mathcal{X} so that its output is (sufficiently) different from the original, and the perturbation ϵ\epsilon is minimal to an objective function oo (usually the L1, L2, or L-infinity norm on the input for digital attacks). Sufficient difference can be formulated in terms of a yy-specific partition of the output set Y\mathcal{Y} into a benign output set Y+⊂Y\mathcal{Y}^{+} \subset\mathcal{Y} with f(x)∈Y+f(x) \in\mathcal{Y}^{+}, and a malicious one Y−:=Y∖Y+\mathcal{Y}^{-} := \mathcal{Y} \setminus\mathcal{Y}^{+}. The search for the minimum perturbation ϵ\epsilon then is the optimization problem

argmin⁡ϵ o(ϵ)s.t. f(x+ϵ)∈Y−.(1)\underset{\epsilon}{\operatorname{argmin}}\ o(\epsilon) \qquad\text{s.t.}\ f(x+\epsilon) \in\mathcal{Y}^{-}. \tag*{(1)}

Adversarial attack strategies for classification are commonly categorized as targeted or untargeted, depending on the definition of the set Y−\mathcal{Y}^{-}:

Y−={{y∈Y∣y≠l},(untargeted),{y∈Y∣y=l′},(targeted),\mathcal{Y}^{-} = \begin{cases} \{y \in\mathcal{Y} \mid y \ne l\}, & \text{(untargeted)},\\ \{y \in\mathcal{Y} \mid y = l'\}, & \text{(targeted)}, \end{cases}

where ll denotes the true class and l′≠ll' \ne l the targeted incorrect class. The satisfaction relation y⊨ly \models l indicates that instance yy is assigned label ll by the classifier, while y⊭ly \not\models l denotes the negation thereof.

Post-hoc Concept Extraction Let CC be a set of concepts (e.g., C={red,orthogonal}C = \{\text{red}, \text{orthogonal}\}), and assume a possibly small classification dataset Dc=((xk,yc,k))k\mathcal{D}_c = ((x_k, y_{c,k}))_k is available per concept c∈Cc \in C. Further denote by fi→j:Xi→Xjf_{i \to j} : \mathcal{X}_i \to\mathcal{X}_j the NN part that maps from the iith to the jjth layer. Through linear post-hoc concept extraction, additional concept outputs are added to the NN by attaching for each cc a linear classification model fi→c:Xi→Cc=[0,1]f_{i \to c} : \mathcal{X}_i \to\mathcal{C}_c = [0,1] to the iith hidden layer as illustrated in Figure 1. Keeping the NN’s weights fixed, the weights of fi→cf_{i \to c} are trained on pairs ((f→i(xk),yc,k))k((f_{\to i}(x_k), y_{c,k}))_k, such that cc’s concept function fc=fi→c∘f→i:X→Ccf_c = f_{i \to c} \circ f_{\to i} : \mathcal{X} \to\mathcal{C}_c correctly predicts presence of the concept in an input image. Note that fi→cf_{i \to c} being linear, conveniently makes any subspace {v∈Xi∣fi→c(v)>θ}\{v \in\mathcal{X}_i \mid f_{i \to c}(v) > \theta\} an affine linear half-space. In the following, we denote by fC=(fc)c∈C:X→C=(Cc)c∈Cf_C = (f_c)_{c \in C} : \mathcal{X} \to C = (\mathcal{C}_c)_{c \in C} the complete prediction of all concepts, and by Z=Y×CZ = \mathcal{Y} \times C the complete output set after attaching the concept outputs.

Post-hoc concept extraction: two neurons for concept output, blue and green neurons, added to a trained neural network

Figure 1. Post-hoc Concept Extraction: Two neurons for concept output (blue and green neurons) are post-hoc added to the trained NN (gray) using newly trained connections to hidden layers 1/3.

t-Norm Fuzzy Logic The standard Boolean logical connectives (and ∧\land, or ∨\lor, not ¬\lnot) can only operate on binary truth values in B={0,1}\mathbb{B} = \{0,1\}. t-norm fuzzy logics extend the connectives to many-valued truth values in B=[0,1]\mathbb{B} = [0,1] using a so-called t-norm ∧t:[0,1]×[0,1]→[0,1]\land_t : [0,1] \times[0,1] \to[0,1] to replace ∧\land. A valid t-norm must be monotonic, commutative and associative, have a neutral element (the 1), and match ∧\land on Boolean values (0 and 1). Typical choices for a∧tba \land_t b are Product (a⋅ba \cdot b), Łukasiewicz (max⁡(0,a+b−1)\max(0, a + b - 1)), and Gödel (min⁡(a,b)\min(a,b)) t-norms [26], since these form a generating system for all continuous t-norms. Given a ∧t\land_t, then the connectives ¬a:=1−a\lnot a := 1-a, ∨t\lor_t, ⇒t:[0,1]2→[0,1]\Rightarrow_t : [0,1]^2 \to[0,1] can be derived and maintain desirable properties, together constituting the resulting t-norm logic.

Desirable properties for use of t-norm logic with NN classification outputs are: (1) The NN typically produces a confidence prediction in [0,1][0,1] instead of a Boolean value, which can be propagated by t-norm fuzzy logic to the confidence of entire logical expressions. (2) The classical piece-wise continuous t-norm logic connectives are also piece-wise differentiable like ReLU activations of NNs. So, they can directly be used in backpropagation and gradient-based adversarial attacks [2].

Approach

In this chapter we first define our new notion of concept-based AAs. Then we show that standard AAs are a special case, and existing attack techniques can easily be adopted to our new attack.

Concept-based Property Attacks

These classical AA types can also be interpreted as special cases of property attacks, where class predictions are represented as logical literals. Using fuzzy logic (see § 3), logical properties over model outputs are evaluated using the satisfaction relation ⊨ρ\models\rho, which denotes that instance yy satisfies property ρ\rho. A property attack aims to falsify a given property, that is, Y−=Yρ−={y∈Y∣y⊭ρ}\mathcal{Y}^{-} = \mathcal{Y}_{\rho}^{-} = \{y \in\mathcal{Y} \mid y \not\models\rho\}. Untargeted and targeted attacks correspond to properties ρ=l\rho= l and ρ=¬l\rho= \lnot l for true class ll, respectively. This perspective allows adversarial examples to be crafted with higher-order conditions — e.g., enforcing predictions of classes l1l_1 and l2l_2 simultaneously. The corresponding attacked property is its logical negation: ρ=¬l1∨¬l2\rho= \lnot l_1 \lor\lnot l_2.

The point of view of property attacks can also be applied to NNs that are enriched using XAI techniques. Additional concept outputs can be used just like the original task output of the NN to define property attacks— Concept-based Property Attacks (ConPAtt). For denoting the properties we use the following implication-based normal form, which serves as a convenient and intuitive notation throughout this paper. By Lemma 4.1, every logical expression over concept and task literals can be equivalently rewritten into this form. For simplicity, we shorten fc(x)f_c(x) to cc.

Lemma 4.1. Each logical expression φ\varphi with two disjoint literal sets CC and LL can be reformulated into a term of conjunctively linked implication terms where antecedents consist only of conjunctively linked literals of CC, and consequences consist only of disjunctively linked literals of LL.

Proof. Each logical expression can be reformulated into the conjunctive normal form φ≡⋀i(⋁c∈Ci⊆Cc∨⋁l∈Li⊆Ll)\varphi\equiv\bigwedge_i\left(\bigvee_{c\in C_i\subseteq C}c \lor\bigvee_{l\in L_i\subseteq L}l\right). Let us introduce two additional variable families αi,βi\alpha_i,\beta_i that condense the disjunctive subformulas:

αi:=¬⋁c∈Ci⊆C¬c≡⋀c∈Ci⊆Ccβi:=⋁l∈Li⊆Ll(2)\alpha_i := \neg\bigvee_{c\in C_i\subseteq C}\neg c \equiv\bigwedge_{c\in C_i\subseteq C}c \qquad \beta_i := \bigvee_{l\in L_i\subseteq L}l \tag*{(2)}

The subformulas can be replaced by these variables and the whole logical expression φ\varphi reformulates to φ≡⋀i(¬αi∨βi)≡⋀i(αi⟹βi)\varphi\equiv\bigwedge_i(\neg\alpha_i\lor\beta_i)\equiv\bigwedge_i(\alpha_i\Longrightarrow\beta_i).

Definition 4.2 (Concept-based property). A concept-based property φ\varphi is a logical expression over two disjoint literal sets CC—the concept literals—and LL—the task literals—, admitting the following implication-based representation, where antecedents consist only of conjunctively linked concept literals and consequences consist only of disjunctively linked task literals.

φ:=⋀i(αi⟹βi),withαi:=⋀c∈Ci⊆Ccandβi:=⋁l∈Li⊆Ll(3)\varphi:= \bigwedge_i(\alpha_i\Longrightarrow\beta_i),\qquad\text{with}\qquad\alpha_i:=\bigwedge_{c\in C_i\subseteq C}c\qquad\text{and}\qquad\beta_i:=\bigvee_{l\in L_i\subseteq L}l \tag*{(3)}

This implication-based representation is purely notational and neither restricts expressiveness nor alters the results (according to Lemma 4.1).

Definition 4.3 (Concept-based Property Attack). Let φ\varphi be a concept-based property and let oo be a minimality measure for perturbations ϵ\epsilon. A Concept-based Property Attack (ConPAtt) of φ\varphi is the search for an oo-minimal perturbation ϵ\epsilon to an input xx transforms xx into an adversarial example xadv=x+ϵx^{\mathrm{adv}}=x+\epsilon which falsifies φ\varphi, i.e., lies in the malicious output set

Z−=Zφ−={z∈Z∣z⊭φ}(4)\mathcal{Z}^{-}=\mathcal{Z}^{-}_{\varphi}=\{z\in\mathcal{Z}\mid z\nvDash\varphi\} \tag*{(4)}

Intuitively, a ConPAtt adversarial example xadvx^{\mathrm{adv}} to φ=(⋀cc⟹⋁ll)\varphi=(\bigwedge_c c\Longrightarrow\bigvee_l l) like red∧octogonal⟹stop_sign\mathrm{red}\land\mathrm{octogonal}\Longrightarrow\mathrm{stop\_sign}, causes the NN to predict all cc as true, and all ll as false. This can happen if (1) some cc is predicted true even though it should be false (e.g., red\mathrm{red} predicted true even though the change ϵ\epsilon turned the sign gray), and/or (2) some ll is predicted negative even though it should be positive (e.g., stop_sign\mathrm{stop\_sign} flipped to false).

ConPAtts as Generalized Adversarial Attacks

Note that falsifying one implication term is enough to falsify a concept-based property and thus, it is sufficient to consider one implication ϕ=α⟹β\phi=\alpha\Longrightarrow\beta for an attack. The set of adversarial example task outputs can be derived from this definition, i.e. Yφ−:={y∈Y∣(y,c)∈Zφ−}\mathcal{Y}_{\varphi}^{-}:=\{y\in\mathcal{Y}\mid(y,c)\in\mathcal{Z}_{\varphi}^{-}\}. Furthermore:

Corollary 4.4. Standard targeted and untargeted AAs are special cases of ConPAtt.

Proof. First note the two special cases of ConPAtt where only a single task literal is used:

  1. Generalized untargeted AAs: α⟹l\alpha\Longrightarrow l.

  2. Generalized targeted AAs: α⟹¬l\alpha\Longrightarrow\neg l.

Un-/targeted AAs are generalized un-/targeted AAs with α≡true\alpha\equiv\mathrm{true}, i.e., no concept restriction. □\square

A neat property of ConPatts is that the search space is generally reduced compared to vanilla AAs:

Theorem 4.5. The task output spaces of adversarial examples for generalized untargeted/targeted AAs are smaller than or equal to those for standard untargeted/targeted AAs.

Yα⟹l⊆YlYα⟹¬l⊆Y¬l\mathcal{Y}_{\alpha\Longrightarrow l}\subseteq\mathcal{Y}_l \qquad \mathcal{Y}_{\alpha\Longrightarrow\neg l}\subseteq\mathcal{Y}_{\neg l}

Proof. Let us first look at generalized untargeted AA properties like α⟹l\alpha\Longrightarrow l. Each adversarial example must lack class prediction ll but requires concept predictions α\alpha, i.e., they satisfy the property α∧¬l\alpha\land\neg l. In contrast to that, standard untargeted AAs only require the misclassification of ll, i.e. each adversarial example satisfies ¬l\neg l and they accept adversarial examples that do not additionally fulfill α\alpha. It follows that the valid output space of adversarial examples for generalized untargeted AAs Zα⟹l\mathcal{Z}_{\alpha\Longrightarrow l} is smaller than or equal to that for standard untargeted AAs Z¬l\mathcal{Z}_{\neg l} as well as for their valid task output spaces Yα⟹l⊆Y¬l\mathcal{Y}_{\alpha\Longrightarrow l} \subseteq\mathcal{Y}_{\neg l}.

In this explanation, it does not matter whether both adversarial examples expect a misclassification ¬l\neg l or a specific task output ll. That is why this relation also applies between generalized targeted AAs and standard targeted AAs, i.e. Yα⟹¬l⊆Y¬l\mathcal{Y}_{\alpha\Longrightarrow\neg l} \subseteq\mathcal{Y}_{\neg l}.

ConPAtt Procedure ConPAtt can be easily performed with any existing AA approach. The trick is to use the result of the (partially) differentiable fuzzy operation φ∘(f,fC):X→B\varphi\circ(f, f_C): \mathcal{X} \to\mathbb{B} instead of the output of the NN. This makes ConPAtt a targeted AA with the expected result false or 0 for the adversarial examples.

Evaluation

In this section, we evaluate the effectiveness of ConPAtt in terms of generalization and robustness under adversarial retraining. Overall, we aim to assess whether ConPAtt improves robustness beyond standard attacks such as PGD and whether it induces qualitatively different adversarial behavior. Following our theoretical analysis, we hence explore the intuitive hypotheses that (1) ConPAtt also practically generalizes AAs in robustification, i.e., adversarial retraining under ConPAtt achieves competitive robustness; and (2) ConPAtt is superior to the standard AA formulation in correcting semantic model bias. We focus on F1 score as the primary evaluation metric and analyze performance along two axes: (i) generalization on original data after retraining, and (ii) robustness to PGD adversarial examples. Finally, we complement vision experiments (§ 5.1 and § 5.2) with an additional study on a large language model to assess whether the observed effects extend beyond the vision domain (§ 5.3).

Experimental Setup

Datasets We validate and evaluate our approach on two vision benchmarks, MNIST [11], GTSRB [54], which differ in semantic complexity and can be described by rules. In addition to these datasets, we construct a biased variant of GTSRB by introducing simple class-specific features (small static coloured rectangle pasted into the image) that create strong spurious correlations, encouraging models to rely on shortcut solutions. Both use their standard train–test splits. All models are trained with early stopping based on validation loss, and the best checkpoint is used for evaluation.

Models and Training We consider convolutional, residual, and transformer-based architectures to cover various inductive biases, namely LeNet-5 [30], M3 [1], ResNet-8 [22], VGG-16 [52] (ImageNet-pretrained), and a Vision Transformer (ViT) [12]. Each architecture is trained with multiple seeds. We follow standard training procedures (details in Section B of the Appendix).

Concept Mining Concepts are learned by training linear classifiers on intermediate feature representations of each model. These classifiers predict the presence of predefined, task-specific concepts, enabling a structured representation of model internals. For MNIST, concepts correspond to geometric primitives with an explicit hierarchical structure, while for GTSRB, concepts are grouped into shape, colour, and symbol categories, using a synthetically generated dataset (details in Section B).

Adversarial Attacks We focus on PGD [36] as a strong classical baseline to generate adversarial examples; extending to additional attacks is left for future work. An ϵ\epsilon-sweep on MNIST identifies ϵ=0.3\epsilon= 0.3 as a reliable trade-off between attack success and perceptual distortion, which we use across all experiments.

ConPAtt operates on a predefined set of logical rules using Gödel t-norm semantics. We consider two complementary strategies: our approach, decreasing rule compliance (R↓), and for validation increasing rule compliance (R↑). The latter corresponding to attacking the negated rule set, where an inversed effect on any ConPAtt-specific improvements is expected. This allows to assess whether ConPAtt benefits arise from training on perturbed samples in general, or whether truly semantic improvements are introduced by the attack formulation. The full rule set is provided in the appendix (Section B).

Adversarial Retraining and Evaluation Protocol To compare standard adversarial attacks with ConPAtt, we retrain models on a mixture of clean and adversarial examples generated by each attack, while keeping the concept classifiers fixed. Evaluation is conducted along two axes. First, we report F1 score on the original data to assess generalization after retraining. Second, we evaluate retraining robustness by testing adversarial examples from one attack against models retrained with another.

While rule compliance (i.e., the fraction of satisfied rules across samples and rules) is useful to characterize the effect of these attacks on semantic consistency, it does not necessarily reflect whether rules are correctly causally used for prediction. In particular, high rule compliance can arise from spurious correlations (e.g., in biased settings where concepts of interest are never predicted, only a biased feature). Hence, it is not used as a primary evaluation metric, but reported only to verify that the generated adversarial examples consistently increase or decrease rule satisfaction as intended. The complete analysis of this rule compliance is included in the Appendix (Section C).

Results

Generalization after Retraining Table 1 reports F1 scores on original data after adversarial retraining. Across all datasets and architectures, retraining consistently improves performance compared to the original models, excluding VGG-16 on MNIST. Comparing attack strategies, R↓R_{\downarrow} and PGD achieve comparable F1 scores, while R↑R_{\uparrow} performs slightly but consistently worse. This shows that ConPAtt benefits go beyond the ones from generally training on perturbed samples. In the biased setting, R↓R_{\downarrow} yields a significant improvement over PGD on the larger models, suggesting that targeting rule violations can mitigate shortcut learning effects.

BackboneNo retrainingPGDR↓R_{\downarrow}R↑R_{\uparrow}
MNIST
LENET-5.988±.003.997±.001.998±.000.994±.001
M3.992±.001.998±.001.998±.001.992±.002
ResNet-8.986±.005.998±.000.998±.000.994±.001
ViT.916±.012.940±.011.937±.010.937±.015
VGG-16.992±.001.986±.006.913±.253.853±.346
GTSRB
LENET-5.968±.006.973±.001.975±.001.964±.004
M3.985±.016.993±.001.993±.001.990±.002
ResNet-8.831±.114.907±.013.927±.022.919±.020
ViT.917±.007.932±.007.939±.004.930±.006
VGG-16.880±.001.990±.001.992±.004.992±.002
Biased
LENET-5.522±.053.965±.007.965±.005.964±.004
M3.989±.002.989±.001.989±.004.989±.002
ResNet-8.296±.035.861±.050.881±.041.862±.050
ViT.132±.025.926±.008.939±.007.925±.011
VGG-16.689±.002.988±.010.993±.002.991±.003

Table 1. F1 scores on original data after adversarial retraining. Each model is retrained using adversarial examples generated by the corresponding method. Values are reported as mean ± standard deviation across five runs. R↓R_{\downarrow} achieves performance comparable to PGD, while the wrong attack direction R↑R_{\uparrow} is consistently lower. In the biased setting, R↓R_{\downarrow} yields significant improvements over PGD for the majority of models.

We observe increased variance for VGG-16 on MNIST, where several training runs for R↓R_{\downarrow} and R↑R_{\uparrow} do not converge. This effect is not present for PGD-based retraining and results in higher standard deviations and lower mean for these configurations. Apart from that, maintained F1 scores after adversarial training are competitive to vanilla PGD.

Robustness to PGD Adversarial Examples Table 2 evaluates robustness by testing PGD adversarial examples across differently retrained models. As expected, PGD adversarial examples achieve very low F1 scores on the original (non-retrained) models, in some cases achieving a 100% attack success rate. However, models retrained with R↓R_{\downarrow} and R↑R_{\uparrow} generalize well to previously unseen PGD adversarial examples, achieving substantially higher F1 scores than models without robustification. While PGD-retrained models perform best on PGD adversarial examples, R↓R_{\downarrow} achieves mostly competitive results. This indicates that ConPAtt-based retraining improves robustness beyond its own attack distribution.

BackboneNo retrainingPGDR↓R_{\downarrow}R↑R_{\uparrow}
MNIST
LENET-5.102±.084.997±.001.938±.033.919±.025
M3.373±.114.998±.001.995±.001.987±.004
ResNet-8.110±.013.998±.000.994±.002.985±.005
ViT.430±.102.927±.012.910±.014.923±.016
VGG-16.000±.000.984±.008.909±.252.850±.345
GTSRB
LENET-5.057±.012.906±.003.822±.009.822±.011
M3.114±.024.935±.007.788±.025.849±.008
ResNet-8.003±.002.667±.041.664±.037.609±.076
ViT.000±.000.866±.023.689±.029.637±.056
VGG-16.000±.000.943±.009.938±.013.909±.020
Biased
LENET-5.012±.005.890±.014.849±.010.861±.006
M3.138±.092.909±.004.794±.040.832±.017
ResNet-8.009±.006.659±.064.645±.064.616±.078
ViT.000±.000.885±.012.676±.047.591±.101
VGG-16.000±.000.943±.014.937±.014.929±.011

Table 2. F1 scores on PGD adversarial examples evaluated across differently retrained models. PGD adversarial examples strongly degrade performance on non-retrained models, indicating high attack success. Models retrained with R↓R_{\downarrow} and R↑R_{\uparrow} generalize well to unseen PGD adversarial examples, although PGD-retrained models perform best due to exposure during training. Values are reported as mean ± standard deviation across five runs.

Semantic Properties of Adversarial Examples We also investigate rule compliance of adversarial examples generated by different attack strategies (detailed results in Section C). R↓R_{\downarrow} produces adversarial examples that cause significantly lower rule compliance than PGD on vanilla models, whereas R↑R_{\uparrow} increases rule compliance beyond both PGD and the original samples. This demonstrates that, despite relying on similar optimization procedures, the two ConPAtt variants generate semantically distinct adversarial examples, as can also be seen in Figure 2. In particular, they systematically manipulate rule satisfaction rather than producing arbitrary perturbations, highlighting a key difference to the standard AA formulation.

Figure 2. Adversarial examples generated by PGD, R↓R_{\downarrow}, and R↑R_{\uparrow} for the same random selected input sample.

Extension to Large Language Models

To assess whether ConPAtt extends beyond image classifiers, we instantiate the same framework on a code understanding task. Thus, a Qwen-3.5 base model [45] is fine-tuned for binary vulnerability classification on a public dataset [71], and post-hoc probes are attached to its hidden layers to predict five memory-safety concepts. The concept-based property used as attack target is the standard sufficient condition for the presence of a memory safety bug, op∧(size∨¬bounds∨ret_unchk∨alloc_unchk)⟹vulnop \land(size \lor\neg bounds \lor ret\_unchk \lor alloc\_unchk) \Longrightarrow vuln, evaluated under the product t-norm. The entire experimental setup is described in detail in Section D of the Appendix.

Adversarial examples are created by a series of semantics-preserving transformations of the source code [48] while retaining those samples that either flip the model’s task output (standard AA) or flip the satisfaction value of the concept-based property (ConPAtt). The trained baseline is then fine-tuned on each adversarial set, mirroring the retraining protocol from § 5.1. For robustness, five seeds are evaluated per configuration. Table 3 reports mean and standard deviation on the held-out test set.

Acc.Prec.Rec.F1
Baseline.649±.008.658±.038.514±.094.569±.046
Std. AA.589±.037.683±.140.407±.284.423±.167
ConPAtt.650±.003.645±.033.551±.091.587±.040

Table 3. Test metrics for the baseline LLM and its two adversarially fine-tuned variants on the code vulnerability detection task. Mean ± std over five seeds.

The pattern is consistent with the vision results. Standard adversarial fine-tuning degrades clean F1 by 0.15 on average, whereas ConPAtt retraining preserves clean F1 and yields an improved score. ConPAtt also reduces the standard deviation across all metrics relative to the baseline, suggesting that targeting concept-based properties acts as a regularizer on the model’s internal representations.

Discussion

Regarding validation of our approach, the presented results highlight that ConPAtt generates adversarial examples in a structurally different way compared to standard attacks such as PGD. The attack on rule compliance leads to systematic changes in semantic properties, as reflected by the distinct behavior of R↓R_{\downarrow} and R↑R_{\uparrow}. This indicates that adversarial perturbations can be guided by high-level structure rather than only low-level input variations. These observations are consistent with the Theorem 4.5, which shows the restriction of the adversarial search space. This restriction may bias the optimization towards semantically meaningful perturbations, providing a possible explanation for the qualitative differences observed in the generated adversarial examples.

Furthermore, regarding our strong hypothesis (2), in the biased setting we observe that R↓R_{\downarrow} outperforms PGD under adversarial retraining. It is more effective in mitigating semantic rule violations like the considered spurious correlations, even for maliciously crafted, easy-to-attack biases. For our choice of small spurious features, we find that standard attacks such as PGD can also mitigate shortcut behavior to a certain extent. Whether similar behavior holds in more complex or realistic bias scenarios or whether ConPAtt here increases the margin remains an interesting open question.

The evaluation on PGD adversarial examples further shows that models retrained with ConPAtt generalize to unseen attacks. Since these PGD adversarial examples are not observed during training, this proving our hypothesis (1): ConPAtt-based retraining can indirectly mitigate vulnerabilities that are also exploited by standard attacks.

However, our experiments also reveal limitations of rule compliance as an evaluation metric. While it captures correlations between predictions and predefined rules, it does not necessarily reflect whether these rules are causally used by the model. Unused rules can trivially receive optimal rule compliance values if the left hand of the rule is constantly false (none of the features detected). This becomes apparent in biased settings, where high rule compliance can coincide with shortcut-based decision making. As a result, novel metrics for assessing the correctness of model reasoning are needed.

Future work should further investigate and optimized convergence of ConPAtt formulations, to avoid the instability we observed for some architectures (in particular VGG-16 on MNIST).

Conclusion

In this paper, we introduce ConPAtt, a novel generalized adversarial attack goal: Instead of targeting a change in (respectively falsification of) the output class, our attacks aim to falsify the compliance of the NN with prior symbolic knowledge on sufficient indicators for an output class. We showed theoretically that standard AAs arise as a special case of our formulation and that concept-based properties can restrict the adversarial search space with increasing numbers of concepts. Beyond these theoretical properties, our experiments demonstrate that ConPAtt generates semantically structured adversarial examples that differ qualitatively from standard attacks such as PGD. Furthermore, adversarial retraining with ConPAtt improves robustness and shows promising behaviour in biased settings, while also generalizing beyond the vision domain. Overall, our results suggest that ConPAtt provide a promising direction for studying robustness, semantic consistency, and the interaction between symbolic structure and adversarial learning.

Concept Datasets

MNIST Concept Dataset

We identified six concepts present in the MNIST dataset: lines, curves, circles, semicircles, right angles, and crossings. For each concept, we generated parameterized variations on a high-resolution canvas, applied global transformations, and finally downsampled the images.

  1. drawing pipeline. Each concept is rendered on a 112×112112 \times112 pixel canvas, then downsampled to 28×2828 \times28 pixel with anti-aliasing (Gaussian smoothing). All drawing parameters (e.g. lengths, radii) are specified in the final 28×2828 \times28 pixel grid.

  1. Class variability For each concept we sampled drawing parameters:

    • Lines: lengths of 8, 10, 12, 14, 16, and 18 pixel.

    • Curves: arc angles {60∘,75∘,90∘,105∘,120∘}\{60^\circ, 75^\circ, 90^\circ, 105^\circ, 120^\circ\}.

    • Circles: radii of 4, 6, 8, 10, and 12 pixel with aspect ratios {0.6,0.8,1.0,1.2,1.4}\{0.6, 0.8, 1.0, 1.2, 1.4\}.

    • Semicircles: spans {150∘,180∘,300∘}\{150^\circ, 180^\circ, 300^\circ\}.

    • Right angles: lengths of 6, 8, and 10 pixel with deviations {80∘,90∘,100∘}\{80^\circ, 90^\circ, 100^\circ\}.

    • Crossings: lengths of 6, 8, and 10 pixel with intersection angles {80∘,90∘,100∘}\{80^\circ, 90^\circ, 100^\circ\}.

  1. Global transformations. On each instance we applied:

    • rotations from 0∘0^\circ to 160∘160^\circ in 20∘20^\circ steps,

    • translations of {−5,−2.5,0,2.5,5}\{-5, -2.5, 0, 2.5, 5\}px in both xx and yy,

    • constant scale factor s=1.0s = 1.0.

  1. Dataset summary. In total, we generated 1,500 labeled images with size 28×2828 \times28px for each concept class. These samples are partitioned into fixed training (72.25%), validation (12.25%) and test datasets (15%).

GTSRB Concept Dataset

We identified 3 groups of concepts for traffic signs — shape, color, and symbol. The concepts for the shape are triangle, inverted triangle, circle, octagon, and diamond; for the color red, blue, yellow with a white border (white_yellow), white with a red border (white_red) and white with black symbols (white_black). The symbols basically correspond to the usual figures or lettering on static traffic signs, such as "STOP" or the speed limit as a lettering, but also signs such as "right/left curve", "snowflake", "roadworks" or two cars next to each other (general "no overtaking") but no place or country names. Each sample of the GTSRB concept dataset is a combination of three concepts — one from each concept group — with a random background. This dataset therefore also contains completely unrealistic images, such as a diamond-shaped, blue stop sign and a triangular, yellow 100 km/h speed limit sign (Figure 3). As a result, concept recognition cannot utilize the "clever Hans" effect. With realistic images, there would be, for example, only one sign class which is octagonal and has the word "STOP" printed on it – these two concepts would therefore be indistinguishable using realistic images.

Samples of the GTSRB concept dataset

Figure 3. Samples of the GTSRB concept dataset.

In total, we generated 7,227 labeled RGB images with size 64×6464 \times64px. Each symbol concept is contained at least 15 times, and all shape and color concepts are included to the same extent. These samples are partitioned into fixed training (60%), validation (20%) and test datasets (20%).

Experimental Setup Details

Biased Dataset Based on GTSRB, we add a coloured rectangle of 5×55 \times5 pixels on the left side of the image. The rectangle position is fixed, and the colour is derived from the label class. Each class has its own unique colour. The image size is standardized to 64×6464 \times64 pixels before adding the bias.

Models We use the following architectures:

  • LeNet-5 [30],

  • M3 [1],

  • ResNet-8 [22],

  • VGG-16 [52] (pretrained on ImageNet),

  • Vision Transformer (ViT) [12] with 8 attention heads, hidden dimension 256, dropout rate 0.1, and patch size 4.

Model Training All models are trained using the Adam optimizer with default parameters (β1=0.9,β2=0.999\beta_1 = 0.9, \beta_2 = 0.999). The learning rate is set to 10−310^{-3} for MNIST and 10−410^{-4} for GTSRB. A batch size of 64 is used throughout all experiments.

Early stopping is applied based on validation loss with a threshold of 10−310^{-3}. Each model is trained with five random seeds.

Inputs are resized using bilinear interpolation if required by the architecture. Standard data augmentation is applied during training, including random rotations, affine transformations with translation, and random resized crops.

Cross-entropy loss is used for all classification tasks. Temperature scaling is used for calibration.

Concept Mining Concept classifiers are trained on intermediate feature representations of each model using three random seeds. We consider up to three layers per architecture to capture different levels of abstraction.

For each concept, five linear classifiers with sigmoid activation are trained using balanced binary cross-entropy loss. Predictions are calibrated via temperature scaling. The final concept classifier is obtained by averaging weights and biases across the ensemble.

Concept datasets are augmented and partially mixed with original task data to mitigate domain shift.

Concept definitions are task-specific.

  • MNIST:

    • curve

    • semicircle ⊂\subset curve

    • circle ⊂\subset semicircle

    • line

    • right_angle ⊂\subset line

    • crossing ⊂\subset right_angle

  • GTSRB:

    • octogonal

    • circle

    • diamond

    • inverted_triangle

    • red

    • white_yellow

    • white_red

    • stop_symbol

    • symbol_30

  • symbol_50

  • symbol_120

  • symbol_no_overtaking_truck

  • symbol_no_overtaking_pkw

Adversarial Attacks Adversarial examples are generated using the torchattack library. We use a standard PGD implementation with ϵ=0.3\epsilon= 0.3 (determined via sweep on MNIST). Unless stated otherwise, default parameters are used.

Rules

  • MNIST:

    • zero⇒circle\mathtt{zero} \Rightarrow\mathtt{circle}

    • one⇒line\mathtt{one} \Rightarrow\mathtt{line}

    • two⇒line∧semicircle\mathtt{two} \Rightarrow\mathtt{line} \land\mathtt{semicircle}

    • two⇒line∧curve\mathtt{two} \Rightarrow\mathtt{line} \land\mathtt{curve}

    • three⇒semicircle\mathtt{three} \Rightarrow\mathtt{semicircle}

    • four⇒line∧crossing\mathtt{four} \Rightarrow\mathtt{line} \land\mathtt{crossing}

    • five⇒line∧right_angle∧semicircle\mathtt{five} \Rightarrow\mathtt{line} \land\mathtt{right\_angle} \land\mathtt{semicircle}

    • five⇒curve∧right_angle∧semicircle\mathtt{five} \Rightarrow\mathtt{curve} \land\mathtt{right\_angle} \land\mathtt{semicircle}

    • six⇒curve∧circle\mathtt{six} \Rightarrow\mathtt{curve} \land\mathtt{circle}

    • seven⇒line∧right_angle\mathtt{seven} \Rightarrow\mathtt{line} \land\mathtt{right\_angle}

    • seven⇒line∧right_angle∧crossing\mathtt{seven} \Rightarrow\mathtt{line} \land\mathtt{right\_angle} \land\mathtt{crossing}

    • eight⇒semicircle\mathtt{eight} \Rightarrow\mathtt{semicircle}

    • eight⇒semicircle∧crossing\mathtt{eight} \Rightarrow\mathtt{semicircle} \land\mathtt{crossing}

    • nine⇒curve∧circle\mathtt{nine} \Rightarrow\mathtt{curve} \land\mathtt{circle}

    • curve⇒zero∨two∨three∨five∨six∨eight∨nine\mathtt{curve} \Rightarrow\mathtt{zero} \lor\mathtt{two} \lor\mathtt{three} \lor\mathtt{five} \lor\mathtt{six} \lor\mathtt{eight} \lor\mathtt{nine}

    • semicircle⇒zero∨two∨three∨five∨six∨eight∨nine\mathtt{semicircle} \Rightarrow\mathtt{zero} \lor\mathtt{two} \lor\mathtt{three} \lor\mathtt{five} \lor\mathtt{six} \lor\mathtt{eight} \lor\mathtt{nine}

    • circle⇒zero∨six∨eight∨nine\mathtt{circle} \Rightarrow\mathtt{zero} \lor\mathtt{six} \lor\mathtt{eight} \lor\mathtt{nine}

    • line⇒one∨two∨four∨five∨seven\mathtt{line} \Rightarrow\mathtt{one} \lor\mathtt{two} \lor\mathtt{four} \lor\mathtt{five} \lor\mathtt{seven}

    • right_angle⇒four∨five∨seven\mathtt{right\_angle} \Rightarrow\mathtt{four} \lor\mathtt{five} \lor\mathtt{seven}

    • crossing⇒four∨seven\mathtt{crossing} \Rightarrow\mathtt{four} \lor\mathtt{seven}

    • crossing⇒four∨seven∨eight\mathtt{crossing} \Rightarrow\mathtt{four} \lor\mathtt{seven} \lor\mathtt{eight}

  • GTSRB:

    • stop_sign⇔octogonal∧red∧stop_symbol\mathtt{stop\_sign} \Leftrightarrow\mathtt{octogonal} \land\mathtt{red} \land\mathtt{stop\_symbol}

    • speed_limit_30⇔circle∧white_red∧symbol_30\mathtt{speed\_limit\_30} \Leftrightarrow\mathtt{circle} \land\mathtt{white\_red} \land\mathtt{symbol\_30}

    • speed_limit_50⇔circle∧white_red∧symbol_50\mathtt{speed\_limit\_50} \Leftrightarrow\mathtt{circle} \land\mathtt{white\_red} \land\mathtt{symbol\_50}

    • speed_limit_120⇔circle∧white_red∧symbol_120\mathtt{speed\_limit\_120} \Leftrightarrow\mathtt{circle} \land\mathtt{white\_red} \land\mathtt{symbol\_120}

    • no_overtaking_trucks⇔circle∧white_red∧symbol_no_overtaking_truck\mathtt{no\_overtaking\_trucks} \Leftrightarrow\mathtt{circle} \land\mathtt{white\_red} \land\mathtt{symbol\_no\_overtaking\_truck}

    • no_overtaking⇔circle∧white_red∧symbol_no_overtaking_pkw\mathtt{no\_overtaking} \Leftrightarrow\mathtt{circle} \land\mathtt{white\_red} \land\mathtt{symbol\_no\_overtaking\_pkw}

    • priority_road⇔diamond∧white_yellow\mathtt{priority\_road} \Leftrightarrow\mathtt{diamond} \land\mathtt{white\_yellow}

    • give_way⇔inverted_triangle∧white_red\mathtt{give\_way} \Leftrightarrow\mathtt{inverted\_triangle} \land\mathtt{white\_red}

    • no_entry⇔circle∧white_red\mathtt{no\_entry} \Leftrightarrow\mathtt{circle} \land\mathtt{white\_red}

Adversarial Retraining Models are retrained using a 1:1 mixture of clean and adversarial samples.

Reproducibility All experiments are conducted with fixed random seeds across libraries to ensure reproducibility using an NVIDIA H100 NVL GPU and a containerized PyTorch environment (version 24.11).

CV Additional Experimental Results

Attack Success Rate Detailed results on the attack success rate of the different attack approaches are reported in Table 4.

AttackLENET-5M3ResNet8VGG-16ViT
MNIST
PGD.898±.084.898 \pm.084.627±.114.627 \pm.114.890±.013.890 \pm.0131.0±.0001.0 \pm.000.570±.102.570 \pm.102
R↑R \uparrow.174±.028.174 \pm.028.413±.093.413 \pm.093.893±.011.893 \pm.011.970±.007.970 \pm.007.511±.096.511 \pm.096
R↓R \downarrow.401±.261.401 \pm.261.381±.142.381 \pm.142.896±.011.896 \pm.011.861±.002.861 \pm.002.355±.065.355 \pm.065
GTSRB
PGD.943±.012.943 \pm.012.886±.024.886 \pm.024.997±.002.997 \pm.0021.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
R↑R \uparrow.865±.026.865 \pm.026.913±.017.913 \pm.0171.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
R↓R \downarrow.689±.010.689 \pm.010.767±.033.767 \pm.033.994±.007.994 \pm.007.999±.000.999 \pm.000.992±.004.992 \pm.004
Biased
PGD.988±.005.988 \pm.005.862±.092.862 \pm.092.991±.006.991 \pm.0061.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
R↑R \uparrow.968±.006.968 \pm.006.885±.077.885 \pm.077.993±.008.993 \pm.0081.0±.0001.0 \pm.000.999±.001.999 \pm.001
R↓R \downarrow.897±.019.897 \pm.019.709±.055.709 \pm.055.991±.005.991 \pm.005.999±.000.999 \pm.000.997±.002.997 \pm.002

Table 4. Attack success rate with respect to misclassification for standard attacks and their ConPAtt variants across datasets and architectures. Results are reported as mean ±\pm standard deviation over multiple runs.

Different Adversarial Attacks To assess whether the observed behaviour depends on the particular adversarial attack, we additionally evaluated FGSM and VMI-FGSM besides the PGD attack used throughout the main paper. The results are summarized in Table 5 and Table 6. Table 5 shows that the differences between the standard attacks and the corresponding ConPAtt variants remain comparable across all considered attack methods and model architectures. Furthermore, Table 6 demonstrates that adversarial examples generated by the standard attacks continue to result in few misclassifications on adversarially retrained models to a similar extent for FGSM and VMI-FGSM as observed for PGD. Overall, these results indicate that the conclusions drawn in the main paper are not specific to PGD but generalize across different attack methods.

RetrainedLeNet-5M3ResNet-8VGG-16ViT
No retraining.988±.003.988 \pm.003.992±.001.992 \pm.001.986±.005.986 \pm.005.992±.001.992 \pm.001.916±.012.916 \pm.012
PGD.997±.001.997 \pm.001.998±.001.998 \pm.001.998±.000.998 \pm.000.986±.006.986 \pm.006.940±.011.940 \pm.011
PGD↓\downarrow.998±.000.998 \pm.000.998±.001.998 \pm.001.998±.000.998 \pm.000.913±.253.913 \pm.253.937±.010.937 \pm.010
PGD↑\uparrow.994±.001.994 \pm.001.992±.002.992 \pm.002.994±.001.994 \pm.001.853±.346.853 \pm.346.937±.015.937 \pm.015
FGSM.991±.001.991 \pm.001.991±.002.991 \pm.002.989±.009.989 \pm.009.986±.004.986 \pm.004.939±.004.939 \pm.004
FGSM↓\downarrow.992±.002.992 \pm.002.992±.002.992 \pm.002.993±.002.993 \pm.002.847±.344.847 \pm.344.945±.011.945 \pm.011
VMI-FGSM.991±.002.991 \pm.002.991±.003.991 \pm.003.992±.002.992 \pm.002.986±.005.986 \pm.005.934±.012.934 \pm.012
VMI-FGSM↓\downarrow.993±.001.993 \pm.001.993±.003.993 \pm.003.994±.002.994 \pm.002.981±.009.981 \pm.009.942±.009.942 \pm.009

Table 5. F1 scores on original data after adversarial retraining. Each model is retrained using adversarial examples generated by the corresponding method. Values are reported as mean ±\pm standard deviation across five runs.

AERetrainedLeNet-5M3ResNet-8VGG-16ViT
PGDNo retraining.102±.084.373±.114.110±.013.000±.000.430±.102
PGD.997±.001.998±.001.998±.000.984±.008.927±.012
R↓.938±.033.995±.001.994±.002.909±.252.910±.014
R↑.919±.025.987±.004.985±.005.850±.345.923±.016
FGSMNo retraining.270±.071.703±.065.098±.000.102±.003.213±.061
FGSM.989±.002.989±.005.990±.004.989±.005.916±.009
FGSM↓.904±.034.983±.005.975±.010.840±.341.908±.017
VMI-FGSMNo retraining.176±.098.300±.113.121±.044.024±.003.271±.106
VMI-FGSM.990±.005.992±.003.992±.002.984±.007.927±.013
VMI-FGSM↓.937±.033.981±.006.978±.010.975±.012.910±.016

Table 6. F1 scores on adversarial examples of PGD, FGSM and VMIFGSM evaluated across differently retrained models. Values are reported as mean ± standard deviation across five runs.

Rule Compliance Detailed results regarding the rule compliance metric are provided in Table 12 (on original data), Table 13 (on attacked samples) and Table 14 (on samples attacked with R↑R \uparrow).

Table 12: Rule compliance on original dataset

BackboneOriginalPGDR↓R\downarrowR↑R\uparrow
MNIST — LENET-5.926±.006.926\pm.006.890±.022.890\pm.022.895±.029.895\pm.029.887±.023.887\pm.023
MNIST — M3.982±.002.982\pm.002.957±.014.957\pm.014.957±.014.957\pm.014.964±.009.964\pm.009
MNIST — ResNet-8.987±.002.987\pm.002.973±.005.973\pm.005.975±.006.975\pm.006.978±.004.978\pm.004
MNIST — ViT.958±.006.958\pm.006.903±.017.903\pm.017.907±.014.907\pm.014.903±.014.903\pm.014
MNIST — VGG-16.985±.001.985\pm.001.897±.022.897\pm.022.899±.010.899\pm.010.889±.053.889\pm.053
GTSRB — LENET-5.937±.021.937\pm.021.900±.029.900\pm.029.916±.028.916\pm.028.906±.024.906\pm.024
GTSRB — M3.938±.007.938\pm.007.933±.016.933\pm.016.929±.019.929\pm.019.928±.014.928\pm.014
GTSRB — ResNet-8.941±.012.941\pm.012.940±.013.940\pm.013.939±.012.939\pm.012.940±.012.940\pm.012
GTSRB — ViT.827±.010.827\pm.010.825±.036.825\pm.036.828±.035.828\pm.035.805±.028.805\pm.028
GTSRB — VGG-16.910±.008.910\pm.008.955±.001.955\pm.001.956±.000.956\pm.000.955±.001.955\pm.001
Biased — LENET-5.925±.024.925\pm.024.858±.036.858\pm.036.856±.078.856\pm.078.853±.031.853\pm.031
Biased — M3.945±.004.945\pm.004.931±.019.931\pm.019.934±.014.934\pm.014.935±.014.935\pm.014
Biased — ResNet-8.926±.019.926\pm.019.938±.018.938\pm.018.936±.018.936\pm.018.938±.016.938\pm.016
Biased — ViT.869±.067.869\pm.067.830±.020.830\pm.020.830±.020.830\pm.020.819±.040.819\pm.040
Biased — VGG-16.908±.018.908\pm.018.956±.000.956\pm.000.956±.000.956\pm.000.956±.000.956\pm.000

Table 12.

DatasetBackboneOriginalPGDR↓R_{\downarrow}
MNISTLENET-5.830±.037.830 \pm.037.872±.020.872 \pm.020.851±.021.851 \pm.021
MNISTM3.855±.011.855 \pm.011.962±.012.962 \pm.012.954±.013.954 \pm.013
MNISTResNet-8.939±.014.939 \pm.014.972±.006.972 \pm.006.974±.006.974 \pm.006
MNISTViT.903±.013.903 \pm.013.904±.019.904 \pm.019.904±.011.904 \pm.011
MNISTVGG-16.821±.005.821 \pm.005.897±.022.897 \pm.022.899±.010.899 \pm.010
GTSRBLENET-5.212±.035.212 \pm.035.839±.053.839 \pm.053.841±.045.841 \pm.045
GTSRBM3.850±.071.850 \pm.071.888±.048.888 \pm.048.890±.046.890 \pm.046
GTSRBResNet-8.606±.116.606 \pm.116.955±.011.955 \pm.011.952±.011.952 \pm.011
GTSRBViT.272±.072.272 \pm.072.653±.079.653 \pm.079.563±.056.563 \pm.056
GTSRBVGG-16.879±.001.879 \pm.001.956±.001.956 \pm.001.956±.001.956 \pm.001
BiasedLENET-5.184±.073.184 \pm.073.805±.046.805 \pm.046.768±.126.768 \pm.126
BiasedM3.777±.035.777 \pm.035.841±.028.841 \pm.028.842±.029.842 \pm.029
BiasedResNet-8.616±.064.616 \pm.064.954±.016.954 \pm.016.951±.014.951 \pm.014
BiasedViT.441±.098.441 \pm.098.675±.098.675 \pm.098.645±.068.645 \pm.068
BiasedVGG-16.879±.006.879 \pm.006.956±.001.956 \pm.001.955±.001.955 \pm.001

Table 13. Rule compliance on adversarial examples of R↓R_{\downarrow}.

DatasetBackboneOriginalPGDR↑R_{\uparrow}
MNISTLENET-5.972±.008.972 \pm.008.898±.025.898 \pm.025.922±.029.922 \pm.029
MNISTM3.954±.016.954 \pm.016.952±.014.952 \pm.014.965±.007.965 \pm.007
MNISTResNet-8.946±.009.946 \pm.009.970±.008.970 \pm.008.974±.005.974 \pm.005
MNISTViT.923±.006.923 \pm.006.905±.019.905 \pm.019.903±.012.903 \pm.012
MNISTVGG-16.967±.002.967 \pm.002.897±.022.897 \pm.022.890±.053.890 \pm.053
GTSRBLENET-5.982±.005.982 \pm.005.942±.015.942 \pm.015.943±.019.943 \pm.019
GTSRBM3.993±.001.993 \pm.001.953±.005.953 \pm.005.952±.005.952 \pm.005
GTSRBResNet-8.998±.001.998 \pm.001.964±.010.964 \pm.010.962±.006.962 \pm.006
GTSRBViT.997±.002.997 \pm.002.885±.038.885 \pm.038.875±.042.875 \pm.042
GTSRBVGG-161.0±.0001.0 \pm.000.957±.001.957 \pm.001.956±.001.956 \pm.001
BiasedLENET-5.990±.004.990 \pm.004.889±.043.889 \pm.043.891±.031.891 \pm.031
BiasedM3.992±.005.992 \pm.005.953±.009.953 \pm.009.953±.007.953 \pm.007
BiasedResNet-8.947±.018.947 \pm.018.951±.017.951 \pm.017.951±.016.951 \pm.016
BiasedViT.976±.018.976 \pm.018.885±.026.885 \pm.026.884±.035.884 \pm.035
BiasedVGG-161.0±.0001.0 \pm.000.958±.001.958 \pm.001.957±.001.957 \pm.001

Table 14. Rule compliance on adversarial examples of R↑R_{\uparrow}.

Concept Performance Since ConPAtt targets the concept predictions, the quality of the employed concept probes is an important prerequisite. Poor concept prediction performance would imply that the attacks are applied to unreliable concept representations rather than the intended semantic concepts. Therefore, we report the concept prediction performance both before and after retraining. While the pre-retraining performance validates the concept probes used by ConPAtt, the post-retraining performance is reported for transparency only, as it does not affect the task performance of the adversarially retrained models. The corresponding results are given for MNIST in Table 1, for GTSRB in Table 8 and 9, and for the biased GTSRB variant in Table 10 and 11. For GTSRB, we report both the performance of the individual concepts and aggregated results for the colour, shape, and symbol concept groups. Across the evaluated architectures, the observed changes after retraining depend on the model and dataset. VGG16 exhibits the largest decrease in concept prediction performance, particularly for symbol concepts, whereas the remaining architectures show only moderate changes. The biased-trained GTSRB model generally exhibits larger performance differences than the original GTSRB model.

ConceptRetrainedLeNet-5M3ResNet-8VGG-16ViT
CircleNo retraining.967±.019.967 \pm.019.999±.001.999 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.000.999±.000.999 \pm.000
CirclePGD.729±.173.729 \pm.173.990±.007.990 \pm.007.905±.144.905 \pm.144.447±.324.447 \pm.324.906±.052.906 \pm.052
CircleR↓R\downarrow.793±.038.793 \pm.038.991±.005.991 \pm.005.897±.149.897 \pm.149.463±.354.463 \pm.354.916±.059.916 \pm.059
CircleR↑R\uparrow.682±.176.682 \pm.176.981±.016.981 \pm.016.913±.155.913 \pm.155.478±.362.478 \pm.362.960±.027.960 \pm.027
DiamondNo retraining.998±.001.998 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
DiamondPGD.942±.117.942 \pm.1171.0±.0001.0 \pm.000.921±.154.921 \pm.154.996±.002.996 \pm.002.987±.006.987 \pm.006
DiamondR↓R\downarrow.986±.007.986 \pm.0071.0±.0001.0 \pm.000.917±.160.917 \pm.160.997±.002.997 \pm.002.989±.011.989 \pm.011
DiamondR↑R\uparrow.910±.123.910 \pm.1231.0±.0001.0 \pm.000.923±.154.923 \pm.154.999±.001.999 \pm.001.987±.017.987 \pm.017
Inverted TriangleNo retraining.999±.000.999 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
Inverted TrianglePGD.961±.089.961 \pm.0891.0±.0001.0 \pm.000.978±.046.978 \pm.046.999±.001.999 \pm.001.978±.017.978 \pm.017
Inverted TriangleR↓R\downarrow.997±.002.997 \pm.0021.0±.0001.0 \pm.000.982±.041.982 \pm.041.997±.003.997 \pm.003.973±.022.973 \pm.022
Inverted TriangleR↑R\uparrow.952±.091.952 \pm.0911.0±.0001.0 \pm.000.988±.027.988 \pm.027.999±.002.999 \pm.002.986±.007.986 \pm.007
LKW no overtakenNo retraining.631±.123.631 \pm.123.658±.256.658 \pm.256.648±.147.648 \pm.147.756±.062.756 \pm.062.426±.124.426 \pm.124
LKW no overtakenPGD.368±.139.368 \pm.139.803±.038.803 \pm.038.514±.144.514 \pm.144.005±.006.005 \pm.006.387±.150.387 \pm.150
LKW no overtakenR↓R\downarrow.476±.071.476 \pm.071.825±.041.825 \pm.041.473±.133.473 \pm.133.007±.009.007 \pm.009.435±.167.435 \pm.167
LKW no overtakenR↑R\uparrow.357±.125.357 \pm.125.766±.040.766 \pm.040.542±.137.542 \pm.137.023±.023.023 \pm.023.371±.156.371 \pm.156
Limit 120No retraining.376±.043.376 \pm.043.392±.231.392 \pm.231.384±.116.384 \pm.116.644±.055.644 \pm.055.168±.033.168 \pm.033
Limit 120PGD.085±.035.085 \pm.035.648±.059.648 \pm.059.252±.092.252 \pm.092.000±.000.000 \pm.000.163±.044.163 \pm.044
Limit 120R↓R\downarrow.091±.030.091 \pm.030.663±.044.663 \pm.044.232±.076.232 \pm.076.000±.000.000 \pm.000.170±.056.170 \pm.056
Limit 120R↑R\uparrow.095±.046.095 \pm.046.527±.053.527 \pm.053.275±.096.275 \pm.096.002±.004.002 \pm.004.145±.040.145 \pm.040
Limit 30No retraining.357±.032.357 \pm.032.440±.269.440 \pm.269.302±.116.302 \pm.116.384±.119.384 \pm.119.165±.042.165 \pm.042
Limit 30PGD.102±.041.102 \pm.041.650±.036.650 \pm.036.288±.090.288 \pm.090.023±.051.023 \pm.051.161±.034.161 \pm.034
Limit 30R↓R\downarrow.132±.037.132 \pm.037.673±.057.673 \pm.057.274±.112.274 \pm.112.013±.027.013 \pm.027.162±.032.162 \pm.032
Limit 30R↑R\uparrow.109±.058.109 \pm.058.537±.048.537 \pm.048.287±.101.287 \pm.101.069±.121.069 \pm.121.147±.029.147 \pm.029
Limit 50No retraining.341±.050.341 \pm.050.400±.222.400 \pm.222.287±.119.287 \pm.119.543±.112.543 \pm.112.150±.057.150 \pm.057
Limit 50PGD.112±.041.112 \pm.041.561±.050.561 \pm.050.229±.082.229 \pm.082.021±.040.021 \pm.040.142±.065.142 \pm.065
Limit 50R↓R\downarrow.144±.018.144 \pm.018.596±.066.596 \pm.066.212±.072.212 \pm.072.012±.025.012 \pm.025.141±.049.141 \pm.049
Limit 50R↑R\uparrow.126±.051.126 \pm.051.443±.071.443 \pm.071.225±.081.225 \pm.081.052±.088.052 \pm.088.137±.040.137 \pm.040
No overtakenNo retraining.530±.044.530 \pm.044.606±.201.606 \pm.201.537±.123.537 \pm.123.722±.064.722 \pm.064.266±.122.266 \pm.122
No overtakenPGD.202±.067.202 \pm.067.740±.039.740 \pm.039.377±.129.377 \pm.129.000±.000.000 \pm.000.210±.087.210 \pm.087
No overtakenR↓R\downarrow.236±.044.236 \pm.044.769±.030.769 \pm.030.373±.130.373 \pm.130.001±.003.001 \pm.003.218±.091.218 \pm.091
No overtakenR↑R\uparrow.218±.047.218 \pm.047.657±.054.657 \pm.054.388±.118.388 \pm.118.029±.048.029 \pm.048.188±.082.188 \pm.082
OctagonNo retraining.988±.005.988 \pm.005.997±.001.997 \pm.001.999±.000.999 \pm.0001.0±.0001.0 \pm.000.999±.000.999 \pm.000
OctagonPGD.795±.184.795 \pm.184.981±.010.981 \pm.010.883±.158.883 \pm.158.687±.267.687 \pm.267.933±.049.933 \pm.049
OctagonR↓R\downarrow.861±.033.861 \pm.033.984±.007.984 \pm.007.841±.166.841 \pm.166.635±.326.635 \pm.326.944±.049.944 \pm.049
OctagonR↑R\uparrow.743±.206.743 \pm.206.973±.015.973 \pm.015.912±.135.912 \pm.135.705±.305.705 \pm.305.952±.033.952 \pm.033
RedNo retraining.999±.000.999 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
RedPGD.971±.066.971 \pm.0661.0±.0001.0 \pm.000.991±.017.991 \pm.017.955±.028.955 \pm.028.977±.030.977 \pm.030
RedR↓R\downarrow.991±.003.991 \pm.0031.0±.0001.0 \pm.000.959±.073.959 \pm.073.973±.019.973 \pm.019.977±.046.977 \pm.046
RedR↑R\uparrow.906±.172.906 \pm.1721.0±.0001.0 \pm.000.997±.004.997 \pm.004.987±.010.987 \pm.010.980±.043.980 \pm.043
StopNo retraining.596±.081.596 \pm.081.653±.257.653 \pm.257.457±.223.457 \pm.223.904±.118.904 \pm.118.196±.061.196 \pm.061
StopPGD.126±.064.126 \pm.064.760±.082.760 \pm.082.356±.168.356 \pm.168.011±.015.011 \pm.015.176±.055.176 \pm.055
StopR↓R\downarrow.157±.062.157 \pm.062.770±.051.770 \pm.051.322±.161.322 \pm.161.018±.021.018 \pm.021.191±.047.191 \pm.047
StopR↑R\uparrow.108±.056.108 \pm.056.677±.080.677 \pm.080.366±.168.366 \pm.168.077±.058.077 \pm.058.163±.041.163 \pm.041
White with red borderNo retraining.998±.001.998 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0011.0 \pm.001
White with red borderPGD.958±.085.958 \pm.085.999±.001.999 \pm.001.980±.062.980 \pm.062.888±.097.888 \pm.097.986±.019.986 \pm.019
White with red borderR↓R\downarrow.990±.002.990 \pm.002.999±.001.999 \pm.001.982±.063.982 \pm.063.843±.137.843 \pm.137.989±.015.989 \pm.015
White with red borderR↑R\uparrow.928±.139.928 \pm.139.999±.001.999 \pm.001.981±.062.981 \pm.062.970±.027.970 \pm.027.992±.007.992 \pm.007
YellowNo retraining1.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
YellowPGD.922±.205.922 \pm.2051.0±.0001.0 \pm.000.984±.026.984 \pm.026.930±.047.930 \pm.0471.0±.0001.0 \pm.000
YellowR↓R\downarrow.993±.004.993 \pm.0041.0±.0001.0 \pm.000.951±.048.951 \pm.048.934±.053.934 \pm.0531.0±.0001.0 \pm.000
YellowR↑R\uparrow.856±.039.856 \pm.0391.0±.0001.0 \pm.000.990±.019.990 \pm.019.984±.024.984 \pm.0241.0±.0001.0 \pm.000

Table 8. F1 scores on original GTSRB concept data of each concept before and after adversarial retraining, reported as mean ±\pm standard deviation across fifteen runs.

ConceptRetrainedLeNet-5M3ResNet-8VGG-16ViT
CircleNo retraining.973±.004.973 \pm.004.998±.001.998 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.000.999±.000.999 \pm.000
CirclePGD.388±.115.388 \pm.115.977±.023.977 \pm.023.814±.248.814 \pm.248.781±.169.781 \pm.169.784±.074.784 \pm.074
CircleR↓\downarrow.412±.122.412 \pm.122.987±.009.987 \pm.009.822±.244.822 \pm.244.746±.182.746 \pm.182.822±.100.822 \pm.100
CircleR↑\uparrow.386±.095.386 \pm.095.985±.022.985 \pm.022.816±.252.816 \pm.252.779±.166.779 \pm.166.790±.097.790 \pm.097
DiamondNo retraining.997±.001.997 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
DiamondPGD.594±.078.594 \pm.0781.0±.0001.0 \pm.000.962±.037.962 \pm.037.990±.008.990 \pm.008.856±.106.856 \pm.106
DiamondR↓\downarrow.621±.134.621 \pm.134.999±.001.999 \pm.001.952±.078.952 \pm.078.991±.007.991 \pm.007.880±.081.880 \pm.081
DiamondR↑\uparrow.609±.112.609 \pm.1121.0±.0001.0 \pm.000.979±.022.979 \pm.022.993±.006.993 \pm.006.862±.110.862 \pm.110
Inverted TriangleNo retraining.998±.001.998 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000.999±.001.999 \pm.001
Inverted TrianglePGD.708±.102.708 \pm.1021.0±.0001.0 \pm.000.987±.022.987 \pm.022.993±.008.993 \pm.008.957±.020.957 \pm.020
Inverted TriangleR↓\downarrow.745±.156.745 \pm.1561.0±.0001.0 \pm.000.981±.056.981 \pm.056.992±.015.992 \pm.015.957±.039.957 \pm.039
Inverted TriangleR↑\uparrow.713±.085.713 \pm.0851.0±.0001.0 \pm.000.987±.024.987 \pm.024.995±.009.995 \pm.009.955±.026.955 \pm.026
LKW no overtakenNo retraining.275±.023.275 \pm.023.618±.128.618 \pm.128.639±.095.639 \pm.095.907±.038.907 \pm.038.693±.074.693 \pm.074
LKW no overtakenPGD.080±.027.080 \pm.027.428±.150.428 \pm.150.335±.247.335 \pm.247.042±.042.042 \pm.042.254±.132.254 \pm.132
LKW no overtakenR↓\downarrow.131±.050.131 \pm.050.425±.155.425 \pm.155.322±.242.322 \pm.242.031±.030.031 \pm.030.285±.163.285 \pm.163
LKW no overtakenR↑\uparrow.095±.028.095 \pm.028.461±.144.461 \pm.144.334±.233.334 \pm.233.035±.037.035 \pm.037.252±.126.252 \pm.126
Limit 120No retraining.098±.016.098 \pm.016.324±.111.324 \pm.111.464±.096.464 \pm.096.796±.011.796 \pm.011.392±.046.392 \pm.046
Limit 120PGD.063±.014.063 \pm.014.216±.115.216 \pm.115.124±.064.124 \pm.064.001±.005.001 \pm.005.183±.057.183 \pm.057
Limit 120R↓\downarrow.078±.021.078 \pm.021.188±.087.188 \pm.087.132±.071.132 \pm.071.000±.000.000 \pm.000.242±.071.242 \pm.071
Limit 120R↑\uparrow.068±.015.068 \pm.015.203±.101.203 \pm.101.134±.074.134 \pm.074.001±.004.001 \pm.004.188±.057.188 \pm.057
Limit 30No retraining.130±.024.130 \pm.024.336±.065.336 \pm.065.295±.109.295 \pm.109.843±.022.843 \pm.022.293±.065.293 \pm.065
Limit 30PGD.092±.028.092 \pm.028.235±.127.235 \pm.127.168±.062.168 \pm.062.009±.025.009 \pm.025.141±.038.141 \pm.038
Limit 30R↓\downarrow.097±.029.097 \pm.029.259±.113.259 \pm.113.161±.074.161 \pm.074.006±.013.006 \pm.013.175±.047.175 \pm.047
Limit 30R↑\uparrow.090±.022.090 \pm.022.224±.108.224 \pm.108.173±.061.173 \pm.061.007±.015.007 \pm.015.139±.044.139 \pm.044
Limit 50No retraining.141±.025.141 \pm.025.314±.067.314 \pm.067.292±.094.292 \pm.094.824±.088.824 \pm.088.353±.045.353 \pm.045
Limit 50PGD.088±.033.088 \pm.033.196±.058.196 \pm.058.158±.063.158 \pm.063.001±.003.001 \pm.003.198±.081.198 \pm.081
Limit 50R↓\downarrow.093±.023.093 \pm.023.198±.063.198 \pm.063.170±.061.170 \pm.061.000±.000.000 \pm.000.230±.098.230 \pm.098
Limit 50R↑\uparrow.087±.029.087 \pm.029.208±.056.208 \pm.056.164±.061.164 \pm.061.000±.000.000 \pm.000.194±.088.194 \pm.088
No overtakenNo retraining.205±.024.205 \pm.024.516±.101.516 \pm.101.526±.089.526 \pm.089.889±.055.889 \pm.055.541±.064.541 \pm.064
No overtakenPGD.085±.013.085 \pm.013.423±.115.423 \pm.115.199±.112.199 \pm.112.003±.013.003 \pm.013.160±.078.160 \pm.078
No overtakenR↓\downarrow.137±.033.137 \pm.033.384±.115.384 \pm.115.213±.103.213 \pm.103.001±.003.001 \pm.003.193±.076.193 \pm.076
No overtakenR↑\uparrow.108±.027.108 \pm.027.408±.144.408 \pm.144.226±.113.226 \pm.113.015±.034.015 \pm.034.162±.084.162 \pm.084
OctagonNo retraining.974±.006.974 \pm.006.996±.002.996 \pm.002.999±.001.999 \pm.001.999±.001.999 \pm.001.998±.001.998 \pm.001
OctagonPGD.380±.028.380 \pm.028.969±.026.969 \pm.026.743±.184.743 \pm.184.725±.167.725 \pm.167.803±.127.803 \pm.127
OctagonR↓\downarrow.419±.098.419 \pm.098.969±.024.969 \pm.024.705±.208.705 \pm.208.645±.251.645 \pm.251.884±.076.884 \pm.076
OctagonR↑\uparrow.394±.041.394 \pm.041.974±.014.974 \pm.014.789±.178.789 \pm.178.672±.260.672 \pm.260.833±.081.833 \pm.081
RedNo retraining.998±.001.998 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
RedPGD.564±.164.564 \pm.164.999±.001.999 \pm.001.984±.035.984 \pm.035.989±.006.989 \pm.006.848±.052.848 \pm.052
RedR↓\downarrow.640±.143.640 \pm.143.997±.007.997 \pm.007.943±.165.943 \pm.165.958±.035.958 \pm.035.864±.075.864 \pm.075
RedR↑\uparrow.600±.193.600 \pm.193.999±.001.999 \pm.001.995±.009.995 \pm.009.995±.005.995 \pm.005.850±.085.850 \pm.085
StopNo retraining.164±.046.164 \pm.046.411±.111.411 \pm.111.501±.220.501 \pm.220.977±.016.977 \pm.016.500±.129.500 \pm.129
StopPGD.077±.016.077 \pm.016.323±.130.323 \pm.130.281±.117.281 \pm.117.048±.090.048 \pm.090.161±.051.161 \pm.051
StopR↓\downarrow.085±.020.085 \pm.020.278±.115.278 \pm.115.301±.128.301 \pm.128.021±.035.021 \pm.035.218±.068.218 \pm.068
StopR↑\uparrow.077±.018.077 \pm.018.286±.149.286 \pm.149.322±.108.322 \pm.108.064±.100.064 \pm.100.170±.041.170 \pm.041
White with red borderNo retraining.995±.001.995 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000.999±.001.999 \pm.001
White with red borderPGD.611±.174.611 \pm.174.944±.095.944 \pm.095.925±.100.925 \pm.100.871±.144.871 \pm.144.945±.031.945 \pm.031
White with red borderR↓\downarrow.696±.208.696 \pm.208.979±.026.979 \pm.026.912±.101.912 \pm.101.754±.245.754 \pm.245.896±.115.896 \pm.115
White with red borderR↑\uparrow.618±.174.618 \pm.174.971±.054.971 \pm.054.946±.087.946 \pm.087.891±.076.891 \pm.076.930±.040.930 \pm.040
YellowNo retraining1.0±.0011.0 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
YellowPGD.506±.302.506 \pm.3021.0±.0001.0 \pm.000.999±.002.999 \pm.002.855±.068.855 \pm.068.998±.001.998 \pm.001
YellowR↓\downarrow.592±.206.592 \pm.2061.0±.0001.0 \pm.000.990±.012.990 \pm.012.789±.147.789 \pm.147.998±.001.998 \pm.001
YellowR↑\uparrow.576±.238.576 \pm.2381.0±.0001.0 \pm.000.998±.003.998 \pm.003.901±.059.901 \pm.059.998±.001.998 \pm.001

Table 10. F1 scores on original GTSRB concept data of each concept before and after adversarial retraining for biased-trained models, reported as mean ±\pm standard deviation across fifteen runs.

Rule compliance of each architecture, differentiated by samples type

Figure 4. Rule compliance of each architecture, differentiated by samples type. R↓ generates, on average, adversarial examples with the lowest rule compliance, and R↑ those with the highest.

LLM Vulnerability Detection: Setup

This section details the experimental configuration of the LLM extension reported in § 5.3.

Dataset and Task. We use the Devign benchmark [71], which contains functions extracted from large-scale open-source C projects, each labeled as vulnerable or safe. The task is binary classification at the function level. Each run draws an independent train/validation split.

Model and Training. The classifier is a 0.8 B-parameter Qwen-3.5 base model [45] extended with rank-16 LoRA adapters [24] on the query and value projections of every transformer block. The model is prompted with the candidate function and asked to output a single token (YES/NO). The cross-entropy loss is computed only on the two-token logit subset. The baseline is trained for three epochs at learning rate 2×10−42 \times10^{-4} with 10% linear warmup and linear decay, weight decay 0.01, and effective batch size 16. Adversarial fine-tuning continues from the baseline LoRA for two epochs at 5×10−55 \times10^{-5} on the adversarial subset only.

ConceptRetrainedLeNet-5M3ResNet-8VGG-16ViT
CircleNo retraining.803±.042.803 \pm.042.896±.014.896 \pm.014.921±.030.921 \pm.030.962±.002.962 \pm.002.766±.018.766 \pm.018
PGD.824±.040.824 \pm.040.909±.013.909 \pm.013.981±.005.981 \pm.005.906±.018.906 \pm.018.825±.018.825 \pm.018
R↓R\downarrow.813±.043.813 \pm.043.915±.021.915 \pm.021.981±.004.981 \pm.004.908±.031.908 \pm.031.826±.020.826 \pm.020
R↑R\uparrow.818±.038.818 \pm.038.923±.014.923 \pm.014.981±.004.981 \pm.004.883±.139.883 \pm.139.815±.030.815 \pm.030
CrossingNo retraining.540±.031.540 \pm.031.896±.039.896 \pm.039.816±.044.816 \pm.044.913±.007.913 \pm.007.539±.050.539 \pm.050
PGD.517±.066.517 \pm.066.848±.046.848 \pm.046.967±.008.967 \pm.008.714±.074.714 \pm.074.623±.072.623 \pm.072
R↓R\downarrow.554±.064.554 \pm.064.873±.041.873 \pm.041.970±.004.970 \pm.004.704±.105.704 \pm.105.606±.045.606 \pm.045
R↑R\uparrow.570±.022.570 \pm.022.869±.040.869 \pm.040.968±.008.968 \pm.008.699±.197.699 \pm.197.624±.042.624 \pm.042
CurveNo retraining.855±.015.855 \pm.015.949±.012.949 \pm.012.936±.015.936 \pm.015.983±.001.983 \pm.001.840±.022.840 \pm.022
PGD.853±.023.853 \pm.023.907±.020.907 \pm.020.966±.010.966 \pm.010.884±.019.884 \pm.019.849±.019.849 \pm.019
R↓R\downarrow.839±.026.839 \pm.026.918±.017.918 \pm.017.967±.012.967 \pm.012.893±.019.893 \pm.019.854±.017.854 \pm.017
R↑R\uparrow.853±.017.853 \pm.017.912±.025.912 \pm.025.968±.013.968 \pm.013.832±.234.832 \pm.234.858±.017.858 \pm.017
LineNo retraining.818±.010.818 \pm.010.895±.021.895 \pm.021.855±.026.855 \pm.026.944±.003.944 \pm.003.769±.039.769 \pm.039
PGD.821±.020.821 \pm.020.871±.015.871 \pm.015.944±.016.944 \pm.016.864±.020.864 \pm.020.817±.015.817 \pm.015
R↓R\downarrow.818±.022.818 \pm.022.883±.012.883 \pm.012.941±.013.941 \pm.013.859±.018.859 \pm.018.806±.034.806 \pm.034
R↑R\uparrow.832±.014.832 \pm.014.888±.016.888 \pm.016.942±.014.942 \pm.014.845±.074.845 \pm.074.821±.007.821 \pm.007
Right AngleNo retraining.664±.014.664 \pm.014.884±.048.884 \pm.048.851±.032.851 \pm.032.930±.003.930 \pm.003.679±.027.679 \pm.027
PGD.627±.054.627 \pm.054.808±.046.808 \pm.046.965±.006.965 \pm.006.795±.024.795 \pm.024.747±.025.747 \pm.025
R↓R\downarrow.659±.032.659 \pm.032.842±.041.842 \pm.041.963±.008.963 \pm.008.775±.053.775 \pm.053.714±.039.714 \pm.039
R↑R\uparrow.682±.019.682 \pm.019.828±.039.828 \pm.039.967±.008.967 \pm.008.772±.093.772 \pm.093.717±.030.717 \pm.030
Semi-CircleNo retraining.909±.021.909 \pm.021.943±.008.943 \pm.008.931±.013.931 \pm.013.955±.005.955 \pm.005.886±.019.886 \pm.019
PGD.909±.036.909 \pm.036.931±.014.931 \pm.014.963±.004.963 \pm.004.938±.016.938 \pm.016.914±.006.914 \pm.006
R↓R\downarrow.896±.033.896 \pm.033.935±.009.935 \pm.009.965±.004.965 \pm.004.940±.019.940 \pm.019.903±.011.903 \pm.011
R↑R\uparrow.898±.029.898 \pm.029.938±.012.938 \pm.012.963±.004.963 \pm.004.876±.243.876 \pm.243.909±.004.909 \pm.004
AllNo retraining.765±.128.765 \pm.128.911±.037.911 \pm.037.885±.054.885 \pm.054.948±.023.948 \pm.023.746±.118.746 \pm.118
PGD.759±.145.759 \pm.145.879±.051.879 \pm.051.965±.014.965 \pm.014.850±.083.850 \pm.083.796±.098.796 \pm.098
R↓R\downarrow.763±.125.763 \pm.125.895±.041.895 \pm.041.964±.015.964 \pm.015.847±.097.847 \pm.097.785±.103.785 \pm.103
R↑R\uparrow.775±.117.775 \pm.117.893±.045.893 \pm.045.965±.015.965 \pm.015.818±.183.818 \pm.183.791±.098.791 \pm.098

Table 7. F1 scores on original MNSIT concept data before and after adversarial retraining, reported as mean ±\pm standard deviation across fifteen runs.

Concepts and Probes. The five memory-safety concepts op (unsafe memory operation), size (risky size computation), bounds (bounds check), ret_unchk (unchecked return value of a side-effecting call), and alloc_unchk (unchecked allocation) are extracted from the abstract syntax tree of the source code using tree-sitter [7]. A linear probe is trained per concept on mean-pooled hidden states of 3,000 training samples following the post-hoc protocol of § 3. Ultimately the probe with the highest validation AUROC is selected. All five probes have an AUROC between 0.918 and 0.951 across runs.

Code Transformations. We use the eight semantics-preserving code transformations from Risse et al. [48]: parameter rename, function rename, dead-code insertion, comment insertion, whitespace insertion, helper-function wrapping, void-call insertion, and comment removal. For each training sample we sample random transformation chains of length one to four.

Adversarial Generation. For standard adversarial examples a candidate is retained as output-targeted if it flips the trained baseline’s YES/NO prediction; as ConPatt-targeted if it flips the binary value of the concept-based property. Output-targeted generation yields on average 27,032 candidates per run (range 18,017 to 40,064); ConPatt-targeted yields 2,536 (range 2,475 to 2,623). For the comparisons

GroupRetrainedLeNet-5M3ResNet-8VGG-16ViT
ColourNo retraining.999±.001.999 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.0001.0±.0001.0 \pm.000
ColourPGD.950±.132.950 \pm.1321.0±.0011.0 \pm.001.985±.039.985 \pm.039.924±.069.924 \pm.069.988±.022.988 \pm.022
ColourR↓R\downarrow.992±.003.992 \pm.0031.0±.0011.0 \pm.001.964±.062.964 \pm.062.917±.100.917 \pm.100.989±.029.989 \pm.029
ColourR↑R\uparrow.896±.186.896 \pm.1861.0±.0011.0 \pm.001.989±.037.989 \pm.037.980±.022.980 \pm.022.991±.026.991 \pm.026
ShapeNo retraining.988±.017.988 \pm.017.999±.001.999 \pm.0011.0±.0001.0 \pm.0001.0±.0001.0 \pm.000.999±.000.999 \pm.000
ShapePGD.857±.173.857 \pm.173.993±.010.993 \pm.010.922±.135.922 \pm.135.782±.311.782 \pm.311.951±.049.951 \pm.049
ShapeR↓R\downarrow.909±.090.909 \pm.090.994±.008.994 \pm.008.909±.145.909 \pm.145.773±.331.773 \pm.331.956±.048.956 \pm.048
ShapeR↑R\uparrow.822±.189.822 \pm.189.989±.016.989 \pm.016.934±.130.934 \pm.130.795±.319.795 \pm.319.971±.028.971 \pm.028
SymbolNo retraining.456±.140.456 \pm.140.530±.253.530 \pm.253.448±.184.448 \pm.184.653±.179.653 \pm.179.223±.119.223 \pm.119
SymbolPGD.146±.122.146 \pm.122.685±.094.685 \pm.094.329±.146.329 \pm.146.009±.026.009 \pm.026.193±.113.193 \pm.113
SymbolR↓R\downarrow.181±.141.181 \pm.141.709±.089.709 \pm.089.305±.145.305 \pm.145.015±.033.015 \pm.033.204±.127.204 \pm.127
SymbolR↑R\uparrow.150±.117.150 \pm.117.605±.119.605 \pm.119.333±.155.333 \pm.155.044±.076.044 \pm.076.180±.108.180 \pm.108
AllNo retraining.724±.287.724 \pm.287.765±.295.765 \pm.295.724±.305.724 \pm.305.827±.215.827 \pm.215.611±.398.611 \pm.398
AllPGD.522±.403.522 \pm.403.840±.170.840 \pm.170.639±.336.639 \pm.336.426±.454.426 \pm.454.580±.397.580 \pm.397
AllR↓R\downarrow.563±.399.563 \pm.399.853±.157.853 \pm.157.619±.341.619 \pm.341.425±.453.425 \pm.453.587±.395.587 \pm.395
AllR↑R\uparrow.502±.387.502 \pm.387.799±.212.799 \pm.212.645±.340.645 \pm.340.459±.457.459 \pm.457.580±.408.580 \pm.408

Table 9. F1 scores on original GTSRB concept data of concept groups before and after adversarial retraining, reported as mean ±\pm standard deviation across fifteen runs.

in Table 3, each adversarial set is uniformly subsampled to the smaller of the two counts so that fine-tuning sees the same number of examples in both conditions.

Table 11: F1 scores on original GTSRB concept data of concept groups before and after adversarial retraining for biased-trained models, reported as mean ±\pm standard deviation across fifteen runs.

GroupRetrainedLeNet-5M3ResNet-8VGG-16ViT
ColourNo retraining.997±.002.997\pm.0021.0±.0001.0\pm.0001.0±.0001.0\pm.0001.0±.0001.0\pm.0001.0±.0001.0\pm.000
ColourPGD.560±.222.560\pm.222.981±.060.981\pm.060.969±.068.969\pm.068.905±.109.905\pm.109.930±.071.930\pm.071
ColourR↓R\downarrow.643±.189.643\pm.189.992±.018.992\pm.018.948±.114.948\pm.114.834±.186.834\pm.186.919±.097.919\pm.097
ColourR↑R\uparrow.598±.167.598\pm.167.990±.033.990\pm.033.980±.055.980\pm.055.929±.072.929\pm.072.926±.081.926\pm.081
ShapeNo retraining.986±.013.986\pm.013.998±.002.998\pm.0021.0±.0001.0\pm.0001.0±.0011.0\pm.001.999±.001.999\pm.001
ShapePGD.517±.164.517\pm.164.986±.022.986\pm.022.877±.183.877\pm.183.872±.168.872\pm.168.850±.112.850\pm.112
ShapeR↓R\downarrow.549±.190.549\pm.190.989±.018.989\pm.018.865±.197.865\pm.197.844±.216.844\pm.216.886±.089.886\pm.089
ShapeR↑R\uparrow.525±.165.525\pm.165.990±.017.990\pm.017.893±.176.893\pm.176.860±.206.860\pm.206.860±.103.860\pm.103
SymbolNo retraining.170±.064.170\pm.064.421±.143.421\pm.143.459±.167.459\pm.167.857±.082.857\pm.082.444±.151.444\pm.151
SymbolPGD.080±.025.080\pm.025.273±.164.273\pm.164.211±.140.211\pm.140.017±.043.017\pm.043.167±.088.167\pm.088
SymbolR↓R\downarrow.100±.036.100\pm.036.269±.148.269\pm.148.216±.140.216\pm.140.011±.025.011\pm.025.205±.103.205\pm.103
SymbolR↑R\uparrow.086±.025.086\pm.025.274±.162.274\pm.162.224±.139.224\pm.139.020±.048.020\pm.048.170±.087.170\pm.087
AllNo retraining.581±.414.581\pm.414.710±.307.710\pm.307.730±.295.730\pm.295.928±.092.928\pm.092.722±.298.722\pm.298
AllPGD.308±.266.308\pm.266.629±.376.629\pm.376.564±.382.564\pm.382.452±.448.452\pm.448.526±.372.526\pm.372
AllR↓R\downarrow.345±.282.345\pm.282.630±.376.630\pm.376.558±.377.558\pm.377.425±.439.425\pm.439.552±.362.552\pm.362
AllR↑R\uparrow.321±.265.321\pm.265.632±.377.632\pm.377.577±.381.577\pm.381.455±.452.455\pm.452.529±.372.529\pm.372

Table 11.

References

  1. [1]S. An, M. Lee, S. Park, H. Yang, and J. So. An Ensemble of Simple Convolutional Neural Network Models for MNIST Digit Recognition, Oct. 2020. arXiv:2008.10400 [cs].arxiv.org/abs/2008.10400
  2. [2]S. Badreddine, A. d’Avila Garcez, L. Serafini, and M. Spranger. Logic Tensor Networks. Artificial Intelligence, 303:103649, Feb. 2022.DOI
  3. [3]A. Baninajjar, A. Rezine, and A. Aminifar. Formal Local Implication Between Two Neural Networks. In ECAI 2025, pages 1163–1170. IOS Press, 2025.
  4. [4]D. Bau, B. Zhou, A. Khosla, A. Oliva, and A. Torralba. Network Dissection: Quantifying Interpretability of Deep Visual Representations. pages 6541–6549, 2017.arxiv.org/abs/1704.05796
  5. [5]D. Bau, B. Zhou, A. Khosla, A. Oliva, and A. Torralba. Network dissection: Quantifying interpretability of deep visual representations. In Proc. 2017 IEEE Conf. Comput. Vision and Pattern Recognition, pages 3319–3327, Honolulu, HI, USA, 2017. IEEE Computer Society.arxiv.org/abs/1704.05796
  6. [6]D. Brown and H. Kvinge. Making Corgis Important for Honeycomb Classification: Adversarial Attacks on Concept-Based Explainability Tools. pages 620–627, 2023.arxiv.org/abs/2110.07120
  7. [7]M. Brunsfeld and Tree-sitter contributors. Tree-sitter: An incremental parsing system for programming tools. https://tree-sitter.github.io/tree-sitter/, 2018. Accessed: 2026-04-29.DOI
  8. [8]C.-H. Cheng, C.-H. Huang, T. Brunner, and V. Hashemi. Towards Safety Verification of Direct Perception Neural Networks. In 2020 Design, Automation & Test in Europe Conference & Exhibition (DATE), pages 1640–1643, Mar. 2020. ISSN: 1558-1101.arxiv.org/abs/1904.04706
  9. [9]J. Crabbé and M. van der Schaar. Concept Activation Regions: A Generalized Framework For Concept-Based Explanations. Advances in Neural Information Processing Systems, 35:2590–2607, Dec. 2022.arxiv.org/abs/2209.11222
  10. [10]J. Crabbé and M. van der Schaar. Concept Activation Regions: A Generalized Framework For Concept-Based Explanations. Advances in Neural Information Processing Systems, 35:2590–2607, Dec. 2022.arxiv.org/abs/2209.11222
  11. [11]L. Deng. The MNIST Database of Handwritten Digit Images for Machine Learning Research [Best of the Web]. IEEE Signal Processing Magazine, 29(6):141–142, Nov. 2012.DOI
  12. [12]A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale. June 2021. arXiv:2010.11929 [cs].arxiv.org/abs/2010.11929
  13. [13]T. Dreossi, D. J. Fremont, S. Ghosh, E. Kim, H. Ravanbakhsh, M. Vazquez-Chanlatte, and S. A. Seshia. VerifAI: A Toolkit for the Formal Design and Analysis of Artificial Intelligence-Based Systems. In I. Dillig and S. Tasiran, editors, Computer Aided Verification, pages 432–442, Cham, 2019. Springer International Publishing.
  14. [14]M. Dreyer, E. Purelku, J. Vielhaben, W. Samek, and S. Lapuschkin. PURE: Turning Polysemantic Neurons Into Pure Features by Identifying Relevant Circuits. In CVPR2024 Workshops, XAI4CV, Seattle Convention Center, Seattle, WA, USA, June 2024. arXiv.arxiv.org/abs/2404.06453
  15. [15]K. Eykholt, I. Evtimov, E. Fernandes, B. Li, A. Rahmati, C. Xiao, A. Prakash, T. Kohno, and D. Song. Robust Physical-World Attacks on Deep Learning Visual Classification. pages 1625–1634, 2018.DOI
  16. [16]R. Fong and A. Vedaldi. Net2Vec: Quantifying and Explaining How Concepts Are Encoded by Filters in Deep Neural Networks. pages 8730–8738, 2018.arxiv.org/abs/1801.03454
  17. [17]R. Fong and A. Vedaldi. Net2Vec: Quantifying and explaining how concepts are encoded by filters in deep neural networks. In Proc. 2018 IEEE Conf. Comput. Vision and Pattern Recognition, pages 8730–8738, Salt Lake City, UT, USA, 2018. IEEE Computer Society.arxiv.org/abs/1801.03454
  18. [18]D. J. Fremont, T. Dreossi, S. Ghosh, X. Yue, A. L. Sangiovanni-Vincentelli, and S. A. Seshia. Scenic: a language for scenario specification and scene generation. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2019, pages 63–78, New York, NY, USA, June 2019. Association for Computing Machinery.DOI
  19. [19]A. Ghorbani, A. Abid, and J. Zou. Interpretation of Neural Networks Is Fragile. Proceedings of the AAAI Conference on Artificial Intelligence, 33(01):3681–3688, July 2019.arxiv.org/abs/1710.10547
  20. [20]E. Giunchiglia, M. Stoian, S. Khan, F. Cuzzolin, and T. Lukasiewicz. ROAD-R: The Autonomous Driving Dataset with Logical Requirements. In IJCLR 2022 Workshops, Vienna, Austria, June 2022.
  21. [21]M. Graziani, V. Andrearczyk, and H. Müller. Regression concept vectors for bidirectional explanations in histopathology. In D. Stoyanov, Z. Taylor, S. M. Kia, I. Oguz, M. Reyes, A. Martel, L. Maier-Hein, A. F. Marquand, E. Duchesnay, T. Löfstedt, B. Landman, M. J. Cardoso, C. A. Silva, S. Pereira, and R. Meier, editors, Understanding and Interpreting Machine Learning in Medical Image Computing Applications, Lecture Notes in Computer Science, pages 124–132, Cham, 2018. Springer International Publishing.arxiv.org/abs/1904.04520
  22. [22]K. He, X. Zhang, S. Ren, and J. Sun. Deep Residual Learning for Image Recognition. pages 770–778, 2016.arxiv.org/abs/1512.03385
  23. [23]C. Hu, Y. Wang, K. Tiliwalidi, and W. Li. Adversarial Laser Spot: Robust and Covert Physical-World Attack to DNNs. In Proceedings of The 14th Asian Conference on Machine Learning, pages 483–498. PMLR, Apr. 2023. ISSN: 2640-3498.arxiv.org/abs/2206.01034
  24. [24]E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, and W. Chen. Lora: Low-rank adaptation of large language models. In The Tenth International Conference on Learning Representations, ICLR 2022, Virtual Event, April 25-29, 2022. OpenReview.net, 2022.
  25. [25]W. Huang, X. Zhao, G. Jin, and X. Huang. SAFARI: Versatile and Efficient Evaluations for Robustness of Interpretability. pages 1988–1998, 2023.
  26. [26]P. Hájek. Metamathematics of Fuzzy Logic. Trends in Logic. Springer Netherlands, Dordrecht, 1998. ISSN: 1572-6126.DOI
  27. [27]S. Y. Khamaiseh, D. Bagagem, A. Al-Alaj, M. Mancino, and H. W. Alomari. Adversarial Deep Learning: A Survey on Adversarial Attacks and Defense Mechanisms on Image Classification. IEEE Access, 10:102266–102291, 2022.
  28. [28]B. Kim, M. Wattenberg, J. Gilmer, C. Cai, J. Wexler, F. Viegas, and R. Sayres. Interpretability beyond feature attribution: Quantitative testing with concept activation vectors (TCAV). In Proc. 35th Int. Conf. Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 2668–2677, Stockholmsmässan, Stockholm, Sweden, July 2018. PMLR.arxiv.org/abs/1711.11279
  29. [29]P. W. Koh, T. Nguyen, Y. S. Tang, S. Mussmann, E. Pierson, B. Kim, and P. Liang. Concept Bottleneck Models. In Proceedings of the 37th International Conference on Machine Learning, pages 5338–5348. PMLR, Nov. 2020.arxiv.org/abs/2007.04612
  30. [30]Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, Nov. 1998.
  31. [31]A. Ledaguenel, C. Hudelot, and M. Khouadjia. Improving Neural-based Classification with Logical Background Knowledge. In ECAI 2024 Workshop Proceedings, Santiago de Compostela, Spain, Feb. 2024. arXiv.
  32. [32]J. H. Lee, G. Mikriukov, G. Schwalbe, S. Wermter, and D. Wolter. Concept-Based Explanations in Computer Vision: Where Are We and Where Could We Go? In A. Del Bue, C. Canton, J. Pont-Tuset, and T. Tommasi, editors, Computer Vision – ECCV 2024 Workshops, pages 266–287, Cham, 2025. Springer Nature Switzerland.
  33. [33]Y. Li, Y. Li, X. Dai, S. Guo, and B. Xiao. Physical-World Optical Adversarial Attacks on 3D Face Recognition. pages 24699–24708, 2023.
  34. [34]A. Liu, X. Liu, J. Fan, Y. Ma, A. Zhang, H. Xie, and D. Tao. Perceptual-Sensitive GAN for Generating Adversarial Patches. Proceedings of the AAAI Conference on Artificial Intelligence, 33(01):1028–1035, July 2019. Number: 01.DOI
  35. [35]C. Liu, T. Arnon, C. Lazarus, C. Strong, C. Barrett, and M. J. Kochenderfer. Algorithms for verifying deep neural networks. Foundations and Trends® in Optimization, 4(3-4):244–404, Feb. 2021.arxiv.org/abs/1903.06758
  36. [36]A. Madry, A. Makelov, L. Schmidt, D. Tsipras, and A. Vladu. Towards Deep Learning Models Resistant to Adversarial Attacks. Feb. 2018.arxiv.org/abs/1706.06083
  37. [37]R. Mangal, N. Narodytska, D. Gopinath, B. C. Hu, A. Roy, S. Jha, and C. S. Paš̆areanu. Concept-Based Analysis of Neural Networks via Vision-Language Models. In G. Avni, M. Giacobbe, T. T. Johnson, G. Katz, A. Lukina, N. Narodytska, and C. Schilling, editors, AI Verification, pages 49–77, Cham, 2024. Springer Nature Switzerland.arxiv.org/abs/2403.19837
  38. [38]G. Mikriukov, G. Schwalbe, and K. Bade. Local Concept Embeddings for Analysis of Concept Distributions in Vision DNN Feature Spaces. International Journal of Computer Vision, May 2025.DOI
  39. [39]G. Mikriukov, G. Schwalbe, F. Motzkus, and K. Bade. Unveiling the Anatomy of Adversarial Attacks: Concept-Based XAI Dissection of CNNs. In L. Longo, S. Lapuschkin, and C. Seifert, editors, Explainable Artificial Intelligence, pages 92–116, Cham, 2024. Springer Nature Switzerland.DOI
  40. [40]D. Ming, P. Ren, Y. Wang, and X. Feng. Boosting the Transferability of Adversarial Attack on Vision Transformer with Adaptive Token Tuning. Nov. 2024.DOI
  41. [41]T. Oikarinen, S. Das, L. M. Nguyen, and T.-W. Weng. Label-free Concept Bottleneck Models. Sept. 2022.arxiv.org/abs/2304.06129
  42. [42]T. Oikarinen and T.-W. Weng. CLIP-Dissect: Automatic Description of Neuron Representations in Deep Vision Networks. Sept. 2022.arxiv.org/abs/2204.10965
  43. [43]C. Olah, A. Mordvintsev, and L. Schubert. Feature visualization. Distill, 2(11):e7, Nov. 2017.DOI
  44. [44]E. Poeta, G. Ciravegna, E. Pastor, T. Cerquitelli, and E. Baralis. Concept-based Explainable Artificial Intelligence: A Survey, Dec. 2023.DOI
  45. [45]Qwen Team. Qwen3.5: Towards native multimodal agents, February 2026.
  46. [46]A. Radford, J. W. Kim, C. Hallacy, A. Ramesh, G. Goh, S. Agarwal, G. Sastry, A. Askell, P. Mishkin, J. Clark, G. Krueger, and I. Sutskever. Learning Transferable Visual Models From Natural Language Supervision. In Proceedings of the 38th International Conference on Machine Learning, pages 8748–8763. PMLR, July 2021. ISSN: 2640-3498.arxiv.org/abs/2103.00020
  47. [47]P. Rech. Artificial Neural Networks for Space and Safety-Critical Applications: Reliability Issues and Potential Solutions. IEEE Transactions on Nuclear Science, 71(4):377–404, Apr. 2024.DOI
  48. [48]N. Risse and M. Böhme. Uncovering the limits of machine learning for automatic vulnerability detection. In D. Balzarotti and W. Xu, editors, 33rd USENIX Security Symposium, USENIX Security 2024, Philadelphia, PA, USA, August 14-16, 2024. USENIX Association, 2024.arxiv.org/abs/2306.17193
  49. [49]G. Schwalbe. Verification of Size Invariance in DNN Activations Using Concept Embeddings. In I. Maglogiannis, J. Macintyre, and L. Iliadis, editors, Artificial Intelligence Applications and Innovations, volume 627, pages 374–386. Springer International Publishing, Cham, 2021.DOI
  50. [50]G. Schwalbe. Concept Embedding Analysis: A Review, Mar. 2022.arxiv.org/abs/2203.13909
  51. [51]G. Schwalbe, C. Wirth, and U. Schmid. Enabling verification of deep neural networks in perception tasks using fuzzy logic and concept embeddings, Mar. 2022.arxiv.org/abs/2201.00572
  52. [52]K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In 3rd International Conference on Learning Representations (ICLR 2015), pages 1–14. Computational and Biological Learning Society, 2015.
  53. [53]D. Slack, S. Hilgard, E. Jia, S. Singh, and H. Lakkaraju. Fooling LIME and SHAP: Adversarial Attacks on Post hoc Explanation Methods. In Proceedings of the AAAI/ACM Conference on AI, Ethics, and Society, AIES ’20, pages 180–186, New York, NY, USA, Feb. 2020. Association for Computing Machinery.arxiv.org/abs/1911.02508
  54. [54]J. Stallkamp, M. Schlipsing, J. Salmen, and C. Igel. Man vs. computer: Benchmarking machine learning algorithms for traffic sign recognition. Neural Networks, 32:323–332, Aug. 2012.DOI
  55. [55]J. Su, D. V. Vargas, and K. Sakurai. One Pixel Attack for Fooling Deep Neural Networks. IEEE Transactions on Evolutionary Computation, 23(5):828–841, Oct. 2019. Conference Name: IEEE Transactions on Evolutionary Computation.DOI
  56. [56]Y. Sun, M. Wu, W. Ruan, X. Huang, M. Kwiatkowska, and D. Kroening. Concolic testing for deep neural networks. In Proc. 33rd ACM/IEEE Int. Conf. Automated Software Engineering, pages 109–119, Montpellier, France, 2018. ACM.arxiv.org/abs/1805.00089
  57. [57]N. Suryanto, Y. Kim, H. Kang, H. T. Larasati, Y. Yun, T.-T.-H. Le, H. Yang, S.-Y. Oh, and H. Kim. DTA: Physical Camouflage Attacks Using Differentiable Transformation Network. pages 15305–15314, 2022.arxiv.org/abs/2203.09831
  58. [58]C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus. Intriguing properties of neural networks, Feb. 2014. arXiv:1312.6199 [cs].arxiv.org/abs/1312.6199
  59. [59]A. Wan, L. Dunlap, D. Ho, J. Yin, S. Lee, S. Petryk, S. A. Bargal, and J. E. Gonzalez. NBDT: Neural-Backed Decision Tree. Oct. 2020.
  60. [60]D. Wang, W. Yao, T. Jiang, C. Li, and X. Chen. RFLA: A Stealthy Reflected Light Adversarial Attack in the Physical World. pages 4455–4465, 2023.arxiv.org/abs/2307.07653
  61. [61]K. Wang, X. He, W. Wang, and X. Wang. Boosting Adversarial Transferability by Block Shuffle and Rotation. In 2024 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 24336–24346, June 2024. ISSN: 2575-7075.arxiv.org/abs/2308.10299
  62. [62]X. Wang and K. He. Enhancing the Transferability of Adversarial Attacks Through Variance Tuning. pages 1924–1933, 2021.arxiv.org/abs/2103.15571
  63. [63]O. Willers, S. Sudholt, S. Raafatnia, and S. Albrecht. Safety concerns and mitigation approaches regarding the use of deep learning in safety-critical perception tasks. In A. Casimiro, F. Ortmeier, E. Schotitsch, F. Bitsch, and P. Ferreira, editors, Computer Safety, Reliability, and Security. SAFECOMP 2020 Workshops, Lecture Notes in Computer Science, pages 336–350, Cham, 2020. Springer International Publishing.arxiv.org/abs/2001.08001
  64. [64]D. Wu, Y. Wang, S.-T. Xia, J. Bailey, and X. Ma. Skip Connections Matter: On the Transferability of Adversarial Examples Generated with ResNets. Sept. 2019.arxiv.org/abs/2002.05990
  65. [65]X. Xie, K. Kersting, and D. Neider. Neuro-symbolic verification of deep neural networks. In Thirty-First International Joint Conference on Artificial Intelligence, volume 4, pages 3622–3628, July 2022.arxiv.org/abs/2203.00938
  66. [66]J. Xu, Z. Zhang, T. Friedman, Y. Liang, and G. Broeck. A semantic loss function for deep learning with symbolic knowledge. In Proceedings of the 35th International Conference on Machine Learning, pages 5502–5511. PMLR, July 2018.arxiv.org/abs/1711.11157
  67. [67]Y. Yang, A. Panagopoulou, S. Zhou, D. Jin, C. Callison-Burch, and M. Yatskar. Language in a Bottle: Language Model Guided Concept Bottlenecks for Interpretable Image Classification. pages 19187–19197, 2023.arxiv.org/abs/2211.11158
  68. [68]M. Yuksekgonul, M. Wang, and J. Zou. Post-hoc Concept Bottleneck Models. Sept. 2022.arxiv.org/abs/2205.15480
  69. [69]R. Zhang, P. Madumal, T. Miller, K. A. Ehinger, and B. I. P. Rubinstein. Invertible concept-based explanations for CNN models with non-negative concept activation vectors. In Proc. 35th AAAI Conf. Artificial Intelligence, volume 35, pages 11682–11690, virtual, 2021. AAAI Press.arxiv.org/abs/2006.15417
  70. [70]J. Zheng, C. Lin, J. Sun, Z. Zhao, Q. Li, and C. Shen. Physical 3D Adversarial Attacks against Monocular Depth Estimation in Autonomous Driving. pages 24452–24461, 2024.arxiv.org/abs/2403.17301
  71. [71]Y. Zhou, S. Liu, J. K. Siow, X. Du, and Y. Liu. Devign: Effective vulnerability identification by learning comprehensive program semantics via graph neural networks. In H. M. Wallach, H. Larochelle, A. Beygelzimer, F. d’Alché-Buc, E. B. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 10197–10207, 2019.arxiv.org/abs/1909.03496
  72. [72]R. Zhu, Z. Zhang, Z. Liu, C. Xu, and S. Liang. Learning to Transform Dynamically for Better Adversarial Transferability. Jan. 2024.arxiv.org/abs/2405.14077

Paper details

vlnc:W_5z3gvkg5
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 7

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents