<figure><img src="image_1.png" /></figure>

HAL
open science

# Lattice Climber Attack: Adversarial attacks for randomized mixtures of classifiers

Lucas Gneco, Benjamin Negrevergne, Yann Chevaleyre

► To cite this version:

Lucas Gneco, Benjamin Negrevergne, Yann Chevaleyre. Lattice Climber Attack: Adversarial attacks for randomized mixtures of classifiers. Proceedings of ECML PKDD 2025, Sep 2025, Porto, Portugal. hal-05089941v2

HAL Id: hal-05089941

https://hal.science/hal-05089941v2

Submitted on 13 Jun 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_2.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
# Lattice Climber Attack: Adversarial attacks for
randomized mixtures of classifiers

Lucas Gneco Heredia (✉), Benjamin Negrevergne, and Yann Chevaleyre

LAMSADE, CNRS, Université Paris Dauphine - PSL
Correspondence to lucas.gneco-heredia@dauphine.psl.eu

**Abstract.** Finite mixtures of classifiers (a.k.a. randomized ensembles) have been proposed as a way to improve robustness against adversarial attacks. However, existing attacks have been shown to not suit this kind of classifier. In this paper, we discuss the problem of attacking a mixture in a principled way and introduce two desirable properties of attacks based on a geometrical analysis of the problem (effectiveness and maximality). We then show that existing attacks do not meet both of these properties. Finally, we introduce a new attack called *lattice climber attack* with theoretical guarantees in the binary linear setting, and demonstrate its performance by conducting experiments on synthetic and real datasets.

**Keywords:** adversarial robustness · adversarial attacks · randomized classifiers · mixtures.

## 1 Introduction

Deep neural networks have been shown to be vulnerable to adversarial attacks [10], i.e. small perturbations that, although imperceptible to humans, manage to drastically change the predictions of the model. This observation has led to numerous efforts to understand this phenomenon [4] and started a series of publications introducing various techniques to train robust models [14] as well as new algorithms to attack them [22].

One research direction that has been explored is the use of *randomized classifiers*, which include a source of randomness in their predictions. Examples of such classifiers include stochastic pruning [9, 17], noise injection classifiers [12], classifiers with random input transformations [23, 20], finite mixtures [19, 15], among others. Unfortunately, the robustness of these randomized classifiers is not well understood, and most of them have been shown to be less robust than originally claimed under the white-box threat model. The classifier based on random input transformations by Xie et al. [23], which won the 2017 Neurips *Adversarial Attacks and Defences* Competition, was broken by Athalye et al. [2], together with stochastic pruning [9]. The defense by Panousis et al. [17] was debated on a Github issue<fnref n="1" /> by the authors of Robustbench [6], who found that

<footnote n="1">¹ Available at https://github.com/fra31/auto-attack/issues/58</footnote>
the classifier was not robust using a simple adaptation of AutoAttack [6]. The defense *Barrage of random transforms* by Raff et al. [20], which had impressive robustness results on Imagenet, was broken three years later by Sitawarin et al. [21], and Dbouk et al. [7] debate the robustness of finite mixtures.

In addition to showing that the real robustness of randomized classifiers is not yet fully understood, these results also highlight the lack of adaptive attacks for randomized models. The attacks used to evaluate the robustness of these models are often not suitable for the task, leading to an overestimation of their robustness, a phenomenon that is well known nowadays [2, 22]. The lack of strong adaptive attacks for randomized classifiers has undermined research on this family of classifiers and limited its practical applications. As an example, one of the criteria used by the Robustbench benchmark to filter out defenses is the use of randomness in the forward pass, because such defenses often “only make gradient-based attacks harder but do not substantially improve robustness” [6].

Arguably, finite mixtures of classifiers [19, 15] are one of the simplest kind of randomized classifiers, and yet they are not trivial to attack. Dbouk et al. [7] showed that the adaptations of projected gradient descent (PGD) [14] used by Pinot et al. [19] or Meunier et al. [15] were weak, thus overestimating the robustness of finite mixtures. They design ARC, the current state-of-the-art attack for finite mixtures of classifiers, and their evaluation shows a considerable drop in robustness with respect to the results reported by Pinot et al. [19].

In this work, we take a principled approach to understand adversarial attacks for finite mixtures of classifiers using a set-theoretic perspective and the concept of *vulnerability regions*. We show that the problem of attacking a finite mixture can be seen as the problem of climbing a lattice. Using this perspective, we identify a series of desirable properties and limitations of existing attacks. Afterward, we leverage the lattice reformulation to devise a new attack with better theoretical guarantees in binary classification with linear classifiers. More specifically, we make the following 3 contributions: First in Section 3 we model the problem of attacking a mixture using a semi-lattice, which allows us to better characterize the limitations of existing attacks like adaptations of PGD [14] and ARC [7]. Second, we propose in Section 4 a new attack algorithm called *lattice climber* that has strong guarantees in the binary linear setting compared to existing attacks. We then generalize to multiclass differentiable classifiers like neural networks. Finally, we provide extensive experimental results showing that our proposed attack is better at simultaneously attacking a finite mixture compared to existing attacks. Our code is available in https://github.com/lucasgneccoh/lattice_climberattack.

## 2 Preliminaries

**Notations.** For a predicate $C$, we denote by $1\{C\}$ the function that returns 1 if the predicate $C$ is true and 0 otherwise. For an integer $m$, we use the notation $[m] = \{1, \dots, m\}$. For a vector $u \in \mathbb{R}^d$, we denote by $u^{(j)}$ the $j$-th component of $u$. We denote by $\Delta^n$ the probability simplex in $\mathbb{R}^n$. For a probability vector
$p \in \Delta^n$, we denote Cat($p$) the categorical distribution on $n$ elements, where $p^{(i)}$ is the probability of sampling element $i$. To alleviate the notation, when $z$ is a random variable following the distribution Cat($p$), we write $z \sim p$.

**Problem setting.** Given a $d$-dimensional input space $\mathcal{X} \subset \mathbb{R}^d$ and a set $\mathcal{Y} = [K]$ of $K$ class labels, a deterministic classifier $h: \mathcal{X} \to \mathcal{Y}$ is a function that maps each input point $x$ to a predicted label $h(x)$. To measure the quality of the prediction of $h$ at a point $(x, y) \in \mathcal{X} \times \mathcal{Y}$, we use the zero-one loss :

$$ \mathcal{L}^{0-1}(h, x, y) = 1\{h(x) \neq y\} \qquad (1) $$

In this paper, we consider finite mixtures of classifiers [19, 15], which are a type of randomized classifier inspired by mixed strategies in game theory. Given a base set of deterministic classifiers $\mathbf{h} = \{h_1, \dots, h_m\}$ and a probability distribution over them $\mathbf{q} \in \Delta^m$, the mixture classifier $\mathbf{h}_{\mathbf{q}}$ will map any input $x$ by first sampling a classifier $i \sim \mathbf{q}$, and then returning $h_i(x)$. Note that, unlike classical deterministic classifiers, mixtures may predict different labels for the same input $x$ over repeated calls, thus the prediction $\mathbf{h}_{\mathbf{q}}(x)$ is a random variable $\hat{y}$ over $\mathcal{Y}$, and the zero-one loss needs to be adapted to measure the expected error:

$$ \mathcal{L}^{0-1}(\mathbf{h}_{\mathbf{q}}, x, y) = \mathbb{E}_{i \sim \mathbf{q}} [\mathcal{L}^{0-1}(h_i, x, y)] = \sum_{i=1}^{m} \mathbf{q}^{(i)} \cdot \mathcal{L}^{0-1}(h_i, x, y). \qquad (2) $$

In other words, the zero-one loss of a mixture represents the probability of predicting an incorrect label for input $x$.

**Adversarial attacks on classifiers and mixtures.** Given an input point $x \in \mathcal{X}$ and its true label $y$, attacking a classifier $h$ (deterministic or randomized) consists of crafting a norm bounded perturbation $\delta \in \mathbb{R}^d$ (with $\|\delta\| \le \epsilon$) that increases the 0-1 loss at $(x, y)$. Various norms can be used to measure the magnitude of the perturbation $\delta$, the most common being $\ell_p$ norms with $p = 2$ or $p = \infty$. For a given $p$-norm, we denote $B_p(x, \epsilon)$ the ball centered at $x$ with radius $\epsilon$ i.e. $B_p(x, \epsilon) = \{x + \delta \in \mathcal{X} \text{ s.t. } \|\delta\| \le \epsilon\}$. The adversarial zero-one loss $\mathcal{L}_{\epsilon}^{0-1}$ is defined as the zero-one loss under attack by an optimal adversary:

$$ \mathcal{L}_{\epsilon,p}^{0-1}(h, x, y) = \sup_{x' \in B_p(x, \epsilon)} \mathcal{L}^{0-1}(h, x', y) \qquad (3) $$

## 3 Failures of existing attacks

We start by analyzing of the limitations of existing attacks such as Expectation Over Transformation (EOT) [3] and ARC [7].
## 3.1 Attacks based on Expectation Over Transformation (EOT)

Expectation Over Transformation (EOT) was initially developed by Athalye et al. [3], in order to craft attacks that are robust to real world perturbations. EOT introduces a set of transformations $T$ that may be applied to the input, and optimizes the expected loss $\mathcal{L}$ over $T$:

$$ \mathbb{E}_{t \sim T} [\mathcal{L}(h, t(x'), y)]. \qquad (4) $$

The EOT principle was later adapted to attack finite mixture of classifiers by Pinot et al. [19]. Instead of considering random transformations, the idea is to account for the sampling of the classifier as the source of randomness. To attack the mixture $h_q$, our objective function becomes the *Expectation Of the Loss* (EOL), as follows:

$$ \mathbb{E}_{i \sim q} [\mathcal{L}(h_i, x, y)] = \sum_{i=1}^{m} q^{(i)} \mathcal{L}(h_i, x, y), \qquad (5) $$

Note that if we choose $\mathcal{L}$ to be the zero-one loss, then maximizing the objective in (5) directly corresponds to maximizing the classification error of the mixture in (2). Therefore, maximizing the EOL with the zero-one loss is the correct objective for attacking a finite mixture. However, as we will demonstrate, this stops being true if we replace the zero-one loss with a surrogate loss function such as the cross-entropy loss.

*Practical adaptations for attacking finite mixtures.* To generate an adversarial example in practice, one can directly maximize the EOL objective in (5) (as in (6)), or maximize the loss computed on the expected output of the mixture ((7)) [19, 22].

$$ \sup_{x' \in B_p(x, \epsilon)} \sum_{i=1}^{m} q^{(i)} \mathcal{L}(h_i, x', y). \qquad (6) $$

$$ \sup_{x' \in B_p(x, \epsilon)} \mathcal{L} \left( z \mapsto \sum_{i=1}^{m} q^{(i)} h_i(z), x', y \right). \qquad (7) $$

In practice, both of these problems are solved using first-order optimization methods like PGD. We refer to these attacks as EOL-PGD and LOE-PGD, respectively. The problem in doing so is that there is an underlying assumption that all classifiers can be attacked simultaneously and that their vulnerabilities are *aligned*, a concept we illustrate in Figure 1. This is because the gradient of either objective can be rewritten as a linear combination of the gradients of the loss of the individual classifiers with positive coefficients (see Appendix A.1 for more details). Thus, using first-order methods to solve problems (6) or (7) is intuitively trying to attack all classifiers simultaneously, and the success of such attack relies on the assumption that this linear combination is a good attack direction. This can be effective in a scenario like the one depicted in Figure 1
(left), in which all classifiers are vulnerable and their vulnerabilities are aligned, but fail when the vulnerabilities lie outside the set of admissible perturbations, as demonstrated in Figure 1 (right).

This issue with EOL-PGD and LOE-PGD is the starting point for the devel-
opment of ARC [7], a stronger attack against mixtures of classifiers, which we
will discuss in the following section.

<figure><img src="image_3.png" /><figcaption>Fig. 1: Example of two linear classifiers with high (left) and low (right) alignment. The red arrow represents the gradient of the loss of the mixture, while the black arrows represent the gradient of the loss of individual classifiers. The red region in the top-right corner represents the points that are adversarial for both classifiers simultaneously. In the case of high alignment (left), the linear combination of the individual gradients is a successful attack direction, while in the case of low alignment (right), it is *not* an effective attack direction as it leads to a non-adversarial perturbation, even though adversarial perturbations do exist.</figcaption></figure>

3.2 ARC attack and its limitations

Dbouk et al. [7] criticize EOL-PGD and LOE-PGD because of their lack of consistency<fnref n="2" /> [7, Theorem 5.1], meaning that even if there exist adversarial attacks that increase the error of the mixture, EOL-PGD or LOE-PGD can miss them (i.e. Figure 1 (right)). This motivates the authors to create *Attacking Randomized ensembles of Classifiers (ARC)*[7], an attack against finite mixtures of classifiers that is guaranteed to be consistent in binary classification against linear classifiers. In the rest of this section, we will compare ARC to EOL-PGD and discuss the limitations of ARC. We omit the discussion of LOE-PGD, but our analysis applies to it as well.

The key difference between ARC and EOL-PGD is that ARC attacks the
classifiers one by one, instead of trying to attack all of them simultaneously. At
each iteration, ARC follows the direction that attacks the one classifier at hand,
and at the end of the iteration, the new perturbation will be kept only if the error
of the whole mixture was strictly increased (see [7, Algorithm 1] for full details).

<footnote n="2">² This is the term used by authors in the original work. We rather use the term *effectiveness*. See Section 3.3</footnote>
The greedy approach of ARC makes it provably consistent when attacking binary linear classifiers (see [7, Theorem 5.1]). In Figure 2 (left) we revisit a situation akin to Figure 1 (right), and we can see that ARC is able to attack one of the classifiers successfully, while EOL-PGD fails to find an adversarial perturbation.

Dbouk et al. [7] train mixtures of two classifiers using the method proposed in [19] and find that when attacked with ARC<fnref n="3" />, the robustness of these mixtures drops significantly compared to when they are attacked with EOL-PGD or LOE-PGD, which were the attacks used by Pinot et al. [19] for their evaluation. This behavior remains consistent across neural network architectures, datasets, and norms considered. Thus, ARC has proven to be a much stronger attack than EOL-PGD and LOE-PGD and remains, to this day, the state-of-the-art attack against finite mixtures of classifiers.

Although ARC resolves the main issue with EOL-PGD, it does so at the cost of losing the ability to attack multiple classifiers simultaneously in situations of medium alignment. Experimentally, one can verify that even for two linear classifiers in $R^2$, ARC may fail to find a perturbation that is misclassified by both classifiers simultaneously when the region of common vulnerabilities within the ε-ball is very small. An example of such scenario is shown in Figure 2 (right).

<figure><img src="image_4.png" /><figcaption>Fig. 2: Comparison between the perturbation proposed by EOL-PGD and ARC on a mixture of two linear classifiers with low to medium alignment.</figcaption></figure>

To further demonstrate this issue, we test both EOL-PGD and ARC in situations that range from high to low alignment by changing the angle between the normal vectors of the linear classifiers from 0 degrees (perfect alignment) to 180 degrees (opposite normal vectors, low alignment). In Figure 3, we plot the error induced by the perturbations found by both EOL-PGD and ARC and compare

<footnote n="3">³ ARC is born from an analysis in the binary linear case, but it is generalized to the case of multiclass differentiable classifiers like neural networks. In their experiments comparing to the results in Pinot et al. [19], they used the latter.</footnote>
it to the optimal error, which is determined by checking if the intersection of the two linear classifiers lies within the $\epsilon$-ball or not. It can be seen that no attack dominates the other and that each outperforms the other in some regime that depends on the alignment of the decision boundaries.

<figure><img src="image_5.png" /><figcaption>Fig. 3: Comparison between EOL-PGD and ARC w.r.t the level of alignment of the linear classifiers. On the left figure, a schema of the experiment that we run for a fixed angle $\theta$. On the right figure, the error of the perturbations found by EOL-PGD and ARC compared to the optimal error w.r.t. $\theta$.</figcaption></figure>

We end this section with a comparison of ARC, EOL-PGD and LOE-PGD through the lens of the directions used to craft the perturbation at each iteration of the attack. Recall that the gradient directions used by EOL-PGD and LOE-PGD were linear combinations of the gradients of the loss of individual classifiers with non-zero coefficients for all of them. In the case of ARC, these coefficients are all zero except for one, which corresponds to the classifier being considered at the current step (See [7, Algorithm 2] for full details).

### 3.3 Desirable properties of an attack for mixtures

In this section we will formalize the problem of attacking a mixture of classifiers as a combinatorial optimization problem, specifically as the problem of enumerating maximal elements of a lattice. Using this formalism, we will discuss the desirable properties for attack algorithm. This will allow us to identify a new property unsatisfied by existing algorithms: *maximality*.

*Formalizing the problem of attacking a finite mixture.* Note that a deterministic classifier $h$ partitions the input space into at most $K$ non-overlapping regions $h^{-1}(j) \subseteq \mathcal{X}, j \in [K]$, where each region corresponds to a class. Moreover, an optimal untargeted attacker only cares about forcing a prediction *different* from the true label $y$ inside the set of admissible perturbations $B_p(x, \epsilon)$. In that
sense, each classifier $h$ induces a partition of the set of admissible perturbation $B_p(x, \epsilon)$ into two disjoint regions of interest:

$$ B_p(x, \epsilon) = \underbrace{B_p(x, \epsilon) \cap h^{-1}(y)}_{\text{non-adversarial}} \sqcup \underbrace{B_p(x, \epsilon) \cap \bigcup_{j \neq y} h^{-1}(j)}_{\substack{\text{Vulnerability region } V(h) \\ j \neq y}} \quad (8) $$

We call vulnerability region of $h$ the set $B_p(x, \epsilon) \cap \bigcup_{j \neq y} h^{-1}(j)$, and denote it as $V(h)$. With the definition of vulnerability region, attacking $h$ is equivalent to finding a point $x' \in V(h)$, so the error under attack of $\mathbf{h}_q$ at $(x, y)$ becomes:

$$ \mathcal{L}_{\epsilon,p}^{0-1}(\mathbf{h}_q, x, y) = \sup_{x' \in B_p(x, \epsilon)} \sum_{i=1}^{m} \mathbf{q}^{(i)} \mathbf{1}\{x' \in V(h_i)\}. \quad (9) $$

With Equation (9) it is clear that the optimal attack belongs to the intersection of the vulnerability regions of the classifiers that maximizes the total mass according to $\mathbf{q}$. Let us define the common vulnerability region of a subset of classifiers $\mathbf{h}' \subseteq \mathbf{h}$ as $\text{CV}(\mathbf{h}') = \bigcap_{h \in \mathbf{h}'} \text{V}(h) \setminus \bigcup_{h \notin \mathbf{h}'} \text{V}(h)$. In simple terms, $\text{CV}(\mathbf{h}')$ is the set of points that are adversarial for exactly the classifiers in $\mathbf{h}'$, and thus, if $x' \in \text{CV}(\mathbf{h}')$, then $\mathcal{L}^{0-1}(\mathbf{h}_q, x', y) = \sum_{i \text{ s.t. } h_i \in \mathbf{h}'} \mathbf{q}^{(i)}$, and if $\mathbf{h}_1 \subseteq \mathbf{h}_2$ and $\text{CV}(\mathbf{h}_2) \neq \emptyset$, then the following holds:

$$ \forall x_1 \in \text{CV}(\mathbf{h}_2), \forall x_2 \in \text{CV}(\mathbf{h}_1), \mathcal{L}^{0-1}(\mathbf{h}_q, x_2, y) \leq \mathcal{L}^{0-1}(\mathbf{h}_q, x_1, y), \quad (10) $$

which means that an attacker prefers to attack in the common vulnerability region of a larger set of classifiers whenever it is not empty.

Equation (10) suggests that the subsets of classifiers can be ordered by their preference for the attacker. Formally speaking, we can define the partial order

$$ \mathbf{h}_1 \preceq \mathbf{h}_2 \iff \mathbf{h}_1 \subseteq \mathbf{h}_2 \text{ and } \text{CV}(\mathbf{h}_2) \neq \emptyset. \quad (11) $$

The order relation in Equation (11) induces a lower semilattice structure in the family of subsets $S = \{\mathbf{h}' \subseteq \mathbf{h} \mid \text{CV}(\mathbf{h}') \neq \emptyset\} \cup \{\emptyset\}$. For simplicity, we refer to it as adversarial lattice of $\mathbf{h}_q$ at $(x, y)$. Due to space constraints, we illustrate examples of adversarial lattices in Appendix A.

The lattice object allows us to discuss desirable properties of an attack algorithm that faces mixtures of classifiers. The first has already been discussed under the name of consistency [7], but we redefine it as effectiveness:

**Definition 1 (Effectiveness property).** An attack algorithm is effective if for any finite mixture $\mathbf{h}_q$ and point $(x, y)$, it can generate an adversarial example increasing the error of the mixture whenever such a point exists.

**Definition 2 (Maximality property).** An attack algorithm is maximal if for any finite mixture $\mathbf{h}_q$ and any point $(x, y)$, it can generate an adversarial example for a maximal subset of classifiers of the adversarial lattice.
<figure><img src="image_6.png" /><figcaption>Fig. 4: Example of an adversarial lattice for a mixture of four classifiers.</figcaption></figure>

Neither EOL-PGD nor ARC is maximal for binary linear classifiers, as counterexamples can be constructed where they fail to find a maximal subset of classifiers to attack (Figure 2). Figure 4 illustrates an example of an adversarial lattice for a mixture of four classifiers. An *effective* attack is ensured to produce an adversarial attack $x'$ that corresponds to *some* of the nodes highlighted with a blue rectangle. This property is a defining characteristic of ARC for binary linear classifiers —one that EOL-PGD lacks. However, there is no guarantee regarding the level of the lattice that is reached, and the effectiveness guarantee becomes less meaningful as the size of the lattice increases. The nodes with red font represent the maximal nodes, illustrating that the maximality guarantee is a stronger property than effectiveness.

The most desirable property of an attack for mixtures is be *optimality*:

**Definition 3 (Optimality property).** An attack algorithm is optimal if for any finite mixture over $h_q$ and any point $(x, y)$, it can generate an adversarial example that achieves the highest possible 0-1 loss.

The optimal attack corresponds to a *subset* of the maximal elements of the adversarial lattice, depending on the weights of the mixture. Unfortunately, no polynomial-time algorithm is guaranteed to achieve optimality, even when using linear classifiers in binary classification, due to the following result (full proof in Appendix B.1):

**Theorem 1 (Hardness of attacking linear classifiers).** Consider a binary classification setting, $\ell_p$ norm with $p > 1$ and $\epsilon$ to be defined. Given a labeled point $(x, y)$, a set of $m$ linear classifiers $x \mapsto 1\{\theta_i^\top x + b_i \ge 0\}$ where $(\theta_i, b_i) \in \mathbb{R}^{d+1}$, a uniform mixture $h_q$ composed of these linear classifiers and a value $\beta > 0$, there exists a noise budget $\epsilon > 0$ such that the problem of checking if there exists $x' \in B_p(x, \epsilon)$ such that $\mathcal{L}^{0-1}(h_q, x', y) \ge \beta$ is NP-hard.

As a consequence of Theorem 1, the attack algorithm that we will propose will prioritize *maximality* over *optimality*, which can be guaranteed in the case of binary linear classifiers and provides effectiveness for free.
# 4 Lattice Climber attack

In this section, we introduce a new attack called Lattice Climber Attack (LCA). We first present a version of our attack that has maximality guarantees against mixtures of binary linear classifiers under mild assumptions, and then extend it to multiclass differentiable classifiers. Afterwards, we will present experimental results that compare LCA with EOL-PGD and ARC on synthetic and real-world datasets.

The idea behind LCA is to arrive at a maximal element of the lattice by climbing one level at a time. Similar problems have been studied under the name of most specific sentences or maximal frequent itemsets in the domain of data mining and knowledge discovery, where algorithms like AllMSS [11] have been proposed. Our approach is similar to A_Random_MSS in [11].

## 4.1 Binary linear classifiers

In this section and for simplicity, we consider class labels $y \in \{-1, 1\}$ and classifiers $h: \mathbb{R}^d \to \{-1, 1\}$ of the form $h(x) = \text{sign}(f(x))$ for some linear function $f: \mathbb{R}^d \to \mathbb{R}$. In this setting, $h$ correctly classifies the data point $(x, y)$ if $yf(x) > 0$. Therefore, attacking $h$ translates to minimizing $yf(x)$. The optimal attack direction and margin to the decision boundary of a single linear classifier are known for all $l_p$ norm with $p \ge 1$ [7, Appendix A].

The first component of our attack algorithm is a procedure to attack a subset of classifiers $\mathbf{h}'$ and find $x + \delta \in \text{CV}(\mathbf{h}')$ whenever $\text{CV}(\mathbf{h}') \neq \emptyset$. Similar to [18], we consider the reverse hinge loss $\mathcal{L}^{\text{rev}}(yf(x)) = \max(yf(x), 0)$ as an objective to minimize in order to attack one binary linear classifier. Attacking a binary linear classifier with the traditional hinge loss would imply maximizing a convex function, for which there is no guarantee of convergence to a global optimum using algorithms like PGD. On the other hand, using the reverse hinge loss is equivalent to minimizing a bounded convex function, for which PGD is guaranteed to converge to a global optimum.

Another useful property of the reverse hinge loss is that the expected reverse hinge loss over a finite mixture of classifiers is convex and equal to zero if and only if all the classifiers in the mixture misclassify $x$. Then, in order to attack a set of classifiers $\mathbf{h}'$, we can minimize the sum of reverse hinge losses [18]

$$ \text{SRH}(\mathbf{h}', x, y) = \frac{1}{|\mathbf{h}'|} \sum_{h \in \mathbf{h}'} \mathcal{L}^{\text{rev}}(yf(x)). \quad (12) $$

If there exists $x'$ such that $\text{SRH}(\mathbf{h}', x', y) = 0$, then PGD with an appropriately chosen step size and sufficient number of iterations will converge to some $x''$ that is misclassified by all classifiers in $\mathbf{h}'$ (see [18, Theorem 3] for details).

The second component of our attack algorithm is a way to navigate the adversarial lattice. We propose a bottom-up navigation mechanism to climb a branch of the adversarial lattice that consists of keeping a pool of fooled classifiers, attempting to add each classifier in a fixed order. A classifier joins the pool
<caption>**Algorithm 1:** LCA for binary linear classifiers</caption>

**Require:** Set **h** of *m* binary linear classifiers in some order ($h_1, \dots, h_m$), starting point $(x, y) \in \mathbb{R}^d \times \{-1, 1\}. T$ number of iterations and $\eta$ step size for PGD.
1: Initialize pool $\mathbf{h}_{\text{pool}} = \emptyset, \delta = 0_d$
2: **for** $i = 1, 2, \dots, m$ **do**
3: &nbsp;&nbsp;&nbsp;&nbsp; $\mathbf{h}_{\text{pool}} = \mathbf{h}_{\text{pool}} \cup \{h_i\}$ {Add $h_i$ to the pool}
4: &nbsp;&nbsp;&nbsp;&nbsp; Attack SRH($\mathbf{h}_{\text{pool}}, \cdot, y$) starting at $x + \delta$ with PGD $(T, \eta)$ to find new perturbation $\delta$
5: &nbsp;&nbsp;&nbsp;&nbsp; **if** SRH($\mathbf{h}_{\text{pool}}, x + \delta, y) = 0$ i.e. succeeded **then**
6: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $\delta = \delta$ {Update current attack, keep $h_i$ in pool}
7: &nbsp;&nbsp;&nbsp;&nbsp; **else**
8: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $\mathbf{h}_{\text{pool}} = \mathbf{h}_{\text{pool}} \setminus \{h_i\}$ {Reset pool to last state}
9: **return** Adversarial example $x + \delta$

only if it can be fooled alongside all current members; otherwise, it is discarded.
The algorithm terminates after evaluating all classifiers.

The order in which classifiers are considered is a parameter of the algorithm, and similarly to [7], we find that considering them in decreasing order of their associated weight yields good performance in general. For example, in the case $m=2$, and with suitable parameters for the internal PGD, it ensures that LCA is optimal. Another reasonable option is to use a random permutation of the classifiers, which Dbouk et al. [8] found to be useful for ARC. The pseudocode of LCA in the binary linear setting is shown in Algorithm 1.

Recall that the step used by EOL-PGD can be expressed as linear combinations of the gradients of the loss of individual classifiers. For LCA, similar to ARC, the coefficients of this linear combination will be sparse: only the models within the pool $\mathbf{h}_{\text{pool}}$ will have non-zero coefficients. This behavior positions LCA as an intermediate approach between EOL-PGD and ARC: in LCA, the coefficients initially resemble those in ARC, but as the pool grows, they transition to resemble the denser pattern of EOL-PGD. This behavior makes it possible to adapt to different types of adversarial lattice: when classifiers are not simultaneously vulnerable, LCA will behave like ARC, which was created to ensure *effectiveness* for binary linear classifiers, and when they are simultaneously vulnerable, it will behave like EOL-PGD which attacks all classifiers simultaneously.

*Maximality of LCA in the binary linear setting.* In the binary linear classifier setting, PGD$(T, \eta)$ is guaranteed to minimize the function SRH($\mathbf{h}_{\text{pool}}, \cdot, y$) because it is a convex optimization problem [18]. Thus, line 4 of Algorithm 1 ensures that we will find an adversarial attack $x + \delta \in \text{CV}(\mathbf{h}_{\text{pool}})$ if $\text{CV}(\mathbf{h}_{\text{pool}}) \neq \emptyset$. This enables climbing to the top of the adversarial lattice along a branch determined by the classifier order. This is formalized in the following lemma:

**Lemma 1.** Consider a set of *m* binary linear classifiers **h**. Fix $\epsilon > 0$ the attack budget and a point $(x, y)$. If there exists a point $x' \in B_p(x, \epsilon)$ such that
SRH(**h**, *x*', *y*) = 0, then there exist parameters *T* and *η* such that minimizing SRH(**h**, *x*, *y*) w.r.t. *x* with PGD(*T*, *η*) will return *x''* such that SRH(**h**, *x''*, *y*) = 0.

The proof of Lemma 1 is given in Appendix B.2. Lemma 1 allows us to
prove that LCA is maximal for the set of binary linear classifiers (full proof in
Appendix B.3):

**Theorem 2 (LCA is maximal in the binary linear setting).** Let **h** be a finite set of binary linear classifiers and **h**<sub>q</sub> a mixture over **h**. Fix ε > 0 the attack budget and a p-norm with p > 1. For any (x,y) ∈ ℝ<sup>d</sup> × {-1,1}, there exist parameters T and η for the inner PGD such that Algorithm 1 returns an adversarial example x + δ ∈ CV(**h**'), where **h''** is a maximal element of the adversarial lattice of **h**<sub>q</sub> at (x,y).

## 4.2 Multiclass differentiable classifiers

The ideas developed in Section 4.1 for binary linear classifiers need to be adapted
to the multiclass case with general differentiable classifiers, like neural networks,
because we cannot have the guarantees provided by Lemma 1 and Theorem 2.
Moreover, the reverse hinge loss was defined for binary classifiers and not for
multiclass classifiers.

In order to attack a classifier *h* that predicts the class with the highest score
according to the score function *f*: 𝒳 → ℝ<sup>*K*</sup> at an arbitrary point (*x*, *y*), we
choose the target label *y*<sub>adv</sub> ∈ [*K*) \ {*y*} with the largest score according to *f*(*x*)
and minimize the reverse hinge loss of the margin between *f*(*x*)(<sup>*y*</sup>) and *f*(*x*)(<sup>*y*<sub>adv</sub></sup>),
i.e. L<sup>rev</sup>(*f*(*x*)(<sup>*y*</sup>) − *f*(*x*)(<sup>*y*<sub>adv</sub></sup>)). This is a common choice that has been used by
Perdomo et al. [18] and also by Carlini et al. [5], who found it to perform well
as an objective function for crafting adversarial attacks. Our proposed attack
is presented in Algorithm 2 in Appendix A.3. As there is no guarantee on the
convergence of the attack to SRH(**h**<sub>pool</sub>, ·, *y*) in line 4, we change the criteria to
update the pool of classifiers: each time we find a perturbation δ with a higher
error for the mixture, we keep it and update the pool to be the classifiers that
misclassify the current adversarial example *x* + *δ*.

5 Experiments

In this section, we show the experimental results that support the theoretical guarantees of LCA in the binary linear setting. We also compare the performance of LCA with ARC and EOL-PGD in the multiclass differentiable setting, in which guarantees are not provided, and show that LCA generally performs better than existing state-of-the-art attacks. More details on the experimental setup and additional experiments can be found in Appendix C and D.

**5.1 Synthetic data: Linear classifiers**

*Binary linear classifiers in high dimension.* In this experiment, we assess how the
performance of EOL-PGD, ARC and LCA scale with the number of classifiers *m*
in a higher dimension $d$. For each value $m$ and a fixed value of $\epsilon = 1$, we repeat the following experiment 1000 times: we fix our point $(x, y) = (0_d, -1)$ and sample $m$ i.i.d linear classifiers $(w_i, b_i)$ where $w_i$ is uniformly sampled from the unit sphere in $\mathbb{R}^d$ and $b_i \sim -|\mathcal{N}(\alpha, \beta)|$ follows a folded Gaussian distribution, and we test the three attacks against the sampled mixture. The hyperparameter $\alpha$ controls the expected distance from $x$ to the decision boundary of the classifiers, and $\beta$ the variance of such distance.

Figure 5 shows that the average performance of all attacks deteriorates as the number of models increases, but LCA remains superior for all $m$. Note that depending on the difficulty of the configurations $(\alpha$ and $\beta)$, the performance of the attacks can change drastically. Nevertheless, LCA remained superior in all configurations, regardless of the dimension. More combinations of $\alpha$ and $\beta$ and more details on the experimental setup can be found in Appendix C.

<figure><img src="image_7.png" /><figcaption>Fig. 5: On the left figure, the average error obtained by the attacks in $\mathbb{R}^{128}$ as a function of the number of classifiers in the mixture with 99% confidence intervals. The right figure shows the average time in seconds that each attack took to generate an adversarial example as a function of the number of classifiers with one standard deviation intervals. For each number of models, the experiment was repeated 1000 times. Note that the y-axis limits have been adapted for visualization purposes. In this case, $\alpha = 0.25$, $\beta = 0.2$.</figcaption></figure>

## 5.2 CIFAR-10

*Experimental setup.* To test our attack against differentiable multiclass classifiers, we measure the accuracy of mixtures built using models trained with different ensemble diversity techniques. To have a wide variety of models and training methods, we take the pre-trained models from the DVERGE [24] repository$^4$, which compares baseline models trained without any defense (BASE)

<footnote>$^4$ https://github.com/zjysteven/DVERGE/tree/main</footnote>
<table><caption>Table 1: Expected accuracy of mixtures against EOL-PGD, ARC and LCA under the $\ell_\infty$ threat model. Attacker wants to minimize accuracy, so lower is better. All models use ResNet20 as the base architecture, except † which uses ResNet18.</caption><thead><tr><th rowspan="2">Model</th><th rowspan="2">Nat</th><th colspan="3">ε = 0.01</th><th colspan="3">ε = 0.03</th></tr><tr><th>EOL</th><th>ARC</th><th>LCA</th><th>EOL</th><th>ARC</th><th>LCA</th></tr></thead><tbody><tr><td>BASE/3</td><td>91.8%</td><td>15.0%</td><td>4.3%</td><td><strong>1.7%</strong></td><td>0.1%</td><td>0.2%</td><td><strong>0.0%</strong></td></tr><tr><td>BASE/5</td><td>91.9%</td><td>12.3%</td><td>6.1%</td><td><strong>2.7%</strong></td><td><strong>0.0%</strong></td><td>0.2%</td><td>0.1%</td></tr><tr><td>BASE/8</td><td>91.8%</td><td>10.6%</td><td>7.9%</td><td><strong>4.6%</strong></td><td><strong>0.0%</strong></td><td>0.2%</td><td>0.1%</td></tr><tr><td>ADP/3</td><td>89.4%</td><td>15.7%</td><td><strong>14.6%</strong></td><td>15.1%</td><td><strong>0.4%</strong></td><td>5.2%</td><td>1.8%</td></tr><tr><td>ADP/5 [16]</td><td>88.8%</td><td>15.4%</td><td>16.1%</td><td><strong>13.9%</strong></td><td><strong>0.2%</strong></td><td>2.5%</td><td>1.5%</td></tr><tr><td>ADP/8</td><td>88.5%</td><td><strong>15.2%</strong></td><td>18.4%</td><td>15.4%</td><td><strong>0.3%</strong></td><td>4.2%</td><td>3.3%</td></tr><tr><td>GAL/3</td><td>87.1%</td><td>43.0%</td><td>18.0%</td><td><strong>14.3%</strong></td><td>14.5%</td><td>5.8%</td><td><strong>0.9%</strong></td></tr><tr><td>GAL/5 [13]</td><td>88.7%</td><td>46.2%</td><td>45.1%</td><td><strong>36.0%</strong></td><td>11.5%</td><td>9.4%</td><td><strong>7.1%</strong></td></tr><tr><td>GAL/8</td><td>89.7%</td><td><strong>44.5%</strong></td><td>52.4%</td><td>50.2%</td><td><strong>3.9%</strong></td><td>11.7%</td><td>15.9%</td></tr><tr><td>AT/3</td><td>77.3%</td><td>68.6%</td><td>68.3%</td><td><strong>65.3%</strong></td><td>47.2%</td><td>47.7%</td><td><strong>42.4%</strong></td></tr><tr><td>AT/5 [14]</td><td>77.9%</td><td>69.0%</td><td>69.1%</td><td><strong>65.2%</strong></td><td>47.2%</td><td>49.2%</td><td><strong>42.7%</strong></td></tr><tr><td>AT/8</td><td>77.8%</td><td>69.0%</td><td>69.0%</td><td><strong>64.9%</strong></td><td>47.5%</td><td>50.3%</td><td><strong>44.3%</strong></td></tr><tr><td>DV/3</td><td>89.8%</td><td>52.6%</td><td>44.4%</td><td><strong>31.2%</strong></td><td>39.2%</td><td>5.8%</td><td><strong>1.9%</strong></td></tr><tr><td>DV/5 [24]</td><td>89.9%</td><td>59.0%</td><td>55.1%</td><td><strong>42.1%</strong></td><td>35.3%</td><td>10.1%</td><td><strong>6.0%</strong></td></tr><tr><td>DV/8</td><td>88.6%</td><td>62.1%</td><td>63.2%</td><td><strong>52.8%</strong></td><td>31.7%</td><td>18.4%</td><td><strong>15.0%</strong></td></tr><tr><td>DV+AT/3</td><td>81.7%</td><td>71.4%</td><td>71.3%</td><td><strong>69.0%</strong></td><td>44.4%</td><td>45.2%</td><td><strong>41.0%</strong></td></tr><tr><td>DV+AT/5 [24]</td><td>84.0%</td><td>72.8%</td><td>73.1%</td><td><strong>70.2%</strong></td><td>42.2%</td><td>44.6%</td><td><strong>39.9%</strong></td></tr><tr><td>DV+AT/8</td><td>84.0%</td><td>73.2%</td><td>73.4%</td><td><strong>70.9%</strong></td><td>44.3%</td><td>46.5%</td><td><strong>42.5%</strong></td></tr><tr><td>BARRE/5 [8]</td><td>76.3%</td><td>68.9%</td><td>69.4%</td><td><strong>66.2%</strong></td><td>50.6%</td><td>49.9%</td><td><strong>46.1%</strong></td></tr><tr><td>MR/5 [25]</td><td>73.7%</td><td>65.7%</td><td>66.4%</td><td><strong>62.3%</strong></td><td>46.3%</td><td>46.7%</td><td><strong>41.5%</strong></td></tr><tr><td>MR/5†</td><td>81.3%</td><td>72.7%</td><td>74.1%</td><td><strong>70.2%</strong></td><td>47.1%</td><td>51.4%</td><td><strong>46.5%</strong></td></tr></tbody></table>

against ensemble diversity defenses such as ADP [16], GAL [13], plain adversarial training (AT) [14] and DVERGE (DV) [24]. The authors made available 3 independent runs of each method (except for BASE), and we report the average accuracy over these 3 independent runs. We also trained a mixture of 5 models using the MRBoost [25] framework, using the ResNet20 and the ResNet18 architectures. All these methods are designed to promote ensemble diversity and reduce the joint adversarial vulnerability of the sub-models, so we consider them appropriate to evaluate the performance of attacks against mixtures. We also take pre-trained models from the BARRE [8] repository<fnref n="5" />, in which authors propose a boosting algorithm to specifically train robust mixtures. All these models use the ResNet20 architecture as the base classifiers, except for MRBoost with ResNet18. We use the $\ell_\infty$ threat model with $\epsilon = 0.03$ as in standard practice, and also the $\epsilon = 0.01$ setting to compare with [24]. More details in Appendix D.

To provide a fair comparison, we adjusted the number of iterations $T$ for each attack to ensure that LCA was not given any advantage. Note that the number

<footnote n="5">⁵ https://github.com/hsndbk4/BARRE/tree/main</footnote>
of gradient computations is $T \cdot m$ for EOL-PGD, at most 4 $T \cdot m$ for ARC [7], and at most $T \cdot \frac{m(m+1)}{2}$ for LCA. In our case $m \in \{3, 5, 8\}$. Taking this into account, we set the number of iterations to 50 for LCA, and gave ARC and EOL-PGD up to 200 and 500 iterations respectively. We also tested ARC and EOL-PGD with fewer iterations, and report only the best result. We further give more advantage to EOL-PGD by allowing it to perform random initialization and 5 restarts. In contrast, ARC and LCA do not use random initialization or restarts.

*Results.* Table 1 shows the results of our evaluation. First, we can confirm the observations made in [7]: EOL-PGD, even with the advantage given, tends to overestimate the robustness of mixtures, and it is more notorious for BASE models with $\epsilon = 0.01$ and DV models. In these cases, ARC dramatically outperforms EOL-PGD (as was seen in [7]), and LCA outperforms both ARC and EOL-PGD. Note however that EOL-PGD is better than both ARC and LCA when models are simultaneously vulnerable and the individual gradients used for the attack are highly aligned [7, 13], which seems to be the case for ADP models. This could be explained by the fact that ADP, contrary to methods like GAL, does not explicitly reduce gradient alignment during training.

GAL models show a peculiar behavior: robustness against EOL-PGD tends to *decrease* as the number of models increases, suggesting that the models become more aligned. A similar behavior was also reported in [24, Table 4], suggesting that this method does not scale well with the number of models. However, robustness against ARC or LCA increases with the number of models. This contrast might suggest that GAL models are indeed more diverse locally, but still simultaneously vulnerable inside the $\epsilon$-ball so that EOL-PGD is able to exploit this vulnerability by naively attacking all classifiers enough times.

For the more robust models (AT, DV+AT, BARRE and MR), LCA shows a clear improvement in performance when compared to both ARC and EOL-PGD. The average gap between LCA and ARC in the $\epsilon = 0.03$ setting is 4.9%, with a minimum gap of 3.8%.

Due to space constraints, we provide in Appendix D extra experiments that test stronger versions of ARC and LCA, discuss the effect of using random orderings and restars for LCA, and more importantly the effect of using ARC or LCA in adversarial training. We observed that the use of ARC or LCA in adversarial training was counterproductive and that EOL-PGD produced mixtures with better robustness. This behavior was also observed in [8], which led the authors to use EOL-PGD in the adversarial training part of BARRE, instead of ARC.

# 6 Conclusions and future work

In this paper, we explore the properties of attacks for randomized mixtures and introduce the LCA algorithm that is *maximal* in the binary linear setting and demonstrates good empirical performances against multiclass differentiable classifiers. Despite employing state-of-the-art diversity inducing techniques, our robustness evaluation confirms that the robustness of mixtures largely depends
on the robustness of individual models, often matching that of a single model (the robustness of a 5-ResNet20 mixture in [8] is similar to the robustness of a single ResNet20 reported in [7] by the same authors), limiting the practical impact of mixtures. This discrepancy between the theoretical advantages of mixtures and their practical robustness underscores the persistent challenge of training robust mixtures. Moreover, adversarial training has limited effectiveness for mixtures, as training with stronger adaptive attacks does not produce more robust models (see Appendix E). New theoretical and practical approaches are needed to improve the training of robust mixtures and fully leverage their potential, a direction that has been started in [8].

**Acknowledgments.** This work was carried out using HPC resources from GENCI-IDRIS (AD011014207 and AD011014207R1), and funded by the French National Research Agency (DELCO ANR-19-CE23-0016). Thanks to the reviewers for the valuable feedback.

**Disclosure of Interests.** The authors have no competing interests to declare that are relevant to the content of this article.

## References

1. Amaldi, E., Kann, V.: The complexity and approximability of finding maximum feasible subsystems of linear relations. Theoretical computer science 147(1-2), 181-210 (1995)

2. Athalye, A., Carlini, N., Wagner, D.: Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In: ICML. pp. 274-283. PMLR (2018)

3. Athalye, A., Engstrom, L., Ilyas, A., Kwok, K.: Synthesizing robust adversarial examples. In: ICML. pp. 284-293. PMLR (2018)

4. Bubeck, S., Lee, Y.T., Price, E., Razenshteyn, I.: Adversarial examples from computational constraints. In: ICML. pp. 831-840. PMLR (2019)

5. Carlini, N., Wagner, D.A.: Towards evaluating the robustness of neural networks. In: Symposium on Security and Privacy. pp. 39-57. IEEE Computer Society (2017)

6. Croce, F., Andriushchenko, M., Sehwag, V., Debenedetti, E., Flammarion, N., Chiang, M., Mittal, P., Hein, M.: Robustbench: a standardized adversarial robustness benchmark. arXiv:2010.09670 (2020)

7. Dbouk, H., Shanbhag, N.: Adversarial vulnerability of randomized ensembles. In: ICML. pp. 4890-4917. PMLR (2022)

8. Dbouk, H., Shanbhag, N.R.: On the robustness of randomized ensembles to adversarial perturbations. arXiv:2302.01375 (2023)

9. Dhillon, G.S., Azizzadenesheli, K., Lipton, Z.C., Bernstein, J., Kossaifi, J., Khanna, A., Anandkumar, A.: Stochastic activation pruning for robust adversarial defense. arXiv:1803.01442 (2018)

10. Goodfellow, I.J., Shlens, J., Szegedy, C.: Explaining and harnessing adversarial examples. arXiv:1412.6572 (2014)

11. Gunopulos, D., Mannila, H., Saluja, S.: Discovering all most specific sentences by randomized algorithms extended abstract. In: Int. Conf. on Database Theory. pp. 215-229. Springer (1997)
12. He, Z., Rakin, A.S., Fan, D.: Parametric noise injection: Trainable randomness to improve deep neural network robustness against adversarial attack. In: CCVPR. pp. 588–597 (2019)

13. Kariyappa, S., Qureshi, M.K.: Improving adversarial robustness of ensembles with diversity training. CoRR abs/1901.09981 (2019)

14. Madry, A., Makelov, A., Schmidt, L., Tsipras, D., Vladu, A.: Towards deep learning models resistant to adversarial attacks. arXiv:1706.06083 (2017)

15. Meunier, L., Scetbon, M., Pinot, R.B., Atif, J., Chevaleyre, Y.: Mixed nash equilibria in the adversarial examples game. In: ICML. pp. 7677–7687. PMLR (2021)

16. Pang, T., Xu, K., Du, C., Chen, N., Zhu, J.: Improving adversarial robustness via promoting ensemble diversity. In: ICML. pp. 4970–4979. PMLR (2019)

17. Panousis, K.P., Chatzis, S., Theodoridis, S.: Stochastic local winner-takes-all networks enable profound adversarial robustness. arXiv:2112.02671 (2021)

18. Perdomo, J.C., Singer, Y.: Robust attacks against multiple classifiers. arXiv:1906.02816 (2019)

19. Pinot, R., Ettedgui, R., Rizk, G., Chevaleyre, Y., Atif, J.: Randomization matters how to defend against strong adversarial attacks. In: ICML. pp. 7717–7727. PMLR (2020)

20. Raff, E., Sylvester, J., Forsyth, S., McLean, M.: Barrage of random transforms for adversarially robust defense. In: CCVPR. pp. 6528–6537 (2019)

21. Sitawarin, C., Golan-Strieb, Z.J., Wagner, D.: Demystifying the adversarial robustness of random transformation defenses. In: ICML. pp. 20232–20252. PMLR (2022)

22. Tramer, F., Carlini, N., Brendel, W., Madry, A.: On adaptive attacks to adversarial example defenses. Neurips 33, 1633–1645 (2020)

23. Xie, C., Wang, J., Zhang, Z., Ren, Z., Yuille, A.L.: Mitigating adversarial effects through randomization. In: ICLR (2018)

24. Yang, H., Zhang, J., Dong, H., Inkawhich, N., Gardner, A., Touchet, A., Wilkes, W., Berry, H., Li, H.: Dverge: diversifying vulnerabilities for enhanced robust generation of ensembles. Neurips 33, 5505–5515 (2020)

25. Zhang, D., Zhang, H., Courville, A., Bengio, Y., Ravikumar, P., Suggala, A.S.: Building robust ensembles via margin boosting. In: ICML. vol. 162, pp. 26669–26692. PMLR (06 2022)
# Supplementary Material

## A Supplementary details

### A.1 Computing the gradients of the EOL and LOE objectives

Here we consider a differentiable surrogate loss function $\mathcal{L}$ like the cross-entropy loss. As in standard practice, we consider deterministic classifiers $h$ built from score functions $f: \mathcal{X} \to \mathbb{R}^K$ using the argmax operator. We abuse notation and write $\mathcal{L}(h, x, y)$ even if the loss depends on the underlying score function $f$. First, the gradient of EOL in (6) can be directly computed due to the linearity of the gradient operator:

$$ \nabla_x \sum_{i=1}^{m} \mathbf{q}^{(i)} \mathcal{L}(h_i, x, y) = \sum_{i=1}^{m} \mathbf{q}^{(i)} \nabla_x \mathcal{L}(h_i, x, y). \quad (13) $$

For the LOE objective, we consider the classifier $h_{\text{avg}}$ built from the average of the scores of the classifiers in the mixture $f_{\text{avg}}(x) = \sum_{i=1}^{m} \mathbf{q}^{(i)} h_i(x)$. The gradient of LOE in (7) is equal to:

$$ \nabla_x \mathcal{L}(h_{\text{avg}}, x, y) = \sum_{i=1}^{m} \gamma_i \nabla_x \mathcal{L}(h_i, x, y), \quad (14) $$

where the coefficients $\gamma_i$ depend on the derivative of $\mathcal{L}$ w.r.t. $x$ and are given by

$$ \gamma_i = \frac{\mathbf{q}^{(i)} \cdot \mathcal{L}'(h_{\text{avg}}, x, y)}{\mathcal{L}'(h_i, x, y)}. \quad (15) $$
## A.2 Example of adversarial lattice and different configurations

<figure><img src="image_8.png" /><figcaption>Fig. 6: Four possible configurations for a mixture with two classifiers $h_1$ and $h_2$ assuming $x$ is correctly classified by both. a) Both $h_1$ and $h_2$ are non-vulnerable, the mixture is robust. b) Only one classifier is vulnerable. c) Both $h_1$ and $h_2$ are vulnerable, but they can not be attacked simultaneously. d) Both $h_1$ and $h_2$ are vulnerable, and they can be attacked on the same region. Best viewed in color.</figcaption></figure>

<figure><img src="image_9.png" /><figcaption>Fig. 7: Examples of adversarial lattice for two of the configurations described in Figure 6. Best viewed in color.</figcaption></figure>
### A.3 LCA algorithm for multiclass differentiable classifiers

<caption>**Algorithm 2:** LCA for multiclass classifiers</caption>

**Require:** Set of $m$ classifiers $h$ in some order $(h_1, \dots, h_m)$. Starting point $(x, y)$. $T$ number of iterations and $\eta$ step size for PGD.
1: Initialize pool $h_{\text{pool}} = \emptyset, \delta = 0$
2: **for** $i = 1, 2, \dots, m$ **do**
3: &nbsp;&nbsp;&nbsp;&nbsp;**h**_{pool} = h_{pool} \cup \{h_i\}
4: &nbsp;&nbsp;&nbsp;&nbsp;Attack SRH(h_{pool}, \cdot, y) starting at $x + \delta$ with PGD $(T, \eta)$ to find new perturbation $\delta$
5: &nbsp;&nbsp;&nbsp;&nbsp;**if** $\mathcal{L}^{0-1}(h_q, x + \delta, y) > \mathcal{L}^{0-1}(h_q, x + \delta, y)$ **then**
6: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$$ \delta = \delta $$
7: &nbsp;&nbsp;&nbsp;&nbsp;Recompute pool h_{pool} according to current $\delta$
8: **return** $x + \delta$

## B Proofs

### B.1 Proof of Theorem 1

**Theorem 1 (Hardness of attacking linear classifiers).** Consider a binary classification setting, $\ell_p$ norm with $p > 1$ and $\epsilon$ to be defined. Given a labeled point $(x, y)$, a set of $m$ linear classifiers $x \mapsto 1\{\theta_i^\top x + b_i \ge 0\}$ where $(\theta_i, b_i) \in \mathbb{R}^{d+1}$, a uniform mixture $h_q$ composed of these linear classifiers and a value $\beta > 0$, there exists a noise budget $\epsilon > 0$ such that the problem of checking if there exists $x' \in B_p(x, \epsilon)$ such that $\mathcal{L}^{0-1}(h_q, x', y) \ge \beta$ is NP-hard.

*Proof.* To show NP-hardness of our problem, we will use a reduction involving the NP-hard MaxFLS [1] problem defined as follows:

- **Input of MaxFLS:** A set of $m$ pairs $\{(\theta_i, b_i)\}_{i=1}^m$ where $\theta_i \in \mathbb{R}^d$ and $b_i \in \mathbb{R}$, and a value $\alpha > 0$

- **Output of MaxFLS:** Yes if there exists a vector $\delta \in \mathbb{R}^d$ such that at least a fraction $\alpha$ of inequalities among the set $\{\delta^\top \theta_i + b_i \ge 0 : i \in [m]\}$ are satisfied

Let us consider an instance $((\theta_i, b_i))_{i=1}^m, \alpha$) of MaxFLS. The set $((\theta_i, b_i))_{i=1}^m$ defines an arrangement of hyper-planes in $\mathbb{R}^d$ which can be thought as linear classifiers, and this arrangement partitions the space $\mathbb{R}^d$ into regions. Let $x = 0$. Clearly, we can always find a value $\epsilon$ such that each region has a non-empty intersection with the ball $B_p(x, \epsilon)$. Let $y = 0$ and $q = (\frac{1}{m} \dots \frac{1}{m})$, and define $h_q$ as the mixture of the following binary classifiers

$$ h_i(x) = 1 \{ \theta_i^\top x + b_i \ge 0 \}, \text{ for } i \in [m], $$
with weights $\mathbf{q}$. Then, $\mathcal{L}^{0-1}(\mathbf{h}_{\mathbf{q}}, x + \delta, y) = \frac{1}{m} \sum_{i \in [m]} 1\{\delta^{\top}\theta_i + b_i \ge 0\}$. Clearly, the value $\mathcal{L}^{0-1}(\mathbf{h}_{\mathbf{q}}, x + \delta, y)$ is equal to the fraction of satisfied inequalities among the set $\{\delta^{\top}\theta_i + b_i \ge 0 : i \in [m]\}$. Thus, $\mathcal{L}^{0-1}(\mathbf{h}_{\mathbf{q}}, x + \delta, y) \ge \alpha$ if and only if at least an $\alpha$ proportion of inequalities in MaxFLS are satisfied. Thus, if a polynomial time algorithm was able to solve the problem of finding an optimal adversarial attack for a mixture, we could also use it to solve the MaxFLS problem in polynomial time, which is a contradiction, as MaxFLS is NP-hard [1]. Thus, our problem is also NP-hard.

## B.2 Proof of Lemma 1

**Lemma 1.** Consider a set of $m$ binary linear classifiers $\mathbf{h}$. Fix $\epsilon > 0$ the attack budget and a point $(x, y)$. If there exists a point $x' \in B_p(x, \epsilon)$ such that $\text{SRH}(\mathbf{h}, x', y) = 0$, then there exist parameters $T$ and $\eta$ such that minimizing $\text{SRH}(\mathbf{h}, x, y)$ w.r.t. $x$ with PGD($T, \eta$) will return $x''$ such that $\text{SRH}(\mathbf{h}, x'', y) = 0$.

*Proof.* (See [18, Appendix F])

Note that the hypothesis that there exists $x'$ adversarial to all $h \in \mathbf{h}$ means that $\text{SRH}(\mathbf{h}, x', y) = 0$. This is a global minimum, as SRH is a non-negative function. Also note that SRH as a function of $x$ can only take a finite number of values, the smallest positive one being $\frac{1}{m}$. Applying [18, Theorem 3] with $\delta < \frac{1}{m}$, we conclude that running PGD for $T > \epsilon^2 \cdot m^2$ steps with step size $\eta = \frac{\epsilon}{\sqrt{T}}$ returns a solution $x''$ such that

$$ \text{SRH}(\mathbf{h}, x'', y) - \text{SRH}(\mathbf{h}, x', y) = \text{SRH}(\mathbf{h}, x'', y) < \frac{1}{m}. $$

This implies that $\text{SRH}(\mathbf{h}, x'', y) = 0$.

Note that in the actual implementation of LCA (Algorithm 1), we will perform PGD multiple times with a subset of models that can be of size at most $m$. That means that we can take $T > \epsilon^2 \cdot m^2$ and $\eta < \frac{\epsilon}{\sqrt{T}}$, and these parameters would work for all the PGD runs during the whole execution of the algorithm.

## B.3 Proof of Theorem 2

**Theorem 2 (LCA is maximal in the binary linear setting).** Let $\mathbf{h}$ be a finite set of binary linear classifiers and $\mathbf{h}_{\mathbf{q}}$ a mixture over $\mathbf{h}$. Fix $\epsilon > 0$ the attack budget and a $p$-norm with $p > 1$. For any $(x, y) \in \mathbb{R}^d \times \{-1, 1\}$, there exist parameters $T$ and $\eta$ for the inner PGD such that Algorithm 1 returns an adversarial example $x + \delta \in \text{CV}(\mathbf{h}')$, where $\mathbf{h}'$ is a maximal element of the adversarial lattice of $\mathbf{h}_{\mathbf{q}}$ at $(x, y)$.

*Proof.* Choose parameters $T$ and $\eta$ such that Lemma 1 holds.

Denote $\mathbf{h}_i$ the pool of fooled classifiers at each step $i$ of the $m$ steps in the outer loop of Algorithm 1, and $x_i$ the adversarial attack at each step $i$. By construction, $\mathbf{h}_i \subseteq \mathbf{h}_{i+1}$, $\mathbf{h}_0 = \emptyset$ and $\mathbf{h}_m$ is the final pool of classifiers fooled by $x_m$, the output of Algorithm 1.
Suppose by contradiction that Algorithm 1 returns $x_m$ that attacks a subset of classifiers $\mathbf{h}_m$ that is not maximal in the adversarial lattice of $\mathbf{h}_q$ at $(x, y)$.

By definition of maximality, this means there exists some classifier $h' \in \mathbf{h} \setminus \mathbf{h}_m$ such that $\mathrm{CV}(\mathbf{h}_m \cup \{h'\}) \neq \emptyset$.

Let $j$ be the step at which $h'$ was considered. At step $j-1$ of the algorithm, the pool $\mathbf{h}_{j-1}$ consists of classifiers that are all vulnerable. Given that $\mathbf{h}_{j-1} \cup \{h'\} \subset \mathbf{h}_m \cup \{h'\}$, we have that $\mathrm{CV}(\mathbf{h}_{j-1} \cup \{h'\}) \supset \mathrm{CV}(\mathbf{h}_m \cup \{h'\}) \neq \emptyset$.

As $\mathrm{CV}(\mathbf{h}_{j-1} \cup \{h'\}) \neq \emptyset$, at step $j$, Lemma 1 ensures that the PGD step for attacking the pool of classifiers $\mathbf{h}_{j-1} \cup \{h'\}$ returns $x_j$ such that

$$ \mathrm{SRH}(\mathbf{h}_{j-1} \cup \{h'\}, x_j, y) = 0, $$

meaning that $h'$ would be added to the pool, i.e $\mathbf{h}_j = \mathbf{h}_{j-1} \cup \{h'\}$. This implies that $h' \in \mathbf{h}_m$, which is a contradiction.

This contradiction arises from supposing that $\mathrm{CV}(\mathbf{h}_m)$ was not maximal, which concludes the proof.

## C Synthetic experiments

In this section we provide more details on the synthetic experiments presented in Section 5.1. The first experiment is the one in $\mathbb{R}^2$ with two classifiers that produced Figure 3 in which we vary the angle between the normal vectors of the two linear classifiers and leave their distance to the center point fixed. The second experiment is the one in which we sample $m$ linear models in $\mathbb{R}^d$ with different values for the dimension $d$, and the linear classifiers are sampled with different distances to the center point.

### C.1 ARC and EOL-PGD against two classifiers in the plane at the same distance from the origin

These are the parameters used for the experiment that produced 3. The LCA parameters are

- Norm: $\ell_2$.

- Attack budget $\epsilon$: 1.

- Number of steps $T$ for EOL-PGD: 100.

ARC in the binary linear setting has no parameters to tune.

### C.2 LCA, EOL-PGD and ARC with different number of classifiers with respect to the distribution of the bias of the linear classifiers

We tested EOL-PGD, ARC and LCA against randomly sampled mixtures of different sizes. To control the difficulty of the setting, we introduced the parameters $\alpha$ and $\beta$, which control the average and the variance of the distance from the
center point $x$ to the decision boundaries of the linear classifiers, respectively. Figures 8, 9 and 10 are similar to Figure 5 in the main text but with other values of $\alpha$ and $\beta$, where it can be seen that the hardness of crafting an attack can change drastically depending on the configuration of the classifiers around the point. Recall that $\alpha$ is the average distance from the center point to the decision boundaries, and $\beta$ is the variance of the distances. In all cases, note that the $y$-axis values are not the same, and have been adapted for visual purposes.

<figure><img src="image_10.png" /><figcaption>Fig. 8: Biases sampled from $\mathcal{N}(0.25, 0.05)$. Classifiers are very close to the center point (low $\alpha$), and they are almost all at the same distance (low $\beta$). In this particular case LCA performs very well, being almost always optimal. EOL-PGD also performs really well up to 6 models, which means that until that point, almost all linear classifiers are well aligned, and the common vulnerability region can be found by attacking the average loss. ARC on the other hand degrades sharply as the number of models increases.</figcaption></figure>

In order to check that LCA was performing better than ARC and EOL-PGD, we computed the average over 100 runs of the ratio between the score obtained by each attack and the score that LCA obtained in the same configuration. Figure 11 shows the evolution of such ratio with respect to the number of models. The colored area around the lines corresponds to a 99% confidence interval for the average ratio. We can see that LCA is superior by a rate that tends to stabilize as the number of models increase.

Here are the parameters used for all these experiments:

**General parameters:**

- Norm (threat model): $\ell_2$.

- Attack budget $\epsilon$: 1.
<figure><img src="image_11.png" /><figcaption>Fig. 9: Biases sampled from $|\mathcal{N}(0.25, 0.2)|$. Classifiers are on average very close to the point but with a higher variance in their distance.</figcaption></figure>

<figure><img src="image_12.png" /><figcaption>Fig. 10: Biases sampled from $|\mathcal{N}(0.75, 0.2)|$. This configuration is hard because classifiers are close to the boundary of the $\epsilon$-ball (far from $x$), and the probability of intersection is less than in the cases seen before. LCA is on average superior, but the gap between LCA, ARC and EOL-PGD is smaller.</figcaption></figure>

- ARC for linear classifiers has no extra parameters. That is why it is extremely fast compared to EOL-PGD and LCA.

- ` numpy seed ` was set to 42

- Weights $\mathbf{q}^{(i)}$ of each random mixture were also sampled randomly as follows:

• Sample $m$ i.i.d standard normal values $z_i$.
<figure><img src="image_13.png" /><figcaption>Fig. 11: Ratios for different values of $\alpha$ and $\beta$. y-axis are adapted for visual purposes.</figcaption></figure>

* Compute the softmax with temperature $t = 10$, i.e $\mathbf{q}^{(i)} = \frac{\exp(z_i/10)}{\sum_j \exp(z_j/10)}$.

**Parameters for LCA:**

- Number of steps $T$ for inner PDG: $\max(2 \cdot m^2, 200)$.

- Step size $\eta$ for inner PDG: $\frac{\epsilon}{\sqrt{T}}$.

**Parameters for EOL-PGD:**

- Number of steps $T$ for inner PDG: $\max(2 \cdot m^2, 200)$.

- Step size $\eta$ for inner PDG: $\frac{\epsilon}{\sqrt{T}}$.

# D CIFAR-10 experiments

## D.1 Main results

For the experiments with the pre-trained models available in the DVERGE repository$^6$, we attacked the models with different versions of EOL-PGD, ARC and LCA, trying to cover a reasonable range of hyperparameters for all attacks such as the step size $\eta$ and the number of iterations $T$. For the number of iterations, we tested 50, 100 and 500 for EOL-PGD, and 50, 100 and 200 for ARC. LCA was only tested with 50, to avoid making an unfair comparison. We tested LCA with a constant step size, and also with a changing step size that is divided by 2 at the iteration 40. The best results were used for the results in Table 1.

Here is a summary of the parameters used for the main results in Table 1:

**General parameters:**

- Norm: $\ell_\infty$.

- Attack budget $\epsilon$: 0.01 or 0.03.

<footnote>$^6$ https://github.com/zjysteven/DVERGE/tree/main</footnote>
### Parameters for LCA:

- Number of steps *T* for inner PDG: 50.

- Step size $\eta$ for inner PDG:

* For $\epsilon = 0.01$: 0.0005, 0.001, 0.002

* For $\epsilon = 0.03$: 0.0015, 0.003, 0.006

### Parameters for EOL-PGD:

- Number of steps *T*: 50, 100 and 500.

- Step size $\eta$:

* For $\epsilon = 0.01$: 0.0015, 0.002, 0.006

* For $\epsilon = 0.03$: 0.0015, 0.006

### Parameters for ARC:

- Number of steps *T*: 50, 100, 200.

- Step size $\eta$:

* For $\epsilon = 0.01$: 0.0005, 0.001, 0.002, 0.006

* For $\epsilon = 0.03$: 0.0015, 0.003, 0.006

## D.2 Comparing strong versions of the attacks

We wanted to make sure that the gap between EOL-PGD, ARC and LCA was not influenced by the simple setting we considered for the main experiments in Table 1. We also wanted to test stronger versions of LCA to evaluate the possibility of further improvement.

Firstly, we launched stronger versions of both ARC and LCA against the model DV+AT/5 in the $\epsilon = 0.03$ setting. We added random initialization and 5 restarts to both attacks, and tested with $T \in \{50, 100, 250\}$. For LCA, we also tested dividing the step size of the inner PGD by 2 at iterations $\frac{T}{2}$ and $\frac{3T}{4}$.

From all the different evaluations, we report the lowest robust accuracy (strongest attack) and compare it to the results obtained in Table 1.

<table><caption>Table 2: Mixture robustness evaluation of DV+AT/5 against stronger versions of ARC and LCA.</caption><thead><tr><td>Attack</td><td>From Table 1</td><td>Stronger</td></tr></thead><tbody><tr><td>ARC</td><td>44.6%</td><td>43.6%</td></tr><tr><td>LCA</td><td>39.9%</td><td>36.5%</td></tr></tbody></table>

Including random initialization and restarts only changed the results for ARC by 1% with respect to the results shown in Table 1. On the other hand, LCA
improved by 3.4%, showing that the robustness evaluation of LCA could further improve with more hyperparameter tuning.

Secondly, we performed a more particular experiment varying only the number of iterations, similar to a convergence check when verifying that a proposed defense is not overestimating the reported robustness due to the non-convergence of the attack [22]. Again, we used the model DV+AT/5 in the $\epsilon = 0.03$ setting. We set the step size to 0.006 for all attacks, no random initialization, and LCA was tested with and without the reducing step size at iterations $\frac{T}{2}$ and $\frac{3T}{4}$ by half.

It can be seen that further increasing the number of iterations up to 1000 does not reduce the robustness evaluation of EOL-PGD or ARC by more than 0.2%. On the other hand, for this fixed setting, LCA with the reducing step size obtains an improvement of 0.8%, suggesting again that the reasonable version of LCA that we used for the main results, that already beats EOL-PGD and ARC, can still be enhanced.

<table><caption>Table 3: Convergence check. Robustness evaluation with an increasing number of iterations. LCA† corresponds to the version of LCA with the reducing step size.</caption><thead><tr><th rowspan="2">Attack</th><th colspan="3">T</th></tr><tr><th>100</th><th>500</th><th>1000</th></tr></thead><tbody><tr><td>EOL</td><td>42.0%</td><td>41.9%</td><td>41.9%</td></tr><tr><td>ARC</td><td>44.1%</td><td>44.0%</td><td>43.9%</td></tr><tr><td>LCA</td><td>38.5%</td><td>38.0%</td><td>38.0%</td></tr><tr><td>LCA<sup>†</sup></td><td>38.5%</td><td>37.9%</td><td>37.7%</td></tr></tbody></table>

*Optimality gap: the impact of the number of restarts.* Given that PGD has no optimality guarantee in the case of general multiclass differentiable classifiers, we cannot compute the real optimality gap of LCA. We can, however, compare LCA against a much stronger version of it that tries all the possible orderings of classifiers to perform the lattice climb. Recall that the ordering in which the classifiers are considered determines the path that is used to climb the lattice, and thus the maximal region that is attained. In practice, this ordering is even more important for Algorithm 2, in which the pool of classifiers is adapted depending on the score, and can therefore change in a non-increasing manner.

To have a better understanding of the limits of LCA, we launched LCA with different numbers of random restarts, ranging from 1 (normal LCA) to 10, which means that 10 different random orderings are tested, and at the end of each ordering, only the best perturbation is kept in a greedy way. As an optimality baseline, we launched a brute-force version of LCA, denoted LCA<sub>all</sub>,
that tests all the possible orderings and keeps, at each time, the best perturbation. We used the same mixtures from Table 1, but only for the models AT/5, DV+AT/5, BARRE/5 and MR/5 that showed a good level of robustness. As all these mixtures have 5 sub-models, there is a total of 120 possible orderings tested by $LCA_{all}$.

<figure><img src="image_14.png" /><figcaption>Fig. 12: Impact of restarts in the performance of LCA. The curves show the ratio of the accuracy after attack by LCA and the brute force $LCA_{all}$ (lower the better), averaged over 20 runs with different seeds. Colored regions represent three standard deviations from the average. Best viewed in color.</figcaption></figure>

Figure 12 shows the ratio of the robust accuracy obtained by LCA and $LCA_{all}$ as a function of the number of restarts. The reported values are the average over 20 different seeds, and the shaded region around each curve represents three standard deviations from the mean. It can be seen that with 10 restarts, the ratio between LCA and $LCA_{all}$ is of at most 1% which translates to an absolute accuracy gap of at most 0.38% for the model AT/5 that has the highest gap. This experiment also shows that if more computation time is available to afford random restarts, LCA can improve even further with respect to the main results shown in Table 1 where it was already superior to ARC and EOL-PGD. In our experiment, with 5 restarts for models AT/5 and DV+AT/5, LCA can decrease the accuracy by an extra 2% with respect to the baseline without restarts. For the models MR/5 and BARRE/5, the improvement is of 1%. Note that all the other parameters for LCA were left unchanged from the settings used for the main results (50 iterations for the inner PGD, no random initialization of the perturbation).
## E On adversarial training for mixtures of classifiers

A natural second step, after proposing an attack, is to see if it is beneficial for adversarial training. Our standard training for mixtures optimizes the sum of losses, which makes the training independent even if models are trained at the same time (not sequentially like in [8]). To add dependence, we test a vanilla adversarial training with a mixture attack: the attack is crafted for the mixture, which breaks the independence in the training process.

We tested adversarial training with EOL-PGD, ARC, LCA and vanilla PGD on the ensemble that averages logits, in CIFAR-10, with different architectures for our sub-models. We tested with very small convolutional networks (CNN), with the ResNet20 models used in the experiments in Table 1, and also with a bigger ResNet110. All these experiments were carried out with a different threat model ($\ell_2$ with $\epsilon = 0.5$), so they are not comparable to the results in Table 1.

<table><caption>Table 4: Clean and robust accuracy of mixtures with different base models. Mixtures have been trained with adversarial training using different attacks during training under the $\ell_2$ threat model with $\epsilon = 0.5$ as in standard practice. Higher is better (more robust). Robust accuracy reported is the minimum expected accuracy under any of the tested attacks (EOL-PGD, ARC, LCA, LOE-AutoAttack and LOE-PGD).</caption><thead><tr><th>Model</th><th>Attack for AT</th><th>Natural</th><th>Robust</th></tr></thead><tbody><tr><td rowspan="3">CNN</td><td>EOL-PGD</td><td>59.9%</td><td>34.1%</td></tr><tr><td>LOE-PGD</td><td>61.8%</td><td>32.8%</td></tr><tr><td>LCA</td><td>64.0%</td><td>27.2%</td></tr><tr><td rowspan="4">ResNet20</td><td>EOL-PGD</td><td>81.2%</td><td>50.0%</td></tr><tr><td>LOE-PGD</td><td>81.5%</td><td>43.4%</td></tr><tr><td>LCA</td><td>83.1%</td><td>49.6%</td></tr><tr><td>ARC</td><td>84.5%</td><td>46.5%</td></tr><tr><td rowspan="3">ResNet110</td><td>EOL-PGD</td><td>77.8%</td><td>47.2%</td></tr><tr><td>LOE-PGD</td><td>78.2%</td><td>40.6%</td></tr><tr><td>LCA</td><td>80.7%</td><td>46.3%</td></tr></tbody></table>

We can see that, as has already been noted in the seminal paper [14], models with very low capacity are less able to learn when faced with more complex and stronger attacks. In the case of the CNN, training with EOL-PGD produces models with an individual robustness similar to what independent adversarial training would produce. On the other hand, training with LCA produces models with drastically less robustness. This was noted for all the tested versions of
LCA (from 5 to 30 iterations, and various step sizes) and even with different mixtures sizes.

When the capacity is increased, the performance of AT with EOL-PGD and LCA becomes almost on par. It is intriguing that AT with ARC and LCA yields models with higher standard accuracy. We expected the opposite, considering that LCA and ARC are supposed to be stronger attacks against mixtures. This behavior led the authors in [8] to use EOL-PGD for their training method, BARRE, instead of ARC.

The problem of training a mixture that increases the robustness with respect to the best individual sub-model remains open and is an interesting track for future work.