The pervasiveness of machine learning exposes new vulnerabilities in software systems, in which deployed machine learning models can be used (a) to reveal sensitive information in private training data (Fredrikson et al., 2015), and/or (b) to make the models misclassify, such as adversarial examples (Carlini & Wagner, 2017). Efforts to prevent such attacks typically seek one of three solutions: (1) Models which preserve differential privacy (DP) (Dwork et al., 2006), a rigorous formulation of privacy in probabilistic terms; (2) Adversarial training algorithms, which augment training data to consist of benign examples and adversarial examples crafted during the training process, thereby empirically increasing the classification accuracy given adversarial examples (Kardan & Stanley, 2017;Matyasko & Chau, 2017); and (3) Certified robustness, in which the model classification given adversarial examples is theoretically guaranteed to be consistent, i.e., a small perturbation in the input does not change the predicted label (Cisse et al., 2017;Kolter & Wong, 2017;Salman et al., 2019).
On the one hand, private models, trained with existing privacy-preserving mechanisms (Abadi et al., 2016;Shokri & Shmatikov, 2015;Phan et al., 2016;2017a;b;Yu et al., 2019;Lee & Kifer, 2018), are unshielded under adversarial examples. On the other hand, robust models, trained with adversarial learning (with or without certified robustness to adversarial examples), do not offer privacy protections to the training data (Song et al., 2019). That one-sided approach poses serious risks to machine learning-based systems; since adversaries can attack a deployed model by using both privacy inference attacks and adversarial examples. To be safe, a model must be i) private to protect the training data, and ii) robust to adversarial examples. Unfortunately, there still lacks of study on how to develop such a model, which thus remains a largely open challenge (Phan et al., 2019).
Simply combining existing DP-preserving mechanisms and certified robustness conditions (Cisse et al., 2017;Kolter & Wong, 2017;Raghunathan et al., 2018) cannot solve the problem, for many reasons. (a) Existing sensitivity bounds (Phan et al., 2016;2017a;b) and designs (Yu et al., 2019;Lee & Kifer, 2018;Phan et al., 2019;Wu et al., 2019;Xu et al., 2020) have not been developed to protect the training data in adversarial training. It is obvious that using adversarial examples crafted from the private training data to train our models introduces a previously unknown privacy risk, disclosing the participation of the benign examples (Song et al., 2019). (b) There is an unrevealed interplay among DP preservation, adversarial learning, and robustness bounds. (c) Existing algorithms cannot be readily applied to address the trade-off among model utility, privacy loss, and robustness. (d) It is challenging in applying existing algorithms to train large DNNs given large data (i.e., scalability); since, they employ the vanilla iterative batch-by-batch training, in which only a single batch of data instances can be used at each training step, such that the privacy loss can be es-timated (Lee & Kifer, 2018;Phan et al., 2019;Yu et al., 2019;Wu et al., 2019;Xu et al., 2020). That prevents us from applying scalable methods, e.g., distributed adversarial training (Goyal et al., 2017), to achieve the same level of DP on large DNNs and datasets. Therefore, bounding the robustness of a model (which both protects the privacy and is robust against adversarial examples) at scale is nontrivial.
Motivated by this open problem, we develop a novel stochastic batch (StoBatch) mechanism to: 1) preserve DP of the training data, 2) be provably and practically robust to adversarial examples, 3) retain high model utility, and 4) be scalable to large DNNs and datasets.
• In StoBatch, privacy-preserving noise is injected into inputs and hidden layers to achieve DP in learning private model parameters (Theorem 1). Then, we incorporate ensemble adversarial learning into our mechanism to improve the decision boundary under DP protections, by introducing a concept of DP adversarial examples crafted using benign examples in the private training data (Eq. 8). To address the trade-off between model utility and privacy loss, we propose a new DP adversarial objective function to tighten the model's global sensitivity (Theorem 3); thus, we reduce the amount of noise injected into our function, compared with existing works (Phan et al., 2016;2017a;b). An end-to-end privacy analysis shows that, by slitting the private training data into disjoint and fixed batches across epochs, the privacy budget in our StoBatch is not accumulated across gradient descent-based training steps (Theorems 3, 4).
• After preserving DP in learning model parameters, we establish a new connection between DP preservation in adversarial learning and certified robustness. Noise injected into different layers is considered as a sequence of randomizing mechanisms, providing different levels of robustness. By leveraging the sequential composition theory in DP (Dwork & Roth, 2014), we derive a generalized robustness bound, which is a composition of these levels of robustness in both input and latent spaces (Theorem 5 and Corollary 1), compared with only in the input space (Salman et al., 2019) or only in the latent space (Lecuyer et al., 2018).
• To bypass the iterative batch-by-batch training, we develop a stochastic batch training. In our algorithm, disjoint and fixed batches are distributed to local trainers, each of which learns DP parameters given its local data batches. A synchronous scheme can be leveraged to aggregate gradients observed from local trainers; thus enabling us to efficiently compute adversarial examples from multiple data batches at each iteration. This allows us to scale our mechanism to large DNNs and datasets, under the same DP guarantee. Rigorous experiments conducted on MNIST, CIFAR-10 ( Lecun et al., 1998;Krizhevsky & Hinton, 2009), and (TinyIma-geNet) datasets show that our mechanism notably enhances the robustness and scalability of DP DNNs.
In this section, we revisit DP, adversarial learning, and certified robustness. Let D be a database that contains N tuples, each of which contains data x ∈ [-1, 1] d and a ground-truth label y ∈ Z K (one-hot vector), with K possible categorical outcomes y = {y 1 , . . . , y K }. A single true class label y x ∈ y given x ∈ D is assigned to only one of the K categories. On input x and parameters θ, a model outputs class scores f : R d → R K that maps x to a vector of scores f (x) = {f 1 (x), . . . , f K (x)} s.t. ∀k ∈ [1, K] : f k (x) ∈ [0, 1] and K k=1 f k (x) = 1. The class with the highest score value is selected as the predicted label for x, denoted as y(x) = max k∈K f k (x). A loss function L(f (x), y) presents the penalty for mismatching between the predicted values f (x) and original values y. The notations and terminologies used in this paper are summarized in Table 1 (Appendix A). Let us briefly revisit DP DNNs, starting with the definition of DP.
Definition 1 ( , δ)-DP (Dwork et al., 2006). A randomized algorithm A fulfills ( , δ)-DP, if for any two databases D and D differing at most one tuple, and for all O ⊆ Range(A), we have:
controls the amount by which the distributions induced by D and D may differ, δ is a broken probability.
DP also applies to general metrics ρ(D, D ) ≤ 1, where ρ can be l p -norms (Chatzikokolakis et al., 2013). DPpreserving algorithms in DNNs can be categorized into three lines: 1) introducing noise into parameter gradients (Abadi et al., 2016;2017;Shokri & Shmatikov, 2015;Yu et al., 2019;Lee & Kifer, 2018;Phan et al., 2019), 2) injecting noise into objective functions (Phan et al., 2016;2017a;b), and 3) injecting noise into labels (Papernot et al., 2018).
Adversarial Learning. For some target model f and inputs (x, y x ), the adversary's goal is to find an adversarial example x adv = x + α, where α is the perturbation introduced by the attacker, such that: (1) x adv and x are close, and (2) the model misclassifies x adv , i.e., y(x adv ) = y(x). In this paper, we consider well-known l p∈{1,2,∞} (µ)-norm bounded attacks (Goodfellow et al., 2014), where µ is the radius of the p-norm ball. To improve the robustness of models, prior work focused on two directions: 1) Producing correct predictions on adversarial examples, while not compromising the accuracy on legitimate inputs (Kardan & Stanley, 2017;Matyasko & Chau, 2017;Wang et al., 2016;Papernot et al., 2016b;a;Gu & Rigazio, 2014;Papernot & McDaniel, 2017;Hosseini et al., 2017); and 2) Detecting adversarial examples (Metzen et al., 2017;Grosse et al., 2017;Xu et al., 2017;Abbasi & Gagné, 2017;Gao et al., 2017). Among existing solutions, adversarial training appears to hold the greatest promise for learning robust models (Tramèr et al., 2017). A well-known algorithm was proposed in (Kurakin et al., 2016b). At every training step, new adversarial examples are generated and injected into batches containing both benign and adversarial examples (Alg. 2, Appendix C).
Certified Robustness and DP. Recently, some algorithms (Cisse et al., 2017;Kolter & Wong, 2017;Raghunathan et al., 2018;Cohen et al., 2019;Li et al., 2018;Salman et al., 2019) have been proposed to derive certified robustness, in which each prediction is guaranteed to be consistent under the perturbation α, if a robustness condition is held. Given a benign example x, we focus on achieving a robustness condition to l p (µ)-norm attacks, as follows:
where k = y(x), indicating that a small perturbation α in the input does not change the predicted label y(x). To achieve the robustness condition in Eq. 2, (Lecuyer et al., 2018) introduce an algorithm, called PixelDP. By considering an input x (e.g., images) as databases in DP parlance, and individual features (e.g., pixels) as tuples, PixelDP shows that randomizing the scoring function f (x) to enforce DP on a small number of pixels in an image guarantees robustness of predictions. To randomize f (x), random noise σ r is injected into either input x or an arbitrary hidden layer, resulting in the following ( r , δ r )-PixelDP condition:
Lemma 1 ( r , δ r )-PixelDP (Lecuyer et al., 2018). Given a randomized scoring function f (x) satisfying ( r , δ r )-PixelDP w.r.t. a l p -norm metric, we have:
where Ef k (x) is the expected value of f k (x), r is a predefined budget, δ r is a broken probability.
At the prediction time, a certified robustness check is implemented for each prediction, as follows:
where Êlb and Êub are the lower and upper bounds of the expected value Êf (x) = 1 n n f (x) n , derived from the Monte Carlo estimation with an η-confidence, given n is the number of invocations of f (x) with independent draws in the noise σ r . Passing the check for a given input guarantees that no perturbation up to l p (1)-norm can change the model's prediction. PixelDP does not preserve DP in learning private parameters θ to protect the training data.
StoBatch is presented in Alg. 4 (Appendix D). Our DNN (Fig. 1a) is presented as: f (x) = g(a(x, θ 1 ), θ 2 ), where a(x, θ 1 ) is a feature representation learning model with x as an input, and g will take the output of a(x, θ 1 ) and return the class scores f (x). At a high level, there are four key components: (1) DP a(x, θ 1 ), which is to preserve DP in learning the feature representation model a(x, θ 1 ); (2) DP Adversarial Learning, which focuses on preserving DP in adversarial learning, given DP a(x, θ 1 ); (3) Certified Robustness and Verified Inferring, which are to compute robustness bounds given an input at the inference time; and(4
Our idea is to use auto-encoder to simultaneously learn DP parameters θ 1 and ensure that the output of a(x, θ 1 ) is DP, since: (1) It is easier to train, given its small size; and (2) It can be reused for different predictive models. A typical data reconstruction function (cross-entropy), given a batch B t at the training step t of the input x i , is as follows: R Bt (θ 1 ) =
, where h i = θ T 1 x i , the hidden layer h 1 of a(x, θ 1 ) given the batch B t is denoted as h 1Bt = {θ T 1 x i } xi∈Bt , and
To preserve 1 -DP in learning θ 1 where 1 is a privacy budget, we first derive the 1st-order polynomial approximation of R Bt (θ 1 ) by applying Taylor Expansion (Arfken, 1985), denoted as R Bt (θ 1 ). Then, Functional Mechanism (Zhang et al., 2012) (revisited in Appendix B) is adapted to inject noise into coefficients of the approximated function
where
), parameters θ 1j derived from the function optimization need to be 1 -DP. To achieve that, Laplace noise
, where ∆ R is the sensitivity of R Bt (θ 1 ), as follows:
To ensure that the computation of x i does not access the original data, we further inject Laplace noise 1 m Lap( ∆ R 1 ) into x i . This can be done as a preprocessing step for all the benign examples in D to construct a set of disjoint batches B of perturbed benign examples (Lines 2 and 5, Alg. 1). The perturbed function now becomes:
where
, and x i = θ 1 h i . Let us denote β as the number of neurons in h 1 , and h i is bounded in [-1, 1], the global sensitivity ∆ R is as follows:
Lemma 2 The global sensitivity of R over any two neighboring batches, B t and B t , is:
All the proofs are in Appendix. By setting ∆ R = d(β + 2), we show that the output of a(•), which is the perturbed affine transformation
and θ 1 1,1 is the maximum 1-norm of θ 1 's columns (Operator norm, 2018). This is important to tighten the privacy budget consumption in computing the remaining hidden layers g(a(x, θ 1 ), θ 2 ). In fact, without using additional information from the original data, the computation of g(a(x, θ 1 ), θ 2 ) is also ( 1 /γ)-DP.
Similarly, the perturbation of each benign example x turns
We do not use the post-processing property of DP to estimate the DP guarantee of h 1Bt based upon the DP guarantee of B t , since 1 /γ < 1 /γ x in practice. So, the ( 1 /γ)-DP h 1Bt provides a more rigorous DP protection to the computation of g(•) and to the output layer.
Lemma 3 The computation of the batch B t as the input layer is ( 1 /γ x )-DP, and the computation of the affine transformation h 1Bt is ( 1 /γ)-DP.
Departing from the vanilla Functional Mechanism, in which only grid search-based approaches can be applied to find DP-preserving θ 1 with a low loss R Bt (θ 1 ), our following Theorem 1 shows that gradient descent-based optimizing R Bt (θ 1 ) is ( 1 /γ x + 1 )-DP in learning θ 1 given an ( 1 /γ x )-DP B t batch. In fact, in addition to h i , h i , x i , based on Lemma 3, we further show that the computation of gradients, i.e., ∀j ∈ [1, d] :
, and descent operations given the ( 1 /γ x )-DP B t batch are ( 1 /γ x )-DP, without incurring any additional information from the original data. As a result, gradient descent-based approaches can be applied to optimize R Bt (θ 1 ) in Alg. 1, since all the computations on top of B t are DP, without using any additional information from the original data.
Theorem 1 The gradient descent-based optimization of R Bt (θ 1 ) preserves ( 1 /γ x + 1 )-DP in learning θ 1 .
To integrate adversarial learning, we first draft DP adversarial examples x adv j using perturbed benign examples x j , with an ensemble of attack algorithms A and a random perturbation budget µ t ∈ (0, 1], at each step t (Lines 6-11, Alg. 1). This will significantly enhances the robustness of our models under different types of adversarial examples with an unknown adversarial attack size µ.
with y(x j ) is the class prediction result of f (x j ) to avoid label leaking of x j during the adversarial example crafting.
The proof of Theorem 2 is in Appendix J, Result 4. It can be extended to iterative attacks as: x adv j,0 = x j ,
where y(x adv j,t ) is the prediction of f (x adv j,t , θ), t ∈ [0, T µ -1]. Second, we propose a novel DP adversarial objective function L Bt (θ 2 ), in which the loss function L for benign examples is combined with an additional loss function Υ for DP Algorithm 1 Adversarial Learning with DP Input: Database D, loss function L, parameters θ, batch size m, learning rate t , privacy budgets: 1 and 2 , robustness parameters: r , ∆ x r , and ∆ h r , adversarial attack size µ a , the number of invocations n, ensemble attacks A, parameters ψ and ξ, and the size
adversarial examples, to optimize the parameters θ 2 . The objective function L Bt (θ 2 ) is defined as follows:
where ξ is a hyper-parameter. For the sake of clarity, in Eq. 9, we denote y i and y j as the true class labels y xi and y xj of examples x i and x j . x adv j and x j share the same label y xj . Now we are ready to preserve DP in objective functions L f (x i , θ 2 ), y i and Υ f (x adv j , θ 2 ), y j in order to achieve DP in learning θ 2 . Since the objective functions use the true class labels y i and y j , we need to protect the labels at the output layer. Let us first present our approach to preserve DP in the objective function L for benign examples. Given h πi computed from the x i through the network with W π is the parameter at the last hidden layer h π . Cross-entropy function is approximated as:
where
xi (h πi y ik )W πk . Based on the post-processing property of DP (Dwork & Roth, 2014),
Hence, the optimization of L 1Bt θ 2 does not disclose any information from the training data, and
) ≤ e 1 /γ , given neighboring batches B t and B t . Thus, we only need to preserve 2 -DP in the function L 2Bt (θ 2 ), which accesses the ground-truth label y ik . Given coefficients h πi y ik , the sensitivity ∆ L2 of L 2Bt (θ 2 ) is computed as: Lemma 4 Let B t and B t be neighboring batches of benign examples, we have the following inequality:
The sensitivity of our objective function is notably smaller than the state-of-the-art bound (Phan et al., 2017b), which is crucial to improve our model utility. The perturbed functions become:
We apply the same technique to preserve ( 1 /γ + 2 )-DP in the optimization of the function Υ f (x adv j , θ 2 ), y j over the DP adversarial examples x adv j ∈ B adv t . As the perturbed functions L and Υ are always optimized given two disjoint batches B t and B adv t , the privacy budget used to preserve DP in the adversarial objective function L Bt (θ 2 ) is ( 1 /γ + 2 ), following the parallel composition property (Dwork & Roth, 2014). The total budget to learn private parameters θ
Now, we establish the correlation between our mechanism and certified robustness. In the inference time, to derive the certified robustness condition against adversarial examples x + α, i.e., ∀α ∈ l p (1), PixelDP randomizes the function f (x) by injecting robustness noise σ r into either input x or a hidden layer, i.e., x = x + Lap(
where ∆ x r and ∆ h r are the sensitivities of x and h, measuring how much x and h can be changed given the perturbation α ∈ l p (1) in the input x. Monte Carlo estimation of the expected values Êf (x), Êlb f k (x), and Êub f k (x) are used to derive the robustness condition in Eq. 4.
On the other hand, in our mechanism, the privacy noise σ p includes Laplace noise injected into both input x, i.e., 1 m Lap( ∆ R 1 ), and its affine transformation h, i.e.,
2 )W πk ). This helps us to avoid injecting the noise directly into the coefficients h πi y ik . The correlation between our DP preservation and certified robustness lies in the correlation between the privacy noise σ p and the robustness noise σ r .
We can derive a robustness bound by projecting the privacy noise σ p on the scale of the robustness noise σ r . Given the input x,
r , in our mechanism we have that: x = x + Lap(κ∆ x r / r ). By applying a group privacy size κ (Dwork & Roth, 2014;Lecuyer et al., 2018), the scoring function f (x) satisfies r -PixelDP given α ∈ l p (κ), or equivalently is r /κ-PixelDP given α ∈ l p (1), δ r = 0. By applying Lemma 1, we have
With that, we can achieve a robustness condition against l p (κ)-norm attacks, as follows:
with the probability ≥ η x -confidence, derived from the Monte Carlo estimation of Êf (x). Our mechanism also perturbs h (Eq. 6). Given ϕ
). Therefore, the scoring function f (x) also satisfies r -PixelDP given the perturbation α ∈ l p (ϕ).
In addition to the robustness to the l p (κ)-norm attacks, we achieve an additional robustness bound in Eq. 10 against l p (ϕ)-norm attacks. Similar to PixelDP, these robustness conditions can be achieved as randomization processes in the inference time. They can be considered as two independent and certified defensive mechanisms applied against two l p -norm attacks, i.e., l p (κ) and l p (ϕ).
One challenging question here is: "What is the general robustness bound, given κ and ϕ?" Intuitively, our model is robust to attacks with α ∈ l p ( κϕ κ+ϕ ). We leverage the theory of sequential composition in DP (Dwork & Roth, 2014) to theoretically answer this question. Given S independent mechanisms M 1 , . . . , M S , whose privacy guarantees are 1 , . . . , S -DP with α ∈ l p (1). Each mechanism M s , which takes the input x and outputs the value of f (x) with the Laplace noise only injected to randomize the layer s (i.e., no randomization at any other layers), denoted as f s (x), is defined as
We aim to derive a generalized robustness of any composition scoring function
Our setting follows the sequential composition in DP (Dwork & Roth, 2014). Thus, we can prove that the expected value Ef (M 1 , . . . , M S |x) is insensitive to small perturbations α ∈ l p (1) in Lemma 5, and we derive our composition of robustness in Theorem 5, as follows:
Lemma 5 Given S independent mechanisms M 1 , . . . , M S , which are 1 , . . . , S -DP w.r.t a l p -norm metric, then the expected output value of any sequential function f of them, i.e., f (M 1 , . . . , M S |x) ∈ [0, 1], satisfies:
Theorem 5 (Composition of Robustness) Given S independent mechanisms M 1 , . . . , M S . Given any sequential function f (M 1 , . . . , M S |x), and let Êlb and Êub are lower and upper bounds with an η-confidence, for the Monte Carlo estimation of Êf (M 1 , . . . ,
then the predicted label k = arg max k Êf k (M 1 , . . . , M S |x), is robust to adversarial examples x + α, ∀α ∈ l p (1), with probability ≥ η, by satisfying:
, which is the targeted robustness condition in Eq. 2.
There is no η s -confidence for each mechanism s, since we do not estimate the expected value Êf s (x) independently. To apply the composition of robustness in our mechanism, the noise injections into the input x and its affine transformation h can be considered as two mechanisms M x and M h , sequentially applied as
is applied by invoking f (x) with independent draws in the noise χ 2 , the noise χ 1 injected into x is fixed; and vice-versa. By applying group privacy (Dwork & Roth, 2014) with sizes κ and ϕ, the scoring functions f x (x) and f h (x), given M x and M h , are r /κ-DP and r /ϕ-DP with α ∈ l p (1). With Theorem 5, we have a generalized bound as follows:
e., Eq. 12), then the predicted label k of our function
Compared with state-of-the-art robustness analysis (Salman et al., 2019;Lecuyer et al., 2018), in which either the input space or the latent space are randomized, the advantage of our robustness bound is the composition of different levels of robustness in both input and latent spaces.
At the inference time, we implement a verified inference (Alg. 3, Appendix D) to return a robustness size guarantee for each example x, i.e., the maximal value of κϕ κ+ϕ , for which the robustness condition in Corollary 1 holds. Maximizing κϕ κ+ϕ is equivalent to maximizing the robustness epsilon r , which is the only parameter controlling the size of κϕ κ+ϕ ; since, all the other hyper-parameters, i.e., ∆ R , m, 1 , 2 , θ 1 , θ 2 , ∆ x r , and ∆ h r are fixed given a well-trained model f (x):
e., Eq. 12) (13) The prediction on an example x is robust to attacks up to ( κϕ κ+ϕ ) max . The failure probability 1-η can be made arbitrarily small by increasing the number of invocations of f (x), with independent draws in the noise. Similar to (Lecuyer et al., 2018), Hoeffding's inequality is applied to bound the approximation error in Êf k (x) and to search for the robustness bound ( κϕ κ+ϕ ) max . We use the following sensitivity bounds ∆ h r = β θ 1 ∞ where θ 1 ∞ is the maximum 1-norm of θ 1 's rows, and ∆ x r = µd for l ∞ attacks. In the Monte Carlo Estimation of Êf (x), we also propose a new method to draw independent noise to control the distribution shifts between training and inferring, in order to improve the verified inference effectiveness, without affecting the DP protection and the robustness bounds (Appendix N).
In the vanilla iterative batch-by-batch training for DP DNNs, at each step, only one batch of examples can be used to train our model, so that the privacy loss can be computed (Lee & Kifer, 2018;Yu et al., 2019;Wu et al., 2019;Xu et al., 2020). Parameters θ 1 and θ 2 are independently updated (Lines 4-12, Alg. 1). This prevents us from applying practical adversarial training (Xie et al., 2019;Goyal et al., 2017), in which distributed training using synchronized SGD on many GPUs (e.g., 128 GPUs) is used to scale adversarial training to large DNNs. Each GPU processes a mini-batch of 32 images (i.e., the total batch size is 128 × 32 = 4, 096).
To overcome this, a well-applied technique (Yu et al., 2019) is to fine-tune a limited number of layers, such as a fully connected layer and the output layer, under DP of a pre-trained model, i.e., VGG16, trained over a public and large dataset, e.g., ImageNet, in order to handle simpler tasks on smaller private datasets, e.g., CIFAR-10. Although this approach works well, there are several utility and security concerns:
(1) Suitable public data may not always be available, especially for highly sensitive data; (2) Trojans can be implanted in the pre-trained model for backdoor attacks (Liu et al., 2018); and (3) Public data can be poisoned (Shafahi et al., 2018). Fine-tuning a limited number of layers may not be secure; while fine-tuning an entire of a large pre-trained model iteratively batch-by-batch is still inefficient.
To address this bottleneck, we leverage the training recipe of (Xie et al., 2019;Goyal et al., 2017) to propose a distributed training algorithm, called StoBatch (Fig. 1b), in order to efficiently train large DP DNNs in adversarial learning, without affecting the DP protection (Alg. 4, Appendix D). In StoBatch, fixed and disjoint batches B are distributed to N/(2m) local trainers, each of which have two batches {B i1 , B i2 } randomly picked from B with i ∈ [1, N/(2m)] (Line 4, Alg. 4). At each training step t, we randomly pick N local trainers, each of which gets the latest global parameters θ from the parameter server. A local trainer i will compute the gradients ∇ i θ 1 and ∇ i θ 2 to optimize the DP objective functions R and L using its local batch B i1 and ensemble DP adversarial examples crafted from B i2 (Lines 5-14, Alg. 4). The gradients will be sent back to the parameter server for a synchronized SGD (Lines 15-16, Alg. 4), as follows:
This enables us to train large DNNs with our DP adversarial learning, by training from multiple batches simultaneously with more adversarial examples, without affecting the DP guarantee in Theorem 4; since the optimization of one batch does not affect the DP protection at any other batch and at the dataset level D across T training steps (Theorem 4).
In addition, the average errors of our approximation functions are always bounded, and are independent of the number of data instances N in D (Appendix O). This further ensures that our functions can be applied in large datasets.
Our approach can be extended into two different complementary scenarios: (1) Distributed training for each local trainer i, in which the batches {B i1 , B i2 } can be located across M GPUs to efficiently compute the gradients
(2) Federated training, given each local trainer can be considered as an independent party. In this setting, an independent party can further have different sizes of batches. As long as the global sensitivities ∆ R and ∆ L2 are the same for all the parties, the DP guarantee in Theorem 4 does hold given D be the union of all local datasets from all the parties. This can be achieved by nomalizing all the inputs x to be in [-1, 1] d . This is a step forward compared with the classical federated learning (McMahan et al., 2016). We focus on the distributed training setting in this paper, and reserve the federated learning scenarios for future exploration.
We have conducted an extensive experiment on the MNIST, CIFAR-10, and Tiny ImageNet datasets. Our validation focuses on shedding light into the interplay among model utility, privacy loss, and robustness bounds, by learning 1) the impact of the privacy budget = ( 1 + 1 /γ x + 1 /γ + 2 ), 2) the impact of attack sizes µ a , and 3) the scalability of our mechanism. We consider the class of l ∞ -bounded adversaries. All statistical tests are 2-tail t-tests. Please refer to the Appendix Q for a complete analysis of our experimental results, including Figures 23456789. The implementation of our mechanism is available in TensorFlow 1 .
Baseline Approaches. Our StoBatch mechanism is evaluated in comparison with state-of-the-art mechanisms in: (1) DP-preserving algorithms in deep learning, i.e., DP-SGD (Abadi et al., 2016), AdLM (Phan et al., 2017b); in (2) Certified robustness, i.e., PixelDP (Lecuyer et al., 2018); and in (3) DP-preserving algorithms with certified robustness, i.e., SecureSGD given heterogeneous noise (Phan et al., 2019), and SecureSGD-AGM (Phan et al., 2019) 1 https://github.com/haiphanNJIT/StoBatch given the Analytic Gaussian Mechanism (AGM) (Balle & Wang, 2018). To preserve DP, DP-SGD injects random noise into gradients of parameters, while AdLM is a Functional Mechanism-based approach. PixelDP is one of the state-of-the-art mechanisms providing certified robustness using DP bounds. SecureSGD is a combination of PixelDP and DP-SGD with an advanced heterogeneous noise distribution; i.e., "more noise" is injected into "more vulnerable" latent features, to improve the robustness. The baseline models share the same design in our experiment. Four white-box attacks were used, including FGSM, I-FGSM, Momentum Iterative Method (MIM) (Dong et al., 2017), and MadryEtAl (Madry et al., 2018). Pure robust training and analysis can incur privacy leakage (Song et al., 2019); thus, in this study, similar algorithms to (Salman et al., 2019) do not fit as comparable baselines, since they may not be directly applicable to DP DNNs.
Model Configuration (Appendix P). It is important to note that x ∈ [-1, 1] d in our setting, which is different from a common setting, x ∈ [0, 1] d . Thus, a given attack size µ a = 0.3 in the setting of x ∈ [0, 1] d is equivalent to an attack size 2µ a = 0.6 in our setting. The reason for using x ∈ [-1, 1] d is to achieve better model utility, while retaining the same global sensitivities to preserve DP, compared with x ∈ [0, 1] d . As in (Lecuyer et al., 2018), we apply two accuracy metrics:
where |test| is the number of test cases, isCorrect(•) returns 1 if the model makes a correct prediction (else, returns 0), and isRobust(•) returns 1 if the robustness size is larger than a given attack size µ a (else, returns 0).
Results on the MNIST Dataset. Figure 2 illustrates the conventional accuracy of each model as a function of the privacy budget on the MNIST dataset under l ∞ (µ a )-norm attacks, with µ a = 0.2. Our StoBatch outperforms AdLM, DP-SGD, SecureSGD, and SecureSGD-AGM, in all cases, with p < 1.32e -4. When the privacy budget = 0.2 (a tight DP protection), there are significant drops, in terms of conventional accuracy, given the baseline approaches. By contrast, our StoBatch only shows a small degradation in the conventional accuracy. At = 0.2, our StoBatch achieves 82.7%, compared with 11.2% and 41.64% correspondingly for SecureSGD-AGM and SecureSGD. This shows the ability to offer tight DP protections under adversarial example attacks in our model, compared with existing algorithms. Results on the CIFAR-10 Dataset further strengthen our observations. In Figure 3, our StoBatch outperforms baseline models in all cases (p < 6.17e -9), especially with small privacy budget ( < 4), yielding strong DP protections.
On average conventional accuracy, our StoBatch mechanism has an improvement of 10.42% over SecureSGD, 14.08% over SecureSGD-AGM, 29.22% over AdLM, and 14.62% over DP-SGD. Furthermore, the accuracy of our model is consistent given different attacks with different adversarial perturbations µ a under a rigorous DP protection ( t = 2.0), compared with baseline approaches (Figure 5). In fact, when the attack size µ a increases from 0.05 to 0.5, the conventional accuracies of the baseline approaches are remarkably reduced, i.e., a drop of 25.26% on average given the most effective baseline approach, SecureSGD. Meanwhile, there is a much smaller degradation (4.79% on average) in terms of the conventional accuracy observed in our StoBatch model. Figure 7 further shows that our StoBatch model is more accurate than baseline approaches (i.e., r is set to 0.1 in PixelDP) in terms of certified accuracy in all cases, with a tight privacy budget set to 2.0 (p < 2.04e -18).
Scalability and Strong Iterative Attacks. First, we scale our model in terms of adversarial training in the CIFAR-10 data, i.e., the number of iterative attack steps is increased to T µ =200 in training, and to T a =2,000 in testing. The iterative batch-by-batch DP adversarial training (Alg. 1) is infeasible in this setting, taking over 30 days for one training with 600 epochs. Thanks to the distributed training, our StoBatch takes 3 days to finish the training (N = 1, M = 4). More importantly, our StoBatch achieves consistent accuracies under strong iterative attacks with T a ={1, 000; 2, 000}, compared with the best baseline, i.e., SecureSGD (Figure 8). On average, across attack sizes µ a ∈ {0.05, 0.1, 0.2, 0.3, 0.4, 0.5} and steps T a ∈ {100, 500, 1000, 2000}, our StoBatch achieves 45.25±1.6% and 42.59±1.58% in conventional and certified accuracies, compared with 29.08±11.95% and 19.58±5.0% of SecureSGD (p < 2.75e -20).
• We achieve a similar improvement over the Tiny Ima-geNet with a ResNet18 model, i.e., a larger dataset on a larger network, (N = 1, M = 20) (Figure 9). On average, across attack sizes µ a ∈ {0.05, 0.1, 0.2, 0.3, 0.4, 0.5} and steps T a ∈ {100, 500, 1000, 2000}, our StoBatch achieves 29.78±4.8% and 28.31±1.58% in conventional and certified accuracies, compared with 8.99±5.95% and 8.72±5.5% of SecureSGD (p < 1.55e -42).
Key observations: (1) Incorporating ensemble adversarial learning into DP preservation, tightened sensitivity bounds, a random perturbation size µ t at each training step, and composition robustness bounds in both input and latent spaces does enhance the consistency, robustness, and accuracy of DP model against different attacks with different levels of perturbations. These are key advantages of our mechanism;
(2) As a result, our StoBatch model outperforms baseline algorithms, in terms of conventional and certified accuracies in most of the cases. It is clear that existing DP-preserving approaches have not been designed to withstand against adversarial examples; and (3) Our StoBatch training can help us to scale our mechanism to larger DP DNNs and datasets with distributed adversarial learning, without affecting the model accuracies and DP protections.
In this paper, we established a connection among DP preservation to protect the training data, adversarial learning, and certified robustness. A sequential composition robustness was introduced to generalize robustness given any sequential and bounded function of independent defensive mechanisms in both input and latent spaces. We addressed the trade-off among model utility, privacy loss, and robustness by tightening the global sensitivity bounds. We further developed a stochastic batch training mechanism to bypass the vanilla iterative batch-by-batch training in DP DNNs. The average errors of our approximation functions are always bounded by constant values. Last but not least, a new Monte Carlo Estimation was proposed to stabilize the estimation of the robustness bounds. Rigorous experiments conducted on benchmark datasets shown that our mechanism significantly enhances the robustness and scalability of DP DNNs. In future work, we will test our algorithms and models in the Baidu Fedcube platform (Baidu, 2020). In addition, we will evaluate our robustness bounds against synergistic attacks, in which adversarial examples can be combined with other attacks, such as Trojans (Gu et al., 2017;Liu et al., 2018), to create more lethal and stealthier threats (Pang et al., 2020).
Training data with benign examples x ∈ [-1, 1] d y = {y 1 , . . . , y K } One-hot label vector of K categories f : R d → R K Function/model f that maps inputs x to a vector of scores f (x) = {f 1 (x), . . . , f K (x)} y x ∈ y A single true class label of example x y(x) = max k∈K f k (x) Predicted label for the example x given the function f x adv = x + α Adversarial example where α is the perturbation l p (µ) = {α ∈ R d : α p ≤ µ} The l p -norm ball of attack radius µ ( r , δ r ) Robustness budget r and broken probability δ r Ef k (x)
The expected value of f k (x)
Êlb and Êub Lower and upper bounds of the expected value Êf
Feature representation learning model with x and parameters θ 1
Data reconstruction function given B t in a(x, θ 1 )
The values of all hidden neurons in the hidden layer h 1 of a(x, θ 1 ) given the batch B t R Bt (θ 1 ) and R Bt (θ 1 )
Approximated and perturbed functions of R Bt (θ 1 ) x i and x i Perturbed and reconstructed inputs
a=1 c a = j . By the Stone-Weierstrass Theorem (Rudin, 1976), any continuous and differentiable L(x i , θ) can always be written as a polynomial of θ 1 , . . . , θ d , for some J ∈ [0, ∞], i.e., L(x i , θ) = J j=0 φ∈Φj λ φxi φ(θ) where λ φxi ∈ R denotes the coefficient of φ(θ) in the polynomial.
For instance, the polynomial expression of the loss function in the linear regression is as follows:
is the number of features in x i . In fact, L(x i , θ) only involves monomials in Φ 0 = {1}, Φ 1 = {θ 1 , . . . , θ d }, and Φ 2 = {θ i θ a i, a ∈ [1, d]}. Each φ(θ) has its own coefficient, e.g., for θ j , its polynomial coefficient λ φx i = -2y i x ij . Similarly, L D (θ) can be expressed as a polynomial of θ 1 , . . . , θ d , as
To achieve -DP, L D (θ) is perturbed by injecting Laplace noise Lap( ∆ ) into its polynomial coefficients λ φ , and then the model parameter θ is derived to minimize the perturbed function L D (θ), where the global sensitivity ∆ = 2 max x J j=1 φ∈Φj λ φx 1 is derived given any two neighboring datasets. To guarantee that the optimization of θ = arg min θ L D (θ) achieves -DP without accessing the original data, i.e., that may potentially incur additional privacy leakage, grid search-based approaches are applied to learn the -DP parameters θ with low loss L D (θ). Although this approach works well in simple tasks, i.e., logistic regression, it may not be optimal in large models, such as DNNs.
C. Pseudo-code of Adversarial Training (Kurakin et al., 2016b) Let l p (µ) = {α ∈ R d : α p ≤ µ} be the l p -norm ball of radius µ. One of the goals in adversarial learning is to minimize the risk over adversarial examples: θ * = arg min θ E (x,ytrue)∼D max α p ≤µ L f (x + α, θ), y x , where an attack is used to approximate solutions to the inner maximization problem, and the outer minimization problem corresponds to training the model f with parameters θ over these adversarial examples x adv = x + α. There are two basic adversarial example attacks. The first one is a single-step algorithm, e.g., FGSM algorithm (Goodfellow et al., 2014), in which only a single gradient computation is required to find adversarial examples by solving the inner maximization max α p ≤µ L f (x + α, θ), y x . The second one is an iterative algorithm, e.g., Iterative-FGSM algorithm (Kurakin et al., 2016a), in which multiple gradients are computed and updated in T µ small steps, each of which has a size of µ/T µ .
Given a loss function: Randomly Pick N local trainers, each of which Gets the latest global parameters θ from the parameter server 7:
Ensemble DP Adversarial Examples:
(θ 2 ) with the noise χ3 m 15:
Send ∇ i θ 1 and ∇ i θ 2 to the parameter server 16:
Proof 1 Assume that B t and B t differ in the last tuple, x m (x m ). Then,
The sensitivity of a function h is defined as the maximum change in output, that can be generated by a change in the input (Lecuyer et al., 2018). Therefore, the global sensitivity of h 1 can be computed as follows:
following matrix norms (Operator norm, 2018): θ T 1 1,1 is the maximum 1-norm of θ 1 's columns. By injecting Laplace noise Lap(
, and χ 2 drawn as a Laplace noise [Lap( ∆ R 1 )] β , in our mechanism, the perturbed affine transformation h 1Bt is presented as:
This results in an ( 1 /γ)-DP affine transformation h 1Bt = {θ
, where ∆ x is the sensitivity measuring the maximum change in the input layer that can be generated by a change in the batch B t and
Following (Lecuyer et al., 2018), ∆ x can be computed as follows:
Proof 3 Given χ 1 drawn as a Laplace noise [Lap( ∆ R 1 )] d and χ 2 drawn as a Laplace noise [Lap( ∆ R 1 )] β , the perturbation of the coefficient φ ∈ Φ = { 1 2 h i , x i }, denoted as φ, can be rewritten as follows:
)
we have
we have that:
Consequently, the computation of R Bt (θ 1 ) preserves 1 -DP in Alg. 1 (Result 1). To show that gradient descent-based optimizers can be used to optimize the objective function R Bt (θ 1 ) in learning private parameters θ 1 , we prove that all the computations on top of the perturbed data B t , including h i , h i , x i , gradients and descent, are DP without incurring any additional information from the original data, as follows.
First, by following the post-processing property in DP (Dwork & Roth, 2014), it is clear that the computations of
As in Lemma 3, we also have that
, the post-processing property in DP. In addition, the computations of h 1Bt , h 1Bt , and x i do not access the original data B t . Therefore, they do not incur any additional information from the private data, except the privacy loss measured by ( 1 /γ x )-DP, since the computations of h 1Bt and x i are based on the
Second, the gradient of a particular parameter θ 1j , with ∀j ∈ [1, d], can be computed as follows:
In Eq. 21, we have that
in Eq. 21, its global sensitivity given two arbitrary neighboring batches, denoted as ∆ g , can be bounded as follows:
As a result, we have that:
which is
From Results 3 and 4, the computation of gradients
The of the two terms in Eq. 21 can be treated as two independent DP-preserving mechanisms applied on the perturbed batch B t ; and (2) This is true for every dimension j ∈ [1, d], each of which ∇ θ1j is independently computed and bounded. It is important to note that this result is different from the traditional DPSGD (Abadi et al., 2016), in which the parameter gradients are jointly clipped by a l 2 -norm constant bound, such that Gaussian noise can be injected to achieve DP. In addition, as in Eq. 19, the computation of ∇ θ1j R Bt (θ 1 ) only uses ( 1 /γ x )-DP B t = {x i } xi∈Bt and ( 1 /γ)-DP h 1Bt , without accessing the original data. Basically, h 1Bt is computed on top of B t , without touching any benign example. Therefore, it does not incur any additional information from the private data, except the privacy loss ( 1 / ∆ R ∆g + 1 /γ x )-DP. In practice, we observed that 1 /γ x 1 / ∆ R ∆g 1 × 1e -3, which is tiny. We can simply consider that the computation of gradients ∇ θ1j R Bt (θ 1 ) is ( 1 /γ x )-DP without affecting the general DP protection. In addition to the gradient computation, the descent operations are simply post-processing steps without consuming any further privacy budget. (Result 5)
From Results 1, 2, and 5, we have shown that all the computations on top of ( 1 /γ x )-DP B t , including parameter gradients and gradient descents, clearly are DP without accessing the original data; therefore, they do not incur any additional information from the private data (the post-processing property in DP). As a result, gradient descent-based approaches can be applied to optimize R Bt (θ 1 ) in Alg. 1. The total privacy budget to learn the perturbed optimal parameters θ 1 in Alg. 1 is ( 1 /γ x + 1 )-DP, where the 1 /γ x is counted for the perturbation on the batch of benign examples B t .
Consequently, Theorem 1 does hold.
Proof 4 Assume that B t and B t differ in the last tuple, and x m (x m ) be the last tuple in B t (B t ), we have that
Since y mk and y mk are one-hot encoding, we have that
Lemma 4 does hold.
Proof 5 Let B t and B t be neighboring batches of benign examples, and χ 3 drawn as Laplace noise [Lap( ∆ L2
2 )] |hπ| , the perturbations of the coefficients h πi y ik can be rewritten as:
Since all the coefficients are perturbed, and given ∆ L2 = 2|h π |, we have that
) exp(-
The computation of L 2Bt θ 2 preserves ( 1 /γ + 2 )-differential privacy. Similar to Theorem 1, the gradient descent-based optimization of L 2Bt θ 2 does not access additional information from the original input x i ∈ B t . It only reads the
Consequently, the optimal perturbed parameters θ 2 derived from L 2Bt θ 2 are ( 1 /γ + 2 )-DP.
Proof 6 First, we optimize for a single draw of noise during training (Line 3, Alg. 1) and all the batches of perturbed benign examples are disjoint and fixed across epochs. As a result, the computation of x i is equivalent to a data preprocessing step with DP, which does not incur any additional privacy budget consumption over T training steps (the post-processing property of DP) (Result 1). That is different from repeatedly applying a DP mechanism on either the same or overlapping datasets causing the accumulation of the privacy budget. Now, we show that our algorithm achieves DP at the dataset level D. Let us consider the computation of the first hidden layer, given any two neighboring datasets D and D differing at most one tuple x e ∈ D and x e ∈ D . For any
By having disjoint and fixed batches, we have that:
From Eqs. 24, 25, and Lemma 3, we have that
Eqs. 25 and 26
As a result, the computation of h 1D is ( 1 /γ)-DP given the data D, since the Eq. 27 does hold for any tuple x e ∈ D. That is consistent with the parallel composition property of DP, in which batches can be considered disjoint datasets given h 1B as a DP mechanism (Dwork & Roth, 2014).
This does hold across epochs, since batches B are disjoint and fixed among epochs. At each training step t ∈ [1, T ], the computation of h 1Bt does not access the original data. It only reads the perturbed batch of inputs B t , which is ( 1 /γ x )-DP (Lemma 3). Following the post-processing property in DP (Dwork & Roth, 2014), the computation of h 1Bt does not incur any additional information from the original data across T training steps. (Result 2)
Similarly, we show that the optimization of the function R Bt (θ 1 ) is ( 1 /γ x + 1 )-DP across T training steps. As in Theorem 1 and Proof 3, we have that P r R B (θ 1 ) = d j=1 φ∈Φ exp -
, where B ∈ B. Given any two perturbed neighboring datasets D and D differing at most one tuple x e ∈ D and x e ∈ D :
From Eqs. 25, 28, and Theorem 1, we have that
Eqs. 28 and 29 ⇒ P R D (θ 1 )
As a result, the optimization of R D (θ 1 ) is ( 1 /γ x + 1 )-DP given the data D (which is 1 /γ x -DP (Lemma 3)), since the Eq. 30 does hold for any tuple x e ∈ D. This is consistent with the parallel composition property in DP (Dwork & Roth, 2014), in which batches can be considered disjoint datasets and the optimization of the function on one batch does not affect the privacy guarantee in any other batch, even the objective function given one batch can be slightly different from the objective function given any other batch in B. In addition, ∀t ∈ [1, T ], the optimization of R Bt (θ 1 ) does not use any additional information from the original data D. Consequently, the privacy budget is ( 1 /γ x + 1 ) across T training steps, following the post-processing property in DP (Dwork & Roth, 2014) (Result 3).
Similarly, we can also prove that optimizing the data reconstruction function R
where
, and x adv j = θ 1 h adv j . The right summation component in Eq. 31 does not disclose any additional information, since the sign(•) function is computed from perturbed benign examples (the post-processing property in DP (Dwork & Roth, 2014)). Meanwhile, the left summation component has the same form with R Bt (θ 1 ) in Eq. 6. Therefore, we can employ the Proof 3 in Theorem 1, by replacing the coefficients Φ = { 1 2 h i , x i } with Φ = { 1 2 h adv j , x j } to prove that the optimization of R B adv Regarding the output layer, the Algorithm 1 preserves ( 1 /γ + 2 )-DP in optimizing the adversarial objective function L Bt∪B adv t (θ 2 ) (Theorem 3). We apply the same technique to preserve ( 1 /γ + 2 )-DP across T training steps given disjoint and fixed batches derived from the private training data D. In addition, as our objective functions R and L are always optimized given two disjoint batches B t and B adv t , the privacy budget used to preserve DP in these functions is ( 1 + 1 /γ + 2 ), following the parallel composition property in DP (Dwork & Roth, 2014). (Result 6)
With the Results 1-6, all the computations and optimizations in the Algorithm 1 are DP following the post-processing property in DP (Dwork & Roth, 2014), by working on perturbed inputs and perturbed coefficients. The crafting and utilizing processes of DP adversarial examples based on the perturbed benign examples do not disclose any additional information. The optimization of our DP adversarial objective function at the output layer is DP to protect the ground-truth labels. More importantly, the DP guarantee in learning given the whole dataset level D is equivalent to the DP guarantee in learning on disjoint and fixed batches across epochs. Consequently, Algorithm 1 preserves ( 1 + 1 /γ x + 1 /γ + 2 )-DP in learning parameters θ = {θ 1 , θ 2 } given the training data D across T training steps. Note that the 1 /γ x is counted for the perturbation on the benign examples. Theorem 4 does hold.
Proof 7 Thanks to the sequential composition theory in DP (Dwork & Roth, 2014)
As a result, we have P f (M 1 , . . . , M S |x) ≤ e ( i i ) P f (M 1 , . . . , M S |x + α)
The sequential composition of the expected output is as:
Lemma 5 does hold.
Proof 8 ∀α ∈ l p (1), from Lemma 5, with probability ≥ η, we have that
In addition, we also have
Using the hypothesis (Eq. 12) and the first inequality (Eq. 32), we have that
Now, we apply the third inequality (Eq. 33), we have that
The Theorem 5 does hold.
Proof 9 ∀α ∈ l p (1), by applying Theorem 5, we have
Furthermore, by applying group privacy, we have that
By applying Proof 8, it is straight to have
with probability ≥ η. Corollary 1 does hold.
Recall that the Monte Carlo estimation is applied to estimate the expected value Êf (x) = 1 n n f (x) n , where n is the number of invocations of f (x) with independent draws in the noise, i.e., 1 m Lap(0, ∆ R 1 ) and 2 m Lap(0, ∆ R 1 ) in our case. When 1 is small (indicating a strong privacy protection), it causes a notably large distribution shift between training and inference, given independent draws of the Laplace noise.
In fact, let us denote a single draw in the noise as χ 1 = 1 m Lap(0, ∆ R 1 ) used to train the function f (x), the model converges to the point that the noise χ 1 and 2χ 2 need to be correspondingly added into x and h in order to make correct predictions. χ 1 can be approximated as Lap(χ 1 , ), where → 0. It is clear that independent draws of the noise 1 m Lap(0, ∆ R 1 ) have distribution shifts with the fixed noise χ 1 Lap(χ 1 , ). These distribution shifts can also be large, when noise is large. We have experienced that these distribution shifts in having independent draws of noise to estimate Êf (x) can notably degrade the inference accuracy of the scoring function, when privacy budget 1 is small resulting in a large amount of noise injected to provide strong privacy guarantees.
To address this, one solution is to increase the number of invocations of f (x), i.e., n, to a huge number per prediction. However, this is impractical in real-world scenarios. We propose a novel way to draw independent noise following the distribution of χ 1 + 1 m Lap(0, ∆ R 1 /ψ) for the input x and 2χ 2 + 2 m Lap(0, ∆ R 1 /ψ) for the affine transformation h, where ψ is a hyper-parameter to control the distribution shifts. This approach works well and does not affect the DP bounds and the certified robustness condition, since: (1) Our mechanism achieves both DP and certified robustness in the
. This can be applied to the case of our auto-encoder, as follows:
For the functions F 1j (z j ) = x ij log(1 + e -zj ) and F 2j (z j ) = (1 -x ij ) log(1 + e zj ), we have F
(1+e z j ) 2 . It can be verified that arg min zj F
(2) 1j (z j ) = -e (1+e) 2 < 0, arg max zj F
(2) 1j (z j ) = e (1+e) 2 > 0, min zj F
(2) 2j (z j ) = 0, and arg max zj F
(2) 2j (z j ) = 2e (1+e) 2 > 0. Thus, the average error of the approximation is at most:
Consequently, Eq. 35 does hold. Similarly, by looking into the remainder of Taylor expansion for each label k, Eq. 36 can be proved straightforwardly. In fact, by using the 2nd-order Taylor series with K categories, we have that:
-1 e(1+e) 2 × K.
The MNIST database consists of handwritten digits (Lecun et al., 1998). Each example is a 28 × 28 size gray-level image.
The CIFAR-10 dataset consists of color images belonging to 10 classes, i.e., airplanes, dogs, etc. The dataset is split into 50,000 training samples and 10,000 test samples (Krizhevsky & Hinton, 2009). Tiny Imagenet (64 × 64 × 3) has 200 classes. Each class has 500 training images, 50 validation images, and 50 test images. We used the first thirty classes with data augmented, including horizontal flip and random brightness, in the Tiny ImageNet dataset in our experiment. In general, the dataset is split into 45,000 training samples and 1,500 test samples (TinyImageNet; Hendrycks & Dietterich, 2019). The experiments were conducted on a server of 4 GPUs, each of which is an NVIDIA TITAN Xp, 12 GB with 3,840 CUDA cores. All the models share the same structure, consisting of 2 and 3 convolutional layers, respectively for MNIST and CIFAR-10 datasets, and a ResNet18 model for the Tiny ImageNet dataset.
Both fully-connected and convolution layers can be applied in the representation learning model a(x, θ 1 ). Given convolution layer, the computation of each feature map needs to be DP; since each of them independently reads a local region of input neurons. Therefore, the sensitivity ∆ R can be considered the maximal sensitivity given any single feature map in the first affine transformation layer. In addition, each hidden neuron can only be used to reconstruct a unit patch of input units. That results in d (Lemma 2) being the size of the unit patch connected to each hidden neuron, e.g., d = 9 given a 3 × 3 unit patch, and β is the number of hidden neurons in a feature map.
MNIST: We used two convolutional layers (32 and 64 features). Each hidden neuron connects with a 5x5 unit patch. A fully-connected layer has 256 units. The batch size m was set to 2,499, ξ = 1, ψ = 2. I-FGSM, MIM, and MadryEtAl were used to draft l ∞ (µ) adversarial examples in training, with T µ = 10. Learning rate t was set to 1e -4. Given a predefined total privacy budget , 2 is set to be 0.1, and 1 is computed as: 1 = -2 (1+1/γ+1/γx) . This will guarantee that ( 1 + 1 /γ x + 1 /γ + 2 ) = . ∆ R = (14 2 + 2) × 25 and ∆ L2 = 2 × 256. The number of Monte Carlo sampling for certified inference n is set to 2,000.
CIFAR-10: We used three convolutional layers (128, 128, and 256 features). Each hidden neuron connects with a 4x4 unit patch in the first layer, and a 5x5 unit patch in other layers. One fully-connected layer has 256 neurons. The batch size m was set to 1,851, ξ = 1.5, ψ = 10, and T µ = 3. The ensemble of attacks A includes I-FGSM, MIM, and MadryEtAl. We use data augmentation, including random crop, random flip, and random contrast. Learning rate t was set to 5e -2. In the CIFAR-10 dataset, 2 is set to (1 + r/3.0) and 1 = (1 + 2r/3.0)/(1 + 1/γ + 1/γ x ), where r ≥ 0 is a ratio to control the total privacy budget in our experiment. For instance, given r = 0, we have that = ( 1 + 1 /γ x + 1 /γ + 2 ) = 2. ∆ R = 3 × (14 2 + 2) × 16 and ∆ L2 = 2 × 256. N and M are set to 1 and 4 in the distributed training. The number of Monte Carlo sampling for certified inference n is set to 1,000.
Tiny ImageNet: We used a ResNet-18 model. Each hidden neuron connects with a 7x7 unit patch in the first layer, and 3x3 unit patch in other layers. The batch size m was set to 4,500, ξ = 1.5, ψ = 10, and T µ = 10. The ensemble of attacks A includes I-FGSM, MIM, and MadryEtAl. Learning rate t was set to 1e -2. In the Tiny ImageNet dataset, 2 is set to 1 and 1 = (1 + r)/(1 + 1/γ + 1/γ x ), where r ≥ 0 is a ratio to control the total privacy budget in our experiment. ∆ R = 3 × (32 2 + 2) × 49 and ∆ L2 = 2 × 256. N and M are set to 1 and 20 in the distributed training. The number of Monte Carlo sampling for certified inference n is set to 1,000. baseline approaches (i.e., r is set to 0.1 in PixelDP) in terms of certified accuracy in all cases, with a tight privacy budget set to 2.0 (p < 2.04e -18). We register an improvement of 21.01% in our StoBatch model given the certified accuracy over SecureSGD model, which is the most effective baseline approach (p < 2.04e -18).
Scalability under Strong Iterative Attacks. First, we scale our model in terms of adversarial training in the CIFAR-10 dataset, in which the number of iterative attack steps is increased from T µ = 3 to T µ = 200 in training, and up to T a = 2,000 in testing. Note that the traditional iterative batch-by-batch DP adversarial training (Alg. 1) is nearly infeasible in this setting, taking over 30 days for one training with 600 epochs. Thanks to the parallel and distributed training, our StoBatch only takes 3 days to finish the training. More importantly, our StoBatch achieves consistent conventional and certified accuracies under strong iterative attacks with T a = 1, 000, compared with the best baseline, i.e., SecureSGD (Figure 8). Across attack sizes µ a ∈ {0.05, 0.1, 0.2, 0.3, 0.4, 0.5} and steps T a ∈ {100, 500, 1000, 2000}, on average, our StoBatch achieves 44.87±1.8% and 42.18±1.8% in conventional and certified accuracies, compared with 29.47±12.5% and 20±6.1% of SecureSGD (p < 1.05e -9).
• We achieve a similar improvement over the Tiny ImageNet, i.e., following (Hendrycks & Dietterich, 2019), with a ResNet18 model, i.e., a larger dataset on a larger network (Figure 9). On average, across attack sizes µ a ∈ {0.05, 0.1, 0.2, 0.3, 0.4, 0.5} and steps T a ∈ {100, 500, 1000, 2000}, our StoBatch achieves 29.78±4.8% and 28.31±1.58% in conventional and certified accuracies, compared with 8.99±5.95% and 8.72±5.5% of SecureSGD (p < 1.55e -42).