Adversaries With Incentives: A Strategic Alternative to Adversarial Robustness

## Abstract

Abstract Adversarial training aims to defend against adversaries :
malicious opponents whose sole aim is to harm predictive performance in any way possible—a rather harsh perspective, which we assert
results in unnecessarily conservative models.
Instead, we
propose to model opponents as simply
pursuing their own goals,
rather than working directly against the classifier.
Employing tools from strategic modeling,
our approach uses knowledge or beliefs regarding
the opponent’s possible incentives as inductive bias for learning.
Our method of strategic training is designed to defend against opponents within an ‘incentive uncertainty set’:
this resorts to adversarial learning when the set is maximal,
but offers potential gains when it can be appropriately reduced.
We conduct a series of experiments that show how even mild knowledge regarding the adversary’s incentives can be useful,
and that the degree of potential gains depends on how incentives relate to the structure of the learning task.

## 1 Introduction

The goal of adversarial learning is to train classifiers that are robust to adversarial attacks, defined as small input perturbations crafted to fool the classifier into making erroneous predictions [, ].
As its name suggests, adversarial learning seeks to defend against an *adversary*—an ominous opponent whose actions are intended to induce maximal harm to the classifier’s performance. Learning in this setting can therefore be modeled as a zero-sum game between the learner and the adversary, in which each player’s gain translates to an equivalent loss for the other.
This lends to formulating adversarial training as a
minimax optimization problem in which the learner (min) controls model parameters, and the adversary (max)
controls bounded-norm additive noise terms that are applied to inputs [].

Since learning seeks to make correct predictions,
adversaries are modeled as gaining from predictive errors of any type.
This gives an adversary much flexibility: while there is typically only a single (or perhaps a few) correct labels, most labels are wrong.
Thus, to obtain robustness, learning must defend simultaneously against all attacks targeting any incorrect label.
And while this approach can in principle provide a high degree of protection,
it does so by placing demanding restrictions on the learning objective,
whether explicitly or implicitly [].
This makes robustness attainable—but at a cost;
for example, it is well-known that adversarially trained models suffer from
deteriorated generalization [, ] and reduced performance on clean (i.e., non-adversarial) data [].

In this paper, we argue that such costs can potentially be reduced by injecting into the learning objective a notion of the opponent’s incentives, i.e., what the opponent *wants*—which we propose to use as inductive bias. Notice that while conventional adversarial training considers the prospective harm of an attack,
it lacks to consider the possible motives behind it:
the fact that a panda *can* be turned into a gibbon
does not provide grounds for why (nor whether) an opponent would wish to do so.
Alternatively,
our working assumption is that realistic opponents are much more likely to simply promote their own self-interests,
rather than to always and purposefully counter those of learning—as is assumed in adversarial training.
Thus, if we have some beliefs or knowledge regarding
the opponent’s interests, even if quite general,
then this can and should be exploited to improve prediction.

As an example, consider a malicious opponent who wishes to disrupt traffic by manipulating road signs. Adversarial training, which assumes that attack targets can be arbitrary, will invest effort in protecting against all possible transformations.
But note there is structure to the opponent’s incentives:
for example,
the opponent has
more to gain from mapping a ‘speed limit 90’ to a stop sign than to a similar speed limit;
should prefer ‘no motor vehicles’ over ‘no motorcycles’ since it is more restrictive
(though visually similar);
will benefit from ‘no U-turn’ only if a left turn is possible;
and should be indifferent at a T-intersection between ‘no turn left’ and ‘must turn right’ since they entail the same outcomes.
If such preferences are encoded into the learning objective,
then training can focus on protecting against viable attacks,
while avoiding the unnecessary costs of defending against irrelevant ones.

Borrowing from the literature on strategic classification [, , , ],
our approach is to model the opponent as a strategic agent whose actions are intended to maximize its own utility (rather than to generally minimize accuracy),
this lending to a non-zero sum game formulation.
We focus on utilities that depend on prediction outcomes, meaning that the opponents we consider have preferences regarding *which* predictive errors are made.
Given an uncertainty set of possible utilities for the opponent (or a distribution over such)
which are believed to be plausible for the task at hand,
our goal will be to defend against the worst-case opponent in this set,
a notion which we refer to as *strategic robustness*.

Figure: Figure 1: Strategic opponents benefit only from certain types of attacks, such as preserving label categories (semantic), changing labels drastically (anti-semantic), or mapping each class to a specific target (1-hot). As such, they offer a flexible middle ground between fully adversarial and clean settings. Our *strategic training* approach enables to encode prior knowledge regarding the opponent’s possible incentives into the learning objective, this ensuring that training defends only against viable targets.
Refer to caption: x1.png

Our first observation is that standard adversarial training conforms to learning under the largest
possible set which includes all strategic opponents—i.e., seeks robustness to ‘everything’.
This provides a novel utilitarian
interpretation of the sense in which adversarial learning is worst-case.
Based on this, our key modeling point is that
prior knowledge regarding the opponent’s possible incentives
can be used to reduce this large set.
Since a smaller set means less to defend against, this has potential for reducing the unnecessary costs due to over-conservativeness.
And since an empty set means no incentives and hence recovers the clean setting,
strategic modeling enables a continuum of learning settings that interpolate between clean and adversarial,
and thus provides the flexibility to extend beyond these two extremes.
Our goal is to initiate the study of robust learning in these more nuanced cases.

Towards this, we propose an approach for learning strategically-robust classifiers,
which we refer to as *strategic training*.
Our method builds on standard techniques from adversarial training and adapts them to handle strategic opponents with unknown utilities.
Focusing on a large class of *multi-targeted* strategic opponents,
we propose an implementation of such attacks that permit efficient training.
The key challenge is that different uncertainty sets require different procedures;
here we show that several natural families of strategic opponents admit simple and effective solutions.
These include:
(i) opponents who wish to preserve label semantics;
(ii) opponents who benefit only from drastic label changes;
and (iii) pre-specified targeted attacks.
These are illustrated in Fig. 1, which shows how such strategic opponents lie between the adversarial and clean settings.

To demonstrate the effectiveness of our approach,
we perform a thorough empirical evaluation
using multiple datasets and architectures and in various strategic settings.
We begin by showing that adversarial training is suboptimal against strategic opponents,
and analyze its weaknesses.
We then show the merits of strategic training against known opponents,
and study the risks of learning under misspecified incentives.
Our main insight here is that the degree to which strategic training is useful depends on the relation between the structure of the opponent’s incentives and the structure of the learning task;
for example, whether the opponent gains from *semantic attacks*
(e.g., $\mathrm{dog}\mapsto\mathrm{cat}$) or from *anti-semantic attacks*
(e.g., $\mathrm{dog}\mapsto\mathrm{truck}$).
This motivates our analysis of learning under several natural strategic opponent classes,
where despite their large uncertainty,
the structure of incentives permits effective training.
Results show that strategic training is much more effective against strategic opponents than adversarial training,
while generally maintaining better clean accuracy.
Code is available at [https://github.com/maayango285/Adversaries-With-Incentives](https://github.com/maayango285/Adversaries-With-Incentives).

## 2 Related work

#### Adversarial learning.

Adversarial examples are maliciously crafted inputs designed to make classifiers err.
Amounting evidence suggests that imperceptible (but carefully chosen) noise suffices to cause missclasification [, ].
The process of constructing adversarial examples is termed an ‘adversarial attack’, and many such methods have been developed
[, , , ].
Given the high susceptibility of neural networks to such attacks,
there has been much interest in developing learning methods that provide adversarial robustness.
One popular approach, and our focus herein,
is *adversarial training* [, ],
which modifies the training objective to include adversarial examples instead of raw ones.
Adversarial training has been shown to be effective in improving adversarial accuracy;
however, evidence suggests that a persistent trade off exists between robustness and accuracy on clean inputs [].
Despite new insights []
and recent advances [, ],
this remains to be a major weakness.

#### Strategic classification.

Our work draws inspiration from the fast-growing literature on strategic classification
[, , ].
Works in this field have studied both theoretical
[, ]
and practical
[, ]
aspects of learning under strategic behavior, as well as broader notions such as
transparency and information asymmetry
[, , , , ],
social implications
[, , , , ],
and causality
[, , , ],
among others (see []).
Strategic classification studies learning in a setting where users can ‘game’ the system by modifying their features, at a cost, to obtain favorable predictions.
Motivated by tasks such as loan approval, job hiring, college admissions, and welfare benefits,
standard strategic classification
considers binary tasks in which positive predictions (${\hat{y}}=1$) are globally better for users than negative (${\hat{y}}=0$).
Hence, since all users wish to obtain ${\hat{y}}=1$, negative users ($y=0$) act ‘against’ the system, whereas positive users ($y=1$) are cooperative.
Several works consider a more generalized setting in which all users can be adversarial-like [, ],
but are still restricted to binary labels.
To the best of our knowledge, our work is the first to consider strategic behavior in a multiclass setting,
which enables us to establish a more deeper connection between strategic and adversarial learning.

#### Types of robustness.

Many subfields within machine learning are concerned with providing worst-case robustness. These include
robust statistics (e.g., []),
distributionally robust optimization (e.g., [])
and adversarial learning—all of which rely heavily on minimax formulations.
In adversarial learning, some efforts have been made to promote the less restrictive notion of average-case robustness by replacing the max with an expectation over a prior [, ].
The idea to replace an adversarial opponent with a strategic (or rational) one has been considered to some extent in the domain of cryptographic proof systems []. Within learning, the only work we are familiar with which discusses a possible gap between worst-case and strategic guarantees is
[] who study no-regret learning in games.
Our work proposes a strategic interpretation of worst-case robustness,
achieved by modeling uncertainty as being over a set of strategic opponents.
This draws a connection to the recent work of []
who study minimax optimization in standard strategic classification
under uncertainty in user costs.

## 3 Preliminaries

Let $x\in\mathbb{R}^{d}$ denote inputs and $y\in[K]$ denote categorical labels.
We follow the conventional setup of supervised learning and assume input-label pairs $(x,y)$ are sampled iid from some unknown joint distribution $D$.
Given a model class $F$, the standard goal in learning is to find some $f\in F$
that maximizes expected accuracy.
For the 0-1 loss defined as $\ell(y,{\hat{y}})=\mathds{1}{\{{y\neq{\hat{y}}}\}}$,
this amounts to solving:

$$ $\operatorname*{argmin}\nolimits_{f\in F}\mathbbm{E}{[{\ell(y,f(x))}]}$ (1) $$

In the adversarial setting, learning must contend with an adversary that can
manipulate each input $x$ by adding a small adversarial ‘noise’ term $\delta$, chosen to maximally degrade accuracy.
Given a feasible attack range $\Delta$ (e.g., some norm ball),
the goal in learning
becomes to solve the robust objective:

$$ $\operatorname*{argmin}\nolimits_{f\in F}\mathbbm{E}{[{\max_{\delta\in\Delta} \ell(y,f(x+\delta))}]}$ (2) $$

This models learning as a zero-sum game between the learner, who aims to minimize the loss, and an adversarial opponent who wishes to maximize it.
We will make use of the equivalent formulation:

$$ $\operatorname*{argmin}\nolimits_{f\in F}\mathbbm{E}{[{\ell(y,f(x+\delta^{ \mathrm{adv}}))}]},\qquad\delta^{\mathrm{adv}}=\operatorname*{argmax}\nolimits _{\delta\in\Delta}\,\ell(y,f(x+\delta))$ (3) $$

in which the attack $\delta^{\mathrm{adv}}$ is made explicit.
This is the formulation that is typically optimized in practice (e.g., as in PGD []), often with replacing $\ell$ with a differentiable surrogate loss (e.g., cross-entropy).
We refer to the expected error term in Eq. (1) as *clean error*
and in Eq. (2) as *adversarial error*,
and similarly define clean and adversarial accuracy.

### 3.1 Learning against strategic opponents

At the heart of our approach lies the idea that attacks are the product of strategic behavior.
We define a *strategic opponent* as an agent who attacks inputs in order to maximize its own utility, this given by a *utility function* $u$.
To remain consistent with the adversarial setting,
we restrict our attention to utilities that depend on prediction outcomes,
i.e., are of the form $u(y,{\hat{y}})$.
For convenience, we will sometimes think of these as matrices of size $K\times K$
with entries $u_{yy^{\prime}}=u(y,y^{\prime})$.
Given a strategic opponent with utility $u$,
a *strategic attack* (or response)
against the classifier $f$ on input $x$
is defined as:

$$ $\delta_{u}=\operatorname*{argmax}\nolimits_{\delta\in\Delta}\,u(y,f(x+\delta))$ (4) $$

Thus, strategic opponents have the same capacity as adversarial opponents,
but admit flexible objectives.
Our goal in learning will be to defend against such attacks,
a notion we term *strategic robustness*.

Figure: Figure 2: Utility matrices for different targeted strategic opponents, matching those from Fig. 1.
Refer to caption: x2.png

#### Multi-targeted strategic attacks.

The strategic opponents we will focus on in this paper are based on the common notion of *targeted attacks*, but considered from a novel utilitarian perspective.(^1^11Targeted attacks are typically employed *post-hoc* to demonstrate susceptibility to attacks against any arbitrary target. In contrast, we consider strategic opponents with *a-priori* preferences regarding the possible targets.)
Given a target class ${\bar{y}}\in[K]$, a targeted attack on $x$ is any $\delta\in\Delta$ that gives $f(x+\delta)={\bar{y}}$.
Define a *(multi)-targeted strategic opponent* as one which gains utility from an attack only if it succeeds in flipping predictions to particular, label-dependent target(s).
This captures settings such as our road signs example in which for each object of label $y$,
only a subset of target classes ${\bar{y}}$ are beneficial.
Formally, a targeted strategic opponent is one whose utility is $u(y,y^{\prime})=1$ if $y^{\prime}$ is a valid target for inputs with label $y$, and 0 otherwise
(where again we assume $u_{yy}=0$).
We refer to these as *0-1 utilities*.

Throughout the paper we will work with several natural classes of such targeted opponents:

- •
$k$-hot:
An opponent is *$k$-hot* if each class $y$ has exactly $k$ viable targets; i.e., $\sum_{y^{\prime}}u(y,y^{\prime})=k\,\,\forall\,y$.
- •
Semantic:
If classes can be partitioned semantically
(e.g., animals vs. vehicles, road sign types),
an opponent is *semantic* if for all $y$,
all viable targets are of the same semantic type
(e.g., $\mathrm{dog}\mapsto\mathrm{cat}$).
- •
Anti-semantic:
Similarly, an opponent is *anti-semantic* if
it benefits from changing label semantics,
i.e., if for all $y$,
all viable targets are of a different semantic type
(e.g., $\mathrm{dog}\mapsto\mathrm{truck}$).

These and their relation to $u^{\mathrm{adv}}$ are illustrated in Fig. 2
(matching Fig. 1) and formally defined later.

## 4 The drawbacks of adversarial training in strategic environments

When facing a targeted strategic opponent, adversarial training is a sound approach,
but is likely to be overly restrictive.
How much do we lose by being maximally conservative, and how much can we gain by appropriately reducing uncertainty?
We begin by inspecting adversarial training through the lens of strategic modelling,
and then continue to empirically demonstrate its shortcomings.

### 4.1 Adversarial attacks as worst-case strategic responses

In Eq. (3), the form for $\delta^{\mathrm{adv}}$ implies that the adversary benefits from any erroneous prediction; thus, an adversarial opponent is in fact a strategic opponent with utility $u=u^{\mathrm{adv}}\triangleq\ell$
plugged into Eq. (4).
In general, however, strategic opponents can have other, non-adversarial utilities.
Assuming utilities are normalized, let $\Lambda=[0,1]^{K\times K}$ denote the universal set of all utility functions.
Then for an adversary, since $u^{\mathrm{adv}}_{y{\hat{y}}}=1$ if $y\neq{\hat{y}}$ and 0 otherwise, our first observation is
that Eq. (3) can be rewritten as:

$$ $\operatorname*{argmin}_{f\in F}\max_{u\in\Lambda}\mathbbm{E}{[{\ell(y,f(x+ \delta_{u}))}]}$ (5) $$

where $\delta_{u}$ is defined as in Eq. (4).
This is since for any $u\in\Lambda$ it holds that $u\leq u^{\mathrm{adv}}$ element-wise, i.e., $u$ employs weaker attacks that are subsumed by $u^{\mathrm{adv}}$.
Eq. (5) therefore suggests that adversarial training amounts to learning against an opponent whose utility is worst-case with respect to *all possible utility functions* taking values in $[0,1]$—a rather demanding task,
which may be overly restrictive.

Figure: Figure 3: (Left:) Accuracy of an adversarially trained model on varying opponents: adversarial, clean, and strategic (1-hots and 3-hots), vs. clean accuracy of a clean model. Strategic attacks are effective, but less severe than adversarial—a gap which strategic training aims to capitalize on (right).
Refer to caption: x3.png

### 4.2 The price of adversarial robustness against non-adversarial opponents

Adversarial training prepares for the worst-case opponent; what happens when it faces one that is not?
Building on the common observation that adversarial training sacrifices clean accuracy for robustness, here we examine its performance against strategic opponents of varying strengths.
For simplicity, we focus on $k$-hot opponents;
note that $k=K-1$ recovers the adversarial utility $u^{\mathrm{adv}}$,
and $k=0$ reverts to the clean setting.
Here we present results for ResNet18 classifiers trained on CIFAR-10 data;
additional architectures and datasets are studied in Sec. 6.
We use $\mathrm{test}(f_{\mathrm{train}})$ to denote the accuracy of a classifier trained in one way and tested in a possibly different setting (e.g., $\mathrm{clean}(f_{\mathrm{adv}})$).

#### Adversarial vs. clean training.

Fig. 3 shows the performance of an adversarially trained classifier ($f_{\mathrm{adv}}$)
evaluated against different opponents:
adversarial ($\mathrm{adv}$),
strategic ($\mathrm{1{\text{-}}hot}$ and $\mathrm{3{\text{-}}hot}$), and no opponent ($\mathrm{clean}$).
Against $\mathrm{adv}$ (dark red), for which $f_{\mathrm{adv}}$ is consistent in training,
accuracy is $45.5$.
This increases to $79.8$ (purple) in $\mathrm{clean}$.
This is an improvement—but in comparison, a model trained on clean data ($f_{\mathrm{cln}}$) achieves $93.1$ clean accuracy.
The price $f_{\mathrm{adv}}$ pays for being conservative is therefore quite steep ($-13.3$).
Under our utilitarian perspective, this large gap is the result of assuming that all attacks are valuable for the opponent, when in effect none are.

#### Adversarial vs. strategic evaluation.

Next, consider how the same adversarially trained model fairs against strategic opponents.
Fig. 3 also shows the distribution of strategic accuracies of $f_{\mathrm{adv}}$ against all $k=1$ (dark blue) and a large sample of $k=3$ (light blue) row-wise $k$-hot opponents. Results show that strategic attacks are indeed generally weaker than adversarial attacks,
with average values of $\mathrm{1{\text{-}}hot}(f_{\mathrm{adv}})=69.9$ and $\mathrm{3{\text{-}}hot}(f_{\mathrm{adv}})=58.5$.
These large gaps from $\mathrm{adv}(f_{\mathrm{adv}})$
($+24.4$ and $+13.0$, respectively),
together with the fact that adversarial training is overly-conservative here as well (as it was in $\mathrm{clean}$),
give hope that
strategic learning will capitalize on its more focused defense (orange).

While the strength of strategic opponents generally decreases with $k$,
there is nonetheless considerable variation in strength across opponents *within* each class:
for example, accuracy against the ‘easiest’ 1-hot opponent is very close to clean
($77.3$, vs. $79.8$), whereas for the ‘hardest’ 1-hot opponent it is midway between adversarial and clean ($59.8$), and worse than some 3-hots.
This suggests there is value in knowing not only the strength of the opponent
(e.g., the number of feasible targets),
but also more fine-grained details regarding its possible incentives.
We will examine this idea further in Sec. 6.

## 5 Strategic training

We now turn to presenting our proposed method for training in strategic environments.

#### From worst-case to strategic-case.

Conventional adversarial learning protects against the worst-case perturbations within the feasible set.
Under Eq. (3), this can be interpreted as seeking robustness against an opponent whose utility is *known* to be $u^{\mathrm{adv}}$.
Alternatively, Eq. (5) frames adversarial learning as protecting against an *unknown* opponent by optimizing against the worst-case utility in the uncertainty set $\Lambda$.
Operationally, these are equivalent, since $u^{\mathrm{adv}}$ is always the worst-case utility in $\Lambda$—irrespective of the data distribution.
The advantage of the utilitarian formulation in Eq. (5) is that it provides a means to reduce the uncertainty set
in an informed manner and according to the opponent’s incentive structure.
This forms the main idea underlying our approach.

#### Learning objective.

If we have good reason to believe that some utilities are more plausible for the opponent than others,
then this can serve as valuable prior knowledge. For example, if we know or are willing to commit to a particular $u$
(we will later see such examples),
then we can work with Eq. (3) and directly replace
$u^{\mathrm{adv}}$ with this chosen $u$.
This gives our proposed *strategic training* objective:

$$ $\operatorname*{argmin}\nolimits_{f\in F}\mathbbm{E}{[{\ell(y,f(x+\delta_{u}))} ]},\qquad\delta_{u}=\operatorname*{argmax}\nolimits_{\delta\in\Delta}\,u(y,f(x +\delta))$ (6) $$

Conversely, if we do not know the opponent’s utility precisely,
but are willing to consider a set of possible alternatives,
then we can adapt Eq. (5)
by replacing $\Lambda$ with a smaller, task-specific set $U\subset\Lambda$.
For example, this can be the set of all semantic opponents, a particular subset of anti-semantic opponents,
a small hand-crafted set of $k$-hot opponents,
or any other reduced set that captures the opponent’s possible incentives in the task domain.
Given such $U$, our strategic training objective becomes:

$$ $\operatorname*{argmin}_{f\in F}\max_{u\in U}\mathbbm{E}{[{\ell(y,f(x+\delta_{u }))}]}$ (7) $$

which recovers Eq. (6) for $U=\{u\}$.
If we instead have probabilistic beliefs over the possible utilities in a form of a distribution $p_{u}$, then the max can be replaced with an expectation. We refer to the expected error term in Eq. (7) (including the max) as *strategic error w.r.t. $U$*,
and to the general goal of optimizing Eq. (7) as *strategic-case robustness*
(or simply strategic robustness).

#### Interpretation.

Eq. (7) protects against the worst-case strategic opponent having utility $u\in U$.
Note that this includes as special cases both the adversarial setting (for $U=\Lambda$) and the clean setting (for $U=\{0\}$ and defining $\delta_{0}=0$).
Denoting raw predictions as ${\hat{y}}=f(x)$ and
post-response predictions as ${\hat{y}}_{u}=f(x+\delta_{u})$,
then for any $U$ in which all $u\in U$ have $u_{yy}=0$,
we naturally get that:

$$ $\underbrace{\min_{f\in F}\mathbbm{E}{[{\ell(y,{\hat{y}})}]}}_{\text{\emph{ clean}}}\,\,\leq\,\,\underbrace{\min_{f\in F}\max_{u\in U}\mathbbm{E}{[{\ell(y ,{\hat{y}}_{u})}]}}_{\text{\emph{strategic}}}\,\,\leq\,\,\underbrace{\min_{f \in F}\max_{u\in\Lambda}\mathbbm{E}{[{\ell(y,{\hat{y}}_{u})}]}}_{\text{\emph{ adversarial}}}$ (8) $$

Hence, while strategic opponents are worse than no opponent at all,
they are generally weaker than adversaries.
If the opponent’s true utility lies in $U$, then strategic training should provide robustness—whereas clean training does not, and adversarial training does, but is unnecessarily over-conservative.
As we will see, this also results in strategic training performing better on clean data than adversarial training.
Strategic learning therefore offers a middle ground between the two extremes of clean and adversarial learning,
this giving hope that appropriate strategic modeling can prove to be beneficial for learning.

### 5.1 Optimization

The main challenge in optimizing the strategic objective in Eq. (7) is that it is a minimax objective (over $f$ and $u$) with a nested argmax term ($\delta_{u}$, see Eq. (4)).
Luckily, utilities permit certain structure that enable efficient training even for some large sets $U$.
Generally our approach is similar to the one common in adversarial training,
namely optimizing an empirical objective with a proxy loss and alternating gradient steps between $f$ and $\delta_{u}$.
The main distinction is that to compute gradient steps for $\delta_{u}$ we must account for how $u$ is determined by the internal $\max_{u}$ term.

#### Single utility.

Consider first the case of training under a single chosen $u$
(Eq. (6)).
Note that since utility is of the form $u(y,y^{\prime})$,
for each example $(x,y)$ we need only consider the subset of targets $y^{\prime}$ s.t. $u(y,y^{\prime})=1$.
If there is only a single target, then as a proxy we can maximize the probability to predict $y^{\prime}$:
denoting ${\hat{p}}(y^{\prime}|x)=\operatorname*{softmax}_{y^{\prime}}(f(x+\delta))$,
the strategic response is optimized by $\max_{\delta}{\hat{p}}(y^{\prime}|x)$.
Note this mirrors the popular proxy for adversarial attacks, $\min_{\delta}{\hat{p}}(y|x)$.
If instead we have multiple possible targets $T\subseteq[K]\setminus y$,
then since the opponent gains utility from any one of them,
we solve:

$$ ${\hat{\delta}}_{u}=\max_{\delta}\max_{y^{\prime}\in T}\,{\hat{p}}(y^{\prime}|x)$ (9) $$

#### General sets.

Next, consider the case of training under an uncertainty set $U$ (Eq. (7)).
For general $U$, the simplest approach is to in each batch enumerate over all $u\in U$, find the maximizing $u$, and update $\delta_{u}$ as above accordingly.
In principal, finding the argmax should increase runtime by a factor $|U|$.
However,
since attacks decouple over $y$, we can solve $\max_{u}$ independently for each row $u(y,\cdot)$, which can significantly reduce computational costs:
for example, if $U$ includes all 1-hot utilities,
then despite having $|U|=(K-1)^{K}$, the total number of calls to Eq. (9) is $O(K)$.

#### Structured sets.

Recall that adversarial training protects against the universal set $\Lambda$, but optimizes against a single utility, namely $u^{\mathrm{adv}}$.
This works because protecting against $u^{\mathrm{adv}}$ implicitly provides protection against all $u\leq u^{\mathrm{adv}}$.
Similarly, if we train against a single $u^{*}$, then this protects against
$U=\{u:u\leq u^{*}\}$.
Fortunately, both semantic and anti-semantic opponents
(see Fig. 2) admit such representative utilities.
Denote by $U^{\mathrm{sem}}$ and $U^{\mathrm{a{\text{-}}sem}}$ the sets of all such opponents, respectively.
Let $S(y)\subset[K]$ be the set of classes of the same semantic type as $y$,
and define:

$$ $u^{\mathrm{sem}}(y,y^{\prime})=1\text{ iff }y^{\prime}\in S(y)\qquad\text{and} \qquad u^{\mathrm{a{\text{-}}sem}}(y,y^{\prime})=1\text{ iff }y^{\prime}\not \in S(y)$ (10) $$

Since any semantic utility $u$ has $u\leq u^{\mathrm{sem}}$,
and any anti-semantic utility $u$ has $u\leq u^{\mathrm{a{\text{-}}sem}}$,
each of the above are the worst-case utility of their respective type.
Given this, Eq. (7) reduces to Eq. (6),
and strategic robustness against all semantic or all anti-semantic opponents can be obtained at the cost of training against a single opponent—i.e., on par with adversarial training.

## 6 Learning under multi-targeted strategic attacks

We now proceed to demonstrate the potential benefits of strategic training (see Sec. 5),
discussing also its potential risks and suggesting ways to hedge them.
All experimental details are given in Appx. B.

Figure: Figure 4: (Left:) Improvement of strategic training (for known $u$) over adversarial training on a sample of 1-hot opponents, showing gains are larger against ‘easier’ opponents. (Right:) Correlation between strategic accuracy and attack semantics. Opponents who benefit from changing the label’s semantic meaning (e.g., $\mathrm{animal}\mapsto\mathrm{vehicle}$) for more classes enable higher gains.
Refer to caption: x5.png

### 6.1 The benefits of accurate strategic modeling

Our first experiment aims to show how strategic training with knowledge of the opponent’s utility can improve performance.
Focusing on 1-hot opponents, here we train ResNet18 classifiers on CIFAR-10 using strategic training with a known $u$,
and compare their strategic accuracy (w.r.t. $u$) to that of an adversarially trained classifier.
This allows us to quantify the boost in accuracy gained by correct incentive modelling.
To capture the breadth of possible outcomes,
we partition all 1-hot opponents into 10 bins by how adversarial training performs against them
(as in Fig. 3) and then sample 15 opponents uniformly from each bin,
this serving as a proxy for opponent ‘strength’.

#### Results.

Fig. 4 (left) shows the gain in strategic accuracy from strategic training across all bins:
dots represent single utilities $u$, and boxes show quantiles for each bin.
As can be seen, accurate strategic training improves performance on the entire range
by at least $+6$ accuracy points (on average) across all bins (see inset plot).
As opponents becomes ‘weaker’, average gains increase up to $+10$ points.

#### Strategic vs. semantic structure.

Since there is considerable variation across opponents in the gains of strategic training (even within bins), it will be useful to understand what contributes to gains being large.
Intuitively, we expect strategic training to improve upon adversarial training when the latter unnecessarily defends against a non-target ($u_{yy^{\prime}}=0$) in a way that makes it susceptible to attacks on true targets ($u_{y{\bar{y}}}=1$).
Given this, we conjecture that strategic opponents that benefit from hard-to-attack targets will be easier to defend against using strategic training.

But what makes targets ‘easy’ or ‘hard’ to attack?
Fig. 4 (right) suggests that this difficulty is inherently tied to the *semantics* of the learning task.
For example, since CIFAR-10 consists of either animal or vehicle classes,
semantic attacks (e.g., $\mathrm{animal}\mapsto\mathrm{animal}$)
should be easier for the opponent to accomplish than
anti-semantic attacks (e.g., $\mathrm{animal}\mapsto\mathrm{vehicle}$).
Here we measure for each $u$ the number of semantic pairs,
namely $|\{y:{\bar{y}}\in S(y)\}|$ where ${\bar{y}}$ is the 1-hot target of $y$.
Indeed, results show a strong correlation ($-0.84$) between strategic accuracy
and the semantic degree of $u$.

Figure: Figure 5: Strategic training against single 1-hot opponents of varying strengths. Results show accuracy for increasing risk mitigation ($\epsilon$) for specified and misspecified settings.
Refer to caption: x7.png

### 6.2 The risks of imprecise strategic modeling and how to mitigate them

Our previous results suggest that much can be gained from accurate strategic modeling.
But what would happen if at test time we were to face an opponent whose utility is different from the one we trained on?
A simple way to hedge such risks is to assume that we will face the chosen $u$ with probability $1-\epsilon$, and any other opponent otherwise.
This can be optimized by placing weight $1-\epsilon$ on $u$ and splitting the remainder $\epsilon$ mass uniformly between all other $u^{\prime}\in U$ (e.g., all 1-hots).(^2^22In practice this is implemented by sampling at each batch $u$ w.p. $1-\epsilon$ and $u^{\prime}\sim\mathrm{uniform}(U)$ w.p. $\epsilon$.)
As $\epsilon$ grows, we can expect that if $u$ is well-specified then our gains will decrease,
but if it is misspecified, then our losses will be smaller.
Note that $\epsilon=1$ amounts to providing average-case robustness w.r.t. $U$.

#### Results.

Maintaining the previous setup,
Fig. 5 demonstrates this idea for strategic 1-hot opponents of varying strengths: randomly chosen (showing mean and standard deviation),
and easy and hard representatives.
As can be seen, well-specified strategic training improves upon adversarial training for all considered opponents (blue), where gains are indeed higher for small $\epsilon$,
but even for the hardest opponent still remain positive even at $\epsilon=0.8$.
Conversely, when strategic training is misspecified (orange), performance against the worst-case of all 1-hot opponents is worse than adversarial training.
And while the gap does become smaller as $\epsilon$ increases,
for all opponents the gap remains even at $\epsilon=1$;
this is expected, since evaluation is worst-case, whereas training optimizes for average-case.

#### Semantic evaluation.

Evaluation above is worst-case with respect to *all* possible opponents;
hence, the worst-case $u^{\prime}$ at test time can be arbitrarily different from the $u$ used for training. A more lenient evaluation would be to evaluate against the worst-case $u^{\prime}$ from a smaller set that is ‘closer’ to $u$.
Given the relation between attack strength and semantics,
Fig. 5 also shows accuracy for misspecified $u$
but evaluated against a semantically relevant set (green).
For the hard opponent, the effect disappears;
note how adversarial performance remains the same, suggesting that the hardest opponent is a member of the semantic set.
However, for the easy opponent, not only is there general improvement,
but the gap to adversarial training closes quickly, and at $\epsilon\approx 0.7$ moderately reverses.
Note also how here accuracy for the adversary is close to that of the *correct* setting.
Together, these suggest that even the mild knowledge of the adversary’s incentives—e.g., whether it is semantic or anti-semantic—should prove useful.

### 6.3 Worst-case strategic robustness

If our knowledge of the opponent’s utility is only coarse (and not specific),
then a natural approach is to seek robustness to a set of plausible utilities $U$
(rather than focus on a single $u$).
Motivated by our previous results,
our goal in this section is to explore strategic training when all we assume is that the opponent benefits either from attacks that preserve, or that disrupt, label semantics.

#### Experimental setup.

In addition to CIFAR-10, here we also experiment with the GTSRB road signs dataset, in which we partition road sign classes according to their type.
We consider three architectures: VGG, ResNet18, and vision transformer (ViT).
For adversarial training we implement attacks using PGD [],
and for strategic training we use our approach from Sec. 5.
Since we are interested in strategic robustness, we evaluate the performance of each method as its accuracy against the worst-case strategic opponent in the relevant incentive set. i.e., $U^{\mathrm{sem}}$ for semantic and $U^{\mathrm{a{\text{-}}sem}}$ for anti-semantic.
Appendix B includes further details on data, optimization, and evaluation.

#### Results.

For both semantic and anti-semantic settings,
Table 1 compares models trained using clean, strategic, and adversarial training in terms of their clean, strategic, and adversarial accuracies.
As can be seen, strategic training provides significant gains over adversarial training against worst-case strategic opponents in all cases,
with a more pronounced effect in the anti-semantic setting.
This is made apparent in Table 7, which shows the relative gain of strategic training,
measured as the percentage of attacks it is able to prevent out of
the successful attacks against an adversarial model:

$$ $\%\mathrm{deflected}=(\mathrm{strat}(f_{\mathrm{str}})-\mathrm{strat}(f_{ \mathrm{adv}}))/(\mathrm{clean}(f_{\mathrm{cln}})-\mathrm{strat}(f_{\mathrm{ adv}}))$ (11) $$

Deflection rates can be as high as $40\%$;
this demonstrates the ability of strategic training to exploit mild knowledge regarding incentives,
as well as the price of adversarial over-conservativeness.
To gain insight as to how adversarial learning over-defends,
Fig. 7 (left) illustrates
for CIFAR-10 with ResNet18 the distribution of attacks
adversarial training anticipates to encounter
(i.e., when assuming an adversarial opponent).
In comparison, Fig. 7 (right) shows the distribution of semantic strategic attacks on a strategically trained model.
As can be seen, strategic training anticipates, and therefore focuses its defenses on, the correct targets.
Meanwhile, as Fig. 7 (center) shows,
adversarial training unnecessarily defends against non-targets,
and therefore suffers more attacks on true targets.

**Table 1: Accuracies of clean, strategic, and adversarial models in semantic and anti-sem. settings.**
|  |  |  | CIFAR-10 |  | GTSRB |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | train<br>test | VGG |  | ResNet18 |  | ViT |  | VGG |  | ResNet18 |  | ViT |  |  |  |  |  |  |  |  |  |  |  |  |  |
|  | $\mathrm{clean}$ | $\mathrm{strat}$ | $\mathrm{adv}$ |  | $\mathrm{clean}$ | $\mathrm{strat}$ | $\mathrm{adv}$ |  | $\mathrm{clean}$ | $\mathrm{strat}$ | $\mathrm{adv}$ |  | $\mathrm{clean}$ | $\mathrm{strat}$ | $\mathrm{adv}$ |  | $\mathrm{clean}$ | $\mathrm{strat}$ | $\mathrm{adv}$ |  | $\mathrm{clean}$ | $\mathrm{strat}$ | $\mathrm{adv}$ |  |  |
| sem. | clean |  | 89.2 | 0.1 | 0.6 |  | 93.1 | 0.0 | 0.0 |  | 77.5 | 0.1 | 0.0 |  | 95.1 | 5.8 | 15.4 |  | 96.6 | 1.8 | 1.6 |  | 90.7 | 2.8 | 1.8 |
| strategic |  | 72.2 | 50.9 | 33.7 |  | 78.9 | 52.5 | 40.7 |  | 58.1 | 44.0 | 23.6 |  | 82.4 | 58.3 | 47.0 |  | 92.0 | 64.9 | 61.7 |  | 80.2 | 49.9 | 42.4 |  |
| adversarial |  | 67.7 | 46.4 | 39.3 |  | 79.8 | 49.6 | 45.5 |  | 53.1 | 39.8 | 33.3 |  | 80.5 | 47.2 | 43.8 |  | 90.9 | 55.4 | 53.9 |  | 79.4 | 49.6 | 47.1 |  |
| a-sem. | clean |  | 89.2 | 0.2 | 0.6 |  | 93.1 | 0.0 | 0.0 |  | 77.5 | 0.2 | 0.0 |  | 95.1 | 14.6 | 15.4 |  | 96.6 | 4.3 | 1.6 |  | 90.7 | 6.4 | 1.8 |
| strategic |  | 80.3 | 69.8 | 25.0 |  | 85.1 | 73.4 | 33.4 |  | 65.3 | 58.7 | 13.1 |  | 88.2 | 71.2 | 36.7 |  | 92.0 | 79.1 | 49.0 |  | 83.5 | 74.0 | 34.0 |  |
| adversarial |  | 67.7 | 56.8 | 39.3 |  | 79.8 | 67.4 | 45.5 |  | 53.1 | 45.8 | 33.3 |  | 80.5 | 63.2 | 43.8 |  | 90.9 | 73.0 | 53.9 |  | 79.4 | 64.6 | 47.1 |  |

Figure: Figure 6: Strategic gains.
Refer to caption: x8.png

## 7 Discussion

This paper studies *strategically robust learning*—a novel setting in which opponents are strategic, namely act to maximize their own utility.
Given that this is the basic premise underlying all economic modelling,
we believe our work provides a fresh perspective on robust learning having true practical merit.
At its core, strategic learning offers a means to inject inductive bias on the basis of knowledge regarding the opponent’s likely incentives.
As a middle ground between the (optimistic) clean setting and (pessimistic) adversarial settings,
it allows us—and at the same time requires us—to be precise in our definition of what we seek to be ‘robust’ against.
Our work leans on ideas from the literature of strategic classification, but takes several steps towards making it more realistically applicable.
We see several avenues forward, including better implementations for strategic attacks, improved strategic training,
other modalities (e.g., text),
and new incentive structures.
We leave these for future work.

## Appendix A Broader impact

The field of adversarial learning aims to enable safer deployment of learned models and to make the use of machine learning more secure in real-world applications.
The concern regarding attacks on models is concrete,
and the possible risks such attacks entail span many domains [].
This underlies the many efforts that are and have been put forth,
both in research and in industry, to advance the development of methods for adversarially robust learning.

Our approach to robust learning stems from the observation that in reality,
learned models will be susceptible to the influence of the agents who interact with them;
and whereas adversarial learning prepares to encounter malicious agents,
our main thesis is that even non-benign agents are more likely to promote their own interests than to sabotage learning efforts.
As such, we view our work as contributing an economic perspective to how robust learning should be designed, this by acknowledging and modeling the possible utilities of the agents that learning may encounter.

However, as in any domain or task in which agents are modeled, our approach necessitates making assumptions—even if mild—on the nature of their possible incentives.
As these are intended to relax the demanding restrictions of adversarial learning,
the main limitation of our approach is that the more precisely we model incentives, the more we risk their misspecification.
This is an inherent limitation of any method for robust learning: once we commit to an uncertainty set, all guarantees are with respect to this set only.
In our work we empirically explore (to some extent) the implication of misspecification (Sec. 6.2).
Results are fairly encouraging,
but safe deployment of strategically trained models clearly requires much further investigation of possible failure modes.

Adversarial learning faces similar limitations:
it commits to a certain threat model (e.g., $L_{\infty}$ with a certain budget), and provides robustness against such attacks—but this protection does not generalize to others (e.g., $L_{2}$, or a larger budget) [, ].
Nonetheless, in relation to our approach, adversarial learning is indeed ‘safer’,
but this is only because it seeks to defend against all possible opponents (i.e, ‘everything’).
Our key point in this paper is precisely that safety that is granted through conservativity comes at a cost—for example, in reduced clean performance—and that if we have established knowledge or strong beliefs regarding the opponent’s possible incentives, then it can be highly beneficial to use them as inductive bias for strategic learning.

## Appendix B Experimental details

### B.1 Data and preprocessing

We experiment with two datasets:

- •
CIFAR-10(^3^33[https://www.cs.toronto.edu/~kriz/cifar.html](https://www.cs.toronto.edu/~kriz/cifar.html))
[]:
This dataset include $60,000$ natural images of size $32\times 32\times 3$.
We use the standard split of $50,000$ train and $10,000$ test examples.
There are $10$ classes, 4 of which encode vehicles, and 6 of which encode animals. We use this partition as our definition of label semantics.
- •
GTSRB(^4^44[https://benchmark.ini.rub.de](https://benchmark.ini.rub.de))
[]:
This dataset includes $\sim 50,000$ images of road signs of variable sizes.
We use the standard split of $39,209$ train and $12,630$ test images
For consistency we resize the images to $32\times 32\times 3$.
There are $43$ classes, which we partition according to the shape of the sign—either circular or triangular, which roughly corresponds to road sign types: prohibitory and mandatory signs vs. warning signs.

For both datasets we employ a standard augmentation pipeline,
which includes RandomCrop with a padding of $4$ and RandomHorizontalFlip.

### B.2 Architectures

We experiment with three different model architectures:
(i) VGG [],
(ii) ResNet18 [],
and (ii) ViT [].
The former two are convolution-based,
for which we use standard architectures.
The latter is transformer-based,
and for this we use an implementation adjusted to smaller resolution images.(^5^55[https://github.com/omihub777/ViT-CIFAR](https://github.com/omihub777/ViT-CIFAR))

### B.3 Threat model and attack implementation

For the adversarial and strategic settings, we adopt the following standard adversarial configuration.(^6^66[https://github.com/imrahulr/adversarial_robustness_pytorch](https://github.com/imrahulr/adversarial_robustness_pytorch))
We set the threat model $\Delta$ as the $L_{\infty}$ norm-ball with an adversarial budget of $\frac{8}{255}$.
For training, we use a PGD attack using $7$ steps with a step size of $0.011$.
For evaluation, we use $20$ steps with a step size of $0.0039$.
For both cases, we use the common heuristic of $2.5\frac{\epsilon}{t}$, where $t$ is the number of steps.

### B.4 Training and hyperparameters

Optimization for all models was done using an SGD optimizer with momentum $0.9$ and a base learning rate of $0.01$.
Learning rate $r$ was adjusted using a multi-step scheduler, which multiplies $r$ by $0.1$ at two predetermined epochs during training. These hyperparameters remain constant across experiments, datasets, and architectures.
We used 50 epochs of training throughout, except for ViT on CIFAR-10 which required an additional 50 epochs (used for all methods).
For batch size ($\mathtt{bs}$),
we used mostly 64 samples per batch.
However, several adaptations were necessary to ensure that all models in all settings obtained reasonable clean accuracy.
These changes are summarized as follows:

| architecture | dataset | batch size | epochs |
| --- | --- | --- | --- |
| ResNet18 | CIFAR-10 | 128 | 50 |
| GTSRB | 32/64 | 50 |  |
| VGG | CIFAR-10 | 64 | 50 |
| GTSRB | 64 | 50 |  |
| ViT | CIFAR-10 | 64 | 100 |
| GTSRB | 16 | 50 |  |

The only setting in which we resorted to use different batch sizes for different methods is ResNet18 on GTSRB.
Here we found that
strategic training works well with $\mathtt{bs}=32$ (but not with $\mathtt{bs}=64$),
and that adversarial training works well with $\mathtt{bs}=64$ (but not with $\mathtt{bs}=32$), whereas clean training was mostly agnostic to this choice.
Our main results in Table 1 adhere to these choices;
for completeness, we report here accuracies for strategic training with $\mathtt{bs}=64$ (which matches the reported $\mathtt{bs}$ for adversarial training):
in the semantic setting $\mathrm{clean}(f_{\mathrm{sem}})=87.6$,
$\mathrm{sem}(f_{\mathrm{sem}})=57.0$,
and $\mathrm{adv}(f_{\mathrm{sem}})=54.9$,
and in the anti-semantic setting
$\mathrm{clean}(f_{\mathrm{a{\text{-}}sem}})=92.2$,
$\mathrm{a{\text{-}}sem}(f_{\mathrm{a{\text{-}}sem}})=78.4$,
and $\mathrm{adv}(f_{\mathrm{a{\text{-}}sem}})=50.1$.

As we discuss in Sec. 5.1, we found that strategic training benefits (mostly in terms of clean accuracy) from adding subtle noise to the choice of utility at each step.
Accordingly, at each batch, for each class $y$, with probability $1-\epsilon$ we use the utility $u_{y\cdot}$ defined in the objective,
and with probability $\epsilon$ we draw a target label ${\bar{y}}\in[K]$ uniformly at random.
Throughout all experiments we use $\epsilon=0.1$.

Upon publication we will make our code and all checkpoints publicly available to facilitate reproducibility and further research.

### B.5 Compute and runtime

We ran all the experiments on a cluster of NVIDIA RTX A4000 16GB GPU machines, where each run used between 1-2 GPUs in parallel.
A typical epoch for ResNet18 on CIFAR-10 was timed at roughly $17.5$ seconds per epoch for clean training,
$85$ for adversarial training, and
$144$ for strategic training.
Thus, one experimental instance for each method completes in approximately
$15$ minutes,
$70$ minutes,
and $120$ minutes,
respectively.
For the least computationally demanding setup (VGG on CIFAR-10), an average epoch of clean training takes $18.7$ seconds, $76.2$ seconds for adversarial training and $61$ seconds for strategic.
For the most computationally demanding setup (ViT on GTSRB), an average epoch takes $97$, $451$ and $444$ seconds for clean, strategic and adversarial training, respectively.

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 6
presentation: 4
questions: Is it possible in practice to estimate the opponent’s utility function based on some information such as historical attack data from opponents?
soundness: 4
strengths: - This paper identifies a favorable interpolation between natural training and adversarial training, in which many meaningful optimization problems with real-world significance are formulated.

- This paper provides a comprehensive investigation into the proposed types of strategic opponents, including adversarial, semantic, anti-semantic, preference ordering, and 1-hot.

- Thorough experiments demonstrate the gap between strategic attacks and adversarial attacks, as well as the effectiveness of the proposed strategic training method.
summary: This paper introduces a new perspective in adversarial training by proposing that adversaries may act out of self-interest rather than pure malice. Traditional adversarial training models the adversary as seeking maximal harm to the classifier, requiring models to defend against all possible incorrect labels. This approach, while robust, can reduce model generalization and clean data accuracy. Instead, the authors propose a framework called strategic training, which considers opponents who act to maximize their own utility. By assuming that opponents pursue specific goals, this approach allows models to leverage knowledge about opponent incentives, defining an incentive uncertainty set to guide training.
weaknesses: - Regarding the question of "How much do we lose by being maximally conservative, and how much can we gain by appropriately reducing uncertainty," this paper offers an answer through experimental analysis but lacks a detailed theoretical examination.

- Strategic training requires a predefined utility function or set of utility functions; however, if the utility function is unknown, strategic training cannot proceed.

- (Minor) A typo in Figure 1: "preferecnce" should be corrected to "preference."

---

confidence: 5
contribution: 1
initial_rating: 3
presentation: 3
questions: See the weaknesses above.
soundness: 1
strengths: - The paper is well-written and clearly formalizes the proposed framework.
summary: The paper considers a new adversarial scenario where an attacker has a non-uniform preference for target classes. It introduces a new adversarial training method, named strategic training, designed specifically to defend against such targeted attacks. It claims that prior knowledge of the attacker’s preferences can enhance both clean accuracy and strategic adversarial accuracy.
weaknesses: - The proposed scenario seem impractical, as it is challenging for a defender to anticipate an attacker’s intent in advance. Additionally, an attacker’s preferences may shift over time, and there can be multiple attackers with varying preferences. This is why most work on adversarial robustness assumes a uniform preference among attackers.
- Although the proposed scenario is novel, the framework and its results seem straightforward. Constraining the attacker’s search space is expected to yield higher clean accuracy, reflecting the fundamental trade-off between accuracy and robustness.
- The results in Table 1 appear inconsistent and unreliable. In the GTSRB experiment, strategically trained VGG and ResNet18 models achieve higher adversarial accuracy than standard adversarially trained models. This suggests that the evaluation method may be flawed; the authors should consider using stronger attack algorithms, such as AutoAttack [1]. Using a 20-step PGD attack is an outdated evaluation approach, more commonly seen in studies from 2018.

[1] Francesco Croce, Matthias Hein, Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks, ICML 2020

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: See Weaknesses. Additionally,
1. I found that Figure 1 is not very clear. Some explanations are needed for the meaning of (faded) arrows and such.
2. It's not entirely clear upon reading Section 4.2 how one will solve Eq. (5), or Eq. (4) given a strategic opponent with utility $u$. Without briefly stating the strategy, the results are reported and I think it would help to have some pointers to Section 5 saying that the results are obtained based on Section 5.1 (I suppose).
3. What does Line 360 mean exactly? More explanation is needed for how $\\hat{\\delta}_{y'}$ is defined.
4. Line 451, where the terms "well-specified" and "misspecified" are unclear in this context.

Some minor suggestions in writing:
1. Line 18, "incentive uncertainty set." instead of 'incentive uncertainty set'. Similarly, Line 82 'everything'. to "everything.", etc. 
2. Line 236, $u^{\\text{adv}}$ appears without a definition.
3. Line 266 and 267, it's unclear to me what $\\mathrm{test}(f_{\\text{train}})$ and $\\mathrm{clean}(f_{\\text{adv}})$ stand for without looking at the next paragraph.

>I would be happy to raise scores once these are answered and addressed.
soundness: 3
strengths: Overall,
1. Well-motivated research design, which fills the gap between the two extreme spectrums of adversarial training nicely.
2. Clear formulation for most parts of the presentation. 
3. Extensive experiments that cover a wide range of concerns. Each experiment is also well-motivated.
summary: This paper studies *strategically robust learning*, which fills the gap between adversarial learning and vanilla learning nicely. Specifically, the problem formulation is done in such a way that generalizes both cases. Extensive experiments are conducted to empirically verify the effectiveness of the proposed model and demonstrate the advantage of considering such strategic opponent scenarios instead of blindly chasing for the worst-case guarantees.
weaknesses: 1. It seems like although we consider the set of all possible utilities to be $\\Lambda = [0, 1]^{K \\times K}$, the discussion is tailored towards $\\{0, 1\\}^{K \\times K}$ instead. It is not immediately clear that all the discussions and analysis will follow through within for the more general $\\Lambda$. I'm just curious whether it is possible to consider other than $0$-$1$ utilities in the experiment, since some of the categories, e.g., preferences, will make more sense for the case of $[0, 1]$ utilities.
2. Little emphasis on the algorithm description makes some of the claims not convincing. For example, what is the exact algorithm Line 364 referring to, i.e., "solving $\\max_u$ independently for each row $u(y, \\cdot)$"? What is the advantage in terms of time complexity when using this algorithm? This is crucial and should not be omitted since otherwise, as mentioned in Line 363, the runtime will scale with $|U|$.
3. Perhaps out-of-scope, but it will be nice to see some connection between the existing theory for adversarial training with this setting: how do they generalize, and how do they fail to generalize? The lack of (can be light) theoretical discussions makes the discussion a bit unsatisfying.

Meta-review: This paper adds a new perspective to adversarial training by modeling adversaries as incentive and self-interest driven. Strategic learning is not new to the literature but I believe this paper introduces more alternatives that can cover a broader set of adversaries and when the learner only has limited information about the incentives. The results show that even mild knowledge about the adversary’s incentive can indeed be helpful.

Decision: Accept (Poster)