Title: SCALABLE PRIVATE LEARNING WITH PATE

Abstract: The rapid adoption of machine learning has increased concerns about the privacy implications of machine learning models trained on sensitive data, such as medical records or other personal information. To address those concerns, one promising approach is Private Aggregation of Teacher Ensembles, or PATE, which transfers to a "student" model the knowledge of an ensemble of "teacher" models, with intuitive privacy provided by training teachers on disjoint data and strong privacy guaranteed by noisy aggregation of teachers' answers. However, PATE has so far been evaluated only on simple classification tasks like MNIST, leaving unclear its utility when applied to larger-scale learning tasks and real-world datasets. In this work, we show how PATE can scale to learning tasks with large numbers of output classes and uncurated, imbalanced training data with errors. For this, we introduce new noisy aggregation mechanisms for teacher ensembles that are more selective and add less noise, and prove their tighter differential-privacy guarantees. Our new mechanisms build on two insights: the chance of teacher consensus is increased by using more concentrated noise and, lacking consensus, no answer need be given to a student. The consensus answers used are more likely to be correct, offer better intuitive privacy, and incur lower-differential privacy cost. Our evaluation shows our mechanisms improve on the original PATE on all measures, and scale to larger tasks with both high utility and very strong privacy (ε < 1.0).

1. INTRODUCTION:

Many attractive applications of modern machine-learning techniques involve training models using highly sensitive data. For example, models trained on people's personal messages or detailed medical information can offer invaluable insights into real-world language usage or the diagnoses and treatment of human diseases (McMahan et al., 2017; Liu et al., 2017) . A key challenge in such applications is to prevent models from revealing inappropriate details of the sensitive data-a nontrivial task, since models are known to implicitly memorize such details during training and also to inadvertently reveal them during inference (Zhang et al., 2017; Shokri et al., 2017) .

Recently, two promising, new model-training approaches have offered the hope that practical, highutility machine learning may be compatible with strong privacy-protection guarantees for sensitive training data (Abadi et al., 2017) . This paper revisits one of these approaches, Private Aggregation of Teacher Ensembles, or PATE (Papernot et al., 2017) , and develops techniques that improve its scalability and practical applicability. PATE has the advantage of being able to learn from the aggregated consensus of separate "teacher" models trained on disjoint data, in a manner that both provides intuitive privacy guarantees and is agnostic to the underlying machine-learning techniques (cf. the approach of differentially-private stochastic gradient descent (Abadi et al., 2016) ). In the PATE approach multiple teachers are trained on disjoint sensitive data (e.g., different users' data), and uses the teachers' aggregate consensus answers in a black-box fashion to supervise the training of a "student" model. By publishing only the student model (keeping the teachers private) and by adding carefully-calibrated Laplacian noise to the aggregate answers used to train the student, the Figure 1 : Our contributions are techniques (Confident-GNMax) that improve on the original PATE (LNMax) on all measures. Left: Accuracy is higher throughout training, despite greatly improved privacy (more in Table 1 ). Middle: The ε differential-privacy bound on privacy cost is quartered, at least (more in Figure 5 ). Right: Intuitive privacy is also improved, since students are trained on answers with a much stronger consensus among the teachers (more in Figure 5 ). These are results for a character-recognition task, using the most favorable LNMax parameters for a fair comparison.

original PATE work showed how to establish rigorous (ε, δ) differential-privacy guarantees (Papernot et al., 2017) -a gold standard of privacy (Dwork et al., 2006) . However, to date, PATE has been applied to only simple tasks, like MNIST, without any realistic, larger-scale evaluation.

The techniques presented in this paper allow PATE to be applied on a larger scale to build more accurate models, in a manner that improves both on PATE's intuitive privacy-protection due to the teachers' independent consensus as well as its differential-privacy guarantees. As shown in our experiments, the result is a gain in privacy, utility, and practicality-an uncommon joint improvement.

The primary technical contributions of this paper are new mechanisms for aggregating teachers' answers that are more selective and add less noise. On all measures, our techniques improve on the original PATE mechanism when evaluated on the same tasks using the same datasets, as described in Section 5. Furthermore, we evaluate both variants of PATE on a new, large-scale character recognition task with 150 output classes, inspired by MNIST. The results show that PATE can be successfully utilized even to uncurated datasets-with significant class imbalance as well as erroneous class labels-and that our new aggregation mechanisms improve both privacy and model accuracy.

To be more selective, our new mechanisms leverage some pleasant synergies between privacy and utility in PATE aggregation. For example, when teachers disagree, and there is no real consensus, the privacy cost is much higher; however, since such disagreement also suggest that the teachers may not give a correct answer, the answer may simply be omitted. Similarly, teachers may avoid giving an answer where the student already is confidently predicting the right answer. Additionally, we ensure that these selection steps are themselves done in a private manner.

To add less noise, our new PATE aggregation mechanisms sample Gaussian noise, since the tails of that distribution diminish far more rapidly than those of the Laplacian noise used in the original PATE work. This reduction greatly increases the chance that the noisy aggregation of teachers' votes results in the correct consensus answer, which is especially important when PATE is scaled to learning tasks with large numbers of output classes. However, changing the sampled noise requires redoing the entire PATE privacy analysis from scratch (see Section 4 and details in Appendix A).

Finally, of independent interest are the details of our evaluation extending that of the original PATE work. In particular, we find that the virtual adversarial training (VAT) technique of Miyato et al. (2017) is a good basis for semi-supervised learning on tasks with many classes, outperforming the improved GANs by Salimans et al. (2016) used in the original PATE work. Furthermore, we explain how to tune the PATE approach to achieve very strong privacy (ε ≈ 1.0) along with high utility, for our real-world character recognition learning task. This paper is structured as follows: Section 2 is the related work section; Section 3 gives a background on PATE and an overview of our work; Section 4 describes our improved aggregation mechanisms; Section 5 details our experimental evaluation; Section 6 offers conclusions; and proofs are deferred to the Appendices.

2. RELATED WORK:

Differential privacy is by now the gold standard of privacy. It offers a rigorous framework whose threat model makes few assumptions about the adversary's capabilities, allowing differentially private algorithms to effectively cope against strong adversaries. This is not the case of all privacy definitions, as demonstrated by successful attacks against anonymization techniques (Aggarwal, 2005; Narayanan & Shmatikov, 2008; Bindschaedler et al., 2017) .

The first learning algorithms adapted to provide differential privacy with respect to their training data were often linear and convex (Pathak et al., 2010; Chaudhuri et al., 2011; Song et al., 2013; Bassily et al., 2014; Hamm et al., 2016) . More recently, successful developments in deep learning called for differentially private stochastic gradient descent algorithms (Abadi et al., 2016) , some of which have been tailored to learn in federated (McMahan et al., 2017) settings.

Differentially private selection mechanisms like GNMax (Section 4.1) are commonly used in hypothesis testing, frequent itemset mining, and as building blocks of more complicated private mechanisms. The most commonly used differentially private selection mechanisms are exponential mechanism (McSherry & Talwar, 2007) and LNMax (Bhaskar et al., 2010) . Recent works offer lower bounds on sample complexity of such problem (Steinke & Ullman, 2017; Bafna & Ullman, 2017) .

The Confident and Interactive Aggregator proposed in our work (Section 4.2 and Section 4.3 resp.) use the intuition that selecting samples under certain constraints could result in better training than using samples uniformly at random. In Machine Learning Theory, active learning (Cohn et al., 1994) has been shown to allow learning from fewer labeled examples than the passive case (see e.g. Hanneke (2014) ). Similarly, in model stealing (Tramèr et al., 2016) , a goal is to learn a model from limited access to a teacher network. There is previous work in differential privacy literature (Hardt & Rothblum, 2010; Roth & Roughgarden, 2010) where the mechanism first decides whether or not to answer a query, and then privately answers the queries it chooses to answer using a traditional noiseaddition mechanism. In these cases, the sparse vector technique (Dwork & Roth, 2014, Chapter 3.6) helps bound the privacy cost in terms of the number of answered queries. This is in contrast to our work where a constant fraction of queries get answered and the sparse vector technique does not seem to help reduce the privacy cost. Closer to our work, Bun et al. (2017) consider a setting where the answer to a query of interest is often either very large or very small. They show that a sparse vector-like analysis applies in this case, where one pays only for queries that are in the middle.

3. BACKGROUND AND OVERVIEW:

We introduce essential components of our approach towards a generic and flexible framework for machine learning with provable privacy guarantees for training data.

3.1. THE PATE FRAMEWORK:

Here, we provide an overview of the PATE framework. To protect the privacy of training data during learning, PATE transfers knowledge from an ensemble of teacher models trained on partitions of the data to a student model. Privacy guarantees may be understood intuitively and expressed rigorously in terms of differential privacy. 2 , the PATE framework consists of three key parts: (1) an ensemble of n teacher models, (2) an aggregation mechanism and (3) a student model.

Illustrated in Figure:

Teacher models: Each teacher is a model trained independently on a subset of the data whose privacy one wishes to protect. The data is partitioned to ensure no pair of teachers will have trained on overlapping data. Any learning technique suitable for the data can be used for any teacher.

Training each teacher on a partition of the sensitive data produces n different models solving the same task. At inference, teachers independently predict labels.

Aggregation mechanism: When there is a strong consensus among teachers, the label they almost all agree on does not depend on the model learned by any given teacher. Hence, this collective decision is intuitively private with respect to any given training point-because such a point could have been included only in one of the teachers' training set. To provide rigorous guarantees of differential privacy, the aggregation mechanism of the original PATE framework counts votes assigned (1) an ensemble of teachers is trained on disjoint subsets of the sensitive data, (2) a student model is trained on public data labeled using the ensemble.

to each class, adds carefully calibrated Laplacian noise to the resulting vote histogram, and outputs the class with the most noisy votes as the ensemble's prediction. This mechanism is referred to as the max-of-Laplacian mechanism, or LNMax, going forward.

For samples x and classes 1, . . . , m, let f j (x) ∈ [m] denote the j-th teacher model's prediction and n i denote the vote count for the i-th class (i.e., n i |f j (x) = i|). The output of the mechanism is

A(x) argmax i (n i (x) + Lap (1/γ)).

Through a rigorous analysis of this mechanism, the PATE framework provides a differentially private API: the privacy cost of each aggregated prediction made by the teacher ensemble is known.

Student model: PATE's final step involves the training of a student model by knowledge transfer from the teacher ensemble using access to public-but unlabeled-data. To limit the privacy cost of labeling them, queries are only made to the aggregation mechanism for a subset of public data to train the student in a semi-supervised way using a fixed number of queries. The authors note that every additional ensemble prediction increases the privacy cost spent and thus cannot work with unbounded queries. Fixed queries fixes privacy costs as well as diminishes the value of attacks analyzing model parameters to recover training data (Zhang et al., 2017) . The student only sees public data and privacy-preserving labels.

3.2. DIFFERENTIAL PRIVACY:

Differential privacy (Dwork et al., 2006) requires that the sensitivity of the distribution of an algorithm's output to small perturbations of its input be limited. The following variant of the definition captures this intuition formally:

Definition 1. A randomized mechanism M with domain D and range R satisfies (ε, δ)-differential privacy if for any two adjacent inputs D, D ∈ D and for any subset of outputs S ⊆ R it holds that:

EQUATION

For our application of differential privacy to ML, adjacent inputs are defined as two datasets that only differ by one training example and the randomized mechanism M would be the model training algorithm. The privacy parameters have the following natural interpretation: ε is an upper bound on the loss of privacy, and δ is the probability with which this guarantee may not hold. Composition theorems (Dwork & Roth, 2014) allow us to keep track of the privacy cost when we run a sequence of mechanisms.

3.3 RÉNYI DIFFERENTIAL PRIVACY Papernot et al. (2017) note that the natural approach to bounding PATE's privacy loss-by bounding the privacy cost of each label queried and using strong composition (Dwork et al., 2010) to derive the total cost-yields loose privacy guarantees. Instead, their approach uses data-dependent privacy analysis. This takes advantage of the fact that when the consensus among the teachers is very strong, the plurality outcome has overwhelming likelihood leading to a very small privacy cost whenever the consensus occurs. To capture this effect quantitatively, Papernot et al. (2017) rely on the moments accountant, introduced by Abadi et al. (2016) and building on previous work (Bun & Steinke, 2016; Dwork & Rothblum, 2016) .

In this section, we recall the language of Rényi Differential Privacy or RDP (Mironov, 2017) . RDP generalizes pure differential privacy (δ = 0) and is closely related to the moments accountant. We choose to use RDP as a more natural analysis framework when dealing with our mechanisms that use Gaussian noise. Defined below, the RDP of a mechanism is stated in terms of the Rényi divergence.

Definition 2 (Rényi Divergence). The Rényi divergence of order λ between two distributions P and Q is defined as:

D λ (P Q) 1 λ -1 log E x∼Q (P (x)/Q(x)) λ = 1 λ -1 log E x∼P (P (x)/Q(x)) λ-1 .

Definition 3 (Rényi Differential Privacy (RDP)). A randomized mechanism M is said to guarantee (λ, ε)-RDP with λ ≥ 1 if for any neighboring datasets D and D ,

D λ (M(D) M(D )) = 1 λ -1 log E x∼M(D) Pr [M(D) = x] Pr [M(D ) = x] λ-1 ≤ ε.

RDP generalizes pure differential privacy in the sense that ε-differential privacy is equivalent to (∞, ε)-RDP. Mironov (2017) proves the following key facts that allow easy composition of RDP guarantees and their conversion to (ε, δ)-differential privacy bounds. Theorem 4 (Composition). If a mechanism M consists of a sequence of adaptive mechanisms M 1 , . . . , M k such that for any i ∈

[k], M i guarantees (λ, ε i )-RDP, then M guarantees (λ, k i=1 ε i )-RDP.

Theorem 5 (From RDP to DP). If a mechanism M guarantees (λ, ε)-RDP, then M guarantees (ε + log 1/δ λ-1 , δ)-differential privacy for any δ ∈ (0, 1).

While both (ε, δ)-differential privacy and RDP are relaxations of pure ε-differential privacy, the two main advantages of RDP are as follows. First, it composes nicely; second, it captures the privacy guarantee of Gaussian noise in a much cleaner manner compared to (ε, δ)-differential privacy. This lets us do a careful privacy analysis of the GNMax mechanism as stated in Theorem 6. While the analysis of Papernot et al. (2017) leverages the first aspect of such frameworks with the Laplace noise (LNMax mechanism), our analysis of the GNMax mechanism relies on both.

3.4. PATE AGGREGATION MECHANISMS:

The aggregation step is a crucial component of PATE. It enables knowledge transfer from the teachers to the student while enforcing privacy. We improve the LNMax mechanism used by Papernot et al. (2017) which adds Laplace noise to teacher votes and outputs the class with the highest votes.

First, we add Gaussian noise with an accompanying privacy analysis in the RDP framework. This modification effectively reduces the noise needed to achieve the same privacy cost per student query.

Second, the aggregation mechanism is now selective: teacher votes are analyzed to decide which student queries are worth answering. This takes into account both the privacy cost of each query and its payout in improving the student's utility. Surprisingly, our analysis shows that these two metrics are not at odds and in fact align with each other: the privacy cost is the smallest when teachers agree, and when teachers agree, the label is more likely to be correct thus being more useful to the student.

Third, we propose and study an interactive mechanism that takes into account not only teacher votes on a queried example but possible student predictions on that query. Now, queries worth answering are those where the teachers agree on a class but the student is not confident in its prediction on that class. This third modification aligns the two metrics discussed above even further: queries where the student already agrees with the consensus of teachers are not worth expending our privacy budget on, but queries where the student is less confident are useful and answered at a small privacy cost.

3.5. DATA-DEPENDENT PRIVACY IN PATE:

A direct privacy analysis of the aggregation mechanism, for reasonable values of the noise parameter, allows answering only few queries before the privacy cost becomes prohibitive. The original PATE proposal used a data-dependent analysis, exploiting the fact that when the teachers have large agreement, the privacy cost is usually much smaller than the data-independent bound would suggest.

In our work, we perform a data-dependent privacy analysis of the aggregation mechanism with Gaussian noise. This change of noise distribution turns out be technically much more challenging than the Laplace noise case and we defer the details to Appendix A. This increased complexity of the analysis however does not make the algorithm any more complicated and thus allows us to improve the privacy-utility tradeoff.

Sanitizing the privacy cost via smooth sensitivity analysis. An additional challenge with datadependent privacy analyses arises from the fact that the privacy cost itself is now a function of the private data. Further, the data-dependent bound on the privacy cost has large global sensitivity (a metric used in differential privacy to calibrate the noise injected) and is therefore difficult to sanitize.

To remedy this, we use the smooth sensitivity framework proposed by Nissim et al. (2007) .

Appendix B describes how we add noise to the computed privacy cost using this framework to publish a sanitized version of the privacy cost. Section B.1 defines smooth sensitivity and outlines algorithms 3-5 that compute it. The rest of Appendix B argues the correctness of these algorithms.

The final analysis shows that the incremental cost of sanitizing our privacy estimates is modestless than 50% of the raw estimates-thus enabling us to use precise data-dependent privacy analysis while taking into account its privacy implications.

4. IMPROVED AGGREGATION MECHANISMS FOR PATE:

The privacy guarantees provided by PATE stem from the design and analysis of the aggregation step. Here, we detail our improvements to the mechanism used by Papernot et al. (2017) . As outlined in Section 3.4, we first replace the Laplace noise added to teacher votes with Gaussian noise, adapting the data-dependent privacy analysis. Next, we describe the Confident and Interactive Aggregators that select queries worth answering in a privacy-preserving way: the privacy budget is shared between the query selection and answer computation. The aggregators use different heuristics to select queries: the former does not take into account student predictions, while the latter does.

4.1. THE GNMAX AGGREGATOR AND ITS PRIVACY GUARANTEE:

This section uses the following notation. For a sample x and classes 1 to m, let f j (x) ∈ [m] denote the j-th teacher model's prediction on x and n i (x) denote the vote count for the i-th class (i.e., n i (x) = |{j: f j (x) = i}|). We define a Gaussian NoisyMax (GNMax) aggregation mechanism as:

M σ (x) argmax i n i (x) + N (0, σ 2 ) ,

where N (0, σ 2 ) is the Gaussian distribution with mean 0 and variance σ 2 . The aggregator outputs the class with noisy plurality after adding Gaussian noise to each vote count. In what follow, plurality more generally refers to the highest number of teacher votes assigned among the classes.

The Gaussian distribution is more concentrated than the Laplace distribution used by Papernot et al. (2017) . This concentration directly improves the aggregation's utility when the number of classes m is large. The GNMax mechanism satisfies (λ, λ/σ 2 )-RDP, which holds for all inputs and all λ ≥ 1 (precise statements and proofs of claims in this section are deferred to Appendix A). A straightforward application of composition theorems leads to loose privacy bounds. As an example, the standard advanced composition theorem applied to experiments in the last two rows of Table 1 would give us ε = 8.42 and ε = 10.14 resp. at δ = 10 -8 for the Glyph dataset.

To refine these, we work out a careful data-dependent analysis that yields values of ε smaller than 1 for the same δ. The following theorem translates data-independent RDP guarantees for higher orders into a data-dependent RDP guarantee for a smaller order λ. We use it in conjunction with Proposition 7 to bound the privacy cost of each query to the GNMax algorithm as a function of q, the probability that the most common answer will not be output by the mechanism.

Theorem 6 (informal). Let M be a randomized algorithm with (µ 1 , ε 1 )-RDP and (µ 2 , ε 2 )-RDP guarantees and suppose that given a dataset D, there exists a likely outcome i * such that Pr [M(D) = i * ] ≤ q. Then the data-dependent Rényi differential privacy for M of order λ ≤ µ 1 , µ 2 at D is bounded by a function of q, µ 1 , ε 1 , µ 2 , ε 2 , which approaches 0 as q → 0.

The new bound improves on the data-independent privacy for λ as long as the distribution of the algorithm's output on that input has a strong peak (i.e., q 1). Values of q close to 1 could result in a looser bound. Therefore, in practice we take the minimum between this bound and λ/σ 2 (the data-independent one). The theorem generalizes Theorem 3 from Papernot et al. (2017) , where it was shown for a mechanism satisfying ε-differential privacy (i.e., µ 1 = µ 2 = ∞ and ε 1 = ε 2 ).

The final step in our analysis uses the following lemma to bound the probability q when i * corresponds to the class with the true plurality of teacher votes. Proposition 7. For any i

* ∈ [m], we have Pr [M σ (D) = i * ] ≤ 1 2 i =i * erfc n i * -ni 2σ

, where erfc is the complementary error function.

In Appendix A, we detail how these results translate to privacy bounds. In short, for each query to the GNMax aggregator, given teacher votes n i and the class i * with maximal support, Proposition 7 gives us the value of q to use in Theorem 6. We optimize over µ 1 and µ 2 to get a data-dependent RDP guarantee for any order λ. Finally, we use composition properties of RDP to analyze a sequence of queries, and translate the RDP bound back to an (ε, δ)-DP bound.

Expensive queries. This data-dependent privacy analysis leads us to the concept of an expensive query in terms of its privacy cost. When teacher votes largely disagree, some n i * -n i values may be small leading to a large value for q: i.e., the lack of consensus amongst teachers indicates that the aggregator is likely to output a wrong label. Thus expensive queries from a privacy perspective are often bad for training too. Conversely, queries with strong consensus enable tight privacy bounds. This synergy motivates the aggregation mechanisms discussed in the following sections: they evaluate the strength of the consensus before answering a query.

4.2. THE CONFIDENT-GNMAX AGGREGATOR:

In this section, we propose a refinement of the GNMax aggregator that enables us to filter out queries for which teachers do not have a sufficiently strong consensus. This filtering enables the teachers to avoid answering expensive queries. We also take note to do this selection step itself in a private manner.

The proposed Confident Aggregator is described in Algorithm 1. To select queries with overwhelming consensus, the algorithm checks if the plurality vote crosses a threshold T . To enforce privacy in this step, the comparison is done after adding Gaussian noise with variance σ 2 1 . Then, for queries that pass this noisy threshold check, the aggregator proceeds with the usual GNMax mechanism with a smaller variance σ 2 2 . For queries that do not pass the noisy threshold check, the aggregator simply returns ⊥ and the student discards this example in its training.

In practice, we often choose significantly higher values for σ 1 compared to σ 2 . This is because we pay the cost of the noisy threshold check always, and without the benefit of knowing that the consensus is strong. We pick T so that queries where the plurality gets less than half the votes (often very expensive) are unlikely to pass the threshold after adding noise, but we still have a high enough yield amongst the queries with a strong consensus. This tradeoff leads us to look for T 's between 0.6× to 0.8× the number of teachers.

The privacy cost of this aggregator is intuitive: we pay for the threshold check for every query, and for the GNMax step only for queries that pass the check. In the work of Papernot et al. (2017) , the mechanism paid a privacy cost for every query, expensive or otherwise. In comparison, the Confident Aggregator expends a much smaller privacy cost to check against the threshold, and by answering a significantly smaller fraction of expensive queries, it expends a lower privacy cost overall.

4.3. THE INTERACTIVE-GNMAX AGGREGATOR:

While the Confident Aggregator excludes expensive queries, it ignores the possibility that the student might receive labels that contribute little to learning, and in turn to its utility. By incorporating the Algorithm 1 -Confident-GNMax Aggregator: given a query, consensus among teachers is first estimated in a privacy-preserving way to then only reveal confident teacher predictions.

Input: input x, threshold T , noise parameters σ 1 and σ 2 1: if max i {n j (x)} + N (0, σ 2 1 ) ≥ T then Privately check for consensus 2:

return argmax j n j (x) + N (0, σ 2 2 )

Run the usual max-of-Gaussian 3: else 4:

return ⊥ 5: end if Algorithm 2 -Interactive-GNMax Aggregator: the protocol first compares student predictions to the teacher votes in a privacy-preserving way to then either (a) reinforce the student prediction for the given query or (b) provide the student with a new label predicted by the teachers.

Input: input x, confidence γ, threshold T , noise parameters σ 1 and σ 2 , total number of teachers M 1: Ask the student to provide prediction scores p(x)

2: if max j {n j (x) -M p j (x)} + N (0, σ 2 1 ) ≥ T then

Student does not agree with teachers 3:

return argmax j {n j (x) + N (0, σ 2 2 )} Teachers provide new label 4: else if max{p i (x)} > γ then

Student agrees with teachers and is confident 5:

return arg max j p j (x) Reinforce student's prediction 6: else 7:

return ⊥:

No output given for this label 8: end if student's current predictions for its public training data, we design an Interactive Aggregator that discards queries where the student already confidently predicts the same label as the teachers.

Given a set of queries, the Interactive Aggregator (Algorithm 2) selects those answered by comparing student predictions to teacher votes for each class. Similar to Step 1 in the Confident Aggregator, queries where the plurality of these noised differences crosses a threshold are answered with GN-Max. This noisy threshold suffices to enforce privacy of the first step because student predictions can be considered public information (the student is trained in a differentially private manner).

For queries that fail this check, the mechanism reinforces the predicted student label if the student is confident enough and does this without looking at teacher votes again. This limited form of supervision comes at a small privacy cost. Moreover, the order of the checks ensures that a student falsely confident in its predictions on a query is not accidentally reinforced if it disagrees with the teacher consensus. The privacy accounting is identical to the Confident Aggregator except in considering the difference between teachers and the student instead of only the teachers votes.

In practice, the Confident Aggregator can be used to start training a student when it can make no meaningful predictions and training can be finished off with the Interactive Aggregator after the student gains some proficiency.

5. EXPERIMENTAL EVALUATION:

Our goal is first to show that the improved aggregators introduced in Section 4 enable the application of PATE to uncurated data, thus departing from previous results on tasks with balanced and wellseparated classes. We experiment with the Glyph dataset described below to address two aspects left open by Papernot et al. (2017) : (a) the performance of PATE on a task with a larger number of classes (the framework was only evaluated on datasets with at most 10 classes) and (b) the privacy-utility tradeoffs offered by PATE on data that is class imbalanced and partly mislabeled. In Section 5.2, we evaluate the improvements given by the GNMax aggregator over its Laplace counterpart (LNMax) and demonstrate the necessity of the Gaussian mechanism for uncurated tasks.

In Section 5.3, we then evaluate the performance of PATE with both the Confident and Interactive Aggregators on all datasets used to benchmark the original PATE framework, in addition to Glyph. With the right teacher and student training, the two mechanisms from Section 4 achieve high accuracy with very tight privacy bounds. Not answering queries for which teacher consensus is too low (Confident-GNMax) or the student's predictions already agree with teacher votes (Interactive-GNMax) better aligns utility and privacy: queries are answered at a significantly reduced cost.

5.1. EXPERIMENTAL SETUP:

MNIST, SVHN, and the UCI Adult databases. We evaluate with two computer vision tasks (MNIST and Street View House Numbers (Netzer et al., 2011) ) and census data from the UCI Adult dataset (Kohavi, 1996) . This enables a comparative analysis of the utility-privacy tradeoff achieved with our Confident-GNMax aggregator and the LNMax originally used in PATE. We replicate the experimental setup and results found in Papernot et al. (2017) with code and teacher votes made available online. The source code for the privacy analysis in this paper as well as supporting data required to run this analysis is available on Github. 1A detailed description of the experimental setup can be found in Papernot et al. (2017) ; we provide here only a brief overview. For MNIST and SVHN, teachers are convolutional networks trained on partitions of the training set. For UCI Adult, each teacher is a random forest. The test set is split in two halves: the first is used as unlabeled inputs to simulate the student's public data and the second is used as a hold out to evaluate test performance. The MNIST and SVHN students are convolutional networks trained using semi-supervised learning with GANs à la Salimans et al. (2016) . The student for the Adult dataset are fully supervised random forests.

Glyph. This optical character recognition task has an order of magnitude more classes than all previous applications of PATE. The Glyph dataset also possesses many characteristics shared by real-world tasks: e.g., it is imbalanced and some inputs are mislabeled. Each input is a 28 × 28 grayscale image containing a single glyph generated synthetically from a collection of over 500K computer fonts.2 Samples representative of the difficulties raised by the data are depicted in Figure 3 . The task is to classify inputs as one of the 150 Unicode symbols used to generate them. This set of 150 classes results from pre-processing efforts. We discarded additional classes that had few samples; some classes had at least 50 times fewer inputs than the most popular classes, and these were almost exclusively incorrectly labeled inputs. We also merged classes that were too ambiguous for even a human to differentiate them. Nevertheless, a manual inspection of samples grouped by classes-favorably to the human observer-led to the conservative estimate that some classes remain 5 times more frequent, and mislabeled inputs represent at least 10% of the data.

To simulate the availability of private and public data (see Section 3.1), we split data originally marked as the training set (about 65M points) into partitions given to the teachers. Each teacher is a ResNet (He et al., 2016) made of 32 leaky ReLU layers. We train on batches of 100 inputs for 40K steps using SGD with momentum. The learning rate, initially set to 0.1, is decayed after 10K steps to 0.01 and again after 20K steps to 0.001. These parameters were found with a grid search.

We split holdout data in two subsets of 100K and 400K samples: the first acts as public data to train the student and the second as its testing data. The student architecture is a convolutional network learnt in a semi-supervised fashion with virtual adversarial training (VAT) from Miyato et al. (2017) . Using unlabeled data, we show how VAT can regularize the student by making predictions constant in adversarial3 directions. Indeed, we found that GANs did not yield as much utility for Glyph as for MNIST or SVHN. We train with Adam for 400 epochs and a learning rate of 6 • 10 -5 .

5.2. COMPARING THE LNMAX AND GNMAX MECHANISMS:

Section 4.1 introduces the GNMax mechanism and the accompanying privacy analysis. With a Gaussian distribution, whose tail diminishes more rapidly than the Laplace distribution, we expect better utility when using the new mechanism (albeit with a more involved privacy analysis).

To study the tradeoff between privacy and accuracy with the two mechanisms, we run experiments training several ensembles of M teachers for M ∈ {100, 500, 1000, 5000} on the Glyph data. Re-call that 65 million training inputs are partitioned and distributed among the M teachers with each teacher receiving between 650K and 13K inputs for the values of M above. The test data is used to query the teacher ensemble and the resulting labels (after the LNMax and GNMax mechanisms) are compared with the ground truth labels provided in the dataset. This predictive performance of the teachers is essential to good student training with accurate labels and is a useful proxy for utility.

For each mechanism, we compute (ε, δ)-differential privacy guarantees. As is common in literature, for a dataset on the order of 10 8 samples, we choose δ = 10 -8 and denote the corresponding ε as the privacy cost. The total ε is calculated on a subset of 4,000 queries, which is representative of the number of labels needed by a student for accurate training (see Section 5.3). We visualize in Figure 4 the effect of the noise distribution (left) and the number of teachers (right) on the tradeoff between privacy costs and label accuracy.

Observations. On the left of Figure 1 , we compare our GNMax aggregator to the LNMax aggregator used by the original PATE proposal, on an ensemble of 1000 teachers and for varying noise scales σ. At fixed test accuracy, the GNMax algorithm consistently outperforms the LNMax mechanism in terms of privacy cost. To explain this improved performance, recall notation from Section 4.1. For both mechanisms, the data dependent privacy cost scales linearly with q-the likelihood of an answer other than the true plurality. The value of q falls of as exp(-x 2 ) for GNMax and exp(-x) for LNMax, where x is the ratio (n i * -n i )/σ. Thus, when n i * -n i is (say) 4σ, LNMax would have q ≈ e -4 = 0.018..., whereas GNMax would have q ≈ e -16 ≈ 10 -7 , thereby leading to a much higher likelihood of returning the true plurality. Moreover, this reduced q translates to a smaller privacy cost for a given σ leading to a better utility-privacy tradeoff.

As long as each teacher has sufficient data to learn a good-enough model, increasing the number M of teachers improves the tradeoff-as illustrated on the right of Figure 4 with GNMax. The larger ensembles lower the privacy cost of answering queries by tolerating larger σ's. Combining the two observations made in this Figure , for a fixed label accuracy, we lower privacy costs by switching to the GNMax aggregator and training a larger number M of teachers.

5.3. STUDENT TRAINING WITH THE GNMAX AGGREGATION MECHANISMS:

As outlined in Section 3, we train a student on public data labeled by the aggregation mechanisms. We take advantage of PATE's flexibility and apply the technique that performs best on each dataset: semi-supervised learning with Generative Adversarial Networks (Salimans et al., 2016) for MNIST and SVHN, Virtual Adversarial Training (Miyato et al., 2017) for Glyph, and fully-supervised random forests for UCI Adult. In addition to evaluating the total privacy cost associated with training the student model, we compare its utility to a non-private baseline obtained by training on the sensitive data (used to train teachers in PATE): we use the baselines of 99.2%, 92.8%, and 85.0% reported by Papernot et al. (2017) respectively for MNIST, SVHN, and UCI Adult, and we measure a baseline of 82.2% for Glyph. We compute (ε, δ)-privacy bounds and denote the privacy cost as the ε value at a value of δ set accordingly to number of training samples.

Confident-GNMax Aggregator. Given a pool of 500 to 12,000 samples to learn from (depending on the dataset), the student submits queries to the teacher ensemble running the Confident-GNMax aggregator from Section 4.2. A grid search over a range of plausible values for parameters T , σ 1 and σ 2 yielded the values reported in Table 1 , illustrating the tradeoff between utility and privacy achieved. We additionally measure the number of queries selected by the teachers to be answered and compare student utility to a non-private baseline.

The Confident-GNMax aggregator outperforms LNMax for the four datasets considered in the original PATE proposal: it reduces the privacy cost ε, increases student accuracy, or both simultaneously. On the uncurated Glyph data, despite the imbalance of classes and mislabeled data (as evidenced by the 82.2% baseline), the Confident Aggregator achieves 73.5% accuracy with a privacy cost of just ε = 1.02. Roughly 1,300 out of 12,000 queries made are not answered, indicating that several expensive queries were successfully avoided. This selectivity is analyzed in more details in Section 5.4.

Interactive-GNMax Aggregator. On Glyph, we evaluate the utility and privacy of an interactive training routine that proceeds in two rounds. Round one runs student training with a Confident Figure 5 : Effects of the noisy threshold checking: Left: The number of queries answered by LNMax, Confident-GNMax moderate (T =3500, σ 1 =1500), and Confident-GNMax aggressive (T =5000, σ 1 =1500). The black dots and the right axis (in log scale) show the expected cost of answering a single query in each bin (via GNMax, σ 2 =100). Right: Privacy cost of answering all (LNMax) vs only inexpensive queries (GNMax) for a given number of answered queries. The very dark area under the curve is the cost of selecting queries; the rest is the cost of answering them.

Aggregator. A grid search targeting the best privacy for roughly 3,400 answered queries (out of 6,000)-sufficient to bootstrap a student-led us to setting (T =3500, σ 1 =1500, σ 2 =100) and a privacy cost of ε ≈ 0.59.

In round two, this student was then trained with 10,000 more queries made with the Interactive-GNMax Aggregator (T =3500, σ 1 =2000, σ 2 =200). We computed the resulting (total) privacy cost and utility at an exemplar data point through another grid search of plausible parameter values. The result appears in the last row of Table 1 . With just over 10,422 answered queries in total at a privacy cost of ε = 0.84, the trained student was able to achieve 73.2% accuracy. Note that this students required fewer answered queries compared to the Confident Aggregator. The best overall cost of student training occurred when the privacy costs for the first and second rounds of training were roughly the same. (The total ε is less than 0.59 × 2 = 1.18 due to better composition-via Theorems 4 and 5.)

Comparison with Baseline. Note that the Glyph student's accuracy remains seven percentage points below the non-private model's accuracy achieved by training on the 65M sensitive inputs. We hypothesize that this is due to the uncurated nature of the data considered. Indeed, the class imbalance naturally requires more queries to return labels from the less represented classes. For instance, a model trained on 200K queries is only 77% accurate on test data. In addition, the large fraction of mislabeled inputs are likely to have a large privacy cost: these inputs are sensitive because they are outliers of the distribution, which is reflected by the weak consensus among teachers on these inputs.

5.4. NOISY THRESHOLD CHECKS AND PRIVACY COSTS:

Sections 4.1 and 4.2 motivated the need for a noisy threshold checking step before having the teachers answer queries: it prevents most of the privacy budget being consumed by few queries that are expensive and also likely to be incorrectly answered. In Figure 5 , we compare the privacy cost ε of answering all queries to only answering confident queries for a fixed number of queries.

We run additional experiments to support the evaluation from Section 5.3. With the votes of 5,000 teachers on the Glyph dataset, we plot in Figure 5 the histogram of the plurality vote counts (n i * in the notation of Section 4.1) across 25,000 student queries. We compare these values to the vote counts of queries that passed the noisy threshold check for two sets of parameters T and σ 1 in Algorithm 1. Smaller values imply weaker teacher agreements and consequently more expensive queries.

When (T =3500, σ 1 =1500) we capture a significant fraction of queries where teachers have a strong consensus (roughly > 4000 votes) while managing to filter out many queries with poor consensus. This moderate check ensures that although many queries with plurality votes between 2,500 and 3,500 are answered (i.e., only 50-70% of teachers agree on a label) the expensive ones are most likely discarded. For (T =5000, σ 1 =1500), queries with poor consensus are completely culled out. This selectivity comes at the expense of a noticeable drop for queries that might have had a strong consensus and little-to-no privacy cost. Thus, this aggressive check answer fewer queries with very strong privacy guarantees. We reiterate that this threshold checking step itself is done in a private manner. Empirically, in our Interactive Aggregator experiments, we expend about a third to a half of our privacy budget on this step, which still yields a very small cost per query across 6,000 queries.

6. CONCLUSIONS:

The key insight motivating the addition of a noisy thresholding step to the two aggregation mechanisms proposed in our work is that there is a form of synergy between the privacy and accuracy of labels output by the aggregation: labels that come at a small privacy cost also happen to be more likely to be correct. As a consequence, we are able to provide more quality supervision to the student by choosing not to output labels when the consensus among teachers is too low to provide an aggregated prediction at a small cost in privacy. This observation was further confirmed in some of our experiments where we observed that if we trained the student on either private or non-private labels, the former almost always gave better performance than the latter-for a fixed number of labels.

Complementary with these aggregation mechanisms is the use of a Gaussian (rather than Laplace) distribution to perturb teacher votes. In our experiments with Glyph data, these changes proved essential to preserve the accuracy of the aggregated labels-because of the large number of classes. The analysis presented in Section 4 details the delicate but necessary adaptation of analogous results for the Laplace NoisyMax.

As was the case for the original PATE proposal, semi-supervised learning was instrumental to ensure the student achieves strong utility given a limited set of labels from the aggregation mechanism. However, we found that virtual adversarial training outperforms the approach from Salimans et al. (2016) in our experiments with Glyph data. These results establish lower bounds on the performance that a student can achieve when supervised with our aggregation mechanisms; future work may continue to investigate virtual adversarial training, semi-supervised generative adversarial networks and other techniques for learning the student in these particular settings with restricted supervision.

A APPENDIX: PRIVACY ANALYSIS:

In this appendix, we provide the proofs of Theorem 6 and Proposition 7. Moreover, we present Proposition 10, which provides optimal values of µ 1 and µ 2 to apply towards Theorem 6 for the GNMax mechanism. We start off with a statement about the Rényi differential privacy guarantee of the GNMax. Proposition 8. The GNMax aggregator M σ guarantees λ, λ/σ 2 -RDP for all λ ≥ 1.

Proof. The result follows from observing that M σ can be decomposed into applying the argmax operator to a noisy histogram resulted from adding Gaussian noise to each dimension of the original histogram. The Gaussian mechanism satisfies (λ, λ/2σ 2 )-RDP (Mironov, 2017) , and since each teacher may change two counts (incrementing one and decrementing the other), the overall RDP guarantee is as claimed.

Proposition 7. For a GNMax aggregator M σ , the teachers' votes histogram n = (n 1 , . . . , n m ), and for any i * ∈ [m], we have

Pr [M σ (D) = i * ] ≤ q(n),

where

q(n) 1 2 i =i * erfc n i * -n i 2σ . Proof. Recall that M σ (D) = argmax(n i + Z i )

, where Z i are distributed as N (0, σ 2 ). Then for any i * ∈ [m], we have

Pr[M σ (D) = i * ] = Pr [∃i, n i + Z i > n i * + Z i * ] ≤ i =i * Pr [n i + Z i > n i * + Z i * ] = i =i * Pr [Z i -Z i * > n i * -n i ] = i =i * 1 2 1 -erf n i * -n i 2σ .

where the last equality follows from the fact that Z i -Z j is a Gaussian random variable with mean zero and variance 2σ 2 .

We now present a precise statement of Theorem 6. Theorem 6. Let M be a randomized algorithm with (µ 1 , ε 1 )-RDP and (µ 2 , ε 2 )-RDP guarantees and suppose that there exists a likely outcome i * given a dataset D and a bound q ≤ 1 such that

q ≥ Pr [M(D) = i * ]. Additionally suppose that λ ≤ µ 1 and q ≤ e (µ2-1)ε2 / µ1 µ1-1 • µ2 µ2-1 µ2 .

Then, for any neighboring dataset D of D, we have:

D λ (M(D) M(D )) ≤ 1 λ -1 log (1 -q) • A(q, µ 2 , ε 2 ) λ-1 + q • B(q, µ 1 , ε 1 ) λ-1 (2)

where

A(q, µ 2 , ε 2 ) (1 -q)/ 1 -(qe ε2 ) µ 2 -1 µ 2

and B(q, µ 1 , ε 1 ) e ε1 /q

1 µ 1 -1 .

Proof. Before we proceed to the proof, we introduce some simplifying notation. For a randomized mechanism M and neighboring datasets D and D , we define

β M (λ; D, D ) D λ (M(D) M(D )) = 1 λ -1 log E x∼M(D) Pr [M(D) = x] Pr [M(D ) = x] λ-1

.

As the proof involves working with the RDP bounds in the exponent, we set ζ 1 e ε1(µ1-1) and ζ 2 e ε2(µ2-1) .

Published as a conference paper at ICLR 2018 Finally, we define the following shortcuts:

q i Pr [M(D) = i] and q i =i * q i = Pr [M(D) = i * ] , p i Pr [M(D ) = i] and p i =i * p i = Pr [M(D ) = i * ] ,

and note that q ≤ q.

From the definition of Rényi differential privacy, (µ 1 , ε 1 )-RDP implies:

exp (β M (µ 1 ; D, D )) =   (1 -q) µ1 (1 -p) µ1-1 + i =i * q µ1 i p µ1-1 i   1/(µ1-1) ≤ exp(ε 1 ) =⇒ i>1 q µ1 i p µ1-1 i = i>1 q i q i p i µ1-1 ≤ ζ 1 . (3) Since µ 1 ≥ λ, f (x) x µ 1 -1

λ-1 is convex. Applying Jensen's Inequality we have the following:

   i =i * q i qi pi λ-1 q    µ 1 -1 λ-1 ≤ i =i * q i qi pi µ1-1 q =⇒ i =i * q i q i p i λ-1 ≤ q    i =i * q i qi pi µ1-1 q    λ-1 µ 1 -1 (3) =⇒ i =i * q i q i p i λ-1 ≤ ζ 1 λ-1 µ 1 -1 • q 1-λ-1 µ 1 -1 . (4)

Next, by the bound at order µ 2 , we have:

exp (β M (µ 2 ; D , D)) =   (1 -p) µ2 (1 -q) µ2-1 + i =i * p µ2 i q µ2-1 i   1/(µ2-1) ≤ exp(ε 2 ) =⇒ (1 -p) µ2 (1 -q) µ2-1 + i =i * p µ2 i q µ2-1 i ≤ ζ 2 .

By the data processing inequality of Rényi divergence, we have

EQUATION

)

Combining ( 4) and ( 5), we can derive a bound at λ.

EQUATION

)

which is minimized at µ 2 = σ • log(1/q).

To minimize the second term in (6), we minimize e ε1 /q 1/(µ1-1) as follows: log e ε1 q1/(µ1-1) = log q-1/(µ1-1) exp

µ 1 σ 2 = µ 1 σ 2 + 1 µ 1 -1 log 1 q = 1 σ 2 + µ 1 -1 σ 2 + 1 µ 1 -1 log 1 q ,

which is minimized at µ 1 = 1 + σ • log(1/q) completing the proof.

Putting this together, we apply the following steps to calculate RDP of order λ for GNMax with variance σ 2 on a given dataset D. First, we compute a bound q according to Proposition 7. Then we use the smaller of two bounds: a data-dependent (Theorem 6) and a data-independent one (Proposition 8) :

β σ (q) min 1 λ -1 log (1 -q) • A(q, µ 2 , ε 2 ) λ-1 + q • B(q, µ 1 , ε 1 ) λ-1 , λ/σ 2 ,

where A and B are defined as in the statement of Theorem 6, the parameters µ 1 and µ 2 are selected according to Proposition 10, and ε 1 µ 1 /σ 2 and ε 2 µ 2 /σ 2 (Proposition 8). Importantly, the first expression is evaluated only when q < 1, µ 1 ≥ λ, µ 2 > 1, and q ≤ e (µ2-1)ε2 / µ1 µ1-1 • µ2 µ2-1 µ2 . These conditions can either be checked for each application of the aggregation mechanism, or a critical value of q 0 that separates the range of applicability of the data-dependent and data-independent bounds can be computed for given σ and λ. In our implementation we pursue the second approach.

The following corollary offers a simple asymptotic expression of the privacy of GNMax for the case when there are large (relative to σ) gaps between the highest three vote counts. Corollary 11. If the top three vote counts are n 1 > n 2 > n 3 and n 1 -n 2 , n 2 -n 3 σ, then the mechanism GNMax with Gaussian of variance σ 2 satisfies (λ, exp(-2λ/σ 2 )/λ)-RDP for λ = (n 1 -n 2 )/4.

Proof. Denote the noisy counts as ñi = n i + N (0, σ 2 ). Ignoring outputs other than those with the highest and the second highest counts, we bound q

= Pr [M(D) = 1] as Pr[ñ 1 < ñ2 ] = Pr[N (0, 2σ 2 ) > n 1 -n 2 ] < exp -(n 1 -n 2 ) 2 /

4σ 2 , which we use as q. Plugging q in Proposition 10, we have µ 1 -1 = µ 2 = (n 1 -n 2 )/2, limiting the range of applicability of Theorem 6 to λ < (n 1 -n 2 )/2.

Choosing λ = (n 1 -n 2 )/4 ensures A(q, µ 2 , ε 2 ) ≈ 1, which allows approximating the bound (2) as q • B(q, µ 1 , ε 1 ) λ-1 /(λ -1). The proof follows by straightforward calculation.

B SMOOTH SENSITIVITY AND PUBLISHING THE PRIVACY PARAMETER:

The privacy guarantees obtained for the mechanisms in this paper via Theorem 6 take as input q, an upper bound on the probability that the aggregate mechanism returns the true plurality. This means that the resulting privacy parameters computed depend on teacher votes and hence the underlying data. To avoid potential privacy breaches from simply publishing the data-dependent parameter, we need to publish a sanitized version of the privacy loss. This is done by adding noise to the computed privacy loss estimates using the smooth sensitivity algorithm proposed by Nissim et al. (2007) . This section has the following structure. First we recall the notion of smooth sensitivity and introduce an algorithm for computing the smooth sensitivity of the privacy loss function of the GNMax mechanism. In the rest of the section we prove correctness of these algorithms by stating several conditions on the mechanism, proving that these conditions are sufficient for correctness of the algorithm, and finally demonstrating that GNMax satisfies these conditions.

B.1 COMPUTING SMOOTH SENSITIVITY:

Any dataset D defines a histogram n = (n 1 , . . . , n m ) ∈ N m of the teachers' votes. We have a natural notion of the distance between two histograms dist(n, n ) and a function q: N m → [0, 1] on these histograms computing the bound according to Proposition 7. The value q(n) can be used as q in the application of Theorem 6. Additionally we have n (i) denote the i-th highest bar in the histogram.

We aim at calculating a smooth sensitivity of β (q(n)) whose definition we recall now. Definition 12 (Smooth Sensitivity). Given the smoothness parameter β, a β-smooth sensitivity of f (n) is defined as

SS β (n) max d≥0 e -βd • max n :dist(n,n )≤d LS(n ),

where

LS(n) ≥ max n :dist(n,n )=1 |f (n) -f (n )|

is an upper bound on the local sensitivity.

We now describe Algorithms 3-5 computing a smooth sensitivity of β (q(•)). The algorithms assume the existence of efficiently computable functions q:

N m → [0, 1], B L , B U : [0, 1] → [0, 1],

and a constant q 0 .

Informally, the functions B U and B L respectively upper and lower bound the value of q evaluated at any neighbor of n given q(n), and [0, q 0 ) limits the range of applicability of data-dependent analysis.

The functions B L and B U are defined as follows. Their derivation appears in Section B.4.

B U (q) min m -1 2 erfc erfc -1 2q m -1 - 1 σ , 1 , B L (q) m -1 2 erfc erfc -1 2q m -1 + 1 σ ,

Algorithm 3 -Local Sensitivity: use the functions B U and B L to compute (an upper bound) of the local sensitivity at a given q value by looking at the difference of β (•) evaluated on the bounds.

1: procedure LS(q)

2:

if q 1 ≤ q ≤ q 0 then q 1 = B L (q 0 ). Interpolate the middle part.

3:

q ← q 1 4: end if 5:

return max{β (B U (q)) -β (q) , β (q) -β (B L (q))} 6: end procedure

B.2 NOTATION AND CONDITIONS:

Notation. We find that the algorithm and the proof of its correctness are more naturally expressed if we relax the notions of a histogram and its neighbors to allow non-integer values.

• We generalize histograms to be any vector with non-negative real values. This relaxation is used only in the analysis of algorithms; the actual computations are performed exclusively over integer-valued inputs. i) denote the i-th bar in the descending order. • Define a "move" as increasing one bar by some value in [0, 1] and decreasing one bar by a (possibly different) value in [0, 1] subject to the resulting value be non-negative. Notice the difference between the original problem and our relaxation. In the original formulation, the histogram takes only integer values and we can only increase/decrease them by exactly 1.

• Let n = [n 1 , . . . , n m ] ∈ R m , n i ≥ 0 denote a histogram. Let n (

In contrast, we allow real values and a teacher can contribute an arbitrary amount in [0, 1] to any one class.

Algorithm 4 -Sensitivity at a distance: given a histogram n, compute the sensitivity of β (•) at distance at most d using the procedure LS, function q(•), constants q 0 and q 1 = B L (q 0 ), and careful case analysis that finds the neighbor at distance d with the maximum sensitivity.

1: procedure ATDISTANCED(n, d)

2:

q ← q(n)

3:

if q 1 ≤ q ≤ q 0 then q is in the flat region.

4::

return LS(q), STOP 5:

end if 6:

if q < q 1 then Need to increase q.

7:

if n (1) -n (2) < 2d then n (i) is the ith largest element.

8::

return LS(q 1 ), STOP 9:

else 10: n ← SORT(n) + [-d, d, 0, . . . , 0] 11: q ← q(n ) 12:

if q > q 1 then 13:

return LS(q 0 ), STOP 14:

else 15:

return LS(q ), CONTINUE 16:

end if 17: end if 18:

else Need to decrease q.

19:

if d i=2 n (i) ≤ d then 20: n ← [n, 0, . . . , 0] 21: q ← q(n ) 22:

return LS(q ), STOP 23:

else 24: n ← SORT(n) + [d, 0, . . . , 0] 25: for d = 1, . . . , d do 26: n (2) ← n (2) -1

The index of n (2) may change.

27:

end for 28:

q ← q(n ) 29:

if q < q 0 then 30:

return LS(q 0 ), STOP 31:

else 32:

return LS(q ), CONTINUE until StoppingCondition = STOP 9: end procedure • Define the distance between two histograms n = (n 1 , . . . , n m ) and n = (n 1 , . . . , n m ) as

d(n, n ) max    i:ni>n i n i -n i , i:ni<n i n i -n i    ,

which is equal to the smallest number of "moves" needed to make the two histograms identical. We use the ceiling function since a single step can increase/decrease one bar by at most 1. We say that two histograms are neighbors if their distance d is 1. Notice that analyses of Rényi differential privacy for LNMax, GNMax and the exponential mechanism are still applicable when the neighboring datasets are defined in this manner.

• Given a randomized aggregator M: R m ≥0 → [m], let q: R m ≥0 → [0, 1] be so that q

(n) ≥ Pr[M(n) = argmax(n)].

When the context is clear, we use q to denote a specific value of the function, which, in particular, can be used as q in applications of Theorem 6.

• Let β: [0, 1] → R be the function that maps a q value to the value of the Rényi accountant.

Conditions. Throughout this section we will be referring to the list of conditions on q(•) and β (•):

C1. The function q(•) is continuous in each argument n i . C2. There exist functions B U , B L : [0, 1] → [0, 1] such that for any neighbor n of n, we have B L (q(n)) ≤ q(n ) ≤ B U (q(n)), i.e.

, B U and B L provide upper and lower bounds on the q value of any neighbor of n.

C3. B L (q) is increasing in q.

C4. B U and B L are functional inverses of each other in part of the range, i.e., q = B L (B U (q)) for all q ∈ [0, q 0 ], where q 0 is defined below. Additionally B L (q) ≤ q ≤ B U (q) for all q ∈ [0, 1].

C5. β (•) has the following shape: there exist constants β * and q 0 ≤ 0.5, such that β (q) nondecreasing in [0, q 0 ] and β (q) = β * ≥ β (q 0 ) for q > q 0 . The constant β * corresponds to a data-independent bound.

C6. ∆β (q) β (B U (q)) -β (q) is non-decreasing in [0, B L (q 0 )], i.e., when B U (q) ≤ q 0 . C7. Recall that n (i) is the i-th largest coordinate of a histogram n. Then, if q(n) ≤ B U (q 0 ), then q(n) is differentiable in all coordinates and ∀i > j ≥ 2 ∂q ∂n (j) (n) ≥ ∂q ∂n (i) (n) ≥ 0.

C8. The function q(n) is invariant under addition of a constant, i.e., q(n) = q(n + [x, . . . , x]) for all n and x ≥ 0, and q(n) is invariant under permutation of n, i.e., q(n) = q(π(n)) for all permutations π on [m].

Finally, we require that if n (1) = n (2) , then q(n) ≥ q 0 .

We may additionally assume that q 0 ≥ q([n, 0, . . . , 0]). Indeed, if this condition is not satisfied, then the data-dependent analysis is not going to be used anywhere. The most extreme histogram-[n, 0, . . . , 0]-is the most advantageous setting for applying data-dependent bounds. If we cannot use the data-dependent bound even in that case, we would be using the data-independent bound everywhere and do not need to compute smooth sensitivity anyway. Yet this condition is not automatically satisfied. For example, if m (the number of classes) is large compared to n (the number of teachers), we might have large q([n, 0, . . . , 0]). So we need to check this condition in the code before doing smooth sensitivity calculation.

B.3 CORRECTNESS OF ALGORITHMS 3-5:

Recall that local sensitivity of a deterministic function f is defined as max f (D) -f (D ), where D and D are neighbors. Proposition 13. Under conditions C2-C6, Algorithm 3 computes an upper bound on local sensitivity of β (q(n)).

Proof. Since β (•) is non-decreasing everywhere (by C5), and for any neighbors n and n it holds that B L (q(n)) ≤ q(n ) ≤ B U (q(n)) (by C2), we have the following

|β (q(n)) -β (q(n ))| ≤ max β B U (q(n)) -β q(n) , β q(n) -β B L (q(n)) = max ∆β q(n) , ∆β B L (q(n))

as an upper bound on the local sensitivity of β (q(•)) at input n.

The function computed by Algorithm 3 differs from above when q(n) ∈ (B L (q 0 ), q 0 ). To complete the proof we need to argue that the local sensitivity is upper bounded by ∆β (B L (q 0 )) for q(n) in this interval. The bound follows from the following three observations.

First, ∆β (q) is non-increasing in the range (B L (q 0 ), 1], since β (B U (q)) is constant (by B U (q) ≥ B U (B L (q 0 )) = q 0 and C5) and β (q) is non-decreasing in the range (by C5). In particular, ∆β (q) ≤ ∆β (B L (q 0 )) if q ≥ B L (q 0 ). (8) Second, ∆β (B L (q)) is non-decreasing in the range [0, q 0 ] since B L (q) is increasing (by C3 and C6) . This implies that ∆β (B L (q)) ≤ ∆β (B L (q 0 )) if q ≤ q 0 . (9)

By ( 8) and ( 9) applied to the intersection of the two ranges, it holds that

max ∆β q(n) , ∆β B L (q(n)) ≤ ∆β (B L (q 0 )) if B L (q 0 ) ≤ q ≤ q 0 ,

as needed.

We thus established that the function computed by Algorithm 3, which we call LS(q) from now on, is an upper bound on the local sensitivity. Formally, LS(q) ∆β (B L (q 0 )) if q ∈ (B L (q 0 ), q 0 ), max {∆β (q) , ∆β (B L (q))} otherwise.

The following proposition characterizes the growth of LS(q). Proposition 14. Assuming conditions C2-C6, the function LS(q) is non-decreasing in [0, B L (q 0 )], constant in [B L (q 0 ), q 0 ], and non-increasing in [q 0 , 1].

Proof. Consider separately three intervals.

• By construction, LS is constant in [B L (q 0 ), q 0 ].

• Since both functions ∆β (•) and ∆β (B L (•)) are each non-decreasing in [0, B L (q 0 )), so is their max.

• In the interval (q 0 , 1], β (q) is constant. Hence ∆β (q) = 0 and ∆β (B L (q)) = β (q)β (B L (q)) is non-decreasing. Their maximum value ∆β (B L (q)) is non-decreasing.

The claim follows.

We next prove correctness of Algorithm 4, which computes the maximal sensitivity of β at a fixed distance.

The proof relies on the following notion of a partial order between histograms. Definition 15. Prefix sums S i (n) are defined as follows:

S i (n) i j=1

(n (1) -n (j) ).

We say that a histogram n dominates n , denoted as n n , iff:

∀ (1 < i ≤ m) it holds that S i (n) ≥ S i (n ).

compare n j -n j and n j -n j for j = i, i . At j = i the first term is strictly larger than the second. At j = i , the inequality holds too but it may be not strict.

We may again apply the induction hypothesis to the pair n and n , thus completing the proof of the lemma.

To complete the proof of the proposition, we need to argue that the values of q are also monotone in the chain constructed by the previous lemma. Concretely, we put forth Lemma 18. If n n, q(n ) ≤ B U (q 0 ), d(n, n ) = 1 and n(1) = n (1) , then q(n) ≤ q(n ).

Proof. The fact that d(n, n ) = 1 and n n means that there is either a single index i so that n i < n i , or there exist two indices i and j so that n i < n i and n j > n j . The first case is immediate, since q is non-decreasing in all inputs except for the largest (by C7).

Let n i = n i -x and n j = n j + y, where x, y > 0. Since n n , it follows that n i ≥ n j and x > y. Consider two cases.

Case I: n i ≥ n j , i.e., removing x from n i and adding y to n j does not change their ordering. Let

n(t) (1 -t)n + t • n = [n 1 , . . . , n i -t • x, . . . , n j + t • y, . . . , n m ]. Then, q(n ) -q(n) = q(n(1)) -q(n(0)) = 1 t=0 (q • n) (t) dt = 1 t=0 -x ∂q ∂n i n(t) + y ∂q ∂n j n(t) dt ≤ 0.

The last inequality follows from C7 and the facts that x > y > 0 and n i (t) > n j (t). (The condition that q(n(t)) ≤ B U (q 0 ) follows from C2 and the fact that d(n , n(t)) ≤ 1.)

Case II: n i ≤ n j . In this case we swap the ith and jth indices in n by defining n which differs from it in n i = n j and n j = n i . By C8, q(n ) = q(n ) and, of course, n n since the prefix sums remain unchanged. The benefit of doing this transformation is that we are back in Case I, where the relative order of coordinates that change between n and n remains the same. This concludes the proof of the lemma.

Applying Lemma 17 we construct a chain of histograms between n and n , which, by Lemma 18, is non-increasing in q(•). Together this implies that q(n) ≤ q(n ), as claimed.

We apply the notion of dominance in proving the following proposition, which is used later in arguing correctness of Algorithm 4. Proposition 19. Let n be an integer-valued histogram and d be a positive integer. And q(•) satisfies C1, C7, and C8. The following holds:

1. Assuming n (1) -n (2) ≥ 2d, let n * be obtained from n by decrementing n (1) by d and incrementing n (2) by d. Then d(n, n * ) = d and q(n * ) ≥ q(n ) for any n such that d(n, n ) = d. 

2.. Assuming:



B.4.1 CONDITIONS C1-C4, C7 AND C8:

Defining q and conditions C1, C7, and C8. Following Proposition 7, we define q: R m ≥0 → [0, 1] for a GNMax mechanism parameterized with σ as:

q(n) min    i =i * Pr(Z i -Z i * ≥ n i * -n i ), 1    = min    i =i * 1 2 1 -erf n i * -n i 2σ , 1    = min    i =i * 1 2 erfc n i * -n i 2σ , 1    ,

where i * is the histogram n's highest coordinate, i.e., n i * ≥ n i for all i (if there are multiple highest, let i * be any of them). Recall that erf is the error function, and erfc is the complement error function.

Proposition 7 demonstrates that q(n) bounds from above the probability that GNMax outputs anything but the highest coordinate of the histogram.

Conditions C1, C7, and C8 follow by simple calculus (q 0 , defined below, is at most 0.5).

Functions B L , B U , and conditions C2-C4. Recall that the functions B L and B U are defined in Appendix B as follows:

B U (q) min m -1 2 erfc erfc -1 2q m -1 - 1 σ , 1 , B L (q) m -1 2 erfc erfc -1 2q m -1 + 1 σ ,

Proposition 21 (Condition C2). For any neighbor n of n, i.e., d(n , n) = 1, the following bounds hold:

B L (q(n)) ≤ q(n ) ≤ B U (q(n)).

Proof. Assume wlog that i * = 1. Let x i n 1 -n i and q i erfc(x i /2σ)/2, and similarly define x i for n . Observe that |x i -x i |≤ 2, which, by monotonicity of erfc, implies that

1 2 erfc x i + 2 2σ ≤ q i (n ) ≤ 1 2 erfc x i -2 2σ . Thus 1 2 i>1 erfc x i + 2 2σ ≤ q(n ) ≤ 1 2 i>1 erfc x i -2 2σ .

(Although i * may change between n and n , the bounds still hold.)

Our first goal is to upper bound q(n ) for a given value of q(n). To this end we set up the following maximization problem

max {xi} 1 2 i>1 erfc x i -2 2σ such that 1 2 i>1 erfc x i 2σ = q and x i ≥ 0.

We may temporarily ignore the non-negative constraints, which end up being satisfied by our solution. Consider using the method of Lagrange multipliers and take a derivative in x i ':

-exp - x i -2 2σ 2 + λ exp - x i 2σ 2 = 0 ⇔ λ = exp x i -1 σ 2 .

Since the expression is symmetric in i > 1, it means that the local optima are attained at x 2 = • • • = x m (the second derivative confirms that these are local maxima). After solving for (m -1) erfc(x/2σ) = 2q we have

q(n ) ≤ m -1 2 erfc erfc -1 2q m -1 - 1 σ .

where m is the number of classes. Similarly,

q(n ) ≥ m -1 2 erfc erfc -1 2q m -1 + 1 σ .

Conditions C3, i.e., B L (q) is monotonically increasing in q, and C4, i.e., B L and B U are functional inverses of each other in [0, q 0 ] and B L (q) ≤ q ≤ B U (q) for all q ∈ [0, 1], follow from basic properties of erfc. The restriction that q ∈ [0, q 0 ] ensures that B U (q) is strictly less than one, and the minimum in the definition of B U (•) simplifies to its first argument in this range.

B.4.2 CONDITIONS C5 AND C6:

Conditions C5 and C6 stipulate that the function β (q) σ (q) (defined in Appendix A) exhibits a specific growth pattern. Concretely, C5 states that β (q) is monotonically increasing for 0 ≤ q ≤ q 0 , and constant for q 0 < q ≤ 1. (Additionally, we require that B U (q 0 ) < 1). Condition C6 requires that ∆β

(q) = β (B U (q)) -β (q) is non-decreasing in [0, B L (q 0 )].

Rather than proving these statements analytically, we check these assumptions for any fixed σ and λ via a combination of symbolic and numeric analyses.

More concretely, we construct symbolic expressions for β (•) and ∆β (•) and (symbolically) differentiate them. We then minimize (numerically) the resulting expressions over [0, q 0 ] and [0, B L (q 0 )], and verify that their minimal values are indeed non-negative.

B.5 RÉNYI DIFFERENTIAL PRIVACY AND SMOOTH SENSITIVITY:

Although the procedure for computing a smooth sensitivity bound may be quite involved (such as Algorithms 3-5), its use in a differentially private data release is straightforward. Following Nissim et al. (2007) , we define an additive Gaussian mechanism where the noise distribution is scaled by σ and a smooth sensitivity bound: Definition 22. Given a real-valued function f : D → R and a β-smooth sensitivity bound SS(•), let (β, σ)-GNSS mechanism be

F σ (D) f (D) + SS β (D) • N (0, σ 2 ).

We claim that this mechanism satisfies Rényi differential privacy for finite orders from a certain range.

Theorem 23. The (β, σ)-GNSS mechanism F σ is (λ, ε)-RDP, where ε λ • e 2β σ 2 + βλ -0.5 ln(1 -2λβ) λ -1 for all 1 < λ < 1/(2β).

Proof. Consider two neighboring datasets D and D . The output distributions of the (β, σ)-GNSS mechanism on D and D are, respectively,

P f (D) + SS β (D) • N (0, σ 2 ) = N (f (D), (SS β (D)σ) 2 ) and Q N (f (D ), (SS β (D )σ) 2 ).

The Rényi divergence between two normal distributions can be computed in closed form (van Erven & Harremoës, 2014):

EQUATION

) provided s 2 (1 -λ) • SS β (D) 2 + λ • SS β (D ) 2 > 0.

According to the definition of smooth sensitivity (Definition 12)

EQUATION

and

EQUATION

Bound ( 12) together with the condition that λ ≤ 1/(2β) implies that

EQUATION

)

The above lower bound ensures that s 2 is well-defined, i.e., non-negative, as required for application of (11).

Combining bounds ( 12)-( 14), we have that

D λ (P Q) ≤ λ • e 2β σ 2 + 1 1 -λ ln s SS β (D) e -λβ ≤ λ • e 2β σ 2 + βλ -0.5 ln(1 -2λβ) λ -1 as claimed.

Note that if λ 1, σ λ, and β 1/(2λ), then (β, σ)-GNSS satisfies (λ, (λ+1)/σ 2 )-RDP. Compare this with RDP analysis of the standard additive Gaussian mechanism, which satisfies (λ, λ/σ 2 )-RDP. The difference is that GNSS scales noise in proportion to smooth sensitivity, which is no larger and can be much smaller than global sensitivity.

B.6 PUTTING IT ALL TOGETHER: APPLYING SMOOTH SENSITIVITY:

Recall our initial motivation for the smooth sensitivity analysis: enabling privacy-preserving release of data-dependent privacy guarantees. Indeed, these guarantees vary greatly between queries (see Figure 5 ) and are typically much smaller than data-independent privacy bounds. Since datadependent bounds may leak information about underlying data, publishing the bounds themselves requires a differentially private mechanism. As we explain shortly, smooth sensitivity analysis is a natural fit for this task.

We first consider the standard additive noise mechanism where the noise (such as Laplace or Gaussian) is calibrated to the global sensitivity of the function we would like to make differentially private. We know that Rényi differential privacy is additive for any fixed order λ, and thus the cumulative RDP cost is the sum of RDP costs of individual queries each upper bounded by a dataindependent bound. Thus, it might be tempting to use the standard additive noise mechanism for sanitizing the total, but that would be a mistake.

To see why, consider a sequence of queries n1 , . . . , n answered by the aggregator. Their total (unsanitized) RDP cost of order λ is B σ = i=1 β σ (q(n i )). Even though β σ (q(n i )) ≤ λ/σ 2 (the data-independent bound, Proposition 8), the sensitivity of their sum is not λ/σ 2 . The reason is that the (global) sensitivity is defined as the maximal difference in the function's output between two neighboring datasets D and D . Transitioning from D to D may change one teacher's output on all student queries.

In contrast with the global sensitivity of B σ that may be quite high-particularly for the second step of the Confident GNMax aggregator-its smooth sensitivity can be extremely small. Towards computing a smooth sensitivity bound on B σ , we prove the following theorem which defines a smooth sensitivity of the sum in terms of local sensitivities of its parts. as needed for β-smoothness.

The fact that SS(•) is an upper bound on the local sensitivity of F (•) is implied by the following:

|F (D 1 ) -F (D 2 )| = i=1 f i (D 1 ) - i=1 f i (D 2 ) ≤ i=1 |f i (D 1 ) -f i (D 2 )| ≤ i=1 LS fi (D 1 )

≤ SS(D 1 ), which concludes the proof.

Applying Theorem 24 allows us to compute a smooth sensitivity of the sum more efficiently than summing up smooth sensitivities of its parts. Results below rely on this strategy.

Empirical results. Table 2 revisits the privacy bounds in Table 1 . For all data-dependent privacy claims of the Confident GNMax aggregator we report parameters for their smooth sensitivity analysis and results of applying the GNSS mechanism for their release.

Consider the first row of the table. ) is 283, and the expected Rényi differential privacy is ε = 1.18 at order λ = 14. This translates (via Theorem 5) to (2.00, 10 -5 )-differential privacy, where 2.00 is the expectation of the privacy parameter ε.

These costs are data-dependent and they cannot be released without further sanitization, which we handle by adding Gaussian noise scaled by the smooth sensitivity of ε (the GNSS mechanism, Definition 22). At β = 0.0329 the expected value of smooth sensitivity is 0.0618. We choose σ SS = 6.23, which incurs, according to Theorem 23, an additional (data-independent) (14, 0.52)-RDP cost. Applying (β, σ SS )-GNSS where σ SS = 6.23, we may publish differentially private estimate of the total privacy cost that consists of a fixed part-the cost of applying Confident GN-Max and GNSS-and random noise. The fixed part is 2.52 = 1.18 + 0.52 -ln(10 -5 )/14, and the noise is normally distributed with mean 0 and standard deviation σ SS • 0.0618 = 0.385. We note that, in contrast with the standard additive noise, one cannot publish its standard deviation without going through additional privacy analysis.

Some of these constants were optimally chosen (via grid search or analytically) given full view of data, and thus provide a somewhat optimistic view of how this pipeline might perform in practice.

For example, σ SS in Table 2 were selected to minimize the total privacy cost plus two standard deviation of the noise.

The following rules of thumb may replace these laborious and privacy-revealing tuning procedures in typical use cases. The privacy parameter δ must be less than the inverse of the number of training examples. Giving a target ε, the order λ can be chosen so that log(1/δ) ≈ (λ -1)ε/2, i.e., the cost of the δ contribution in Theorem 5 be roughly half of the total. The β-smoothness parameter can be set to 0.4/λ, from which smooth sensitivity SS β can be estimated. The final parameter σ SS can be reasonably chosen between 2 • (λ + 1)/ε and 4 • (λ + 1)/ε (ensuring that the first, dominant component, of the cost of the GNSS mechanism given by Theorem 23 is between ε/16 and ε/4).

:

https://github.com/tensorflow/models/tree/master/research/differential_privacy

Glyph data is not public but similar data is available publicly as part of the notMNIST dataset.

In this context, the adversarial component refers to the phenomenon commonly referred to as adversarial examples(Biggio et al., 2013;Szegedy et al., 2014) and not to the adversarial training approach taken in GANs.

Figures and Tables:

Figure2: Overview of the approach: (1) an ensemble of teachers is trained on disjoint subsets of the sensitive data, (2) a student model is trained on public data labeled using the ensemble.

Figure 3: Some example inputs from the Glyph dataset along with the class they are labeled as. Note the ambiguity (between the comma and apostrophe) and the mislabeled input.

Figure 4: Tradeoff between utility and privacy for the LNMax and GNMax aggregators on Glyph: effect of the noise distribution (left) and size of the teacher ensemble (right). The LNMax aggregator uses a Laplace distribution and GNMax a Gaussian. Smaller values of the privacy cost ε (often obtained by increasing the noise scale σ-see Section 4) and higher accuracy are better.

Smooth Sensitivity: Compute the β smooth sensitivity of β (•) via Definition 12 by looking at sensitivities at various distances and returning the maximum weighted by e -βd . 1: procedure SMOOTHSENSITIVITY(n, β)

i=2 n (i) ≥ d, let n * * be obtained from n by incrementing n 1 by d, and by repeatedly decrementing the histogram's current second highest value by one, d times. Then d(n, n * * ) = d and q(n * * ) ≤ q(n ) for any n such that d(n, n ) = d. Proof. Towards proving the claims, we argue that n * and n * * are, respectively, the minimal and the maximal elements in the histogram dominance order (Definition 15) in the set of histograms at distance d from n. By Proposition 16 the claims follow.

Let f i : D → R for 1 ≤ i ≤ , F (D) i=1 f i (D)and β > 0. Then SS(D) max d≥0 e -βd • i=1 max D :dist(D,D )≤d LS fi (D ), is a β-smooth bound on F (•) if LS fi (D ) are upper bounds on the local sensitivity of f i (D ).

We need to argue that SS(•) is β-smooth, i.e., SS(D 1 ) ≤ e β • SS(D 2 ) for any neighboring D 1 , D 2 ∈ D, and it is an upper bound on the local sensitivity of F (D 1 ), i.e., SS(D 1 ) ≥ |F (D 1 ) -F (D 2 )|. Smoothness follows from the observation that max D:dist(D1,D)≤d LS fi (D) ≤ max D:dist(D2,D)≤d+1 LS fi (D) for all neighboring datasets D 1 and D 2 (by the triangle inequality over distances)(D2,D)≤d LS fi (D) ≤ e β • SS(D 2 )

The MNIST dataset was partitioned among 250 teachers, each getting 200 training examples. After the teachers were individually trained, the student selected at random 640 unlabeled examples, and submitted them to the Confident GNMax aggregator with the threshold of 200, and noise parameters σ 1 = 150 and σ 2 = 40. The expected number of answered examples (those that passed the first step of Algorithm 1

Utility and privacy of the students. The Confident-and Interactive-GNMax aggregators introduced in Section 4 offer better tradeoffs between privacy (characterized by the value of the bound ε) and utility (the accuracy of the student compared to a non-private baseline) than the LNMax

Table content: <table><tr><td>Queries</td><td>Privacy</td><td>Accuracy</td></tr></table>

Privacy-preserving reporting of privacy costs. The table augments Table1by including smooth sensitivity analysis of the total privacy cost. The expectations are taken over the student's queries and outcomes of the first step of the Confident GNMax aggregator. Order λ, smooth sensitivity parameter β, σ SS are parameters of the GNSS mechanism (Section B.5). The final column sums up the data-dependent cost ε, the cost of applying GNSS (Theorem 23), and the standard deviation of Gaussian noise calibrated to smooth sensitivity (the product of E [SS β ] and σ SS ).

Table content: <table><tr><td/><td>Confident GNMax</td><td>DP</td><td/><td/><td colspan="2">Smooth Sensitivity</td><td/><td>Sanitized DP</td></tr><tr><td colspan="2">Dataset parameters</td><td>E [ε]</td><td>δ</td><td>λ</td><td>β</td><td colspan="2">E [SS β ] σSS</td><td>E [ε] ± noise</td></tr><tr><td colspan="2">MNIST T =200, σ1=150, σ2=40</td><td>2.00</td><td>10 -5</td><td>14</td><td>.0329</td><td>.0618</td><td>6.23</td><td>2.52 ± 0.385</td></tr><tr><td>SVHN</td><td>T =300, σ1=200, σ2=40</td><td>4.96</td><td>10 -6</td><td>7.5</td><td>.0533</td><td>.0717</td><td>4.88</td><td>5.45 ± 0.350</td></tr><tr><td>Adult</td><td>T =300, σ1=200, σ2=40</td><td>1.68</td><td colspan="3">10 -5 15.5 .0310</td><td>0.0332</td><td>7.92</td><td>2.09 ± 0.263</td></tr><tr><td/><td>T =1000, σ1=500, σ2=100</td><td>2.07</td><td colspan="3">10 -8 20.5 .0205</td><td>.0128</td><td>11.9</td><td>2.29 ± 0.152</td></tr><tr><td>Glyph</td><td>Two-round interactive</td><td colspan="2">0.837 10 -8</td><td>50</td><td>.009 .008</td><td>.00278 .00088</td><td>26.4 38.7</td><td>1.00 ± .081</td></tr></table>

Peer review (iclr2018):
 This paper considers the problem of private learning and uses the PATE framework to achieve differential privacy. The dataset is partitioned and multiple learning algorithms produce so-called teacher classifiers. The labels produced by the teachers are aggregated in a differentially private manner and the aggregated labels are then used to train a student classifier, which forms the final output. The novelty of this work is a refined aggregation process, which is improved in three ways: a) Gaussian instead of Laplace noise is used to achieve differential privacy. b) Queries to the aggregator are "filtered" so that the limited privacy budget is only expended on queries where the teachers are confident and the student is uncertain or wrong. c) A data-dependent privacy analysis is used to attain sharper bounds on the privacy loss with each query. I think this is a nice modular framework form private learning, with significant refinements relative to previous work that make the algorithm more practical. On this basis, I think the paper should be accepted. However, I think some clarification is needed with regard to item c above: Theorem 2 gives a data-dependent privacy guarantee. That is, if there is one label backed by a clear majority of teachers, then the privacy loss (as measured by Renyi divergence) is low. This data-dependent privacy guarantee is likely to be much tighter than the data-independent guarantee. However, since the privacy guarantee now depends on the data, it is itself sensitive information. How is this issue resolved? If the final privacy guarantee is data-dependent, then this is very different to the way differential privacy is usually applied. This would resemble the "privacy odometer" setting of Rogers-Roth-Ullman-Vadhan [ https://arxiv.org/abs/1605.08294 ]. Another way to resolve this would be to have an output-dependent privacy guarantee. That is, the privacy guarantee would depend only on public information, rather than the private data. The widely-used "sparse vector" technique [ http://www.cis.upenn.edu/~aaroth/Papers/privacybook.pdf#page=59 ] does this. In any case, this is an important issue that needs to be clarified, as it is not clear to me how this is resolved. The algorithm in this work is similar to the so-called median mechanism [ https://www.cis.upenn.edu/~aaroth/Papers/onlineprivacy.pdf ] and private multiplicative weights [ http://mrtz.org/papers/HR10mult.pdf ]. These works also involve a "student" being trained using sensitive data with queries being answered in a differentially private manner. And, in particular, these works also filter out uninformative queries using the sparse vector technique. It would be helpful to add a comparison.