Plausible Deniability for Privacy-Preserving Data Synthesis
Vincent Bindschaedler Reza Shokri Carl A. Gunter



 





 













    
 
 
 






 

codeindent[1][0.25cm]#1



mechanismMechanism
privacytestPrivacy Test
remarkRemark
theoremTheorem
theoremrecTheorem
corollaryCorollary
lemmaLemma
definitionDefinition
observationObservation

copyrightspace







3


Plausible Deniability for Privacy-Preserving Data Synthesis (Extended Version)
    
Vincent Bindschaedler

UIUC

bindsch2@illinois.edu
Reza Shokri

Cornell Tech

shokri@cornell.edu
Carl A. Gunter

UIUC

cgunter@illinois.edu

    December 30, 2023
=================================================================================================================================================





Releasing full data records is one of the most challenging problems in
data privacy. On the one hand, many of the popular techniques such as data
de-identification are problematic because of their dependence
on the background knowledge of adversaries.  On the other hand,
rigorous methods such as the exponential mechanism for differential
privacy are often computationally impractical to use for releasing high
dimensional data or cannot preserve high utility of original
data due to their extensive data perturbation.

This paper presents a criterion called plausible
deniability that provides a formal privacy guarantee, notably for
releasing sensitive datasets: an output record can be released only
if a certain amount of input records are indistinguishable, up to a
privacy parameter. This notion does not depend on the background
knowledge of an adversary. Also, it can efficiently be checked by privacy tests. We present mechanisms to generate synthetic datasets with similar statistical properties to the input data and the same format. We study this technique both theoretically and experimentally. A key theoretical result shows that, with proper randomization, the plausible deniability mechanism generates differentially private synthetic data.
We demonstrate the efficiency of this generative technique on a large dataset; it is shown to preserve the utility of original data with respect to various statistical analysis and machine learning measures.




§ INTRODUCTION


There is tremendous interest in releasing datasets for research and
development.  Privacy policies of data holders, however, prevent them
from sharing their sensitive datasets.  This is due, to a large
extent, to multiple failed attempts of releasing datasets using
imperfect privacy-preserving mechanisms such as de-identification. A
range of inference attacks on, for example, AOL search log dataset
<cit.>, Netflix movie rating
dataset <cit.>, Genomic
data <cit.>, location
data <cit.>, and social networks
data <cit.>, shows that simple modification
of sensitive data by removing identifiers or by generalizing/suppressing
data features results in major information leakage and cannot
guarantee meaningful privacy for data owners.  These simple
de-identification solutions, however, preserve data utility as they
impose minimal perturbation to real data.

Rigorous privacy definitions, such as differential privacy
<cit.>, can theoretically guarantee privacy and
bound information leakage about sensitive data.  However, known
mechanisms, such as the Laplacian mechanism <cit.> or the
exponential mechanism <cit.>, that achieve
differential privacy through randomization, have practical
limitations.  The majority of scenarios, where they have been applied,
are limited to interactive count queries on statistical databases
<cit.>.  In a non-interactive setting for
releasing generic datasets, these mechanisms are either
computationally infeasible on high-dimensional data, or
practically ineffective because of their large utility costs
<cit.>.  At best, these methods are used to
release some privacy-preserving statistics (e.g., histograms
<cit.>) about a
dataset, but not full data records.  It is not
obvious how to protect the privacy of full records as opposed to that
of aggregate statistics (by adding random noise).

Despite all these obstacles, releasing full data records is firmly
pursued by large-scale data holders such as the U.S. Census
Bureau <cit.>.
The purpose of this endeavor is to allow researchers to develop
analytic techniques by processing full synthetic data records rather
than a limited set of statistics.  Synthetic data could also be used
for educational purpose, application development for data analysis,
sharing sensitive data among different departments in a company,
developing and testing pattern recognition and machine learning
models, and algorithm design for sensitive data.  There exists some
inference-based techniques to assess the privacy risks of
releasing synthetic data <cit.>.  However, the major open problem is how to generate synthetic full data records with provable privacy,
that experimentally can achieve acceptable utility in various
statistical analytics and machine learning settings.

In this paper, we fill this major gap in data privacy by proposing a
generic theoretical framework for generating synthetic data in a
privacy-preserving manner.  The fundamental difference between our
approach and that of existing mechanisms for differential privacy
(e.g., exponential mechanism) is that we disentangle the data
generative model from privacy definitions.  Instead of forcing a
generative model to be privacy-preserving by design, which might
significantly degrade its utility, we can use a utility-preserving
generative model and release only a subset of its output that
satisfies our privacy requirements.  Thus, for designing a generative
model, we rely on the state-of-the-art techniques from data science
independently from the privacy requirements.  This enables us to
generate high utility synthetic data.

We formalize the notion of plausible deniability for data
privacy <cit.>, and generalize it to
any type of data.  Consider a probabilistic generative model that
transforms a real data record, as its seed, into a synthetic data
record.  We can sample many synthetic data records from each seed
using such a generative model.  According to our definition, a
synthetic record provides plausible deniability if there exists a set
of real data records that could have generated the same synthetic data
with (more or less) the same probability by which it was generated
from its own seed.  We design a privacy mechanism that provably
guarantees plausible deniability.  This mechanism results in
input indistinguishability: by observing the output set (i.e.,
synthetics), an adversary cannot tell for sure whether a particular
data record was in the input set (i.e., real data).  The degree of
this indistinguishability is a parameter in our mechanism.

Plausible deniability is a property of the overall process, and
similar to differential privacy, it is independent of any adversary's
background knowledge.  In fact, we prove that our proposed plausible deniable data synthesis process
can also satisfy differential privacy, if we randomize the indistinguishability parameter in the
privacy mechanism.  This is a significant theoretical result towards
achieving strong privacy using privacy-agnostic utility-preserving
generative models.  Thus, we achieve differential privacy without artificially downgrading the utility of the synthesized data
through output perturbation.

The process of generating a single synthetic data record and testing
its plausible deniability can be done independently from that of other
data records.  Thus, millions of data records can be generated and
processed in parallel.  This makes our framework extremely efficient
and allows implementing it at a large scale.  In this paper, we
develop our theoretical framework as an open-source tool, and run it
on a large dataset: the American Community Survey <cit.>
from the U.S. Census Bureau which contains over 3.1 million records. In fact, we can generate over one million
privacy-preserving synthetic records in less than one hour on a
multi-core machine running 12 processes in parallel. 

We analyze the utility of synthetic data in two major scenarios:
extracting statistics for data analysis, and performing prediction
using machine learning.  We show that our privacy test does not impose
high utility cost.  We also demonstrate that a significant fraction of
candidate synthetic records proposed by a generative model can pass
the privacy test even for strict privacy parameters.

We show that a strong adversary cannot distinguish a synthetic record from a real one with better than 63.0% accuracy (baseline: 79.8%). Furthermore, when it comes to classification tasks, the accuracy of the model learned on a synthetic dataset is only slightly lower than that of model trained on real data. For example, for Random Forest the accuracy is 75.3% compared to 80.4% when trained on real data (baseline: 63.8%); whereas for AdaBoostM1 the accuracy is 78.1% compared to 79.3% when trained on real data (baseline: 69.2%). Similar results are obtained when we compare logistic regression (LR) and support vector machine (SVM) classifiers trained on our synthetic datasets with the same classifiers trained (on real data) in a differential private way (using state-of-the-art techniques). 
Concretely, the accuracy of classifiers trained on our synthetic data is 77.5% (LR) and 77.1% (SVM); compared to 76.3% (LR) and 78.2% (SVM) for objective-perturbation ε-DP classifiers.



Contributions.  We introduce a formal framework for
plausible deniability as a privacy definition.  We also design a
mechanism to achieve it for the case of generating synthetic data.  We
prove that using a randomized test in our plausible deniability mechanism achieves
differential privacy (which is a stronger guarantee).  We also show
how to construct generative models with differential privacy guarantees.
The composition of our generative model and plausible deniability
mechanism also satisfies differential privacy.  We show the high accuracy
of our model and utility of our generated synthetic data.  We develop
a generic tool and show its high efficiency for generating millions of
full data records.


§ PLAUSIBLE DENIABILITY


In this section, we formalize plausible deniability as a new privacy notion for releasing privacy-preserving synthetic data.  We also present a mechanism to achieve it.  Finally, we prove that our mechanism can also satisfy differential privacy (which is a stronger guarantee) by slightly randomizing our plausible deniability mechanism. 

Informally, plausible deniability states that an adversary (with any background knowledge) cannot deduce that a particular record in the input (real) dataset was significantly more responsible for an observed output (synthetic record) than was a collection of other input records.  A mechanism ensures plausible deniability if, for a privacy parameter k>0, there are at least k input records that could have generated the observed output with similar probability. 

Unlike the majority of existing approaches (e.g., to achieve differential privacy), designing a mechanism to satisfy plausible deniability for generative models does not require adding artificial noise to the generated data.  Instead, we separate the process of releasing privacy-preserving data into running two independent modules: (1) generative models, and (2) privacy test.  The first consists in constructing a utility-preserving generative data model.  This is ultimately a data science task which requires insight into the type of data for which one wants to generate synthetics.  By contrast, the privacy test aims to safeguard the privacy of those individuals whose data records are in the input dataset.  Every generated synthetic is subjected to this privacy test; if it passes the test it can be safely released, otherwise it is discarded.  This is where the plausible deniability criterion comes into the frame: the privacy test is designed to ensure that any released output can be plausibly denied.

In this section, we assume a generic generative model that, given a data record in the input dataset as seed, produces a synthetic data record.  In Section <ref>, we present a generic generative model based on statistical models, and show how it can be constructed in a differentially-private manner, so that it does not significantly leak about its own training data.  Plausibly deniable mechanisms protect the privacy of the seeds, and are not concerned about how the generative models are constructed. 

Let ℳ be a probabilistic generative model that given any data record d can generate synthetic records y with probability y = ℳ(d). Let k ≥ 1 be an integer and γ≥ 1 be a real number. Both k and γ are privacy parameters. 

 

For any dataset D with |D| ≥ k, and any record y generated by a probabilistic generative model ℳ such that y = ℳ(d_1) for d_1 ∈ D, we state that y is releasable with (k,γ)-plausible deniability, if there exist at least k-1 distinct records d_2, ..., d_k ∈ D ∖{ d_1 } such that
	
    γ^-1≤y = ℳ(d_i)/y = ℳ(d_j)≤γ ,

	for any i,j ∈{1, 2, …, k}.




The larger privacy parameter k is, the larger the indistinguishability set for the input data record.  Also, the closer to 1 privacy parameter γ is, the stronger the indistinguishability of the input record among other plausible records. 

Given a generative model ℳ, and a dataset D, we need a mechanism ℱ to guarantee that the privacy criterion is satisfied for any released data. Specifically ℱ produces data records by using ℳ on dataset D. The following mechanism enforces (k,γ)-plausible deniability by construction. 

[ℱ with Plausible Deniability] 
 
Given a generative model ℳ, dataset D, and parameters k, γ, output a synthetic record y or nothing.

	
  * Randomly sample a seed record d ∈ D.
	
  * Generate a candidate synthetic record y = ℳ(d).
	
  * Invoke the privacy test on (ℳ,D,d,y,k,γ).
	
  * If the tuple passes the test, then release y. 
Otherwise, there is no output.




The core of Mechanism <ref> (ℱ) is a privacy test that simply rejects a candidate synthetic data record if it does not satisfy a given privacy criterion.

We can think of Definition <ref> as a privacy criterion that can be efficiently checked and enforced. So, instead of trying to measure how sensitive the model ℳ is with respect to input data records, we test if there are enough indistinguishable records in the input dataset that could have (plausibly) generated a candidate synthetic data record. 

[Deterministic test 𝒯] 

Given a generative model ℳ, dataset D, data records d and y, and privacy parameters k and γ, output pass to allow releasing y, otherwise output fail. 

	
  * Let i ≥ 0 be the (only) integer that fits the inequalities 
    γ^-i-1 < y = ℳ(d)≤γ^-i .

	
  * Let k' be the number of records d_a ∈ D such that 
    γ^-i-1 < y = ℳ(d_a)≤γ^-i .

	
  * If k' ≥ k then return pass, otherwise return fail.




Step 2 counts the number of plausible seeds, i.e., records in D which could have plausibly produced y. Note that for a given y, there may exist some records d_a ∈ D such that y = ℳ(d_a) = 0. Such records cannot be plausible seeds of y since no integer i ≥ 0 fits the inequalities.

Remark that Privacy Test <ref> (𝒯) enforces a stringent condition that the probability of generating a candidate synthetic y given the seed d and the probability of generating the same record given another plausible seed d_a both fall into a geometric range [γ^-i-1,γ^-i], for some integer i ≥ 0, assuming γ > 1. Notice that, under this test, the set of k-1 different d_as plus d satisfies the plausible deniability condition (<ref>).

Informally, the threshold k prevents releasing the implausible synthetics records y.  As k increases the number of plausible records which could have produced y also increases.  Thus, an adversary with only partial knowledge of the input dataset cannot readily determine whether a particular input record d was the seed of any released record y. This is because there are at least k-1 other records d_i ≠ d in the input dataset which could plausibly have been the seed. 
However, whether y passes the privacy test itself reveals something about the number of plausible seeds, which could potentially reveal whether a particular d is included in the input data.
This can be prevented by using a privacy test which randomizes the threshold k (as Section <ref> shows) in which case the mechanism achieves (ε,δ)-differential privacy.



 §.§ Relationship with Differential Privacy


We show a connection between Plausible Deniability and Differential Privacy, given the following definition.

 

Mechanism F satisfies (ε,δ)-differential privacy if for any neighboring datasets D, D', and any output S ⊆Range(F):
	
    F(D') ∈ S≤ e^εF(D) ∈ S + δ .



Typically, one chooses δ smaller than an inverse polynomial in the size of the dataset, e.g., δ≤ |D|^-c, for some c > 1.

In this section, we prove that if the privacy test is randomized in a certain way, then Mechanism <ref> (ℱ) is in fact (ε,δ)-differentially private for some δ > 0 and ε > 0.  Privacy Test <ref> simply counts the number of plausible seeds for an output and only releases a candidate synthetic if that number is at least k.  We design Privacy Test <ref> which is identical except that it randomizes the threshold k.

[Randomized test 𝒯_ϵ_0] 

Given a generative model ℳ, dataset D, data records d and y, privacy parameters k and γ, and randomness parameter ϵ_0, output pass to allow releasing y, otherwise output fail.

	
  * Randomize k by adding fresh noise: k̃ = k + Lap(1/ϵ_0).
	
  * Let i ≥ 0 be the (only) integer that fits the inequalities 
    γ^-i-1 < y = ℳ(d)≤γ^-i .

	
  * Let k' be the number of records d_a ∈ D such that 
    γ^-i-1 < y = ℳ(d_a)≤γ^-i .

	
  * If k' ≥k̃ then return pass, otherwise return fail.




Here z ∼Lap(b) is a sample from the Laplace distribution 1/2bexp(-|z|/b) with mean 0 and shape parameter b > 0.



 

Let ℱ denote Mechanism <ref> with the (randomized) Privacy Test <ref> and parameters k ≥ 1, γ > 1, and ε_0 > 0. For any neighboring datasets D and D' such that |D|, |D'| ≥ k, any set of outcomes Y ⊆𝒰, and any integer 1 ≤ t < k, we have:
	
    ℱ(D') ∈ Y≤ e^εℱ(D) ∈ Y + δ ,

	for δ = e^-ε_0 (k-t) and ε = ε_0 + ln(1+γ/t).
	
	



The privacy level offered by Theorem <ref> is meaningful provided k is such that δ is sufficiently small. For example, if we want δ≤1/n^c for some c > 1, then we can set k ≥ t + c/ε_0lnn. Here t provides a trade-off between δ and ε.

The proof of Theorem <ref> can be found in Appendix <ref>. 

Roughly speaking, the theorem says that, except with some small probability δ, adding a record to a dataset cannot change the probability that any synthetic record y is produced by more than a small multiplicative factor. The intuition behind this is the following. 


Fix an arbitrary synthetic record y produced by the mechanism on some dataset. Remark that given y, records are partitioned into disjoint sets according to their probabilities of generating y (with respect to ℳ). That is, partition i for i=0,1,2…, contains those records d such that γ^-(i+1) < y = ℳ(d)≤γ^-i. (We ignore records which have probability 0 of generating y.)

Now suppose we add an arbitrary record d' to the dataset. The probability of producing y changes in two ways: (1) the probability that y is generated increases because d' may be chosen as seed, and (2) the probability that y passes the privacy test increases because d' is an additional plausible seed. Remark that this change only impacts whichever partition d' falls into because the probability of passing the privacy test depends only on the number of plausible seeds in the partition of the seed.

Thus, we focus on the partition in which d' falls. If that partition contains a small number of records compared to k then introducing d' could increase the probability of generating y significantly, but the probability of passing the privacy test is very small. (The likelihood of passing the privacy test decreases exponentially the fewer plausible seeds are available compared to k.) In contrast, if the partition contains a number of records comparable to k or larger, then the probability of generating y increases only slightly (because there are already a large number of plausible seeds with similar probability of generating y as d'). And, the probability of passing the privacy test increases by a multiplicative factor of at most e^ε_0 due to adding Laplacian noise. In both cases, the increase to the probability of producing y due to adding d' is small and can be bounded.


§ GENERATIVE MODEL


In this section, we present our generative model, and the process of using it to generate synthetic data.  The core of our synthesizer is a probabilistic model that captures the joint distribution of attributes.  We learn this model from training data samples drawn from our real dataset .  Thus, the model itself needs to be privacy-preserving with respect to its training set.  We show how to achieve this with differential privacy guarantees.

Let S, T, and P be three non-overlapping subsets of dataset .  We use these datasets in the process of synthesis, structure learning, and parameter learning, respectively. 



 §.§ Model


Let {x_1, x_2, ..., x_m } be the set of random variables associated with the attributes of the data records in .  Let 𝒢 be a directed acyclic graph (DAG), where the nodes are the random variables, and the edges represent the probabilistic dependency between them.  A directed edge from x_j to x_i indicates the probabilistic dependence of attribute i to attribute j.  Let (i) be the set of parents of random variable i according to the dependency graph 𝒢.  The following model, which we use in Section <ref> to generate synthetic data, represents the joint probability of data attributes.


    x_1, ..., x_m  = 
    	∏_i=1^m 
    	x_i {x_j }_∀j ∈(i)
 

This model is based on a structure between random variables, captured by 𝒢, and a set of parameters that construct the conditional probabilities.  In Section <ref> and Section <ref>, we present our differentially-private algorithms to learn the structure and parameters of the model from , respectively.



 §.§ Synthesis


Using a generative model, we probabilistically transform a real data record (called the seed) into a synthetic data record, by updating its attributes.  Let {x_1, x_2, ..., x_m } be the values for the set of data attributes for a randomly selected record in the seed dataset S.  Let ω be the number of attributes for which we generate new values.  Thus, we keep (i.e., copy over) the values of m - ω attributes from the seed to the synthetic data.  Let σ be a permutation over {1, 2, ..., m} to determine the re-sampling order of attributes. 

We set the re-sampling order σ to be the dependency order between random variables.  More precisely, ∀j ∈(i): σ(j) < σ(i).  We fix the values of the first m - ω attributes according to σ (i.e., the synthetic record and the seed overlap on their {σ(1), ..., σ(m-ω) } attributes).  We then generate a new value for each of the remaining ω attributes, using the conditional probabilities (<ref>).  As we update the record while we re-sample, each new value can depend on attributes with updated values as well as the ones with original (seed) values. 

We re-sample attribute σ(i), for i > m-ω, as


    x'_σ(i)∼x_σ(i)   {x_σ(j) = x_σ(j)}_∀j ∈(i), j ≤ m-ω, 
       {x_σ(j) = x'_σ(j)}_∀j ∈(i), j > m-ω


In Section <ref>, we show how to protect the privacy of the seed data record using our plausible deniability mechanisms. 


Baseline: Marginal Synthesis. As a baseline generative model, we consider a synthesizer that (independently from any seed record) samples a value for an attribute from its marginal distribution.  Thus, for all attribute i, we generate x_i ∼x_i.  This is based on an assumption of independence between attributes' random variables, i.e., it assumes x_1, ..., x_m = ∏_i=1^m x_i.




 §.§ Privacy-Preserving Structure Learning


Our generative model depends on the dependency structure between random variables that represent data attributes.  The dependency graph 𝒢 embodies this structure.  In this section, we present an algorithm that learns 𝒢 from real data, in a privacy-preserving manner such that 𝒢 does not significantly depend on individual data records.  

The algorithm is based on maximizing a scoring function that reflects how correlated the attributes are according to the data.  There are multiple approaches to this problem in the literature <cit.>.  We use a method based on a well-studied machine learning problem: feature selection.  For each attribute, the goal is to find the best set of features (among all attributes) to predict it, and add them as the attribute's parents, under the condition that the dependency graph remains acyclic. 

The machine learning literature proposes several ways to rank features in terms of how well they can predict a particular attribute.  One possibility is to calculate the information gain of each feature with the target attribute.  The major downside with this approach is that it ignores the redundancy in information between the features.  We propose to use a different approach, namely Correlation-based Feature Selection (CFS) <cit.> which consists in determining the best subset of predictive features according to some correlation measure.  This is an optimization problem to select a subset of features that have high correlation with the target attribute and at the same time have low correlation among themselves.  The task is to find the best subset of features which maximizes a merit score that captures our objective.

We follow <cit.> to compute the merit score for a parent set (i) for attribute i as


    score((i)) = ∑_j∈(i)corr(x_i, x_j)/√(|(i)| +  ∑_j,k∈(i)corr(x_j, x_k)) ,


where |(i)| is the size of the parent set, and corr() is the correlation between two random variables associated with two attributes.  The numerator rewards correlation between parent attributes and the target attribute, and the denominator penalizes the inner-correlation among parent attributes.  The suggested correlation metric in <cit.>, which we use, is the symmetrical uncertainty coefficient:


    corr(x_i, x_j) = 2 - 2 H(x_i, x_j)/H(x_i) + H(x_j) ,


where H() is the entropy function.

The optimization objective in constructing 𝒢 is to maximize the total score((i)) for all attributes i.  Unfortunately, the number of possible solutions to search for is exponential in the number of attributes, making it impractical to find the optimal solution.  The greedy algorithm, suggested in <cit.>, is to start with an empty parent set for a target attribute and always add the attribute (feature) that maximizes the score.

There are two constraints in our optimization problem.  First, the resulting dependency graph obtained from the set of best predictive features (i.e., parent attributes) for all attributes should be acyclic.  This would allow us to decompose and compute the joint distribution over attributes as represented in (<ref>).  

Second, we enforce a maximum allowable complexity cost for the set of parents for each attribute.  The cost is proportional to the number of possible joint value assignments (configurations) for the parent attributes.  So, for each attribute i, the complexity cost constraint is


    cost((i)) = ∏_j∈(i) |x_j| ≤


where |x_j| is the total number of possible values that the attribute j takes.  This constraint prevents selecting too many parent attribute combinations for predicting an attribute.  The larger the joint cardinality of attribute i's parents is, the fewer data points to estimate the conditional probability x_i {x_j }_∀j ∈(i) can be found.  This would cause overfitting the conditional probabilities on the data, that results in low confidence parameter estimation in Section <ref>.  The constraint prevents this.

To compute the score and cost functions, we discretize the parent attributes.  Let  be a discretizing function that partitions an attribute's values into buckets.  If the attribute is continuous, it becomes discrete, and if it is already discrete,  might reduce the number of its bins.  Thus, we update conditional probabilities as follows.


    x_i {x_j }_∀_j ∈(i)≈x_i {x_j}_∀_j ∈(i)


where the discretization, of course, varies for each attribute.  We update (<ref>) and (<ref>) according to (<ref>).  This approximation itself decreases the cost complexity of a parent set, and further prevents overfitting on the data.  




  §.§.§ Differential-Privacy Protection


In this section, we show how to safeguard the privacy of individuals whose records are in , and could influence the model structure (which might leak about their data).  

All the computations required for structured learning are reduced to computing the correlation metric (<ref>) from .  Thus, we can achieve differential privacy <cit.> for the structure learning by simply adding appropriate noise to the metric.  As, the correlation metric is based on the entropy of a single or a pair of random variables, we only need to compute the entropy functions in a differentially-private way.  We also need to make sure that the correlation metric remains in the [0, 1] range, after using noisy entropy values.

Let H̃(z) be the noisy version of the entropy of a random variable z, where in our case, z could be a single or pair of random variables associated with the attributes and their discretized version (as presented in (<ref>)).  To be able to compute differentially-private correlation metric in all cases, we need to compute noisy entropy H̃(x_i), H̃(x_i), H̃(x_i, x_j), and H̃(x_i, x_j), for all attributes i and j.  For each of these cases, we generate a fresh noise drawn from the Laplacian distribution and compute the differentially-private entropy as


    H̃(z) = H(z) + Lap(Δ_H/ε_H)


where Δ_H is the sensitivity of the entropy function, and ε_H is the differential privacy parameter.

It can be shown that if z is a random variable with a probability distribution, estimated from n_T = | T |  data records, then the upper bound for the entropy sensitivity is


    Δ_H≤1/n_T [2 + 1/ln(2) + 2 log_2n_T] = O(log_2n_T/n_T)


The proof of (<ref>) can be found in Appendix <ref>.

Remark that Δ_H is a function of n_T (the number of records in T) which per se needs to be protected.  As a defense, we compute Δ_H in a differentially-private manner, by once randomizing the number of records


    ñ_T = n_T + Lap(1/ε_n_T)

 
By using the randomized entropy values, according to (<ref>), the model structure, which will be denoted by 𝒢̃, is differentially private.  In Section <ref>, we use the composition theorems to analyze the total privacy of our algorithm for obtaining a differentially-private structure. 



 §.§ Privacy-Preserving Parameter Learning


Having a dependency structure 𝒢̃, we need to compute the conditional probabilities for predicting each of the attributes given its parent set (see (<ref>)).  This is a well-known problem in statistics.  In this section, we show how to learn the parameters that represent such conditional probabilities, from P, in a differentially private manner.

The problem to be solved is to first learn a prior distribution over the parameters of the conditional probabilities.  To do so, we learn the hyper-parameters (the parameters of the prior distribution over the model's parameters) from data.  Only then, we can compute the parameters that form the conditional probabilities from the prior distribution.

Let us take the example of computing the parameters for predicting discrete/categorical attributes.  In this case, we assume a multinomial distribution over the attribute's values (that fall into different bins).  The conjugate prior for multinomials comes from a Dirichlet family.  The Dirichlet distribution assigns probabilities to all possible multinomial distributions, according to the statistics obtained from a set of data records.  

Let |x_i| be the number of distinct values that attribute i can take.  The probability of some multinomial distribution parameters p⃗^c_i = p^c_i,1, p^c_i,2, ..., p^c_i,|x_i| to predict attribute i, under configuration c for (i), is


    p⃗^c_i 𝒢̃, P = 
    	Dir(α⃗^c_i + n⃗^c_i)


where α⃗^c_i is the vector of default hyper-parameters for the Dirichlet distribution, and n⃗^c_i is the vector for the number of data records in P with (i) configuration c with different values for attribute i (i.e., element n ^c_i,l is the number of records for which x_i = l and (i) configuration is c).  The Dirichlet distribution is computed as


    Dir(α⃗^c_i + n⃗^c_i) = 
    	∏_i=1^m ∏_c=1^#cΓ(α^c_i + n^c_i) ∏_l=1^|x_i|(p^c_i)^α^c_i,l + n^c_i,l-1/Γ(α^c_i,l + n^c_i,l)


where α^c_i = ∑_l α^c_i,l, and n^c_i = ∑_l n^c_i,l, and the number of configurations #c is ∏_j∈(i) |x_j|, which according to constraint (<ref>) can at most be .  

Learning the parameters of the model, in the case of a Dirichlet prior for multinomial distribution, is simply computing n⃗^c_i from the data records in P.  Given the probability distribution (<ref>) over the multinomial parameters, we can compute the most likely set of parameters as 


    p^c_i,l = α^c_i,l + n^c_i,l/α^c_i + n^c_i


or, we can sample a set of multinomial parameters according to (<ref>).  This is what we do in our generative model, in order to increase the variety of data samples that we can generate. 

Note that for computing the marginal distributions, that are needed for the baseline, we perform the same computations by setting the parent sets to be empty.

If an attribute is continuous, we can learn the parameters of a Normal distribution or learn a regression model from our data to construct its conditional probability.  We omit the details here (as in the dataset we evaluate in Section <ref> all attributes are discrete).



  §.§.§ Differential-Privacy Protection


The parameters of the conditional probabilities depend on the data records in P, thus they can leak sensitive information about individuals who contributed to the real dataset.  In this section, we show how to learn parameters of the attribute conditional probabilities (i.e., p⃗^c_i values) with differential privacy guarantees.

Note that in (<ref>), the only computations that are dependent on P are the n⃗^c_i counts (for all c and i).  To find the variance of the noise to be added to these counts, to achieve differential privacy, we need to compute their sensitivity with respect to one individual's data record.  

Suppose we are computing the parameters associated with predicting a given attribute i given its parent set (i).  Note that adding a record to P increases exactly a single component n^c_i,l, for which it matches value l for attribute i and configuration c for its parent set.  So, only one single element among all #c × |x_i| elements of n⃗_i = n⃗^1_i, n⃗^2_i, ..., n⃗^#c_i changes.  This implies that the L1 sensitivity of n⃗_i is 1.  Consequently, a random noise drawn from Lap(1/ε_p) can be added to each component of n⃗_i independently.  More precisely, for any attribute i value l, and configuration c, we randomize counts as


    ñ^c_i,l = max(0, n^c_i,l + Lap(1/ε_p))


and use them to compute (<ref>) with differential privacy.




 §.§ Differential Privacy Analysis


In this section, we compute the differential privacy level that we can guarantee for the whole dataset  for learning the structure and the parameters of the model.  We compute the total (ϵ, δ) privacy by composing the differentially-private mechanisms in Section <ref> and Section <ref>.

Remark that we often protect the output f(x) of some function f by adding noise from Lap(Δ_f/ε), where Δ_f is the L1 sensitivity of f. This mechanism is known as the Laplace mechanism and it satisfies ε-differential privacy (Theorem 3.6 of <cit.>).

Thus the m (m+1) entropy values, H̃(z), needed for structure learning (Section <ref>) are obtained in an a way that satisfies ε_H-differential privacy. This is also the case for the number of records n_T, i.e., it satisfies ε_n_T-differential privacy. Similarly, the counts n^c_i,l parameters learned for each configuration (Section <ref>) satisfy ε_p-differential privacy.

For structure learning, we make use of both sequential composition (Theorem <ref>) and advanced composition (Theorem <ref>).

Specifically, we use advanced composition for the m (m+1) entropy values and sequential composition with the number of records. That is, the overall privacy achieved (of structure learning) is (ε_L,δ_L)-differential privacy for a fixed δ_L ≪1/n_T and ε_L = ε_n_T + ε_H √(2 m(m+1) ln(δ_L^-1))+ m(m+1) ε_H (e^ε_H - 1).

For the parameter learning (as explain in Section <ref>), for a given attribute i, the L1 sensitivity of all configurations of the parent set of i, i.e., (i), is 1. The overall privacy achieved (of parameter learning) is (ε_P,δ_P)-differential privacy using advanced composition over the m attributes. Here, δ_P ≪1/n_p (where n_p is the number of records in P) and ε_P = ε_p √(2 m ln(δ_P^-1)) + m ε_p (e^ε_p - 1).

Given that T and P are non-overlapping, the privacy obtained for the generative model is differentially private with parameters (max{ε_L, ε_P}, max{δ_L,δ_P}).  Due to random subsampling of T and P from , the privacy parameters can be further improved by using the amplification effect of sampling (Theorem <ref>) to obtain (ε,δ)-differential privacy.


§ DATA


For validation, we use the 2013 American Community Survey (ACS) <cit.> from the U.S. Census Bureau. The dataset contains upwards of 3 million of individual records. Each record includes a variety of demographics attributes such as age, sex, race, as well as attributes related to the individual's income such as yearly income in USD.

The ACS dataset has been used for various purposes ranging from examining the relationship between education and earnings <cit.> to looking at current language use patterns of children of immigrants <cit.>. Furthermore, the prominent UCI Adult dataset, which provides a well-established benchmark for machine learning tasks, was extracted from the 1994 Census database. The 2013 ACS dataset contains similar attributes so we process it in a manner similar to how the Adult dataset was extracted. In particular, we extract the same attributes whenever possible.

As pre-processing, we discard records with missing or invalid values for the considered attributes (Table <ref>). 

Table <ref> shows some statistics of the data cleaning and extracted dataset. This is a highly dimensional dataset despite having only 11 attributes, there are more than half a trillion possible records and out of the roughly 1.5 million records obtained after cleaning, approximately 2/3 are unique.







We bucketize (Section <ref>) values of the age attribute in bins (i.e., buckets) of 10, i.e., 17 to 26, 27 to 36, etc. (Following the rules used to extract the Adult dataset, we only consider individuals older than 16.) We also bucketize the values of: hours worked per week (HPW), in bins of 15 hours; education, to aggregate education level below a high-school diploma in a single bin, and high-school diploma but not college into (another) single-bin. Bucketization is performed based on the data format and the semantics of attributes (and thus is privacy-preserving). It is done only for structured learning (Section <ref>); both the input and output data format remain the same.


§ SYNTHETICS GENERATOR TOOL


The synthetic generator <cit.> is implemented as C++ tool which takes as input: a dataset represented as a CSV file, a few metadata text files describing the dataset, and a config file. As output, the tool produces a synthetic dataset of the requested size and some metadata.

The generation process is defined by the config file, i.e., parameters defined within in control various aspects of the generation process. The parameters are the privacy parameters k, γ, ε_0, and also parameters of the generative model such as ω. In addition, the tool takes two optional parameters to control the privacy test:  and , which allow the test to terminate early. Specifically, the implementation initially sets k' = 0, and iterates over the records of D in a random order, incrementing k' for each plausible seed record d_a encountered. The process terminates whenever k' ≥ or if  records have been examined (whichever occurs first). Note that this affects performance (but not privacy); lower values lead to faster generation time in cases where plausible seeds are abundant, at the cost of fewer synthetics passing the test (potentially lowering utility).

The synthesis process, given a chosen seed, is independent of other seeds (Section <ref>); so the generation process itself is embarrassingly parallel. One hurdle with running multiple concurrent instances is implementing differentially-private parameters learning (Section <ref>). In general, the number of configuration (in the sense of Section <ref>) of the model is too large (i.e., exponential in the number of attributes) to learn the model as a pre-processing step. So we design the tool to learn the model for each configuration as it encounters it. To ensure that the privacy guarantee holds we set the RNG seed number to be a deterministic function (i.e., a hash) of the configuration.






§ EVALUATION


We feed the 2013 ACS dataset (Section <ref>) as input to our tool and generate millions of synthetic records. We start with a description of the experimental setup. The evaluation itself is divided into four logical parts: (Section <ref>) statistical measures (how good are the synthetics according to well-established statistical metrics); (Section <ref>) machine learning measures (how good are the synthetics for machine learning tasks, specifically classification); (Section <ref>) distinguishing game (how successful is an adversary at distinguishing between a real record and a synthetic one); and (Section <ref>) performance measures (how computationally complex it is to generate synthetics).



 §.§ Setup


To achieve differential privacy we sampled the input dataset into disjoint sets of records. Each of T and P contains roughly 280,000 records, whereas S contains roughly 735,000 records (Section <ref>). For differential privacy of the generative model, we set ε=1 (though we give some results for ε=0.1) and always set δ to be at most 2^-30≈ 10^-9.

We typically compare the quality of our generated synthetics with real records (coming from the input dataset) and privacy-preserving marginals (Section <ref>) which we refer to as reals and marginals, respectively. The synthetics we generate are referred by their generation parameters (e.g., ω = 10). Unless otherwise stated, we set k=50, ε_0=1, γ = 4, and ω is set to vary between 5 and 11. 

We maintain a testing set of roughly 100,000 records. Evaluation of classifiers (in this section) uses at least 100,000 records for training and a (disjoint) testing set of size at least 30% of the size of the aforementioned training set.






 §.§ Statistical Measures


We evaluate the quality of the synthetics in terms of their statistical utility, i.e., the extent to which they preserve the statistical properties of the original (input) dataset. We can do this at the level of the generative model (Section <ref>) itself. Concretely, we directly quantify the error of the privacy-preserving generative model before any synthetic record is generated. We do this for each attribute by repeatedly selecting a record from the input dataset (uniformly at random) and using the generative model to find the most likely attribute value (of that attribute) given the other attributes. The generative model error is then measured as the proportion of times that the most likely attribute value is not the correct (i.e., original) one. We repeat this procedure millions of times to quantify the average error of the model for each attribute. Because the generative model is made differentially private by adding noise (Section <ref>) we additionally repeat the whole procedure 20 times (learning a different private model each time) and take the average.

The results are shown in Figures <ref> and <ref>. Figure <ref> shows the relative decrease in model error (i.e., improvement of model accuracy) over the (privacy-preserving) marginals; it shows this improvement for the un-noised, (ε=1)-differential private, and (ε=0.1)-differential private generative models. There is a clear accuracy improvement over marginals, in addition to a low decrease in improvement between the un-noised model and the ε=1 and ε=0.1 noisy versions.  


Figure <ref> shows the accuracy of the un-noised generative model against the (un-noised) marginals, random guessing (baseline), and the best classifier we could find (trained on as many records as the generative model), the random forest (RF). While RF's accuracy is sometimes higher than that of the generative model, the accuracy of the latter is in many cases significantly higher than that of marginals and random guessing.  We conclude that while the proposed generative model does not perform as well as RF (though making RF differentially private would certainly lower its performance) it does perform significantly better than marginals (or random guessing).




In addition to the error of the generative model, we can more directly evaluate the extent to which the generated synthetics preserve the statistical properties of the original (input) dataset. To do this, we compare the probability distributions of the synthetics with the reals and marginals. Specifically, for reals, marginals and synthetics datasets, we compute the distribution of each attribute and of each pair of attributes. We compare each of these distributions to those computed on (other) reals and quantify their distance. We use a well-established statistical distance metric called “the” statistical distance (a.k.a. total variation distance <cit.>).

The results are shown in Figures <ref> and <ref>, where Figure <ref> shows box-and-whisker plots for the distance of the distributions of each attribute separately, and Figure <ref> shows box-and-whisker plots for the distance of the distributions of all pairs of attributes.
While marginals do well for single attribute and sometimes outperform our synthetics (though the statistical distance for all datasets is small), synthetics clearly outperform marginals for pairs of attributes. We conclude that the generated synthetics preserve significantly more statistical information than marginals.



 §.§ Machine Learning Measures


In addition to preserving statistical properties of the original (input) dataset, the synthetics should also be suitable to various machine learning tasks. In particular, given a learning task, we can evaluate the extent to which synthetics are suitable replacements for a real dataset. For the ACS dataset, a natural and well-establish classification task is to predict a person's income class (i.e., ≥ 50K or < 50K) using the other attributes as features (Section <ref>).




We train various classifiers on the synthetic datasets and on the real (input) dataset. We then compare: the classification accuracy obtained, and the agreement rate of the learned classifiers. Specifically, for two classifiers trained on different datasets (but with the same classification task), we define the agreement rate to be the percentage of records for which the two classifiers make the same prediction (regardless of whether the prediction is correct). Given that we look at the agreement rate of classifiers trained on reals and synthetics, the agreement rate reveals the extent to which the classifier trained on synthetic data has learned the same model as the classifier trained on real data.

Table <ref> shows the obtained results for three (best) classifiers: Classification Tree (Tree), Random Forest (RF), and AdaBoostM1 (Ada). The accuracy and agreement rate are calculated as the average over 5 independent runs, that is, for each run, we use different (randomly sampled) training and testing datasets. Overall, we see that both the accuracy and the agreement rates of the synthetics are significantly closer to that of the reals than the marginals are.

In addition to comparing the best classifiers trained on real data versus those trained on synthetic data, we can also compare privacy-preserving classifiers trained on real data versus non-private classifiers trained on (privacy-preserving) synthetic data.  In particular, Chaudhuri et al. <cit.> propose two techniques based on empirical risk minimization to train logistic regression (LR) and support vector machines (SVM) binary classifiers: output perturbation (noise is added to the learned model), and objective perturbation (noise is added to the objective function of the minimization problem). To train such classifiers, we first pre-process our datasets following the instructions in <cit.>: we transform each categorical attribute into an equivalent set of binary attributes, and normalize features so that each feature takes values in [0,1] and subsequently further normalize each training example such that its norm is at most 1. The target attribute for classification is again the person's income class. The method proposed in <cit.> has two parameters: the privacy budget ε which we set to 1 (the same as for our generative model), and λ which is a regularization parameter. We use the code of <cit.>, which we obtain courtesy of the authors, to train the LR and SVM classifiers. Because the classification models vary greatly depending on λ, we vary its value in the set {10^-3,10^-4,10^-5, 10^-6} and (optimistically) pick whichever value maximizes the accuracy of the non-private classification model.

We report the accuracy obtained in each case in Table <ref>, where we contrast non-private, output perturbation DP, and objective perturbation DP classifiers trained on real data with non-private classifiers trained on our synthetic datasets (for various values of ω). Remark that for the case ω=11, for example, this is a fair comparison as the obtained LR and SVM classifiers are ε=1-DP and thus provides the exact same privacy guarantee as the output perturbation and objective perturbation LR and SVM classifiers. Non-private LR and SVM classifiers trained on our (privacy-preserving) synthetic datasets are competitive with differentially private LR and SVM classifiers trained on real data.




We emphasize that the results should be interpreted in favor of our proposed framework. Indeed, the classifiers trained on our privacy-preserving synthetics outperforms ε-DP LR classifier and only achieves about 1% lower accuracy than the objective-perturbation ε-DP SVM.  This is significant because the technique to train the ε-DP LR and SVM is specifically optimized for that task. In contrast, our synthetics are not specifically generated to optimize any particular classification task; instead the general objective is to preserve the statistical properties of real data.





 §.§ Distinguishing Game


A different way to evaluate the quality of synthetic datasets is to quantify the extent to which the synthetics can “pass off” as real records. In other words, we can imagine a game in which the participant is given a random record either from a real dataset or a synthetic dataset (but doesn't know which) and is asked to distinguish between the two possibilities. In this case, the utility is measured by how likely a sophisticated participant (e.g., a well-established learning algorithm) is to make a mistake, i.e., confuse a synthetic record with a real record or vice-versa.

For our purpose the role of the participant is played by the two best classifiers (those that best distinguish synthetics from reals): Random Forest (RF) and Classification Tree (Tree). Specifically, we provide 50,000 records from both a real dataset and a synthetic dataset (i.e., 100,000 total) as training examples to the (binary) classifier. We then evaluate the accuracy on a 50% mix of real and synthetic records which were not part the training set. Table <ref> shows the results: both classifiers obtain reasonably high (79.8% and 73.2%) accuracy in distinguishing marginals from real records. However, both classifiers obtain much lower accuracy (i.e., 63%) when trying to distinguish synthetics from reals.









 §.§ Performance Measures


In addition to how much utility they preserve, synthetics also need to be easy to generate. The generation is a parallel process, so we measure the time taken for both the learning of the privacy-preserving generative model (model learning) and the synthetics generation (synthesis) itself. Figure <ref> shows the time taken to produce various number of synthetics records (totaling over 1 million). The parameters  and  (Section <ref>) were set to 100 and 50000 respectively. The machine used for the experiment runs Scientific Linux and is equipped with an Intel Xeon E5-2670 processor (2.60GHz) with 32 processing units and 128GB of RAM. We ran 96 instances (16 in parallel at a time) and picked a random maximum runtime for each instance between 3 and 15 minutes.

The generator outputs all synthetics produced regardless of whether they pass the privacy test. Naturally, only those which pass the test should to be released. Thus, the extent to which we can synthesize large (privacy-preserving) datasets depends on how easy it is to find synthetics that pass the privacy-test (Section <ref>). To evaluate this, we set γ = 2 and = 100,000, and vary k and ω. We measure the proportion of synthetics which pass the privacy test. The results are shown in Figure <ref>: even for stringent privacy parameters (e.g., k=100) a significant proportion (i.e., over 50% for ω∈_R [5-11]) of synthetics pass the test. 






§ RELATED WORK


Data synthesis is the process of creating artificial data that can be used to serve some key purposes of real data. For example, it can be used to test software <cit.> when there is an inadequate supply of real tests available from operations. It can be used to evaluate the performance of database systems <cit.> when obtaining real data at sufficient scale is difficult or expensive.  It can also be used to protect privacy. In 1993, Rubin <cit.> proposed the idea of creating synthetic data based on multiple imputation, that is, on repeated use of a function that proposes values for missing fields in a record. The generative model we presented in Section <ref> uses a similar technique. This and related work have given rise to a substantial body of research on the release of synthetic data <cit.>. Such techniques have achieved significant deployment; for example, they have been adopted by the U.S. Census Bureau <cit.>.

An alternative to data synthesis sometimes called syntactic privacy protection transforms the sensitive data using a combination of aggregation, suppression, and generalization, to achieve criteria such as k-anonymity <cit.> or l-diversity <cit.>. Although these techniques support privacy protected data publishing without synthesis, the degree of privacy protection they provide depends on the background knowledge of adversaries. The key difference between (k,γ)-plausible deniability and k-anonymity is that the latter is a syntactic condition on the output of a sanitization process, whereas plausible deniability is a condition on a synthetic generator mechanism with respect to its input data.

Plausible deniability as a privacy notion for synthetic data was proposed by Bindschaedler and Shokri in <cit.> which describes a technique to synthesize location trajectories in a privacy-preserving way. The use of plausible deniability in <cit.> is specific to location privacy as it is defined in terms of a semantic distance between two location trajectories. In contrast, this work generalizes the notion of plausible deniability for general data synthesis by establishing it as a privacy criterion in terms of the underlying synthesis probabilities. Consequently, this criterion is applicable to any system and any (kind of) data. The generative framework described in this paper enables us to formally connect plausible deniability to differential privacy (Theorem <ref>).

Differential privacy provides guarantees even against adversaries with (almost) unlimited background knowledge. However, popular differentially private mechanisms such as the Laplacian mechanism target the release of aggregate statistics. By contrast, we focus on synthesizing data with the same format as the (sensitive) input data. Preserving the data format is valuable for many reasons, such as enabling the use of applications and code that are targeted at raw or sanitized data. There is a line of work on mechanisms that are differentially private and provide data as an output. Some of these techniques have theoretical properties that may make them impractical in important cases <cit.>.

A prominent example is the Exponential Mechanism <cit.>. 
Informally, the mechanism induces a distribution on the space of output records by assigning a weight to each such record and then producing output records by sampling from that distribution. The mechanism is of great importance for algorithm design due to its generality. However, as several researchers have pointed out <cit.>, a direct application is too costly to be practical for high-dimensional datasets due to the complexity of sampling, which grows exponentially in the dimension of the data records. Concretely, a straightforward implementation of the exponential mechanism to generate synthetic records from the ACS dataset (Section <ref>) would sample from a universe of records of size roughly 2^39 (Table <ref>). This would require pre-computing that many probabilities. If we assume we can store each value in four bytes this would require about 2TB of memory. In contrast, the complexity of synthesizing a record with our framework depends only on the number of records in the dataset and on the complexity of our generative model and thus the process is very efficient in practice (Section <ref>).

There is a growing collection of mechanisms and case studies for differentially private release of data <cit.>, although some of these are based on a broad view of data release, such as the release of histograms or contingency tables. Our use of plausible deniability to achieve differentially private data adds to this body of work. The typical approach to protect privacy in this context is to add noise directly to the generative model. For example, this is the approach taken by <cit.>. In particular, <cit.> constructs a generative model based on Bayesian networks similar to the generic generative model of Section <ref>.

Our work takes a novel approach: instead of trying to achieve differential privacy directly, we design the generative framework to achieve plausible deniability. A major step towards achieving plausible deniability and a key novelty is the idea of testing privacy. That is, instead of designing the mechanism so it achieves that notion by design, we use a privacy test which rejects “bad” samples. As a side effect, the generative model is decoupled from the framework. Privacy is guaranteed in a way that is oblivious to the specifics of the generative model used for synthesis. Furthermore, the guarantee offered by our proposed (k,γ)-plausibly deniable mechanism is surprisingly close to that of differential privacy, as evidenced by the fact that merely randomizing the threshold yields a differentially private mechanism.

The idea of running data synthesis and then testing privacy has been used before. For example, Reiter et al. in <cit.> and <cit.> use inference to evaluate privacy risk for a synthetic data release. However, there is no proof of privacy, and it is not efficient to run a set of inference attacks to estimate the risk before releasing a dataset. 


§ DISCUSSION


Regardless of whether one intends to release a set of aggregate statistics or a synthetic dataset, there is no privacy protection technique that can preserve utility for all meaningful utility functions. However, one key feature of our generative framework is that, unlike other approaches based on differential privacy, any generative model ℳ can be used while keeping the same privacy guarantees. 
As a result, designing ℳ is a data science problem which need not involve considerations of the privacy of the seeds.

Parameter ω (Section <ref>) controls the closeness of synthetics to their seeds. (Lower ω means more dependence on the seed but it is harder to pass the privacy test.) A pragmatic approach is to generate synthetics for various values of ω and then randomly sample a subset of those synthetics which pass the privacy test (this is evaluated in Section <ref>). Note that no matter what the value of ω is, the privacy of the seeds is ensured because of the privacy test.

In the special case where the generative model ℳ is independent of the seed, the privacy guarantee applies to any output from Mechanism <ref> because the privacy test always passes. However, for a seed-dependent generative model, the privacy of the seeds is safeguarded by rejecting synthetics which do not pass the privacy test. So, when generating several synthetics using the same input dataset, the privacy obtained depends on the number of synthetics released. 
In fact, when Privacy Test <ref> is used, the (ε,δ)-differential privacy guarantee applies to a single (released) synthetic record y. That said, the composition theorems for differential privacy can be used to extend the guarantee to arbitrarily large synthetic datasets, provided the privacy budget is appropriately increased. We leave as future work the design of improved composition strategies.



§ CONCLUSIONS


We have presented the first practical data synthesis tool with strong privacy guarantees. We have formalized plausible deniability for generating generic data records, and have proven that our mechanisms can achieve differential privacy without significantly sacrificing data utility. 


    Acknowledgments.
	This work was supported in part by NSF CNS grants 13-30491 and 14-08944. The views expressed are those of the authors only.


	abbrv
	




§ COMPOSING DIFFERENTIAL PRIVACY



	Let ℱ_i be an (ε_i,δ_i)-differentially private mechanism, for i=1,…,m. Then, for any dataset D, the mechanism which releases outputs: (ℱ_1(D), ℱ_2(D), …, ℱ_m(D) ) is an (ε,δ)-differentially private mechanism for ε = ∑_i=1^mε_i, and δ = ∑_i=1^mδ_i.




	Let ℱ_i be an (ε,δ)-differentially private mechanism, for i=1,…,m. Then the mechanism represented by the sequence of k queries over ℱ_1(·), ℱ_2(·), …, ℱ_m(·) with potentially different inputs is (ε',δ')-differentially private for:
	
    ε' = ε√(2 k ln1/δ”) + k ε ( e^ε - 1 )    and    δ' = kδ + δ” .




 

	Let mechanism ℱ be an (ε,δ)-differentially private mechanism. The mechanism which first sub-samples each record of its input dataset with probability δ < p < 1 and then runs ℱ on the sub-sampled dataset is (ε',δ')-differentially private for:
	
    ε' = ln(1 + p (e^ε - 1))   and    δ' = pδ .






§ PROOF: SENSITIVITY OF ENTROPY


 

Let z be a discrete random variable with a probability distribution estimated from n data records. The sensitivity of H(z) is:
	
    Δ_H≤1/n [2 + 1/ln(2) + 2 log_2n]   .

	


Lemma <ref> is used in Section <ref> (<ref>).


	Let z and z' be the random variables associated with two histograms (of dimension m) computed from two neighboring datasets D and D', respectively. Both datasets have n records but differ in exactly one record.
	
	Let z_c = (c_1, c_2, …, c_m) and z'_c = (c'_1, c'_2, …, c'_m) represent the histograms over the m values of the attribute for z and z', respectively. The entropy is computed over the probability distribution represented by a histogram.
	
	Remark that the histograms of the considered neighboring datasets D and D' can only differ in two positions. If they do not differ in any position, then the Lemma trivially holds (Δ_H = 0). That is, without loss of generality, there exists j_1 and j_2 (with j_1 ≠ j_2) such that c'_j_1 = c_j_1 + 1 and c'_j_2 = c_j_2 - 1. Also, n-1 ≥ c_j_1≥ 0 which means that n ≥ c'_j_1≥ 1, and n ≥ c_j_2≥ 1 which means that n-1 ≥ c'_j_2≥ 0. Furthermore for i ≠ j_1, j_2, we have c'_i = c_i, and also: 
    ∑_i=1^m c_i = ∑_i=1^m c'_i = n  .

	
	
	Now:
	
    H(z)    = -∑_i=1^mc_i/nlog_2c_i/n
       = -1/n[ ∑_i=1^m c_i log_2c_i - n log_2n]	
       = log_2n - 1/n( c_j_1log_2c_j_1 + c_j_2log_2c_j_2 + ∑_i ≠ j_1,j_2 c_i log_2c_i)  .

	Similarly,
	
    H(z')    = log_2n - 1/n∑_i ≠ j_1,j_2 c_i log_2c_i
       - 1/n[ (c_j_1+1) log_2(c_j_1+1) + (c_j_2-1) log_2(c_j_2-1)]  .

		
	We have that Δ_H = max_c_j_1,c_j_2|H(z) - H(z') |, but for brevity we omit the max and analyze this quantity with respect to the values of c_j_1 and c_j_2 to show that the lemma holds in each case.
	
	Observe that: 
	
    Δ_H   = |H(z) - H(z') |
       = 1/n| c_j_1log_2c_j_1 - (c_j_1+1) log_2(c_j_1+1). 
       + . c_j_2log_2c_j_2 - (c_j_2-1) log_2(c_j_2-1)| .

	
	
  * Case 1: c_j_1 = 0. We have 
    Δ_H = 1/n | c_j_2log_2c_j_2 - (c_j_2-1) log_2(c_j_2-1)|  .

	Clearly, if c_j_2 = 1 then Δ_H = 0 and the Lemma trivially holds. So assume c_j_2 > 1.
	We have: 
	
    Δ_H   = 1/n | c_j_2log_2c_j_2 - (c_j_2-1) log_2(c_j_2-1) | 
       = 1/n| c_j_2log_2(c_j_2/c_j_2 - 1) + log_2(c_j_2 - 1)|
       ≤1/n| c_j_2log_2(c_j_2/c_j_2 - 1)| + 1/nlog_2(c_j_2 - 1)
       ≤1/nlog_2(n-1) + 1/n| (a+1) log_2(1+1/a)| ,

	where a = c_j_2-1 ≥ 1. It is easy to see that (a+1) log_2(1+1/a) ≤ 2. We conclude that: Δ_H≤1/n (2 + log_2n).
	
	
  * Case 2: c_j_2 = 1. We have 
    Δ_H = 1/n | c_j_1log_2c_j_1 - (c_j_1+1) log_2(c_j_1+1)|  .

	Again if c_j_1 = 0, then the Lemma trivially holds. So assume c_j_1 > 0.
	We have:
	
    Δ_H   = 1/n | c_j_1log_2c_j_1 - (c_j_1+1) log_2(c_j_1+1)| 
       = 1/n|  c_j_1log_2(c_j_1/c_j_1+1) - log_2(c_j_1+1)|
       ≤log_2n/n +  1/n|  c_j_1log_2(c_j_1/c_j_1+1)|
       = log_2n/n + 1/n c_j_1log_2(c_j_1+1/c_j_1)
       = log_2n/n + 1/n c_j_1log_2(1 + 1/c_j_1) .

	Using L'Hopital's rule we have c_j_1log_2(1 + 1/c_j_1)≤1/ln2. We conclude that: Δ_H≤1/n (1/ln2 + log_2n).
	
	
  * Case 3: c_j_1≥ 1, c_j_2≥ 2.
		We have: 
	
    Δ_H   = 1/n | c_j_1log_2c_j_1 - (c_j_1+1) log_2(c_j_1+1)
       + c_j_2log_2c_j_2 - (c_j_2-1) log_2(c_j_2-1) | 
       ≤1/n | c_j_1log_2c_j_1 - (c_j_1+1) log_2(c_j_1+1)| 
       + 1/n | c_j_2log_2c_j_2 - (c_j_2-1) log_2(c_j_2-1) |  ,

	where it is seen that the two terms have been bounded for cases 1 and 2. Thus, putting it all together, we conclude that Δ_H≤1/n( 2 + 1/ln2 + 2 log_2n).
	
	






§ PROOF: CONNECTION WITH DIFFERENTIAL PRIVACY


In this section, we prove Theorem <ref> of Section <ref>.

[Differential Privacy of ℱ] 

Let ℱ denote Mechanism <ref> with the (randomized) Privacy Test <ref> and parameters k ≥ 1, γ > 1, and ε_0 > 0. For any neighboring datasets D and D' such that |D|, |D'| ≥ k, any set of outcomes Y ⊆𝒰, and any integer 1 ≤ t < k, we have:
	
    ℱ(D') ∈ Y≤ e^εℱ(D) ∈ Y + δ ,

	for δ = e^-ε_0 (k-t) and ε = ε_0 + ln(1+γ/t).




We start with some notation. Let 𝒰 denote the universe of data records. All data records, i.e., those from the datasets D and D', including synthetic records produced by ℳ (and ℱ) are elements of 𝒰. Let D and D' denote two neighboring datasets, i.e., either D = D' ∪{ d } for some d ∈𝒰, or D' = D ∪{ d' } for some d' ∈𝒰. We assume that both D and D' have at least k records, and we have parameters k ≥ 1, γ > 1, ε_0 > 0. For convenience we write p_d(y) = y = ℳ(d), and refer to ℳ only implicitly.

Given a dataset D^⋆, we want to reason about the probability that synthetic record y is released: ℱ(D^⋆) = y. Observe that given synthetic record y ∈𝒰, the records of D^⋆ can be partitioned (into disjoint sets) by the privacy criterion. Concretely, let I_d(y) be the partition number of a record d ∈ D^⋆ with respect to y. The partition number I_d(y) is the unique non-negative integer such that γ^-(I_d(y)+1) < p_d(y) ≤γ^-I_d(y). In other words, I_d(y) = ⌊ - log_γ p_d(y) ⌋. If p_d(y) = 0 then the partition number is undefined. Similarly, we define the partition (or partition set) for i ≥ 0  as C_i(D^⋆,y) = { d : d ∈ D^⋆, I_d(y) = i }. That is, partition i is the set of records with partition number i. 

A key step is to express the probability ℱ(D^⋆) = y in terms of: (1) the probability of generating y from a specific partition (i.e., the seed is in that partition) and (2) the probability of passing the test. For (2) remark that the probability of passing the privacy test depends only on the partition of the seed (see Privacy Test <ref>).


	For any dataset D^⋆, if the seed is in partition i, the probability of passing the privacy test is given by: pt(D^⋆, i, y) = L ≥ k - |C_i(D^⋆,y)|, where L ∼Lap(1/ε_0).



	For any dataset D^⋆, the probability of producing y from partition i is: 
		
    q(D^⋆, i, y) = pt(D^⋆, i, y) ∑_s ∈ C_i(D^⋆,y) p_s(y)  .



As the following demonstrates, ℱ(D^⋆) = y is readily expressed in terms of (1) and (2).

	
		
	For any dataset D^⋆ and any synthetic record y ∈𝒰 we have: 
	
    ℱ(D^⋆) = y = 1/|D^⋆|∑_i ≥ 0 q(D^⋆, i, y)   .

	


In other words, the probability of releasing y (from D^⋆) can be expressed as the sum, over all partitions, of the probability of generating y from a given partition and then releasing it.


	Fixing a y and following the description of Mechanism <ref>, we have:
		
    ℱ(D^⋆) = y   = ∑_s ∈ D^⋆s  is seed, ℱ(D^⋆) = y
       = 1/|D^⋆|∑_s ∈ D^⋆ p_s(y)  (D^⋆,s,y)  passes test ,

	given the fact that the seed is sampled uniformly at random.

	Further, observe that terms of the sum for which p_s(y) = 0 can be omitted and that we can partition the set { d : d ∈ D^⋆, p_d(y) > 0 } with respect to the partition number of its elements. That is:
	
    { d : d ∈ D^⋆, p_d(y) > 0 } = ∪_i ≥ 0 C_i(D^⋆, y)  ,

	where for each d ∈ D^⋆ such that p_d(y) > 0, there exists a unique non-negative integer j such that d ∈ C_j(D^⋆, y).
	
	Thus:
		
    ℱ(D^⋆) = y
       = 1/|D^⋆|∑_s ∈ D^⋆ p_s(y)  (D^⋆,s,y)  passes test
       = 1/|D^⋆|∑_i ≥ 0∑_s ∈ C_i(D^⋆, y) p_s(y)  (D^⋆,s,y)  passes test
       = 1/|D^⋆|∑_i ≥ 0 L ≥ k - |C_i(D^⋆,y)|∑_s ∈ C_i(D^⋆, y) p_s(y) 
       = 1/|D^⋆|∑_i ≥ 0 pt(D^⋆, i, y) ∑_s ∈ C_i(D^⋆, y) p_s(y) 
       = 1/|D^⋆|∑_i ≥ 0 q(D^⋆, i, y)  ,

	given that the privacy test depends only on the partition of the seed (and not on the seed itself). (See
    the description of Privacy Test <ref> with L being drawn from Lap(1/ε_0).)


Remark that q(D^⋆, i, y) = 0 if and only if C_i(D^⋆, y) = ∅. Also, observe that if a record is added to or subtracted from D^⋆ then only one partition changes. As a result, we can analyze case-by-case the change in the probability of releasing y from partition i, when adding or removing a record to partition i. 

The following shows that adding a record to some partition only increases the probability of passing the privacy test by at most e^ε_0. (This is a consequence of adding Laplacian noise to the threshold.)


	Given any y ∈𝒰, any two neighboring datasets D and D' such that D' = D ∪{ d' }. For any partition i we have:
	
    pt(D, i, y) ≤pt(D', i, y) ≤ e^ε_0pt(D, i, y)  .

	



To prove Lemma <ref>, we use the following observation (which comes from the CDF of the Laplace distribution).


For any x ∈ℝ, if L is a Laplace random variable with shape parameter b and mean 0, then we have: 

    L ≥ x≤L ≥ x - 1≤ e^1/bL ≥ x .






	There are two cases: i = I_d'(y) or i ≠ I_d'(y).
	If i = I_d'(y) then d' falls into partition i and so C_i(D',y) = C_i(D,y) ∪{ d' }. We have:
	
    pt(D', i, y)    = L ≥ k - |C_i(D',y)|
       ≤ e^ε_0L ≥ k - |C_i(D',y)| + 1
       = e^ε_0L ≥ k - |C_i(D,y)| = e^ε_0pt(D, i, y)  ,

	Also, we have that: pt(D', i, y) > pt(D, i, y).
	
	Otherwise, if i ≠ I_d'(y) then C_i(D',y) = C_i(D,y), and so:
	
    pt(D', i, y) 
    		   = L ≥ k - |C_i(D,y)| = pt(D, i, y)  .

	Putting it together yields the result.




To quantify the change in q(D^⋆, i, y) due to adding a record to partition i we need to separate two cases: (1) the partition is initially empty (or more generally has initially less than t records) and (2) the partition is not empty (or more generally has at least t records).


	For any y ∈𝒰 and any dataset D. Let D' = D ∪{ d' } for some d' ∈𝒰. Let j be the partition number of d' (i.e., I_d(y) = j). The following holds.	
	
	
		
  (a)
			For all i ≠ j, we have q(D',i,y) = q(D,i,y).
		
		
  (b)
			If |C_j(D, y)| < t: 
			
    q(D, j, y) < q(D', j, y)  ,
 and
			
    q(D', j, y) ≤ e^-ε_0 (k - t)∑_s ∈ C_j(D',y) p_s(y) ≤ t  e^-ε_0 (k - t) .

			If |C_j(D, y)| ≥ t:
			
    q(D', j, y)/q(D, j, y)≤ e^ε_0[ 1 + γ/t]   .
	
	
	



	For any y ∈𝒰 and any dataset D. Let D' = D ∪{ d' } for some d' ∈𝒰. We have q(D, i, y) ≤ q(D', i, y), for all i ≥ 0.
	




	Fix y and let j be the partition that d' falls into. 
	
	For part (a), remark that for i≠ j, we have C_i(D,y) = C_i(D',y). So q(D, i, y) = q(D', i, y). 
	
	For part (b), we have that:
	
    q(D, j, y)    = pt(D, j, y) ∑_s ∈ C_j(D,y) p_s(y) 
       < pt(D, j, y) [ ∑_s ∈ C_j(D,y) p_s(y) + p_d'(y) ]  
       = pt(D, j, y) ∑_s ∈ C_j(D',y) p_s(y) 
       ≤pt(D', j, y) ∑_s ∈ C_j(D',y) p_s(y) 
       = q(D', j, y)  ,

	given that p_d'(y) > 0 and pt(D', j, y) ≥pt(D, j, y) (Lemma <ref>).
	
	Now, if |C_j(D, y)| < t, then:
	
    q(D', j, y)    = pt(D', j, y) ∑_s ∈ C_j(D',y) p_s(y) 
       ≤ e^-ε_0 (k - t)∑_s ∈ C_j(D',y) p_s(y) 
       ≤ t  e^-ε_0 (k - t) ,

	given that |C_j(D', y)| ≤ t and p_d(y) ≤ 1 for any d. Here, the first inequality follows from the fact that pt(D', j, y) = L ≥ k - |C_j(D',y)|≤L ≥ k - t = 1/2 e^-ε_0 (k - t).
	
	If |C_j(D, y)| ≥ t, we have:
	
    q(D', j, y)    = pt(D', j, y)  ∑_s ∈ C_j(D',y) p_s(y) 
       = pt(D', j, y)  [ ∑_s ∈ C_j(D,y) p_s(y) + p_d'(y) ] 
       ≤ e^ε_0 pt(D, j, y)  [ ∑_s ∈ C_j(D,y) p_s(y) + p_d'(y) ] 
       ≤ e^ε_0 [1 + γ/t]  pt(D, j, y) ∑_s ∈ C_j(D,y) p_s(y) 
       = e^ε_0 [1 + γ/t]  q(D, j, y)  ,

	given Lemma <ref> and the fact that p_d'(y) ≤γ p_s(y) for any s ∈ C_j(D,y) and so p_d'(y) ≤γ/t∑_s ∈ C_j(D,y)  p_s(y).






The following Lemma is the core result underlying Theorem <ref>.


Let ℱ denote Mechanism <ref> with the (randomized) Privacy Test <ref> and parameters k ≥ 1, γ > 1, and ε_0 > 0. Take any dataset D with |D| ≥ k and let D' = D ∪{d'} for any d' ∈𝒰. Then for any integer 1 ≤ t < k and synthetic record y ∈𝒰, we have:
	
	
    ℱ(D) = y≤ e^εℱ(D') = y ,

	and
	
    ℱ(D') = y≤ e^εℱ(D) = y + δ ,

	where δ = δ(D', d', y) ≤ e^-ε_0 (k-t) and ε = ε_0 + ln(1+γ/t). Here, δ(D',d',y) = e^-ε_0 (k - t) |D'|^-1∑_s ∈ C_j(D',y) p_s(y), with j = I_d'(y).
	



	Fix an arbitrary synthetic record y ∈𝒰 and an arbitrary dataset D with |D| ≥ k. Let D' = D ∪{ d' } for some arbitrary d' ∈𝒰. Applying Lemma <ref> to D we have: ℱ(D) = y = 1/|D|∑_i ≥ 0 q(D, i, y).
	Also, from Corollary <ref> we have q(D, i, y) ≤ q(D', i, y) for all i. Thus: 
	
	
    ℱ(D) = y   = 1/|D|∑_i ≥ 0 q(D, i, y) 
       ≤1/|D|∑_i ≥ 0 q(D', i, y) 
       = |D'|/|D|ℱ(D') = y
       ≤( 1 + 1/k)  ℱ(D') = y .

	Observe that since (by assumption) γ > 1 and 1 ≤ t ≤ k, we have: 1/k≤1/t, and so 1+1/k < 1 + γ/t≤ e^ε_0 (1 + γ/t) = e^ε. This shows the first part.
	
	For the second part, apply Lemma <ref> to D', and let j be the partition number of d', i.e., j = I_d'(y). We have:
	
	
    ℱ(D') = y   = 1/|D'|∑_i ≥ 0 q(D', i, y) 
       = 1/|D'|[ ∑_i ≥ 0 : i ≠ j q(D', i, y) + q(D', j, y)  ] 
       = 1/|D'|∑_i ≥ 0 : i ≠ j q(D, i, y) + q(D', j, y)/|D'| .

	The last equality follows from Lemma <ref> part (a).
	
	Applying Lemma <ref> part (b), we obtain two cases.
	
		
  * Case 1: |C_j(D, y)| < t. 
			We have:
			
			
    ℱ(D') = y   = 1/|D'|∑_i ≥ 0 : i ≠ j q(D, i, y) + q(D', j, y)/|D'|
       ≤1/|D'|∑_i ≥ 0 : i ≠ j q(D, i, y) + δ(D',j,y)  
       ≤1/|D'|∑_i ≥ 0 q(D, i, y) + δ(D',j,y) 
       = |D|/|D'|ℱ(D) = y + δ(D',j,y) 
       ≤ℱ(D) = y + δ ,
 
			where δ(D',j,y) = 1/|D'| e^-ε_0 (k - t)∑_s ∈ C_j(D',y) p_s(y).
		
		
  * Case 2: |C_j(D, y)| ≥ t. 
			We have:
			
			
    ℱ(D') = y
       = 1/|D'|[ ∑_i ≥ 0 : i ≠ j q(D, i, y) + q(D', j, y) ] 
       ≤1/|D'|[ ∑_i ≥ 0 : i ≠ j q(D, i, y) +  e^ε_0[1 + γ/t] q(D, j, y) ] 
       ≤ e^ε_0[1 + γ/t] 1/|D'|∑_i ≥ 0 q(D, i, y) 
       = e^ε_0[1 + γ/t] |D|/|D'|ℱ(D) = y
       ≤ e^εℱ(D) = y ,

			for ε = ε_0 + ln(1 + γ/t) given that |D|/|D'| < 1.
		
	
	
	Letting δ(D',d',y) = δ(D',I_d'(y),y) finishes the proof.



With this, we are in a position to prove Theorem <ref>.


	Fix dataset D with |D| ≥ k and any record d' ∈𝒰. Let D' = D ∪{d'}. The range of ℱ is 𝒰 and so any outcome Y is a non-empty subset of 𝒰. Fix an arbitrary Y ⊆𝒰 with Y ≠∅. 
	
	We will show that F(D_1) ∈ Y≤ e^εF(D_2) ∈ Y + δ, whether D_1 = D and D_2 = D', or D_1 = D' and D_2 = D.
	
	Consider first the case D_1 = D and D_2 = D'. Applying Lemma <ref>, we obtain:
	
	
    ℱ(D) ∈ Y   = ∑_y ∈ Yℱ(D) = y
       ≤∑_y ∈ Y e^εℱ(D') = y
       = e^εℱ(D') ∈ Y .

	
	Now, consider the case D_1 = D' and D_2 = D. Define c(d',y) = |C_I_d'(y)(D, y)|. Given d', we can partition Y between those y ∈ Y such that the partition in which d' falls has at least t and those such that the partition has less than t. That is, Y = Y_t-∪ Y_t+, with Y_t- = { y : y ∈ Y, c(d',y) < t } and Y_t+ = { y : y ∈ Y, c(d',y) ≥ t }. We have:
	
	
    ℱ(D') ∈ Y   = ∑_y ∈ Yℱ(D') = y
       ≤∑_y ∈ Y_t+  e^εℱ(D) = y
       + ∑_y ∈ Y_t-  [ e^εℱ(D) = y + δ(D', I_d'(y), y) ] 
       = e^ε∑_y ∈ Yℱ(D) = y +  ∑_y ∈ Y_t-δ(D', d', y) 
       = e^εℱ(D) ∈ Y + ∑_y ∈ Y_t-δ(D', d', y)  ,

	where the inequality applies cases of Lemmas <ref> and <ref> separately to each y depending on whether y ∈ Y_t- (case 1 in the proof of Lemma <ref>) and y ∈ Y_t+ (case 2 in the proof of Lemma <ref>).
	
	It remains to show that ∑_y ∈ Y_t-δ(D', d', y) ≤ e^-ε_0 (k - t). For this define C(D', d', y) = C_I_d'(y)(D', y). We have:
	
	
    ∑_y ∈ Y_t-δ(D', d', y)    = ∑_y ∈ Y_t-e^-ε_0 (k - t)/|D'|∑_s ∈ C(D', d', y) p_s(y) 
       = e^-ε_0 (k - t)/|D'|∑_s ∈ D'∑_y ∈ Y_t-1_I_d'(y) = I_s(y) p_s(y) 
       ≤ e^-ε_0 (k - t) ,

	given that ∑_y ∈ Y_t-1_I_d'(y) = I_s(y)  p_s(y) ≤∑_y ∈𝒰 p_s(y) ≤ 1 for all s ∈ D'.
	




