P REDICTION P OISONING : T OWARDS D EFENSES
A GAINST DNN M ODEL S TEALING A TTACKS
Anonymous authors
Paper under double-blind review
A BSTRACT
High-performance Deep Neural Networks (DNNs) are increasingly deployed in many real-world applications e.g., cloud prediction APIs.
Recent advances in model functionality stealing attacks via black-box access (i.e., inputs in, predictions out) threaten the business model of such applications, which require a lot of time, money, and effort to develop.
Existing defenses take a passive role against stealing attacks, such as by truncating predicted information.
We ﬁnd such passive defenses ineffective against DNN stealing attacks.
In this paper, we propose the ﬁrst defense which actively perturbs predictions targeted at poisoning the training objective of the attacker.
We ﬁnd our defense effective across a wide range of challenging datasets and DNN model stealing attacks, and additionally outperforms existing defenses.
Our defense is the ﬁrst that can withstand highly accurate model stealing attacks for tens of thousands of queries, amplifying the attacker’s error rate up to a factor of 85 × with minimal impact on the utility for benign users.
I NTRODUCTION
Effectiveness of state-of-the-art DNN models at a variety of predictive tasks has encouraged their usage in a variety of real-world applications e.g., home assistants, autonomous vehicles, commercial cloud APIs.
Models in such applications are valuable intellectual property of their creators, as developing them for commercial use is a product of intense labour and monetary effort.
Hence, it is vital to preemptively identify and control threats from an adversarial lens focused at such models.
In this work we address model stealing, which involves an adversary attempting to counterfeit the functionality of a target victim ML model by exploiting black-box access (query inputs in, posterior predictions out).
Stealing attacks dates back to Lowd & Meek (2005), who addressed reverse-engineering linear spam classiﬁcation models.
Recent literature predominantly focus on DNNs (speciﬁcally CNN image classiﬁers), and are shown to be highly effective (Tram ` er et al., 2016) on complex models (Orekondy et al., 2019), even without knowledge of the victim’s architecture (Papernot et al., 2017b) nor the training data distribution.
The attacks have also been shown to be highly effective at replicating pay-per-query image prediction APIs, for as little as $30 (Orekondy et al., 2019).
Defending against stealing attacks however has received little attention and is lacking.
Existing defense strategies aim to either detect stealing query patterns (Juuti et al., 2019), or degrade quality of predicted posterior via perturbation .
Since detection makes strong assumptions on the attacker’s query distribution (e.g., small L 2 distances between successive queries), our focus is on the more popular perturbation-based defenses.
A common theme among such defenses is accuracypreserving posterior perturbation: the posterior distribution is manipulated while retaining the toplabel.
For instance, rounding decimals (Tram`er et al., 2016), revealing only high-conﬁdence predictions (Orekondy et al., 2019), and introducing ambiguity at the tail end of the posterior distribution (Lee et al., 2018).
Such strategies beneﬁt from preserving the accuracy metric of the defender.
However, in line with previous works (Tram`er et al., 2016; Orekondy et al., 2019; Lee et al., 2018), we ﬁnd models can be effectively stolen using just the top-1 predicted label returned by the black-box.
More speciﬁcally, in many cases we observe (see Fig. 1) < 1% difference between attacks that use the full range of posteriors to train stolen models and the top-1 label alone.
In this paper, we work towards effective defenses (red line in Fig. 1) against DNN stealing attacks at a marginal cost to defender’s accuracy.
[Figure] [Figure]
[Figure]
The main insight to our approach is that unlike a benign user, a model stealing attacker additionally uses the predictions to train a replica model.
By introducing controlled perturbations to predictions, our approach targets poisoning the training objective (see Fig.
Our approach allows for a utility-preserving defense, as well as trading-off a marginal utility cost to signiﬁcantly degrade attacker’s performance.
As a practical beneﬁt, the defense involves a single hyperparameter (perturbation utility budget) and can be used with minimal overhead to any classiﬁcation model without retraining or modiﬁcations.
We rigorously evaluate our approach by defending six victim models, against four recent and effective DNN stealing attack strategies (Papernot et al., 2017b; Juuti et al., 2019; Orekondy et al., 2019).
Our defense consistently mitigates all stealing attacks and further shows improvements over multiple baselines.
In particular, we ﬁnd our defenses degrades the attacker’s query sample efﬁciency by 1orders of magnitude.
Our approach signiﬁcantly reduces the attacker’s performance (e.g., 30-53% reduction on MNIST and 1328% on CUB200) at a marginal cost (1-2%) to defender’s test accuracy.
Furthermore, our approach can achieve the same level of mitigation as baseline defenses, but by introducing signiﬁcantly lesser perturbation.
Contributions.
(i)
We propose the ﬁrst utility-constrained defense against DNN model stealing attacks; (ii) We present the ﬁrst active defense which poisons the attacker’s training objective by introducing bounded perturbations; and (iii) Through extensive experiments, we ﬁnd our approach consistently mitigate various attacks and additionally outperform baselines.
R ELATED L ITERATURE
Model stealing attacks (also referred to as ‘extraction’ or ‘reverse-engineering’) in literature aim to infer hyperparameters (Oh et al., 2018; Wang & Gong, 2018), recover exact parameters (Lowd &
Meek, 2005; Tram ` er et al., 2016; Milli et al., 2018), or extract the functionality (Correia-Silva et al., 2018; Orekondy et al., 2019) of a target black-box ML model.
In some cases, the extracted model information is optionally used to perform evasion attacks (Lowd & Meek, 2005; Nelson et al., 2010;
Papernot et al., 2017b).
The focus of our work is model functionality stealing, where the attacker’s yardstick is test-set accuracy of the stolen model.
Initial works on stealing simple linear models (Lowd & Meek, 2005) have been recently succeeded by attacks shown to be effective on complex
CNNs (Papernot et al., 2017b; Correia-Silva et al., 2018; Orekondy et al., 2019) (see Appendix B for an exhaustive list).
In this work, we works towards defenses targeting the latter line of DNN model stealing attacks.
Since ML models are often deployed in untrusted environments, a long line of work exists on guaranteeing certain (often orthogonal) properties to safeguard against malicious users.
The properties include security (e.g., robustness towards adversarial evasion attacks (Biggio et al., 2013; Goodfellow et al., 2014; Madry et al., 2018)) and integrity (e.g., running in untrusted environments (Tramer & Boneh, 2019)).
To prevent leakage of private attributes (e.g., identities) speciﬁc to training data in the resulting ML model, differential privacy (DP) methods (Dwork et al., 2014) introduce randomization during training (Abadi et al., 2016; Papernot et al., 2017a).
In contrast, our defense objective is to provide conﬁdentiality and protect the functionality (intellectual property) of the ML model against illicit duplication.
Model stealing defenses are limited.
Existing works (which is primarily in multiclass classiﬁcation settings) aim to either detect stealing attacks (Juuti et al., 2019;
Kesarwani et al., 2018; Nelson et al., 2009; Zheng et al., 2019) or perturb the posterior prediction.
We focus on the latter since detection involves making strong assumptions on adversarial query patterns.
Perturbation-based defenses are predominantly non-randomized and accuracy-preserving (i.e., top-1 label is unchanged).
Ap- proaches include revealing probabilities only of conﬁdent classes (Orekondy et al., 2019), rounding probabilities (Tram`er et al., 2016), or introducing ambiguity in posteriors (Lee et al., 2018).
None of the existing defenses claim to mitigate model stealing, but rather they only marginally delay the attack by increasing the number of queries.
Our work focuses on presenting an effective defense, signiﬁcantly decreasing the attacker’s query sample efﬁciency within a principled utility-constrained framework.
P RELIMINARIES
Model Functionality Stealing.
Model stealing attacks are cast as an interaction between two parties: a victim/defender V (‘teacher’ model) and an attacker A (‘student’ model).
The only means of communication between the parties are via black-box queries: attacker queries inputs x ∈ X and defender returns
a posterior probability distribution y ∈ ∆ K = P ( y | x ) =
F V ( x ) , where ∆ K = { y (cid:23) 0 , 1 T y = 1 } is the probability simplex over K classes (we use K instead of K −for notational convenience).
The attack occurs in two (sometimes overlapping) phases: (i) querying : the attacker uses the black-box as an oracle labeler on a set of inputs to construct a ‘transfer set’ of input-prediction pairs D transfer = { ( x i , y i ) } B i =1 ; and (ii) training : the attacker trains a model F A to minimize the empirical risk on D transfer .
The end-goal of the attacker is to maximize accuracy on a held-out test-set (considered the same as that of the victim for evaluation purposes).
Knowledge-limited Attacker.
In model stealing, attackers justiﬁably lack complete knowledge of the victim model F V .
Of speciﬁc interest are the model architecture and the input data distribution to train the victim model P V ( X ) that are not known to the attacker.
Since prior work (Hinton et al., 2015; Papernot et al., 2016; Orekondy et al., 2019) indicates functionality largely transfers across architecture choices, we now focus on the query data used by the attacker.
Existing attacks can be broadly categorized based on inputs { x ∼ P A ( X ) } used to query the black-box: (a) independent distribution : (Tram ` er et al., 2016; Correia-Silva et al., 2018; Orekondy et al., 2019) samples inputs from some distribution (e.g., ImageNet for images, uniform noise) independent to input data used to train the victim model; and (b) synthetic set : (Papernot et al., 2017b; Juuti et al., 2019) augment a limited set of seed data by adaptively querying perturbations (e.g., using FGSM) of existing inputs.
We address both attack categories in our paper.
We perturb predictions in a controlled setting: ˜
y = F δV ( x ) =
y + δ s.t.
˜ y , y ∈ ∆ K .
The defender has two (seemingly conﬂicting) objectives: (i) utility : such that perturbed predictions remain useful to a benign user.
We consider two utility measures: (a) Acc( F δV , D test ) : accuracy of defended model on test examples; and (b) dist ( y , ˜ y ) =
|| y − ˜
y
|| p
= (cid:15) to measure perturbation.
(ii) non-replicability
to reduce the test accuracy of an attacker (denoted as Acc( F A , D test ) ) who exploits the predictions to train a replica F A on D transfer .
For consistency, we evaluate both the defender’s and attacker’s stolen model accuracies on the same set of test examples D test .
Defender’s Assumptions. We closely mimic an assumption-free scenario similar to existing perturbation-based defenses.
The scenario entails the knowledge-limited defender: (a) unaware whether a query is malicious or benign; (b) lacking prior knowledge of the strategy used by an attacker; and (c) perturbing each prediction independently (hence circumventing Sybil attacks).
For added rigor, we also study attacker’s countermeasures to our defense in Section 5.
A PPROACH : M AXIMIZING A NGULAR D EVIATION BETWEEN G RADIENTS
Motivation: Targeting First-order Approximations.
We identify that the attacker eventually optimizes parameters of a stolen model F ( · ; w ) (we drop the subscript · A for readability) to minimize the loss on training examples { ( x i , ˜ y i ) } .
Common to a majority of optimization algorithms is estimating the ﬁrst-order approximation of the empirical loss, by computing the gradient of the loss w.r.t.
the model parameters w ∈ R D :
[Equation]
Maximizing Angular Deviation ( MAD ).
The core idea of our approach is to perturb the posterior probabilities y which results in an adversarial gradient signal that maximally deviates (see Fig. 2) from the original gradient (Eq. 1).
More formally, we add targeted noise to the posteriors which results in a gradient direction:
[Equation]
to maximize the angular deviation between the original and the poisoned gradient signals:
[Equation]
Given that the attacker model is trained to match the posterior predictions, such as by minimizing the cross-entropy loss L ( y , ˜ y )
= − (cid:80)
k
˜ y
k log y k we rewrite Equation (2) as:
[Equation]
where G ∈ R K × D represents the Jacobian over log-likelihood predictions F ( x ; w ) over K classes w.r.t.
parameters w ∈ R D .
By similarly rewriting Equation (1), substituting them in Equation (3) and including the constraints, we arrive at our poisoning objective (Eq. 4-7) of our approach which we refer to as MAD .
We can optionally enforce preserving accuracy of poisoned prediction via constraint (8), which will be discussed shortly.
[Equation]
[Equation]
where G = ∇ w log F ( x ; w )
[Equation]
G
[Equation] [Equation]
s.
[Equation]
(Simplex constraint
[Equation]
[Equation]
The above presents a challenge of black-box optimization problem for the defense since the defender justiﬁably lacks access to the attacker model F (Eq. 5). Apart from addressing this challenge in the next few paragraphs, we also discuss (a) solving a non-standard and non-convex constrained maximization objective; and (b) preserving accuracy of predictions via constraint (8).
Estimating G .
Since we lack access to adversary’s model F , we estimate the jacobian G = ∇ w log F sur ( x ; w ) (Eq. 5) per input query x using a surrogate model F sur . We empirically determined (details in Appendix E.1) choice of architecture of F sur robust to choices of adversary’s architecture F .
However, the initialization of F sur plays a crucial role, with best results on a ﬁxed randomly initialized model. We conjecture this occurs due to surrogate models with a high loss provide better gradient signals to guide the defender.
Heuristic Solver. Gradient-based strategies to optimize objective (Eq. 4) often leads to poor local maxima.
This is in part due to the objective increasing in all directions around point y (assuming G is full-rank), making optimization sensitive to initialization.
Consequently, we resort to a heuristic to solve for ˜ y .
Our approach is motivated by Hoffman (1981), who show that the maximum of a convex function over a compact convex set occurs at the extreme points of the set.
Hence, our two-step solver: (i) searches for a maximizer y ∗ for (4) by iterating over the K extremes y k (where y k =1) of the probability simplex ∆ K ; and (ii) then computes a perturbed posterior ˜ y as a linear interpolation of the original posteriors y and the maximizer y ∗ :
˜ y
=
(1 − α )
y + α y ∗ , where α is selected such that the utility constraint (Eq. 7) is satisﬁed.
We further elaborate on the solver and present a pseudocode in Appendix C.
Variant: MAD-argmax .
Within our defense formulation, we encode an additional constraint (Eq. to preserve the accuracy of [-predictions: dist-argmax ( y , ˜ y ) = 
-]perturbed predictions. MAD-argmax variant helps us perform accuracy-preserving perturbations similar to prior work.
But in contrast, the perturbations are constrained (Eq. 7) and are speciﬁcally introduced to maximize the MAD objective.
We enforce the accuracy-preserving constraint in our solver by iterating over extremes of intersection of sets Eq.(6) and (8): ∆ K k = { y (cid:23) 0 , 1 T y = 1 , y k ≥ y j , k (cid:54) =
j } ⊆ ∆ K .
E XPERIMENTAL R ESULTS 5. E XPERIMENTAL S ETUP
Victim Models and Datasets.
We set up six victim models (see Table 1), each model trained on a popular image classiﬁcation dataset.
All models are trained using SGD (LR = 0.1) with momentum (0.5) for 30 (LeNet) or 100 epochs (VGG16), with a LR decay of 0.1 performed every 50 epochs.
We train and evaluate each victim model on their respective train/test sets.
[Table]
Attack Strategies.
We hope to broadly address all DNN model stealing strategies during our defense evaluation.
To achieve this, we consider attacks that vary in query data distributions (independent and synthetic; see Section 3) and strategies (random and adaptive).
Speciﬁcally, in our experiments we use the following attack models: (i) Jacobian-based Data Augmentation ‘ JBDA ’ (Papernot et al., 2017b); (ii,iii) ‘ JB-self ’ and ‘ JB-top3 ’ (Juuti et al., 2019); and (iv) Knockoff Nets ‘ knockoff ’ (Orekondy et al., 2019); We follow the default conﬁgurations of the attacks where possible.
A recap and implementation details of the attack models are available in Appendix D.
In all attack strategies, the adversary trains a model F A to minimize the cross-entropy loss on a transfer set ( D transfer = { ( x i , ˜ y i ) } Bi =1 ) which is obtained by iteratively querying inputs x i (sampled or adaptively synthesized) to the defender’s model.
By default, we use B =50K queries, which achieves reasonable performance for all attacks and additionally makes defense evaluation tractable.
In line with prior work (Papernot et al., 2016; Orekondy et al., 2019), we too ﬁnd (Section 5.2.3) attack and defense performances are unaffected by choice of architectures, and hence use the victim architecture for the stolen model F A .
Due to the complex parameterization of VGG-16 (100M+), we initialize the weights from a pretrained TinyImageNet or ImageNet model (except for the last
FC layer, which is trained from scratch).
All stolen models are trained using SGD (LR=0.1) with momentum (0.5) for 30 epochs (LeNet) and 100 epochs (VGG16).
We ﬁnd choices of attacker’s architecture and optimization does not undermine the defense (discussed in Section 5.2.3).
Effectiveness of Attacks.
We evaluate accuracy of resulting stolen models from the attack strategies as-is on the victim’s test set, thereby allowing for a fair head-to-head comparison with the victim model (additional details in Appendix A and D).
The stolen model test accuracies, along with undefended victim model F V accuracies are reported in Table 1.
We observe for all six victim models, using just 50K black-box queries, attacks are able to signiﬁcantly extract victim’s functionality e.g., > 87% on MNIST.
We ﬁnd the knockoff attack to be the strongest, exhibiting reasonable performance even on complex victim models e.g., 74.6% (0.93 × Acc( F V ) ) on Caltech256.
How Good are Existing Defenses?
Most existing defenses in literature (Tram`er et al., 2016;
Orekondy et al., 2019; Lee et al., 2018) perform some form of information truncation on the posterior probabilities e.g., rounding, returning top- k labels; all strategies preserve the rank of the most conﬁdent label.
We now evaluate model stealing attacks on the extreme end of information truncation, wherein the defender returns just the top-1 ‘argmax’ label.
This strategy illustrates a rough lower bound on the strength of the attacker when using existing defenses.
Speciﬁc to knockoff , we observe the attacker is minimally impacted on simpler datasets (e.g., 0.2% accuracy drop on
CIFAR10; see Fig. A5 in Appendix).
While this has a larger impact on more complex datasets involving numerous classes (e.g., a maximum of 23.4% drop observed on CUB200), the strategy also introduces a signiﬁcant perturbation ( L 1 =1 ± 0.5) to the posteriors.
The results suggest existing defenses, which largely preserve the top-1 label, are ineffective at mitigating model stealing attacks.
Defenses: Evaluation.
We evaluate all defenses on a non-replicability vs. utility curve at various operating points (cid:15) of the defense.
We furthermore evaluate the defenses for a large query budget (50K).
We use as non-replicability the accuracy of the stolen model on held-out test data D test .
We use two utility metrics: (a) accuracy: test-accuracy of the defended model producing perturbed predictions on D test ; and (b) perturbation magnitude (cid:15) : measured as L 1 distance || y − ˜
y
|| 1 .
[Figure]
Defense: Baselines.
We compare our approaches against three methods: (i) reverse-sigmoid (Lee et al., 2018): which softens the posterior distribution and introduces ambiguity among nonargmax probabilities.
For this method, we evaluate non-replicability and utility metrics for the defense operating at various choices of their hyperparameter β ∈ [0 , 1] , while keeping their datasetspeciﬁc hyperparameter γ ﬁxed (MNIST: 0.2, FashionMNIST: 0.4, CIFAR10: 0.1, rest: 0.2).
(ii) random noise : For controlled random-noise, we add uniform random noise δ z on the logit prediction scores (
˜ z
= z + δ z , where z = log( y 1 − y ) ), enforce utility by projecting δ z to an (cid:15)
z -ball (Duchi et al., 2008), and renormalizing probabilities ˜ y
= 1 1+ e − ˜ z .
(iii) dp-sgd : while our method and previous two baselines perturbs predictions , we also compare against introducing randomization to victim model parameters by training with the DP-SGD algorithm (Abadi et al., 2016).
DP is a popular technique to protect the model against training data inference attacks.
This baseline allows us to verify whether the same protection extends to model functionality.
5. R ESULTS
In the follow sections, we demonstrate the effectiveness of our defense rigorously evaluated across a wide range of complex datasets, attack models, defense baselines, query, and utility budgets.
For readability, we ﬁrst evaluate the defense against attack models, proceed to comparing the defense against strong baselines and then provide an analysis of the defense.
5.2. MAD D EFENSE VS . A TTACKS
Figure 3 presents evaluation of our defenses MAD (Eq. 4-7) and MAD-argmax (Eq. 4-8) against the four attack models.
To successfully mitigate attacks as a defender, we want the defense curves (solid lines with operating points denoted by thin crosses) to move away from undefended accuracies (denoted by circles, where (cid:15) =0.0) to ideal defense performances (cyan cross, where Acc(Def.) is unchanged and Acc(Att.) is chance-level).
We observe from the Figure 3 that by employing an identical defense across all datasets and attacks, we ﬁnd the effectiveness of the attacker can be greatly reduced.
Across all models, we ﬁnd
MAD provides reasonable operating points (above the diagonal), where defender achieves signiﬁcantly higher test accuracies compared to the attacker.
For instance, on MNIST, for < 1% drop in defender’s accuracy, our defense simultaneously reduces accuracy of the jbtop3 attacker by 64% (99.4% → 35.7%) and knockoff by 30% (99.4% → 69.8%).
We ﬁnd similar promising results even on high-dimensional complex datasets e.g., on CUB200, a 23% (65% → 41.9%) performance drop of knockoff for 2% drop in defender’s test performance.
Our results indicate effective defenses are achievable, where the defender can trade-off a marginal utility cost to drastically impede the attacker.
5.2. MAD D EFENSE VS . B ASELINE D EFENSES
We now study how our approach compares to baseline defenses, by evaluating the defenses against the knockoff attack (which resulted in the strongest attack in our experiments).
From Figure 4, we observe:
(i) Utility objective =
L 1 distance (Fig. 4a):
Although random-noise and reverse-sigmoid reduce attacker’s accuracy, the strategies in most cases involves larger perturbations.
In contrast, MAD and
[Figure] [Figure] Follow-up to Figure 4b (CI- FAR10), but with attacker using only the argmax label.
[Figure] [Figure] MAD-argmax provides similar non-replicability (i.e., Acc(Att.) ) with signiﬁcantly lesser perturbation, especially at lower magnitudes.
For instance, on MNIST (ﬁrst column), MAD ( L 1 = 0.95) reduces the accuracy of the attacker to under 80% with 0.63 × the perturbation as that of reversesigmoid and random-noise ( L 1 ≈ 1.5).
(ii) Utility objective = argmax-preserving (Fig. 4b): By setting a hard constraint on retaining the label of the predictions, we ﬁnd the accuracy-preserving defenses MAD-argmax and reverse-sigmoid successfully reduce the performance of the attacker by at least 20% across all datasets.
In most cases, we ﬁnd MAD-argmax in addition achieve this objective by introducing lesser distortion to the predictions compared to reverse-sigmoid
For instance, in Fig.
4a, we ﬁnd MAD-argmax consistently reduce the attacker accuracy to the same amount at lesser L 1 distances.
In reverse-sigmoid, we attribute the large L 1 perturbations to a shift in posteriors towards a uniform distribution e.g., mean entropy of perturbed predictions is 3.02 ± 0.16 (max-entropy = 3.32) at L 1 =1.0 for MNIST; in contrast, MAD-argmax displays a mean entropy of 1.79 ± 0.11.
However, common to accuracypreserving strategies is a pitfall that the top-1 label is retained.
In Figure 5 (see overlapping red and yellow cross-marks), we present the results of training the attacker using only the top-1 label.
In line with previous discussions, we ﬁnd that the attacker is able to signiﬁcantly recover the original performance of the stolen model for accuracy-preserving defenses MAD-argmax and reverse-sigmoid.
(iii) Non-replicability vs. utility trade-off (Fig. 4b): We now compare our defense MAD (blue lines) with other baselines ( rand-noise and dp-sgd ) which trade-off utility to mitigate model stealing.
Our results indicate MAD offers a better defense (lower attacker accuracies for similar defender accuracies).
For instance, to reduce the attacker’s accuracy to < 70%, while the defender’s accuracy signiﬁcantly degrades using dp-sgd (39%) and rand-noise (56.4%), MAD involves a marginal decrease of 1%. [Figure] [Figure]
[Figure] [Figure] [Figure] A NALYSIS
How much angular deviation does MAD introduce?
To obtain insights on the angular deviation induced between the true and the perturbed gradient [Figure] we conduct an experiment by tracking the true gradient direction (which was unknown so far) at each training step.
We simulate this by training an attacker model using online SGD (LR=0.001) over N iterations using B distinct images to query and a batch size of 1.
At each step t of training, the attacker queries a randomly sampled input x t to the defender model and backpropogates the loss resulting from ˜ y t .
In this particular experiment, the perturbation ˜ y t is crafted having exact knowledge of the attacker’s parameters.
We evaluate the angular deviation between gradients with ( a ) and without ( u ) the perturbation.
In Figure
[Figure]
we visualize a histogram of deviations: θ = arccos [Equation] || , where u = ∇ w L ( w t , y , · ) and a = ∇ w L ( w t , ˜ y , · ) .
We observe: (i) although our perturbation space is severely restricted (a low-dimensional probability simplex), we can introduce surprisingly high deviations (0-115 ◦ ) in the high-dimensional parameter space of the VGG16; (ii) for (cid:15) values at reasonable operating points which preserves the defender’s accuracy within 10% of the undefended accuracy (e.g., (cid:15) ∈ [0.95, 0.99] for CIFAR10), we see deviations with mean 24.9 ◦ (yellow bars in Fig. 6).
This indicates that the perturbed gradient on an average leads to a slower decrease in loss function; (iii) on the extreme end, with (cid:15)
=
(cid:15) max
= 2, on an average, we ﬁnd the perturbations successfully ﬂips ( > 90 ◦ ) the gradient direction leading to an increase on the test loss, as seen in Figure 7 (blue line).
We also ﬁnd the above observations reasonably transfers to a black-box attacker setting (see Appendix F.4), where the perturbations are crafted without knowledge of the attacker’s parameters.
Overall, we ﬁnd our approach considerably inﬂuences the gradient direction.
Ablative Analysis.
We present an ablation analysis of our approach in Figure 8.
In this experiment, we compare our approach MAD and MAD-argmax to: (a) G
= I : We substitute the jacobian G (Eq. 5) with a K × K identity matrix; and (b) y ∗ =rand :
Inner maximization term (Eq. 4) returns a random extreme of the simplex.
Note that both (a) and (b) do not use the gradient information to perturb the posteriors.
From Figure 8, we observe: (i) poor performance of y ∗ =rand , indicating random untargeted perturbations of the posterior probability is a poor strategy; (ii) G
=
I , where the angular deviation is maximized between the posterior probability vectors is a slightly better strategy; (iv) MAD outperforms the above approaches.
Consequently, we ﬁnd using the gradient information (although a proxy to the attacker’s gradient signal) within our formulation (Equation 4) is crucial to providing better model stealing defenses.
Subverting the Defense.
We now explore various strategies an attacker can use to circumvent the defense.
To this end, we evaluate the following strategies: (a) argmax : attacker uses only the most-conﬁdent label during training; (b) arch-
* : attacker trains other choices of architectures; (c) nquery : attacker queries each image multiple times; (d) nquery+aug : same as (c), but with random cropping and horizontal ﬂipping; and (e) opt-* : attacker uses an adaptive LR optimizer e.g., ADAM (Kingma & Ba, 2014).
We present results over the subversion strategies in Figure 9.
We ﬁnd our defense robust to above strategies.
Our results indicate that the best strategy for the attacker to circumvent our defense is to discard the probabilities and rely only on the most conﬁdent label to train the stolen model.
In accuracy-preserving defenses (see Fig. 5), this previously resulted in an adversary entirely circumventing the defense (recovering up to 1.0 × original performance).
In contrast, we ﬁnd MAD is nonetheless effective in spite of the strategy, maintaining a 9% absolute accuracy reduction in attacker’s stolen performance.
C ONCLUSION
In this work we were motivated by limited success of existing defenses against DNN model stealing attacks.
While prior work is largely based on passive defenses focusing on information truncation, we proposed the ﬁrst active defense strategy that attacks the adversary’s training objective.
We found our approach effective in defending a variety of victim models and against various attack strategies.
In particular, we ﬁnd our attack can reduce the accuracy of the adversary by up to 65%, without signiﬁcantly affecting defender’s accuracy
Appendix A O VERVIEW AND N OTATION
[Figure] train build Utility Metric
Non
[Figure]
Replicability
Metric Utility
[Figure]
Adversary x Inputs (images ∈ [Table] ) y ,
[Table]
Original,
[Table]
predictions ∆
[Table]
Probability simplex over
[Table]
vertices
Attacker A
P A ( X )
Attacker’s input data distribution
D transfer
Transfer set ( = { ( x i , y i ) } , where x i ∼ P
A
( X ) ,
y i
= F V ( x i ) )
F A
Attacker’s (stolen) model trained on D transfer
Victim/Defender V
P V ( X )
Victim’s input data distribution
D train
Training data ( = { ( x i , y i ) } , where x i ∼ P V ( X ) )
F V
Undefended model trained on D train
F δ V
Defended model
D test
Test set ( = { ( x i , y i ) } , where x i ∼ P V
( X ) )
B R ELATED W ORK : E XTENSION
A summary of existing model stealing attacks and defenses is presented in Table A2.
C D ETAILED A LGORITHM
We present a detailed algorithm (see Algorithm 1) for our approach described in Section 4. The algorithm roughly follows four steps:
(i) Predict (L2) :
Obtains posterior probability predictions y for input x using a victim model F V ( x ; w V ) .
[Table]
(ii) Estimate Jacobian G (L3) : We estimate a R K × D jacobian matrix on a surrogate model F . By default, we use as F a randomly initialized model (more details in Appendix E.1). Each row of G represents the gradient direction (in parameter space R D ) over log likelihood of class k . (iii) Maximize MAD Objective (L4) :
We ﬁnd the optimal direction y ∗ which maximizes the MAD objective (Eq. 3).
To compute the arg max , we iterative over the K extremes of the probability simplex ∆ K to ﬁnd y ∗ which maximizes the objective.
The extreme y k denotes a probability vector with y k = 1 .
(iv) Enforce Utility Constraint (L5-7) :
We enforce the perturbation utility constraint (Eq. 7) by considering a linear interpolation of y ∗ and y .
The resulting interpolation probability vector ˜ y
= h ( α ∗ ) represents the utility-constrained perturbed prediction that is returned instead of y .
[Table]
PerturbedPredict-MAD
[Table] x ) [Table] Input: Input data x , model to defend F V ( · ; w V ) , proxy attacker model F ( · ; w ) Output: Perturbed posterior probability
y
∆ K s. dist y , y ) ≤ (cid:15) [Table]
y
[Table] = F V ( x ; w V )
Obtain posteriors
[Table]
[Equation]
∇ w log F ( x ; w ) //
[Table]
[Equation] G T y k || G T y k
{+|| 2 − G T y || G T y || 
+}
(cid:13)(cid:13)(cid:13) 2// Alternatively ext( ∆ Kk ) for MAD-argmax
Deﬁne h
( α ) = (1 − α )
y + α y ∗ α ∗ :=
arg max α ∈ [0 , 1] , dist ( · ) ≤ (cid:15) dist ( h ( α ) , y ∗ ) // Find optimal step-size via bisection, or OptStep(.) for L p norms ˜
y :
= h ( α ∗ ) //
Perturbed probabilities 8 return ˜ y 10 Function OptStep( y , y ∗ , (cid:15), p ) : α ∗ := max (cid:110) (cid:15) ||
y − y ∗ || p ,(cid:111)
12 return α ∗
D A TTACK M ODELS : R ECAP AND I MPLEMENTATION D ETAILS
Jacobian Based Data Augmentation ( jbda ) (Papernot et al., 2017b).
The motivation of the approach is to obtain a surrogate of the victim black-box classiﬁer, with an end-goal of performing evasion attacks (Biggio et al., 2013; Goodfellow et al., 2014).
We restrict discussions primarily to the ﬁrst part of constructing the surrogate.
To obtain the surrogate (the stolen model), the authors depend on an unlabeled ‘seed’ set, typically from the same distribution as that used to train the victim model.
As a result, the attacker assumes (mild) knowledge of the input data distribution and the class-label of the victim.
The key idea behind the approach is to query perturbations of inputs, to obtain a reasonable approximation of the decision boundary of the victim model.
The attack strategy involves performing the following steps in a repeated manner: (i) images from the substitute set (initially the seed) D is labeled by querying the victim model F V as an oracle labeler; (ii) the surrogate model F A is trained on the substitute dataset; (iii) the substitute set is augmented using perturbations of existing images:
D ρ +
= D ρ ∪ { x + λ ρ +1 · sgn
( J F [ F A ( x )]) : x ∈ D ρ } , where J is the jacobian function.
We use a seed set of: 100 (MNIST and FashionMNIST), 500 (CIFAR10, CUB200, Caltech256) and 1000 (CIFAR100).
We use the default set of hyperparameters of Papernot et al.
(2017b)
in other respects.
Jacobian Based { self, top-k } ( jbself , jbtop3 ) (Juuti et al., 2019) .
The authors generalize the above approach, by extending the manner in which the synthetic samples are produced.
In jbself , the jacobian is calculated w.r.t to k nearest classes and in jb-self , w.r.t the maximum a posterior class predicted by F A .
Knockoff Nets ( knockoff ) (Orekondy et al., 2019) .
Knockoff is a recent attack model, which demonstrated model stealing can be performed without access to seed samples.
Rather, the queries to the black-box involve natural images (which can be unrelated to the training data of the victim model) sampled from a large independent data source e.g., ImageNet1K.
Consequently, no knowledge of the input data distribution nor the class-label space of the victim model is required to perform model stealing.
The paper proposes two strategies on how to sample images to query: random and adaptive.
We use the random strategy in the paper, since adaptive resulted in marginal increases in an open-world setup (which we have).
As the independent data sources in our knockoff attacks, we use: EMNIST-Letters (when stealing
MNIST victim model), EMNIST (FashionMNIST), CIFAR100 (CIFAR10), CIFAR10 (CIFAR100),
ImageNet1k (CUB200, Caltech256).
Overlap between query images and the training data of the victim models are purely co-incidental.
We use the code from the project’s public github repository.
Evaluating Attacks.
The resulting replica model F A from all the above attack strategies are evaluated on a held-out test set.
We remark that the replica model is evaluated as-is, without additional ﬁnetuning or modiﬁcations.
Similar to prior work, we evaluate the accuracies of F A on the victim’s held-out test set.
Evaluating both stolen and the victim model on the same test set allows for fair head-to-head comparison.
E S UPPLEMENTARY A NALYSIS
In this section, we present additional analysis to supplement Section 5.2.3. E. E STIMATING G Central to our defense is estimating the jacobian matrix G = ∇ w log F ( x ; w ) (Eq. 5), where
F ( · ; w ) is the attacker’s model.
However, a defender with black-box attacker knowledge (where F is unknown) requires determining G by instead using a surrogate model F sur .
We determine choice of F sur empirically by studying two factors: (a) architecture of F sur : choice of defender’s surrogate architecture robust to varying attacker architectures (see Fig. A2); and (b) initialization of F sur : initialization of the surrogate model parameters plays a crucial role in providing a better defense.
We
[Figure]
[Figure]
[Table]
[Table]
consider four choices of initialization: { ‘rand’, ‘early’, ‘mid’, ‘late’ } which exhibits approximately { chance-level 25%, 50%, 75% } test accuracies respectively.
We observe (see Fig.
A3) that a randomly initialized model, which is far from convergence, provides better gradient signals in crafting perturbations.
E. R UN - TIME A NALYSIS
We present the run-times of our defended and undefended models in Table A3.
The reported numbers were summarized over 10K unique predictions performed on an Nvidia Tesla V100.
We ﬁnd our optimization procedure Eq.
(4-7) for all models take under a second, with at most 0.8s in the case of Caltech256.
The primary computational bottleneck of our defense implementation is estimating matrix G ∈ R K × D in Eq.
5, which currently requires performing K (i.e., number of output classes) backward passes through the surrogate model.
F A DDITIONAL P LOTS F. A TTACKER E VALUATION
We present evaluation of all attacks considered in the paper on an undefended model in Figure A4.
Furthermore, speciﬁc to the knockoff attack, we analyze how training using only the top-1 label (instead of complete posterior information) affects the attacker in Figure A5.
F. B UDGET VS . A CCURACY
We plot the budget (i.e., number of distinct black-box attack queries to the defender) vs. the test accuracy of the defender/attacker in Figure A6.
The ﬁgure supplements Figure 1 and the discussion found in Section 5.2.1 of the main paper. [Figure] [Figure] [Figure]
F a s h
i o n M N I S TE M N I S T T e s t A cc u r a c y
[Figure]
[Figure]
[Figure]
t e s t - l o ss ( a tt a c k e r )
[Figure]
[Figure]
[Figure] [Figure] ‘ = [Figure]
MNIST
[Figure]
F. A TTACKER ARGMAX
In Figure A7, we perform the non-replicability vs. utility evaluation (complementing Fig.
in the main paper) under a special situation: the attacker discards the probabilities and only uses the top- ‘argmax’ label to train the stolen model.
Relevant discussion can be found in Section 5.2.2.
F. B LACK - BOX A NGULAR D EVIATIONS
In Figure A8, we provide the angular deviations obtained in a black-box setting over the course of training the attack model.
We train the attacker model using the transfer set obtained by the knockoff approach (the strongest attacker in our experiments) for 50 epochs using a SGD (lr = 0.01, momentum = 0.5) and a batch size of 64.
The experiment compliments our previous discussion in Section 5.2.3 of the main paper under “How much angular deviation does MAD introduce?”.
As before, we estimate the angular deviations as: θ = arccos u · a || u |||| a || , where u = ∇ w L ( w t , y , · ) and a = ∇ w L ( w t , ˜ y , · ) .
We observe from Figure A8: (i) the defensive angular deviations introduced by MAD to posterior predictions transfer to a black-box attacker setting, when crafting perturbations without access to the adversary’s model parameters; and (ii) although the setting introduces lower angular deviations at the extreme case of (cid:15) =2.0 (e.g., 114.7 ◦ → 76.5 ◦ in CIFAR10), we observe the perturbation sufﬁcient to maximize the attacker’s test loss.
We ﬁnd signiﬁcant angular deviations introduced by our approach in a black-box setting as well.
F. MAD A BLATION E XPERIMENTS
We present the ablation experiments covering all defender models in Figure A9.
Relevant discussion is available in Section 5.2.3 of the main paper under “Ablative Analysis”. [Figure]