WorksComputer Science
Distributed and Private Textual Data Synthesis from Embeddings
Abstract
We revisit differentially private (DP) text synthesis in the realistic setting of distributed users, where privacy concerns preclude a trusted curator with access to raw user texts. Existing DP text synthesis pipelines are designed for a trusted, centralized curator and often cannot be deployed in distributed settings due to unrealistic trust and access assumptions; when adapted naively, they require repeated, tightly synchronized user participation and incur significant overhead. To address this gap, we propose a DP–cryptography co-design for textual data synthesis that requires no trusted curator and requires only lightweight user participation. Our approach has two optimized components. First, we design a distributed-friendly DP synthesis algorithm that releases a one-time DP summary in an embedding space: it identifies frequent semantic regions and releases their DP centroids, enabling training-free, non-iterative offline text synthesis. We further introduce semantic support protection, which ensures the released summary avoids semantic neighborhoods of infrequent texts, reducing the risk of exposing rare user data. Second, we develop a custom secure protocol that implements this algorithm over distributed user data, enforcing end-to-end DP guarantees without requiring a trusted curator. On four benchmarks, we achieve utility comparable to the state-of-the-art centralized DP synthesis method.
Introduction
Users generate massive volumes of text on their devices [8, 9, 22, 26, 29, 52, 62, 92, 116]. These texts contain valuable insights into user needs and preferences as well as failure modes of deployed systems. However, collecting and analyzing raw user text poses significant privacy risks [10, 11, 25, 38, 54, 93, 99] as texts inherently contain sensitive information.
Differentially private (DP) text synthesis [49, 68, 96] is a promising approach to obtain population-level insights from user texts. DP [41] offers a robust, worst-case privacy guarantee for individual data against strong adversaries. In the ideal workflow, one releases a synthetic textual dataset generated under DP; the synthetic data can then be used for diverse downstream tasks such as data mining or model training without incurring additional privacy risks [74, ?, 113].
Most existing DP text synthesis methods are proposed in the centralized setting and typically adopt the following paradigms: (i) DP fine-tuning: Fine-tuning a generative language model (LM) with DP-SGD [1] or its variants on private texts, then sample synthetic texts from the fine-tuned model [19, 46, 113]; (ii) API-based private evolution: Iteratively refining synthetic text candidates generated from public LLM APIs using feedbacks from private texts [31, 110]. Such paradigms suffer from four main drawbacks.
(1) Trusted curator assumption. These approaches are designed for settings with a trusted curator that holds the full dataset [19, 31, 46, 110, 113]. In practice, user texts are often distributed and users may not trust a centralized curator with their sensitive data, as evidenced by recent data misuse and technical failures [11, 93].
(2) Repeated user participation in distributed deployments. When private texts originate from cross-device populations, straightforward deployments of iterative synthesis pipelines become multi-round protocols that require repeated user participation and synchronization [47, 55, 56, 110]. Such interactions are often misaligned with cross-device reality, where device availability is intermittent and communication is expensive [20, 70, 73, 83]. These constraints are worsened under DP due to the need for sufficient participation per round to offset noise and maintain utility [36, 65].
(3) Expensive computation and restrictive assumptions. DP fine-tuning methods require access to gradients (and often to model parameters) [19, 46, 47, 56, 113], whereas many capable models are available only through APIs. Even when gradients are available, DP fine-tuning can be prohibitively costly due to gradient computation and communication [57, 61, 65, 74, 75, 101, 112]. On the other hand, even though API-based private evolution methods do not compute gradients, they can still be costly—e.g., Aug-PE [110] generates thousands of candidate texts per iteration and broadcasts them to every participating user, who must compute nearest-neighbour distances in an embedding space and return a DP vote, blocking the next iteration, which can take hours across tens of iterations. Moreover, existing approaches often rely on publicly available labels [110, 113] or metadata information for private texts, which are frequently unavailable or too expensive/sensitive to obtain.
(4) Limited protection. Finally, standard DP ensures on the plausible deniability of membership information [42, 109], but does not explicitly prevent outputs from lying near a particular infrequent user data in the embedding space. This can be undesirable, motivating an additional protection tailored to text synthesis.
Our Contributions
We address the aforementioned gaps through a holistic approach. We design a DP text synthesis algorithm tailored to the distributed setting, alongside a customized secure computation protocol.
Our algorithm constructs a DP summary via two steps without any costly model fine-tuning: (i) identifying frequent semantic regions in the embedding space, and (ii) summarising embeddings within those regions into a privacy-preserving aggregated embedding called DP centroids. This DP summary can be post-processed to produce synthetic texts without further privacy loss.
For step (i), we use the Johnson–Lindenstrauss projection followed by randomized grid bucketing as a one-shot, training-free distributed clustering, replacing the existing iterative pipelines. For step (ii), we derive a probabilistic sensitivity bound from data-independent randomness, which lets us calibrate DP noise to a high-probability radius inside each frequent bucket, with the failure event absorbed into the term of the overall DP guarantee.
Beyond standard DP, we formalize semantic support protection. This privacy notion strengthens protection for semantically infrequent user texts by ensuring that, with a high probability, the algorithm output avoids regions near infrequent texts in the embedding space (see Section 2.2 for details). We provide theoretical analysis and empirical validation of this property. We emphasize that DP does not directly lead to/violate semantic support protection.
We develop a secure distributed implementation of our algorithm in Section 6. Our inherently distributed-friendly DP algorithm supports local computation and requires only two phases of user participation. At a high level, each user locally maps their text to an index via sequential embedding, projection, and partitioning, and then shares the encrypted index, with some probability. After users estimate the frequency of their texts, they perform secure, perturbed aggregation of text embeddings associated within the same heavy-hitting group of semantically similar embeddings. The resulting DP centroids enable subsequent text synthesis entirely offline while avoiding model fine-tuning, additional user participation, and further privacy cost. We summarize our contributions as follows.
(1) New DP algorithm. We propose a new training-free DP synthesis algorithm based on a DP summary in an embedding space.
(2) New privacy notion. We introduce semantic support protection, which complements DP by limiting proximity to semantically infrequent user texts in the embedding space, and provide theoretical and empirical evidence for this property.
(3) Distributed-friendly algorithm design. We show that the core computations of the algorithm are simple aggregations admitting an efficient distributed implementation with only two phases of user participation. We do not claim new cryptography protocols.
(4) High utility. We comprehensively evaluate our approach using four datasets, most of which are not associated with publicly available labels or metadata information. Our algorithm achieves utility comparable to the state-of-the-art centralized DP baseline, while offering superior flexibility for deployment in distributed environments and stronger protection for infrequent texts.
Problem Definition
We study differentially private text synthesis. Let be a dataset of texts in which is the single text held by user on their own device. Our goal is to release a high-utility synthetic textual dataset while protecting user-level privacy.
We target settings in which no single party may hold the raw texts: there is no trusted curator that collects user texts off-device.
Instead, we assume there are two servers that do not collude. We name the two servers based on their roles: (i) The tagging server assists users in encoding their reports into a random identifier, so that equal inputs receive equal identifiers, without itself learning either the inputs or the identifier. (ii) The synthesis server receives the encoded user reports, which is then used to produce a DP summary of users, and derives the synthetic texts from it. Section 6.2 explains the two roles concretely.
Threat model. All parties, including both servers and all users, are honest-but-curious: they follow the protocol but may try to infer information about other users’ texts from their views. Neither server is trusted with any user’s text or embedding vector. A user communicates with servers in at most two short phases and never communicate with another user. We discuss potential extensions to malicious settings in Appendix D.
The servers and do not collude. It is a common assumption in two-server deployments [12, 14, 18, 35, 64, 87, 98] which can be supported by separate operators or collusion cost due to legal and regulatory constraints [5, 60, 72]. Every message a user/server sends to a server/user is through an anonymizing proxy, which was also used in prior work [14, 16, 21, 43, 64, 98].
We assume that both users and servers have black-box access to an embedding model that maps a text to a -dimensional embedding vector, with fixed. In particular, maps semantically similar texts to nearby vectors. Access to such a semantics-preserving embedding model was also assumed in prior work [110].
We treat the raw private text as a whole piece of user information to protect. We do not assume any publicly available label information associated with that can be used for free, such as domain/category labels for user reviews [55, 56, 110, 113]. We also do not assume that there is a trained model that extracts metadata information of the user data [31], since such data may be sensitive and are not used for any model training.
Differential Privacy Requirement
Differential privacy (DP) [41] is commonly regarded as the gold privacy standard for data synthesis [2, 49, 68, 96].
Definition 1 (Differential Privacy [41]). Let be a randomized algorithm with output domain . Then satisfies DP if, for any neighboring datasets and , the probability distributions of and are similar as quantified by and , i.e.,
Here, and are neighboring datasets if one can be obtained from the other by adding or deleting a single record (i.e., a single text).
DP provides plausible deniability for the membership of any user text: with or without it, the output distribution is similar. Smaller and correspond to stronger privacy protection; and vice versa. Every parameter of the DP mechanism we propose, including the randomness it used, is public unless otherwise stated. Such randomness is fixed before any user input and is known to the DP adversary. The probability of an unfavorable draw is absorbed into .
Semantic Support Protection (SSP)
DP does not preclude the mechanism from emitting outputs that are close to a unique or rare user text in the embedding space. The output of a DP mechanism can appear close to an infrequent user text, which may violate user expectations and can be undesirable [3, 109]. This motivates us to consider an additional protection tailored to text synthesis, named semantic support protection. The aim is to prevent a DP mechanism from emitting outputs near semantically infrequent texts except with small probability. We first define semantically infrequent texts.
Definition 2 (()-Semantically Infrequent). Given and positive integer , textual dataset , and embedding model , we say a data point is -semantically infrequent (for and ) if fewer than data points from are within distance of in the embedding space:
We denote the set of -semantically infrequent and frequent texts in as and , respectively.
Definition 3 ((-Semantic Support Protection). Let be an -DP mechanism that outputs a set of texts . We say that satisfies -semantic support protection (SSP) if for any -semantically infrequent ,
where , and is the failure probability.
Difference from DP, LDP, and metric-DP. This definition provides an additional privacy layer beyond DP [41] and local DP [66] by explicitly limiting the probability that released outputs lie within radius of any semantically infrequent input in the embedding space. As we will see in Figure 4, a standard DP method for text synthesis such as Aug-PE [110] does not automatically achieve SSP. Indeed, DP or LDP permits events such as “the output lies close to an infrequent input text” to occur with non-negligible probability as long as the probability ratio under neighboring datasets is bounded. SSP explicitly complements this limitation. Metric-LDP [6, 45, 76, 84] guarantees that outputs cannot distinguish embeddings that are close in metric, such as the distance measured on the embedding space. Similar to DP and LDP, metric-LDP does not explicitly bound the probability of emitting a value near a rare user input.

Figure 4. Empirical semantic support protection. Probability (lower is better) that an infrequent text has a neighbor among the synthetic texts within distance where sweeps in . Lighter and darker colors show results on -infrequent texts with and , respectively.
At first sight, requiring the released output to avoid a neighbourhood of an infrequent input may look like it could distinguish the dataset that contains from the neighbourhood that does not. The key observation is that: if is -infrequent in then it is at least -infrequent in , and conversely a point that is infrequent under remains infrequent under . Definition 3 therefore applies to the same under both and , and the neighbourhood location is never released.
Simplified definition. Setting , we obtain the following simplified SSP.
Definition 4 ((-Semantic Support Protection). Mechanism satisfies -SSP if for any ,
Related Work
As we have mentioned in Section 1, DP text synthesis has been studied primarily in the centralized setting with a trusted curator holding the full private dataset [19, 31, 46, 78, 110, 113]. Adapting the existing paradigms to distributed settings has been explored in recent work, but existing solutions typically retain at least one of the following requirements: gradient/parameter access to an LM for training, publicly available labels/categories for private texts, or multi-round synchronized user and server participation. For example, methods that update or optimize models using user feedback, such as POPri [56] and federated DP fine-tuning variants [47], require gradient access and repeated rounds with tight synchronization between users and the server. Similarly, distributed adaptations of private evolution [55] require users to repeatedly process server-provided public candidates and return DP-perturbed signals in each round. Such designs can be difficult to scale in cross-device environments, where user availability is intermittent and communication is costly [20, 70, 73, 83], and these constraints are further amplified under DP due to the need for sufficient participation per round to offset noise [36, 65].
A complementary line of work directly perturbs token, sentence, or document embeddings under metric-LDP (also called -privacy), so that the indistinguishability guarantee scales with a distance in embedding space rather than being uniform across all pairs [45, 69, 82, 84]. We target the standard text-level -DP rather than a distance-scaled guarantee.
Beyond formal DP mechanisms, recent works have explored privacy-preserving analysis of user text corpora via layered, non-DP protections. For example, Clio [104] uses LLM-based summarization and embedding-based clustering to surface aggregated usage patterns, and then applies multiple privacy layers such as PII-avoiding prompts and automated auditing to reduce exposure of private information. Clio focuses on the output utility rather than worst-case privacy guarantees such as DP, making it prone to attacks [7]. There are also some other work in the literature, e.g., secret protection [51, 108], privacy with respect to sensitive references [106], and control codes [117]. These methods often rely on assumptions about sensitive information and prior knowledge regarding the data distribution, and sometimes the computation power of an adversary.
Synthesizing Texts via Frequent Embeddings
We present our DP algorithm for synthesizing texts, named Fre-E2T. Fre-E2T achieves formal differential privacy guarantees for individual texts (Definition 1) and also provide semantic support protection for infrequent texts (Definition 3). Section 6 gives the two-server protocol that realizes the functionality of Fre-E2T under the threat model introduced in Section 2.
To reduce the number of traversals on input and therefore enable a lightweight distributed implementation, we first sketch the user texts as a summary, and then synthesize texts from the summary.
Clustering embedding vectors. A canonical method for summarizing data is clustering [79, 81, 111]. In clustering, similar data points are grouped together based on some measure. Such a group of data points is referred to as a cluster. The goal of clustering is to find representative structures to summarize the input dataset. A common approach for accomplishing that is to ensure that each input data point lies within a ball of some radius centered at a centroid, the Euclidean average of all points within the same cluster. We could apply this approach to text embeddings and obtain cluster centroids for input texts.
Inverting embeddings to texts. For each centroid (a vector in ), we can then use a function/model that inverts embedding vectors into textual data [80, 88] to generate high-utility synthetic texts. Intuitively, if each centroid is near some data points, then the texts synthesized from the centroid should also bear similarity to the original texts corresponding to those data points.
Technical Challenges. Existing DP clustering methods generally rely on an iterative approach to refine centroids, based on their distances from each data point : each iteration traverses the whole dataset in order to evaluate the distances from each data point to all the centroids, followed by updating the centroids to maximize the overall utility [17, 90, 94, 100]. To build a more distributed-friendly algorithm, we avoid such iterative updates and computing pairwise distances between data points, which would require user-user communication in the distributed setting. Furthermore, when computing the centroid for each cluster, standard worst-case DP analysis [1] requires an additive random noise whose scale is proportional to the maximum norm of any data point, which is not ideal. Intuitively, we should be able to utilize the structural information of clusters to reduce the amount of noise needed for DP.
The Complete Algorithm
Our algorithm named Fre-E2T (Frequent Embedding to Text) consists of four sequential steps, presented as Algorithm 1 and Figure 1.

Figure 1. Overall idea of Fre-E2T, illustrated in the centralized setting.
Step 1: Projection and Partitioning. We first obtain the embedding vector for each text. Each embedding vector is obtained via an embedding function . The entire matrix of embedding vectors is written as . Next, we project each vector to , by computing . Here, is a random matrix where each entry is sampled independently from the standard Gaussian distribution. Pairwise distances are preserved up to a small multiplicative distortion with high probability for Gaussian projectors, when is large enough, by the Johnson Lindenstrauss Lemma [33, 63]. In other words, two records are close in if and only if their originals are close in . As a result, data points with a high support in their neighborhood in will still have a high support in . The Euclidean average of data points in the same cluster can thus serve as a good representation of them and frequent texts will be placed in a cluster with many close neighbors.
To group nearby projected points without computing all pairwise distances, we partition the -dimensional space into “buckets.” To do that, we first discretize with a randomly shifted grid of edge length . In particular, for each coordinate , a public random offset is sampled from . The grid boundaries are placed at for all . The -dimensional bucket index for user is the integer vector , with . We refer to Figure 6 for an illustration. is then randomly permuted to obtain . Vectors that are close to each other in are likely to end up with the same index before and after the permutation; and vice versa [34, 53, 59].

Figure 6. Partitioning the -dimensional space with a fixed edge length and random offsets.
The edge length is fixed a priori as a public design parameter of the protocol. Choosing controls the granularity of the partitioning and clustering: a smaller yields finer buckets, making it less likely that two nearby points fall into the same bucket (thus producing more, smaller clusters), while a larger coarsens the grid and increases the probability that points which are potentially farther apart in collide in the same -dimensional bucket. As we will see later, also influences the privacy guarantees. Consequently, the appropriate choice of is application-dependent and should be guided by the desired trade-off between resolution and the privacy protection for user texts.
Step 2: DP heavy hitters. With the buckets assigned, we then count the number of data points in each bucket. For each data point, we flip a coin to decide whether it contributes to the corresponding bucket and filter out buckets with counts . This sample-and-threshold process separates heavy-hitting bucket indices from those that have not accumulated enough counts while introducing enough randomness to ensure DP [15] and also has an efficient distributed implementation [98]. Our design has avoided injecting random noises to each user’s embedding vector directly as in local DP [44, 66], which would introduce a large perturbation to the results, compromising utility.
Step 3: DP Centroid computation. Now that we have identified the “heavy-hitting buckets”, we can then compute the average of the original data points within each of these buckets in . In particular, each text that has contributed to a heavy-hitting bucket index (with coin) contributes to the vector sum; those that are not sampled during the last step are not counted. Additive random Gaussian noise is injected to the sum. For DP analysis, we avoid considering the worst-case sensitivity of the vector sum, which is the radius of the whole -dimensional space. Instead, we rely on the crucial property that only data points that are close to each other can reside in the same cluster, except with a small error probability. Therefore, we only need to inject DP noise that is proportional to the radius of the cluster rather than the whole space.
Step 4: Embedding to text conversions. Finally, from the centroids of each heavy-hitting bucket, we invert it to obtain synthesized texts. DP is preserved under post-processing [41].
Algorithm 1: Fre-E2T
Input: Text entries ; embedding function ; random projection matrix ; bucket edge length ; random offsets ; random hash function ; subsampling rate ; threshold ; noise scale .
Initialize , ,
Projection and Partitioning
for do
Compute embedding
Compute projection
Identify bucket index based on , ,
Randomly permute .
DP Heavy Hitters
for do
if is 1 then
Add to bucket
for each bucket index in do
Count
if then
Remove bucket index from
DP Centroid Computation
for each bucket index in do
Compute sum
Compute
Add to
Embedding to Text Conversion
for each centroid in do
Synthesize text
Output
Privacy Analysis
Differential Privacy Guarantees
Privacy loss comes from two components, identifying heavy hitting buckets and computing the centroid within each heavy hitting bucket. Without loss of generality, we work on the matrix of embedding vectors, written as . The -th row of is associated with text . We consider a neighboring input such that has an additional embedding vector . We condition on the event that inputs and work with the same projection matrix and the same hash function . We let the permuted bucket index of be .
Heavy Hitters. For the truncated heavy hitter histogram, it suffices to analyze the count of index , when it reaches threshold .
Lemma 1 (Sample-and-threshold privacy [15]). With and , the heavy hitter histogram in Alg. 1 satisfies -DP with
The sum of all random contributions of , denoted as , therefore follows the Bernoulli distribution , where is the overall number of users with index . For its neighboring dataset, this distribution becomes . Lemma 1 bounds this divergence, with a high probability.
Choosing . The threshold is a public parameter that controls which buckets are declared heavy hitters. We set , so that in expectation a bucket with strictly fewer than neighbors within distance contributes at most sampled submissions and is therefore filtered out. Larger leads to fewer heavy hitting buckets and smaller via Lemma 1.
Heavy Hitting Indices. The indices of heavy hitters correspond to frequent embedding vectors. These indices are conceptually close to labels of user texts (e.g., “Texas barbecue joints”), which were utilized in prior works [110, 113]. In our setting, such information is not publicly available beforehand. Here, the index of a heavy-hitting bucket index is conceptually similar and obtained in a privacy-preserving manner, albeit being less informative (since we cannot interpret the indices themselves).
Computing Centroids. Again, we consider any bucket with count . There are two cases. If the additional data point in , denoted as , is not added to the bucket (due to the zero outcome of the coin flip), then the privacy cost is 0. Otherwise, we need to analyze the privacy cost for releasing the sum of embedding vectors perturbed by the Gaussian noise. To do that, we need to first analyze the sensitivity of the sum of embedding vectors.
The worst-case sensitivity of a bucket’s embedding sum is the largest embedding norm, which is unbounded; adding noise scaled to it would destroy all utility. We instead use a probabilistic bound whose failure probability is paid in the final .
Lemma 2 (High-probability Sensitivity). Consider any bucket in the -dimensional projection space, with bucket edge length . It holds that the sensitivity for the sum of embedding vectors within the bucket is bounded by , with probability
We choose the sensitivity bound so that the coupled pair violates it has a small, negligible probability. Conditioned on its complement, Theorem 3 applies with sensitivity . Our default experiment setting with , , and (for any ) gives , a negligible share of the overall .
Proof sketch of Lemma 2. Consider neighboring inputs and condition on the added point being assigned to bucket . The sampled contributions to under and can be coupled so that they differ in a single replaced point that is assigned to the same bucket . The sum over bucket therefore changes by at most for two points that collide in all projected coordinates, and it suffices to bound the distance of same-bucket collisions. Let . Each projection coordinate is with independent , so the coordinate-wise gap is i.i.d. . Buckets have edge length per coordinate with an independent uniform random offset, so two points with gap share a cell in coordinate with probability
max. Taking the expectation over gives the per-coordinate collision probability and independence across the coordinates yields the statement. □
Theorem 3 (Gaussian mechanism). Let be the sensitivity for the vector sum and be the parameter of the Gaussian noise. The centroids in Alg. 1 satisfies -CDP, and -DP with
The overall DP guarantee comes from linear composition [42], and accounting for failure probability of sensitivity bound into .
Theorem 4 (Overall DP guarantee). With sensitivity , defined as in (7), and the parameters computed as in Lemma 1 and Theorem 3, Algorithm 2 satisfies -DP for
Semantic Support Protection
For any infrequent user embedding , there will not be any DP centroid such that is close to in terms of distance.
Theorem 5 (SSP by Alg. 1). For any such that there are at most data points from that has distance at most to in and any DP centroid with items subsampled into the cluster, we have with probability
where , and is the cumulative density function (cdf) of noncentral chi-squared distribution
Namely, Algorithm 1 satisfies semantic support protection for the DP centroids. This quickly converges to 0 as , and increases, when , , and are moderate and times some constant. We include text-level evaluation in Section 7, where additional error may come from the vector-to-text inversion process.
We sketch the proof (detailed in Appendix C). We condition on the high-probability good event “Within any bucket, there are at most data points that are close to and every two data points have distance at most ”. This can be proved using the fact that we cluster data points based on the distance together with a concentration argument [86]. Next, we can argue that for any DP centroid in Alg. 1, the corresponding cluster has many data points that are far from and these “far data points” are close to each other. Based on this, we can argue that the average of all data points’ embedding vectors in this cluster is far from , since the average is dominated by the majority data points that are far from . Finally,
injecting random DP noise to the centroid will not decrease its distance to by a significant margin. Note that we do not claim that existing solutions such as [110, 113] do not achieve similar guarantees. Nevertheless, working directly on the embedding space with explicit truncation for infrequent texts has made the proof easier.
Distributed Implementation
Algorithm 2 implements Algorithm 1 in the distributed environment, with threat model specified as in Section 2. We refer to Figure 5 in Appendix B for an illustration.

Figure 5. Overall idea of our algorithm in the distributed setting.
The implementation mainly makes use of three existing distributed protocols: (i) Verifiable oblivious pseudorandom function (VOPRF) [35]; (ii) distributed discrete Gaussian with secure aggregation (SecAgg) [21, 64] for differential privacy; and (iii) a standard shuffler-style channel that strips per-user identifiers from messages [16, 30, 35, 98]. We treat each of these as a black-box with the security guarantees inherited from the original papers.
Step 1: Local pre-processing. The local data pre-processing step is identical to the centralized setting, assuming that all users have access to the same embedding function and the same public randomness. In the end of this step, each user obtains a -dimensional bucket index for its embedded vector (line 8 of Algorithm 2).
Step 2: Distributed heavy hitter estimation. There is no trusted curator to directly process the bucket indices for finding heavy hitters. Instead, each user obliviously communicates with the tagging server to encrypt index into a random string (line 3 of Algorithm 2). User then flips a coin to decide whether to submit the encrypted string to the synthesis server (lines 4–6 of Algorithm 2). The synthesis server collects the encrypted indices from the users and computes a heavy-hitter histogram to identify frequent indices (lines 7–9 of Algorithm 2).
Step 3: Aggregation of frequent text embeddings. The synthesis server broadcasts the frequent encrypted indices to all users (line 10 of Algorithm 2). Every user who shares the same encrypted index and has submitted the index in the last phase proceeds to securely aggregate their original data embedding vectors in the -dimensional space with additive DP noise (lines 11–15 of Algorithm 2), obtaining a DP average for embedding vectors (i.e., a DP centroid for the cluster). For this phase, we need the two non-colluding servers, tagging server and synthesis server . The two servers can then combine their secret shares to reconstruct the noisy private centroid for each heavy hitting index (lines 16–19 of Algorithm 2). Note that only users who already submitted the encrypted index in Step 2 respond to the Step 3 broadcast for that index. The synthesis server therefore observes that “some set of anonymized endpoints share encrypted index ”, which is exactly the heavy-hitter event whose existence is already covered by the DP guarantee in Lemma 1.
Step 4: Offline post-processing. Finally, the synthesis server uses each perturbed centroid to synthesize new textual data by inverting it back to a token sequence using the Vec2Text algorithm [89]. This is post-processing and does not cost additional privacy budget.
Paraphrasing. In addition, one can also use open-sourced language models such as GPT-2 [95] to paraphrase the generated texts to improve the diversity of the generated texts—e.g., 10 times for each text inverted from a centroid. Inversion and paraphrasing steps
Algorithm 2: Differentially text synthesis (distributed version of Fre-E2T)
Input: $N$ users, each one of which holds a private textual data point $v_i$; public embedding function $E$; embedding dimension $d$; projected dimension $k$; public Gaussian matrix $Z \in \mathbb{R}^{d \times k}$; edge length $L$; public offsets $\{o_j\}_{j=1}^{k}$; tagging server $S_{\mathrm{tag}}$; synthesis server $S_{\mathrm{syn}}$; subsampling rate $p_s$; truncated shifted Laplace distribution $\operatorname{TSDLap}(\lambda,\gamma)$; heavy-hitter threshold $\tau$; Discrete Gaussian noise std $\sigma$ and quantization granularity $\beta$.
Output: Synthesized texts.
1 for User $i = 1,\ldots,N$ do
2 Compute the $k$-dimensional bucket index $b_i$ for $v_i$ using Local-Preprocess$(v_i)$ // done locally
3 Obtain $h_i$ using User-TaggingServer$(b_i)$ // interacting with the Tagging Server
4 Sample $\operatorname{coin}_i \in \{0,1\}$ with $p_s$ probability of 1 // done locally
5 if $\operatorname{coin}_i = 1$ then
6 Submit index $h_i$ to the synthesis Server
7 Dummy = Dummy-Data-Creation$(\tau,\operatorname{TSDLap}(\lambda,\gamma))$
8 Synthesis server receives ReceivedData = sampled$\{h_i\} \cup$ Dummy
9 Synthesis server filters out indices with counts smaller than $\tau$, obtaining index set $\mathcal{H}$ and corresponding counts $C$
10 Synthesis server broadcasts $\mathcal{H}$ and $C$ to all users
11 for User $i = 1,\ldots,N$ do
12 if $\operatorname{coin}_i = 1$ then
13 if $h_i \in \mathcal{H}$ then
14 Obtain $\tilde{x}_i = \operatorname{Discrete\text{-}Gaussian}(x_i,\sigma,\beta)$ // Locally perturb the embedding vector
15 Compute two secret shares $\tilde{x}_i[1]$ and $\tilde{x}_i[2]$ for $\tilde{x}_i$ and send to tagging server and synthesis server, respectively
16 for $h \in \mathcal{H}$ do
17 Tagging server and synthesis server reconstruct $\hat{x}^{(h)} = \frac{1}{\beta}\sum \tilde{x}_i$ with index $h$ $\tilde{x}_i$
18 Synthesis server computes centroid $\hat{x}^{(h)} \leftarrow \frac{1}{c^{(h)}}\cdot\hat{x}^{(h)}$ // $c^{(h)}$ is the count of index $h$
19 Generate text $\tilde{v}_h \leftarrow \operatorname{Invert}(\hat{x}_h)$
20 Output $\tilde{v}_h$
require no further involvement from the users and can be done completely offline on the server side. In addition, assuming that the language model used for paraphrasing is not trained on the user texts, this paraphrasing step also incurs no additional privacy cost. Step 1 and 4 are done completely on the user and server side, respectively. Next, we discuss the distributed Step 2 and 3 in details.
Distributed Heavy Hitter Estimation
The idea is similar to the recent Nebula system [98] for distributed heavy hitter estimation. Each user first communicates obliviously with the tagging server to obtain the encrypted index for its -dimensional bucket index (line 2 in Algorithm 2) while ensuring that the tagging server learns nothing about users’ bucket assignments. A Verifiable Oblivious PseudoRandom Function [35] is applied to hash the -dimensional bucket indices so that users in the same bucket obtain the same encrypted index without the tagging server noticing and no user-to-user communications (Algorithm 4 in Appendix B).
Next, user submits with probability to the synthesis server (lines 4-6 in Algorithm 2), who then computes the aggregate counts and filters out all the indices that have not accumulated to submissions from the users (lines 8-10 in Algorithm 2). This truncated histogram satisfies DP.
In addition to that, the non-frequent (encrypted) indices should also receive proper privacy protection, since they are observed by server . To that end, we follow [98] and introduce a dummy user who can send additional dummy indices to the server such that the non-frequent indices will also receive DP protection while preserving the correctness of the aggregation result (line 7 in Algorithm 2). Roughly speaking, if the number of dummy indices follows the truncated shifted discrete Laplace distribution (TSDLap), then the impact of an encrypted index is negligible compared with the dummy submission, ensuring DP. We refer to Definition 5 and Algorithm 5 in Appendix B for more details.
Distributed Centroid Computation
For each encrypted frequent index , each user who has submitted its index to the aggregate server in Step 2 examines : if it matches , then the user obtain a perturbed version for the embedding vector , written as , where is computed based on the target privacy budget and and the quantization factor , using the distributed discrete Gaussian mechanism [64]. Practical distributed DP protocols employ discrete noises [4, 24, 64] to reliably enforce privacy guarantees. However, we note that switching to discrete noises does not change the privacy–utility trade-off as long as the discretization granularity is not too coarse, according to [64], which is why we simulate with the continuous Gaussian noise in our experiments. We defer more technical details to Section 6.3 and Appendix B.
Next, the perturbed data points with the same frequent index are aggregated securely, then divided by the occurrence and the quantization parameter . Here, the DP guarantee is collectively contributed by the local discrete Gaussian noises generated by users with the same index . To perform the secure aggregation, we reuse the tagging server and synthesis server from heavy hitter estimation: each user computes two secret shares for her/his perturbed embedding vector and sends them to the servers. The secret shares are tagged by the encrypted index so that the servers can later combine them to reconstruct the overall sum, as is done in federated analytics [32, 103]. One may also consider using the implementations from [21, 50]. Note that we cannot use the anonymous channel to replace distributed DP protocol, since the shuffle-model amplification for vector sums attains meaningful guarantees only in restricted regimes [30]; while secret-shared aggregation reconstructs the exact noisy sum at any .
Deployment costs. Recall that we write for the number of users, for the embedding dimension, for the projection dimension, for the subsampling rate, for the heavy-hitter threshold, for the set of released buckets, and for the number of submissions that participate in the centroid phase. On the user side, it first embeds its own text once and projects it in time offline. The distributed protocol is one-shot: the heavy-hitter phase costs each user , and a user whose bucket is released spends a further for the rotation and for quantization, discrete-Gaussian noise and secret sharing. Per-user communication is upstream in the heavy-hitter phase and upstream if participating in the centroid phase, and downstream to receive the released bucket set. For the server side, the tagging server performs VOPRF evaluations and share accumulation, while the synthesis server performs tag counting, accumulation and reconstruction.
Party roles and observations. User performs all data-dependent computation on its own device: it embeds text , projects it, derives the bucket index , obtains the tag , draws its participation coin and its noise, and forms its two shares for DP centroid computation. It learns about other users only through the public release: the broadcast heavy-hitter histogram and the published centroids, both of which are differentially private results.
The tagging server issues the bucket tags obliviously, generates the dummy tags that pad the sub-threshold histogram (Algorithm 5), and contributes one of the two additive shares of every perturbed embedding, sending the per-bucket aggregate share.
The synthesis server collects the sampled tag reports, counts them, discards tags below the threshold , broadcasts heavy-hitting tags with their sampled counts, combines the two secret shares into the noisy per-bucket sum, and inverts the noisy centroids into synthetic text offline. Our privacy guarantee applies to the whole multiset of tags with their multiplicities and the DP centroids; therefore applies to every party.
Privacy in Distributed Settings
The privacy guarantees of the distributed implementation are largely similar to Algorithm 1. We highlight some differences.
Non-released indices in distributed heavy hitters. For each index that has accumulated user submissions, the synthesis server observes the encrypted version of its index, and the noisy count. To argue the privacy for such statistics, we note that the index itself carries no information, as it looks random to any computationally bounded adversary [85]. So, the problem becomes analyzing the privacy cost for releasing an anonymized histogram (sometimes referred to as the count-of-counts [23, 71]), which reports the number of indices that have a count of , for each . According to [14, 37, 98], injecting TSDLap() into the number of indices of each count satisfies -DP, which is exactly why we need to create dummy indices as in Alg. 5. The subsampling ratio of amplifies the privacy guarantee to -DP with
We can then obtain the following guarantee for all indices.
Lemma 6 (DP heavy hitter estimation). For any adversary who observes the broadcast heavy hitter histogram and the synthesis server who observes the counts of all indices (including dummies), Algorithm 2 satisfies -DP, where and are from Lemma 1; and are from (11).
Computing Centroids with Discrete Gaussian. The data preprocessing is not influenced by the distributed protocol. Hence, we can use the same sensitivity , with a high probability. Conditioned on this, we can apply the distributed discrete Gaussian mechanism (DDG) [64]. More concretely, the user first quantizes the embedding vector with parameter to an integer-valued vector in by multiplying the real vector by and then randomly rounding each coordinate to the nearest integer. We note that while some biases will appear due to rounding, they can be offset to a negligibly small influence on the final result if is small enough, according to [64]. Then, for each coordinate of the integer-valued vector, the user perturbs it with a discrete Gaussian noise independently, computes two secret shares for the perturbed vector, and then sends them to the synthesis server and the perturbation server along with the encrypted index, using the framework suggested in [32, 103]. During secure aggregation, the discrete Gaussian noises contributed by independent users will aggregate into a larger noise (of standard deviation at least ) to amplify the DP guarantee. After obtaining the aggregated result, the synthesis server will then multiply it by to obtain an estimation for the original vector sum. We give the privacy guarantee of DDG as follows for completeness. Details are in Appendix B.
Theorem 7 (Distributed discrete Gaussian [64]). Let be the quantization parameter and be the parameter of the local discrete Gaussian noise. Under the same assumption as Theorem 3, define
where , and is some constant; see Theorem 9 for more details. The perturbed sum of embedding vectors from Alg. 2 satisfies -CDP, and -DP with
Overall DP guarantee. The overall DP guarantee comes from linearly composing the parameters from Lemma 6 and Theorem 7, and accounting for failure probability of sensitivity bound into the final . Inverting centroids to texts costs no privacy. The only difference is that composition of parameters only occurs on the data points that appear in frequent buckets. Those data points that are not frequent do not participate in the release of DP sum of embedding vectors; hence, they compose in parallel [42].
Theorem 8 (Overall DP guarantee). With the parameters specified as in Lemma 1, Lemma 2, Lemma 6, and Theorem 7, and defined as in (7), Algorithm 2 satisfies -DP for any adversary with
Experiments
We demonstrate the utility of our algorithm and compare it with the state of the art [110]. Our goal is to show that our Fre-E2T achieves utility comparable to the strong centralized baseline under the same privacy constraints while being more distributed-friendly and offering additional protection for infrequent texts.
Datasets. Our experiments include four datasets containing user queries to search engines/LLMs: TaylorAI [105], Instructions-2M [89], LMSYS Chat [118], and Yelp [115]. See Appendix A for details.
Infrequent and frequent texts. Recall Section 2.2. We enforce additional privacy protection for infrequent user texts that have fewer than neighbors in its -neighborhood in the embedding space. Conversely, we say a text is frequent if it has more than neighbors in the -neighborhood. We take and , unless otherwise stated.
Baseline and implementation. We focus on the state-of-the-art baseline for DP text synthesis from the centralized setting, i.e., Aug-PE [110], and use it as the reference point for evaluating the utility of our distributed Fre-E2T. We omit other baselines as they achieve similar performance as [110], while some of them relying on additional gradient access to the LM [47, 56, 113]. Since we assume no label information is available before hand and some datasets such as [89, 105] do not have such information, we remove such information (if there is any) from the prompts for a fair comparison. We follow their setup and use Aug-PE’s published hyperparameters. We use GPT-2 [95] as the generator API for [110] and gtr-t5-base [91] as the embedding model. gtr-t5-base maps each text input into a 768-dimensional vector.
For our implementation, we simulate our algorithm on a single machine with 4 A100 GPUs. We use the same embedding model. For the projected dimension, we focus on unless otherwise stated. We set the heavy hitter threshold , where is the subsampling rate controlling the privacy budget for the heavy hitter release. We vary . Next, the Gaussian noise parameter for centroid computation is determined by the remaining privacy budget. Throughout we fix the overall and vary the overall . For , we run our Fre-E2T without any additional noise or privacy constraint. We leverage the open-sourced vec2text [88] to invert embeddings back to texts. This model contains 235M parameters. By default, the server uses vec2text to synthesize one text for each obtained DP centroid of embedding vectors. For our Fre-E2T, we also include a variant that uses GPT-2 to obtain more variations of each synthetic text generated from the released embedding vector, ensuring a fair comparison with Aug-PE. GPT-2 never touches the user data without affecting DP (see Section 6). To ensure a fair comparison, both Aug-PE and our Fre-E2T obtain 3000 texts in total.
Utility metrics. Given a synthetic dataset and the original private dataset , and constants and , we measure utility using three metrics that largely follow prior work [110, 113]: precision (higher is better), recall (higher is better), and average distance (lower is better). We also report F1 score, the harmonic mean of precision and recall. The main here difference is that we compute these metrics on semantically frequent texts, i.e., , since Definition 3 explicitly restricts outputs near semantically infrequent texts.
Here, a larger makes the neighborhood condition in Precision/Recall easier to satisfy. We fix throughout unless otherwise stated, giving a threshold .
Main Results
Precision and recall. We report the utility of our Fre-E2T under different privacy budgets in Table 1. Overall, the precision, recall, and F1 score increases as the privacy constraint increases from 4 to . Namely, as the privacy constraint loosens, the synthetic texts achieve higher utility. This trend is consistent across all four datasets. On TaylorAI, both Aug-PE [110] and our method achieve almost perfect precision and recall. On Instructions-2M and LMSYS Chat, our Fre-E2T achieves notable improvements. We attribute such differences to the datasets: TaylorAI and Yelp have long sequences, leading to embedding vectors of smaller norms in general, hence easier to synthesize due to a smaller space. Other datasets contain shorter sequences and are in general more difficult to obtain closer synthetic texts.
| Dataset | Fre-E2T (no GPT-2) Precision | Recall | F1 | Fre-E2T (GPT-2) Precision | Recall | F1 | Aug-PE (GPT-2) Precision | Recall | F1 | ||||
| TaylorAI | 4 | 0.31 | 0.92 | 0.47 | 0.82 | 1.00 | 0.98 | 0.99 | 0.41 | 0.99 | 0.99 | 0.99 | 0.40 |
| TaylorAI | 8 | 0.62 | 0.95 | 0.75 | 0.74 | 1.00 | 0.98 | 0.99 | 0.41 | 0.99 | 0.99 | 0.99 | 0.40 |
| TaylorAI | 16 | 0.82 | 0.97 | 0.88 | 0.68 | 1.00 | 0.98 | 0.99 | 0.41 | 0.98 | 0.99 | 0.99 | 0.40 |
| TaylorAI | 0.83 | 0.97 | 0.89 | 0.67 | 1.00 | 0.98 | 0.99 | 0.40 | 0.98 | 0.99 | 0.98 | 0.40 | |
| Instructions-2M | 4 | 0.25 | 0.32 | 0.28 | 0.92 | 0.97 | 0.71 | 0.82 | 0.61 | 0.98 | 0.60 | 0.75 | 0.84 |
| Instructions-2M | 8 | 0.38 | 0.34 | 0.36 | 0.80 | 0.97 | 0.74 | 0.84 | 0.57 | 0.98 | 0.60 | 0.75 | 0.83 |
| Instructions-2M | 16 | 0.56 | 0.37 | 0.45 | 0.71 | 0.98 | 0.76 | 0.86 | 0.54 | 0.99 | 0.59 | 0.74 | 0.84 |
| Instructions-2M | 0.69 | 0.39 | 0.50 | 0.62 | 0.99 | 0.79 | 0.88 | 0.54 | 0.99 | 0.60 | 0.75 | 0.83 | |
| LMSYS Chat | 4 | 0.31 | 0.74 | 0.43 | 0.92 | 0.96 | 0.82 | 0.89 | 0.73 | 0.92 | 0.80 | 0.86 | 0.86 |
| LMSYS Chat | 8 | 0.52 | 0.83 | 0.64 | 0.85 | 0.96 | 0.87 | 0.91 | 0.56 | 0.92 | 0.80 | 0.86 | 0.91 |
| LMSYS Chat | 16 | 0.75 | 0.86 | 0.80 | 0.69 | 0.97 | 0.88 | 0.92 | 0.53 | 0.90 | 0.81 | 0.85 | 0.89 |
| LMSYS Chat | 0.83 | 0.84 | 0.83 | 0.67 | 0.97 | 0.86 | 0.91 | 0.57 | 0.91 | 0.80 | 0.85 | 0.91 | |
| Yelp | 4 | 0.30 | 0.96 | 0.46 | 0.82 | 1.00 | 1.00 | 1.00 | 0.37 | 0.98 | 1.00 | 0.99 | 0.37 |
| Yelp | 8 | 0.65 | 1.00 | 0.76 | 0.72 | 1.00 | 1.00 | 1.00 | 0.37 | 0.94 | 1.00 | 0.97 | 0.37 |
| Yelp | 16 | 0.87 | 1.00 | 0.93 | 0.67 | 1.00 | 1.00 | 1.00 | 0.38 | 0.98 | 1.00 | 0.99 | 0.36 |
| Yelp | 0.97 | 1.00 | 0.98 | 0.64 | 1.00 | 1.00 | 1.00 | 0.37 | 0.95 | 1.00 | 0.97 | 0.37 |
Table 1. Precision, recall, F1 score, and distance (lower is better) across datasets for . denotes the non-DP setting. GPT-2 is used for paraphrasing by Fre-E2T and for generation and variation by Aug-PE.
Comparing the utility of Fre-E2T (no GPT-2) and Fre-E2T (GPT-2), we see that paraphrasing leads to higher utility. Utilizing stronger embedding models and corresponding vec2text reconstruction models will likely lead to further improvements. We leave that as a future work direction (discussed in Section 8).
distance. The distance metric of (17) is an absolute distance in embedding space. Here, we include two references using the same embedding model. The same-dataset reference replaces the synthetic set by 3000 texts drawn uniformly from the frequent subset and scores them against the remaining frequent texts, setting the lower bound. The unrelated reference instead draws 3000 texts uniformly from the other three datasets and scores them against the target corpus: demonstrating what the distance metric looks like when the released text is irrelevant with the data. On TaylorAI, Instructions-2M, LMSYS Chat, and Yelp, the same-dataset and unrelated references are 0.20 and 1.37, 0.12 and 1.42, 0.06 and 1.29, and 0.26 and 1.51, respectively. Both methods fall into the range set up by the two references on all four datasets.
On Instructions-2M and LMSYS Chat, Fre-E2T is closer to the real input texts than Aug-PE under every privacy budget. On TaylorAI and Yelp, the two are within 0.02 of each other and quite close to the lower bound. Aug-PE and Fre-E2T also differ in how they use the privacy budget. The distance of Fre-E2T falls monotonically with on all four datasets shown, whereas Aug-PE barely moves. Similar trends are observed in Table 1. We explain this next.
To further inspect the closeness between a synthetic text and a input private text, in Figure 2, we report histograms of the smallest distance from a frequent text (in blue) and an infrequent text (in red) to a synthetic text, with Instructions-2M dataset as the input. For private texts that are frequent, the distances to the nearest synthetic texts are smaller, compared with infrequent texts, which is aligned with our utility objective and the privacy framework of semantic support protection—texts that are infrequent in the input should not find close neighbors in the synthetic output. We observe similar trends on other datasets and omit them here.

Figure 2. The smallest distance from a frequent/infrequent text (blue/red) to a synthetic text on Instructions-2M.
We also group the frequent texts from Instructions-2M dataset by their number of neighbors within distance , and report the average distance to the closest synthetic text within each frequent-text group in Figure 3. The trend is similar: as the number of neighbors of a frequent text increases, the distance to its closest synthetic text decreases. This aligns with our algorithm design: for each heavy hitting bucket, the count of items in general increases as the number of neighbors for a frequent text therein increases. As we inject DP noises to the sum of embedding vectors, the DP noise averaged by the bucket count decreases as the count increases, leading to smaller distances.

Figure 3. Average distances to synthetic texts for frequent texts as a function of neighbor number on Instructions-2M.
Comparison with Aug-PE [110]. Aug-PE refines a population of candidate texts by having each private text vote for its nearest
candidate, releasing that vote histogram under DP, and asking a language model for variations of the candidates that receive more votes. When no label or category information is available, the histogram is the only signal connecting the candidate synthetic texts with the real inputs. It reports how many private texts lie near a candidate, but not which region of the input distribution that candidate should evolve towards. The variation step is therefore undirected and the population never separates into clusters matching the structure of the input data, so reducing the noise on the histogram only sharpens a signal that carries little directional information. That is what the flat trend of Aug-PE shows. The same insensitivity of text utility to the privacy budget is also observed in the original paper [110]. Fre-E2T supplies this missing structure: it clusters the frequent texts and generates each released text from one cluster centroid. This centroid is a soft label that tells what the texts therein is meant to represent in the embedding space. The privacy budget influences the accuracy of those centroids; hence, less noise translates directly into shorter distances and higher precision and recall.
Semantic support protection. Recall Definition 3, the parameters and control the strength of semantic support protection: larger and smaller impose stronger restrictions on the probability of outputs appearing near—i.e., within distance —semantically infrequent texts, which are defined by and (recall Definition 2). We empirically evaluate the level of from -Semantic Support Protection in Figure 4. We fix and vary for and from 10 to 100. We observe highly similar results on different ’s and report only for and 100. In TaylorAI and Yelp, we achieve perfect protections of infrequent texts (i.e., ) that vanish in the log-scale plot. Also, fixing (namely, ), Fre-E2T achieves a near under the simplified Definition 4 across all datasets. In general, the semantic support protection of our Fre-E2T is much stronger than Aug-PE [110], and sometimes by orders of magnitude.
In practice, we advise to set following Definition 4, with set to —a small failure probability that is also widely used in DP [1, 64]. Regarding , any value smaller than the reference distance from unrelated datasets makes sense. Here, we have chosen for an illustration. For , we recommend a negligible number compared with the population. Here, each dataset contains around 1 million records and we have chosen and 100.
More Results on Text Quality
Downstream utility. For dataset Yelp with labels, we train a classifier to rate the released texts, and evaluate on the official 50,000 test split, which is never used during synthesis. The task is five-way star prediction. We consider two ways of using the output of Fre-E2T. The first is directly operated on the released noisy centroids: a test review is embedded using the same model and classified by a majority vote over the nearest centroids released by Fre-E2T, across all 5 labels. We sweep and report the best result. The second uses the inverted texts from Fre-E2T to fine-tune the RoBERTa-base classifier, following the setup in [110]. For Fre-E2T, we paraphrase each text 5 times, obtaining around 3000 texts in total for each temperature. We also make Aug-PE output the same number of texts, to make it a fair comparison.
Table 2 reports the classification accuracy. The non-DP baseline fine-tuned on RoBERTa achieves accuracy of 0.63 while the random guessing baseline is 0.20. With , our method achieves competitive performance as directly obtained by Aug-PE. Notably, the difference between using the inverted texts and the centroids directly is not large, which confirms the utility of the DP centroids obtained by Fre-E2T. Still, there remains some gap to fill, and we conjecture that a better vector-to-text inverter could bridge this gap. We defer further discussions on the limitations and future work to Section 8.
| Method | ||||
| Fre-E2T: nearest centroid, | 0.35 | 0.45 | 0.46 | 0.47 |
| Fre-E2T: nearest centroid, best | 0.35 | 0.46 | 0.48 | 0.49 |
| Fre-E2T: RoBERTa (paraphrase ) | 0.32 | 0.44 | 0.46 | 0.48 |
| Fre-E2T: RoBERTa (paraphrase ) | 0.32 | 0.42 | 0.46 | 0.47 |
| Fre-E2T: RoBERTa (paraphrase ) | 0.30 | 0.45 | 0.47 | 0.51 |
| Aug-PE: RoBERTa (default ) | 0.49 | 0.51 | 0.52 | 0.52 |
| Non-DP: RoBERTa | 0.63 |
Table 2. Downstream classification accuracy on Yelp.
Diversity. Each cluster of Fre-E2T emits one text from the inversion model. However, diversity can be improved by paraphrasing and tuning the temperature of the paraphraser model (larger means more randomness and therefore higher diversity). In Table 2, we can see that the classification utility is largely unaffected by the paraphrasing temperature, which is aligned with [110]. Table 3 shows that higher temperature leads to better diversity, measured as the Self-BLEU (smaller is more diverse) per cluster, averaged over all clusters. Still, paraphrasing does not fully close the gap to real texts, since each cluster ultimately emits only one centroid based on the users’ contributions. We acknowledge this as a limitation.
| Temperature | Real | ||||
| 52.3 | 50.8 | 48.4 | 46.4 | ||
| 49.6 | 47.3 | 46.3 | 45.4 | 27.7 | |
| 47.5 | 44.1 | 42.1 | 41.7 |
Table 3. Diversity in BLEU score () of Fre-E2T under different temperatures for paraphrasing, evaluated on Yelp.
Perplexity. We also evaluate the released texts directly against matched-size random samples from the frequent subset of the original input, based on the perplexity score (smaller is more natural) computed from GPT-2. As we can see from Table 4, the average perplexity score of Fre-E2T improves monotonically as grows and approaches the real text samples. Note that the average metric can be affected by outliers. We show that most of the texts are deemed natural—namely, they have a low perplexity—in Appendix A.3 (see also the formal definition of perplexity).
| Dataset | Real | ||||
| TaylorAI | 196 | 125 | 74 | 51 | 22 |
| Instructions-2M | 95 | 42 | 26 | 26 | 57 |
| LMSYS Chat | 135 | 87 | 52 | 31 | 30 |
| Yelp | 184 | 90 | 51 | 34 | 27 |
Table 4. Average perplexity () of Fre-E2T evaluated with GPT-2.
Ablation Studies
We ablate each parameter of Fre-E2T on Instructions-2M and LMSYS Chat. Unless otherwise stated, parameters take their default values , , bucket edge , and we conduct experiments mostly on to observe a stable trend. Results are evaluated on text level, without GPT-2 paraphrasing, unless otherwise stated. Finally, we recall the couplings of the parameters: the heavy-hitter threshold enters the accounting only through , and the sensitivity bound is paid for with , so must be calibrated together with and .
Subsampling rate . At fixed , moves both terms of the budget: grows with , while shrinks with . Here, controls the budget split between the heavy hitter histogram and the centroid computation. The feasible region at overall is therefore bounded on both sides: exhausts the budget for every (). Inside the feasible region, the optimal is near 0.5, as Table 5 shows. For each we have chosen the budget split that minimizes the calibrated . The used for the main experiments is not that choice: at , raises F1 from 0.36 to 0.42 on Instructions-2M and from 0.64 to 0.71 on LMSYS Chat. We advise to choose as large as the budget allows and confirm that we did not specifically fine-tune the parameters of Fre-E2T to gain advantage over Aug-PE.
| F1 Instructions-2M | F1 LMSYS Chat | ||
| 0.15 | (5, 0.914) | 0.35 | 0.45 |
| 0.20 | (4, 0.873) | 0.33 | 0.51 |
| 0.30 | (3, 0.886) | 0.37 | 0.61 |
| 0.50 | (2, 0.923) | 0.42 | 0.71 |
| 0.70 | (2, 1.067) | 0.35 | 0.74 |
Table 5. Subsampling rate at and . Parameter is chosen to minimize the noise scale .
Bucket edge . We scale by with , which keeps the failure probability of sensitivity bound invariant. Accordingly, we re-calibrate , which is exactly proportional to . We list the values of in Table 12. The results are shown in Table 6. With differential privacy (), smaller buckets win consistently: halving halves the noise, and still there are enough buckets that reach the threshold . At , F1 score first increases and then decreases as the increases. This is because without noise, coarser buckets improves the recall while reducing the precision in general. The default in our main
| Dataset | ||||||
| 2 | Instructions-2M | 0.18 | 0.18 | 0.16 | 0.14 | 0.12 |
| 2 | LMSYS Chat | 0.34 | 0.29 | 0.24 | 0.24 | 0.25 |
| 8 | Instructions-2M | 0.41 | 0.37 | 0.35 | 0.29 | 0.28 |
| 8 | LMSYS Chat | 0.71 | 0.69 | 0.66 | 0.64 | 0.60 |
| Instructions-2M | 0.50 | 0.50 | 0.50 | 0.76 | 0.72 | |
| LMSYS Chat | 0.78 | 0.79 | 0.83 | 0.86 | 0.86 |
Table 6. F1 score under different bucket-edge scaled by multiplier .
| 0.5 | 0.75 | 1 | 1.5 | 2 | |
| 2 | 2.84 | 4.26 | 5.69 | 8.53 | 11.4 |
| 8 | 0.566 | 0.848 | 1.13 | 1.70 | 2.26 |
| 0 | 0 | 0 | 0 | 0 |
Table 12. Noise scale under different bucket-edge scaled by multiplier .
| Algorithm 6: User Procedure for distributed discrete Gaussian mechanism [64] | |
| Input: Vector . | |
| Parameters: Dimension ; sensitivity ; quantization granularity ; modulus ; noise scale ; bias ; a uniform random sign vector and a Walsh–Hadamard matrix that are shared among all parties. | |
| Output: for the secure aggregation protocol. | |
| 1 | |
| 2 | . |
| 3 | repeat |
| 4 | Draw from a product distribution such that and . |
| 5 | until |
| 6 | |
| 7 | Sample with independent coordinates for . |
| 8 | . |
Table 6.
setup is not fine-tuned to optimize our Fre-E2T, ensuring a fair comparison with Aug-PE.
Embedding model. We repeat the pipeline with another open-sourced embedding model gte-modernbert-base [114]. Since embedding normal scales are not comparable across different embedding families—gte has median norms while gtr has norms around –, so we transfer the radius by quantile matching. We choose that matches the quantile of nearest-neighbour distance distribution that produces under the gtr embedding. This gives on Instructions-2M and on LMSYS Chat. Since no public vector-to-text inverter exists for this embedding family, the results are evaluated at the centroid level, shown in Table 7.
| Dataset | gtr-t5-base Precision | gtr-t5-base Recall | gte-modernbert-base Precision | gte-modernbert-base Recall | |
| Instructions-2M | 2 | 0.29 | 0.39 | 0.30 | 0.65 |
| Instructions-2M | 8 | 1.00 | 0.47 | 1.00 | 0.81 |
| Instructions-2M | 1.00 | 0.48 | 1.00 | 0.82 | |
| LMSYS Chat | 2 | 0.03 | 0.82 | 0.09 | 0.40 |
| LMSYS Chat | 8 | 0.99 | 0.95 | 1.00 | 0.66 |
| LMSYS Chat | 0.99 | 0.95 | 0.99 | 0.67 |
Table 7. Utility with different embedding models, measured at the centroid level.
| Algorithm 7: Server Procedure [64] | |
| Input: Aggregated modulo sum obtained via secure aggregation. | |
| Parameters: Same as Algorithm 6. | |
| Output: | |
| 1 | Map coordinate-wise so that and . |
| 2 | Compute , where is diagonal with on the diagonal. |
Table 7.
Design Choices and Limitations
Fre-E2T essentially performs two tasks: identifying heavy hitting regions in the embedding space and inverting from the heavy hitters to synthetic texts. We first analyze the utility on the first task—identifying heavy hitting regions in the embedding space with DP. The first task is supported by two major technical components: random projection and partitioning and DP heavy hitter estimation, followed by the DP centroid computation.
Comparison with LDP mechanisms. For a clear reference, we evaluate two locally differentially private (LDP) baselines and a centralized-DP baseline. The first LDP baseline, named LDP (embedding), is to let each user release its text embedding vector with Gaussian noise injected [13]. Any post-processing on the noisy embeddings does not incur additional privacy cost [42]. The second LDP baseline, named LDP (OUE), is to replace the sample-and-threshold subroutine (lines 7–15 in Algorithm 1) with the OUE frequency estimation algorithm [107]. The rest follows: surviving buckets compute the noisy centroid with additive Gaussian noise with the remaining privacy budget. Here, we report the privacy budget split that maximizes utility.
The centralized DP baseline removes every distributed constraint while keeping the rest of the pipeline unchanged: a trusted curator observes all embeddings, releases each occupied bucket’s count with Gaussian noise and its embedding sum with Gaussian noise under the same probabilistic sensitivity bound as ours, then keeps the buckets whose noisy count exceeds . This baseline upper-bounds what any distributed realization of our pipeline can achieve.
Table 8 reports how well each mechanism identifies the heavy clusters in terms of precision and recall. The first LDP baseline identifies nothing at any : its local noise is , which is the same scale as the diameter of the whole embedding space, so no two users ever share a bucket and no cluster survives the threshold. The second fails for the same structural reason: the OUE count estimator’s noise is in , where is the number of users, which makes the heavy hitter histogram very noisy. As a result, the recall is only 3% and 14% for TaylorAI and Instructions-2M, respectively at . It reaches to about half at , and catches up with Fre-E2T only at . Fre-E2T, in contrast, identifies the heavy clusters with precision and recall above 0.90 at every .
| Method | TaylorAI Prec. | TaylorAI Rec. | Instructions-2M Prec. | Instructions-2M Rec. | |
| LDP (Embedding) | 4 | 0.00 | 0.00 | 0.00 | 0.00 |
| LDP (OUE) | 4 | 0.03 | 0.03 | 0.14 | 0.14 |
| Fre-E2T | 4 | 0.93 | 0.91 | 0.92 | 0.92 |
| Central-DP | 4 | 0.97 | 0.96 | 1.00 | 1.00 |
| LDP (Embedding) | 8 | 0.00 | 0.00 | 0.00 | 0.00 |
| LDP (OUE) | 8 | 0.51 | 0.52 | 0.56 | 0.57 |
| Fre-E2T | 8 | 0.94 | 0.95 | 0.95 | 0.98 |
| Central-DP | 8 | 0.98 | 0.98 | 1.00 | 1.00 |
| LDP (Embedding) | 16 | 0.00 | 0.00 | 0.00 | 0.00 |
| LDP (OUE) | 16 | 0.98 | 0.95 | 0.98 | 0.98 |
| Fre-E2T | 16 | 0.98 | 0.96 | 0.99 | 0.99 |
| Central-DP | 16 | 1.00 | 0.99 | 1.00 | 1.00 |
Table 8. Precision and recall measured at cluster level for heavy hitting clusters with .
These results justify our design. First, sample-and-threshold solves the identification task at almost no cost relative to a trusted curator. The LDP alternatives show the utility loss. Second, probabilistic sensitivity is what makes the centroid sums achieve high utility at all . A local randomizer must be indistinguishable over the entire input space, introducing large noises that are in the same scale of the space’s diameter, overwhelming useful information. Our release instead adds noise proportional to the probabilistic sensitivity.
Representativeness. Representativeness concerns which population the output speaks for. The released texts hold only 41% and 3.9% of the entire corpus, but 97% and 39% of the frequent subset of TaylorAI and 4.5% Instructions-2M, respectively, matching the numbers in Table 1. This is by our design, we filter out infrequent buckets to catch SPP while achieving high recall and precision for the frequent user texts.
Limitation and future work. We also identify a key limitation of our Fre-E2T. Table 9 scores the synthetic texts obtained after inversion for Fre-E2T. Comparing Tables 9 and 8, we can see that the embedding-to-text inversion, rather than the DP machinery, is the current bottleneck of Fre-E2T, as we observe a utility drop on the inverted text. In particular, for Instructions-2M dataset, when , the precision and recall dropped from 0.95 and 0.98 to 0.38 and 0.34.
| Method | TaylorAI Prec. | TaylorAI Rec. | Instructions-2M Prec. | Instructions-2M Rec. | |
| Fre-E2T | 4 | 0.31 | 0.92 | 0.25 | 0.32 |
| Central-DP | 4 | 0.72 | 0.97 | 0.48 | 0.37 |
| Fre-E2T | 8 | 0.62 | 0.95 | 0.38 | 0.34 |
| Central-DP | 8 | 0.83 | 0.97 | 0.62 | 0.38 |
| Fre-E2T | 16 | 0.82 | 0.97 | 0.56 | 0.37 |
| Central-DP | 16 | 0.86 | 0.97 | 0.62 | 0.38 |
Table 9. Precision and recall of the synthetic texts.
For the centralized DP method that uses the same inversion model, this drop is still substantial. At , Fre-E2T achieves almost the same utility as its centralized-DP version. This confirms that the utility drop is from the inverter [88] that we used as a black box, not the distributed constraints. It was also noted in [89] that even inverting from noiseless embeddings may not recover the perfect text. Overall, domain-adapted inverters and designs that capture the objectives of diversity and downstream task utility (recall Section 7.2) are therefore promising directions for improving the end-to-end quality of Fre-E2T.
Conclusion
We propose a lightweight distributed algorithm for synthesizing texts from distributed users. Our algorithm design does not rely on trusted servers, gradient/parameter access to LMs, iterative and tight user synchronization, or publicly available labels, addressing major limitations of the existing literature. Our method can also be implemented efficiently based on existing distributed protocols. Compared with the state of the art, our method achieves comparable and sometimes better utility across real-world datasets, with an extra layer of privacy protection for infrequent user data and better practicality in distributed settings.
Acknowledgments
We would like to thanks the reviewers and editors for their constructive feedbacks during the reviewing process.
Ethical Considerations
We have read and adhered to the PoPETs ethics guidelines and the Menlo Report and believe the work was conducted ethically. The work does not involve human subjects, sensitive user data, or system vulnerability disclosure; all experiments use publicly available benchmark datasets and openly released language models.
Stakeholders. The primary stakeholders are:
End users. Our protocol is designed so that distributed users can collectively contribute to a synthetic text corpus without any party, including the server that runs the protocol, observing their raw texts. Users benefit from formal -DP guarantees that protect individual records and additional protection for users whose texts are semantically infrequent.
Researchers. Our work enables the research community to collaboratively generate synthetic texts from distributed private corpora, facilitating research collaboration while preserving the privacy of the underlying data.
System developers. The algorithm can be deployed in privacy-preserving data collection and analysis pipelines, enabling service providers to improve models and user experience without ingesting raw user text.
Ethical principles. Following the Menlo Report, we adhere to four principles:
Beneficence. The purpose of this research is to improve the practicality and the theory of synthesizing texts from distributed users without degrading privacy or utility. Experiments are restricted to public benchmarks.
Respect for persons. No personal or private user data was used. All datasets and models were either synthetic or publicly available.
Justice. We highlight the scalability issue of existing DP text-synthesis methods and provide a more practical distributed solution. We hope our work can be used by system developers to facilitate privacy-preserving data collection and analysis.
Respect for law and public interest. All experiments comply with the applicable open-source software licenses.
Potential harms and mitigations.
Risk of over-interpretation. Our contribution is an algorithm for DP text synthesis; it is not intended to be used to generate fake content for misuse.
Controlled scope. Our work is restricted to the differential privacy framework under the semi-honest threat model. The algorithm should not be deployed in arbitrary environments outside this assumption set, as that may lead to data exploits not covered by the analysis.
Decision to conduct and publish. We believe that proposing a practical algorithm for distributed differentially private text synthesis is valuable to the community, since our algorithm enables researchers and system developers to share, collect, and analyse sensitive textual data without exposing individual records or violating user privacy.
External review. This work was not submitted to an external ethics panel (e.g., IRB or the Tor Research Safety Board) because the study uses only public benchmarks and does not involve human subjects or sensitive user data.
Open Science
All datasets used in this work are publicly available. Upon acceptance, the artifacts will be released, including: (1) implementations of the algorithm; (2) all dataset preprocessing scripts; and (3) any scripts essential to reproduce the results.
AI Use
We disclose all use of generative AI in the preparation of this manuscript and the underlying research. The authors used ChatGPT to revise the text to improve flow, correct typographical and grammatical issues, and improve the presentation of figures, based on experimental results. We verified that AI did not introduce new claims, and did not fabricate references. Generative AI was not used to design the algorithm or derive the privacy analysis. All references were collected from the original publications.
References
Algorithm 3: CalibrateNoise
Input: target $(\varepsilon,\delta)$; radius $r$; frequency threshold $t$; projection dimension $k$; subsampling rate $p_s$; budget factor $v \ge 1$; sensitivity ratio $u$ (so $\Delta_{\mathrm{dist}} = u r$)
Output: Gaussian noise scale $\sigma$ for the centroid sums
1. $\tau \leftarrow p_s t$ // threshold on sampled counts
2. $\varepsilon_{\mathrm{fre}} \leftarrow v \ln \frac{1}{1-p_s}$
3. $q \leftarrow 1-(1-p_s)^{v+1}$
4. $\delta_{\mathrm{fre}} \leftarrow \exp\left(-\frac{\tau}{d}D(q \mathbin{\|} p_s)\right)$ // Lemma 1
5. $\delta_{\mathrm{sens}} \leftarrow f(2/u)^k$ // Lemma 2
6. $\varepsilon_{\mathrm{agg}} \leftarrow \varepsilon-\varepsilon_{\mathrm{fre}}$
7. $\delta_{\mathrm{agg}} \leftarrow \delta-\delta_{\mathrm{fre}}-\delta_{\mathrm{sens}}$ // budget for Gaussian
8. if $\varepsilon_{\mathrm{agg}} \le 0$ or $\delta_{\mathrm{agg}} \le 0$ then
9. abort // lower $v$ (or $p_s$) if $\varepsilon_{\mathrm{agg}} \le 0$; raise $\tau$, $v$, or $u$ if $\delta_{\mathrm{agg}} \le 0$
10. $\rho_{\mathrm{agg}} \leftarrow \max\left\{\rho > 0:\inf_{\alpha \in (1,\infty)}\frac{\exp((\alpha-1)(\alpha\rho-\varepsilon_{\mathrm{agg}}))}{\alpha-1}\left(1-\frac{1}{\alpha}\right)^\alpha \le \delta_{\mathrm{agg}}\right\}$ // Thm. 3
11. return $\sigma \leftarrow \frac{u r}{\sqrt{2\rho_{\mathrm{agg}}}}$
Additional Experiment Details and Results
We have used the following datasets.
TaylorAI [105] includes 1.5 million user queries.
Instructions-2M [89] is a meta-dataset containing approximately 2.33 million instructions, including user and system prompts spanning different problem domains.
LMSYS Chat-1M [118] contains one million real-world conversations with 25 state-of-the-art LLMs. The dataset includes interactions collected from 210K unique IP addresses. We consider each user query as an individual.
Yelp [115] consists of reviews from Yelp. It is extracted from the Yelp Dataset Challenge 2015 data.
We apply a preprocessing step to filter out samples where the language is non-English, minimizing the potential impact of multilingual limitations in the embedding models. The resulting statistics are summarized in Table 10.
| Dataset | #samples | #texts | Average length |
| TaylorAI | 88.1 | ||
| Instructions-2M | 30.6 | ||
| LMSYS-Chat-1M | 72.0 | ||
| Yelp | 192 |
Table 10. Dataset statistics for the overall number of samples and number of frequent items in millions and the average token length per sample.
Hyperparameters
Our algorithm rely on the following hyperparameters.
Overall privacy parameters. We fix and vary and (i.e., non-DP setting).
Recall that for any two data points in the embedding space , we see them as -neighbors if their distance is not larger than . We say a text is frequent if it has at least neighbors in its -neighborhood. We have taken and unless otherwise stated in our experiments (see Section 7).
Data pre-processing for embedding, projection, and partitioning. Each client calls the public, black-box embedding function to compute a -dimensional embedding vector for its text, with . Next, the -dimensional vector is randomly projected onto the -dimensional space using a Gaussian projector whose entries are sampled independently from , scaled by . We fix in our experiments and provide ablation studies on the impact of in Section 7. The space is then partitioned into buckets of edge length on each dimension, with an independent uniform random offset per dimension.
Component for identifying heavy hitters. Each client contributes its bucket index to the synthesis server with probability (the subsampling rate). The server keeps the bucket indices whose sampled count reaches the threshold , i.e. for with . Following Lemma 1, we spend on this release, with the budget factor for ; the corresponding , , is listed in Table 11. Here was chosen per target so that the remaining budget suffices, see Algorithm 3.
Component for centroid computation. For each heavy bucket, the clients that submitted to it aggregate their -dimensional embedding vectors, and Gaussian noise is added to the sum. We set the target sensitivity to ; the ratio is fixed per projection dimension. We set at our default , and its failure probability is accounted in the final (Theorem 4). For the split , the noise scale is calibrated with the Gaussian mechanism (Theorem 3) via procedure CalibrateNoise (Algorithm 3); for this gives for (noise multipliers of 1.78, 0.95, 0.43). When (non-DP), and no subsampling is applied ().
| budget | |||
| 4 | |||
| 8 | |||
| 16 |
Table 11. Split of the overall budget at .
Split of . Table 11 shows the split of the overall (at ) among the heavy-hitter release , sensitivity-bound failure , and the remainder available to the centroid computation. We can see that consumes a negligible portion of the overall budget—only around .
Numerical procedure. One can use Algorithm 3 to obtain the Gaussian noise scale given target privacy parameters, radius , frequency threshold , projection dimension , subsampling rate , the budget factor , and the sensitivity ratio/noise multiplier . Note that we use the continuous Gaussian mechanism (Theorem 3) instead of the discrete distributed Gaussian mechanism (Theorem 9) for simulation purpose, since [64] have pointed out that when the quantization granularity is high enough, both mechanisms are indistinguishable in utility under the same privacy budget.
More Ablation Studies
For the ablation study on edge length shown in Section 7.3, the noise scale is listed in Table 12.
Embedding model. The comparison in Table 7 is about transferability of observations, not about which encoder is “better”. We can observe that the overall trend of utility-privacy trade-off is similar, precision and recall almost reach the non-DP baseline when . The concrete numbers differ, which is expected, since a different embedding model also changes which infrequent texts the mechanism protects and which frequent texts the mechanism reconstructs. More ablation studies and the details of hyperparameters are in Appendix A.1.
Projection dimension . Table 13 presents the F1 score for . The best depends on , while in general, larger is better for . This is because larger reduces the failure probability of the sensitivity bound (recall Lemma 2), allowing more freedom to choose the noise scale for centroid perturbation.
| dataset | 10 | 15 | 20 | 25 | 30 | |
| Instructions-2M | 2 | 0.11 | 0.15 | 0.17 | 0.17 | 0.18 |
| 4 | 0.13 | 0.22 | 0.28 | 0.31 | 0.30 | |
| 8 | 0.26 | 0.34 | 0.36 | 0.44 | 0.41 | |
| 16 | 0.49 | 0.47 | 0.45 | 0.40 | 0.47 | |
| 0.69 | 0.54 | 0.50 | 0.50 | 0.49 | ||
| LMSYS Chat | 2 | 0.25 | 0.26 | 0.25 | 0.29 | 0.28 |
| 4 | 0.38 | 0.419 | 0.43 | 0.50 | 0.52 | |
| 8 | 0.54 | 0.637 | 0.64 | 0.71 | 0.70 | |
| 16 | 0.75 | 0.77 | 0.80 | 0.79 | 0.76 | |
| 0.85 | 0.84 | 0.83 | 0.83 | 0.79 |
Table 13. F1 score under varying projection dimension .
Frequency threshold . Together with , defines the frequent and infrequent texts from the input (recall Definition 2) and therefore the evaluation metrics. Hence, the results for different ’s are not directly comparable. We also note that decays exponentially in , so at the desired overall , our Fre-E2T is feasible only for at our subsampling rates. From Table 14, as we increase from 100 to 200, the released number of buckets decreases since fewer buckets would satisfy the frequent-text requirement. On the other hand, there is not clear utility trend at different ’s. Our main experiment setup selected , which is a small number compared with the overall population.
| Quantity | 100 | 200 | 400 |
| F1 Instructions-2M | 0.33 | 0.43 | 0.52 |
| F1 LMSYS Chat | 0.69 | 0.78 | 0.73 |
| # Buc. Instructions-2M | 89 | 57 | 39 |
| # Buc. LMSYS Chat | 424 | 175 | 59 |
Table 14. Influence of threshold () on the resulting F1 score at . # Buc. is the number of released buckets.
More on Text Utility
Let be an autoregressive language model and let a text tokenize into under ’s tokenizer. The per-token negative log-likelihood (NLL) of is its average next-token surprisal in nats,
The perplexity score of is the exponential of the per-token NLL, . Lower NLL (equivalently, lower PPL) means the text is closer to natural language as modeled by . We use GPT-2 as .
Here, we report the median of the per-text NLL over each text set, together with the fraction of texts with , on TaylorAI. From Table 15 we can see that for the outputs from Fre-E2T, their NLL approaches that of the real corpus as the privacy budget increases, matching the results from Section 7.2.
| Text set | Median NLL | % texts NLL |
| Fre-E2T () | 5.28 | 77.9% |
| Fre-E2T () | 4.29 | 95.4% |
| Real texts | 3.43 | 99.5% |
Table 15. NLL of Fre-E2T outputs vs. real text of TaylorAI evaluated using under GPT-2. The real texts are a random 1000-text sample of the frequent texts.
Evaluation on All Input Texts
Recall (15) to (17). We restrict the utility metrics to semantically frequent texts. This is a design consequence, not a favorable selection: semantic support protection (Definition 3) requires that infrequent texts remain far from the generated texts. Table 16 repeats every run of the main Table 1 and evaluate against the full input set . Precision is unchanged or higher, since a synthetic text now only has to be close to some input text. Recall falls by the infrequent mass. For example, at it is 0.35 for frequent AOL texts (recall Table 1) and 0.03 over all of them, since in AOL 92% of the corpus is infrequent. On TaylorAI, the recall decreases from 0.97 to 0.41 with 66% infrequent input texts. The gap between the two tables exactly that proves that our protection for infrequent texts works.
| TaylorAI | Instructions-2M | LMSYS Chat | Yelp | |||||||||
| 66% | 90% | 70% | 20% | |||||||||
| Prec. | Rec. | F1 | Prec. | Rec. | F1 | Prec. | Rec. | F1 | Prec. | Rec. | F1 | |
| 4 | 0.31 | 0.33 | 0.32 | 0.27 | 0.03 | 0.06 | 0.32 | 0.22 | 0.26 | 0.30 | 0.77 | 0.44 |
| 8 | 0.62 | 0.35 | 0.45 | 0.53 | 0.03 | 0.06 | 0.54 | 0.26 | 0.35 | 0.61 | 0.83 | 0.70 |
| 16 | 0.82 | 0.39 | 0.53 | 0.60 | 0.04 | 0.07 | 0.77 | 0.28 | 0.41 | 0.87 | 0.85 | 0.86 |
| 0.83 | 0.41 | 0.55 | 0.71 | 0.04 | 0.07 | 0.85 | 0.28 | 0.42 | 0.97 | 0.86 | 0.91 |
Table 16. Utility measured against all input texts . Compared with Table 1 that reports the same runs against the frequent subset , precision is unchanged or higher here (the nearest-text condition is evaluated over a larger set); recall falls by the infrequent mass, which our Fre-E2T mechanism deliberately does not support.
Details of Distributed Fre-E2T
We refer to Figure 5 for the distributed implementation of Fre-E2T and Figure 6 for the illustration of the partitioning procedure on the -dimensional projection space.
We refer to Algorithm 4 for the verifiable oblivious pseudorandom function for randomly permuting user indices. Truncated Shifted Laplace noise is introduced to enforce DP for non-frequent user texts during the heavy hitter identification process. We refer to Definition 5 and Algorithm 5 for the definition and the algorithmic process, respectively.
Definition 5 (Truncated Shifted Discrete Laplace (TSDLap)). The distribution of TSDLap on is defined as
where is the scale, is the shift from 0, and
We note that sees the multiset of sub-threshold tags with their exact multiplicities; the tags themselves are pseudorandom to any party without the OPRF key, and it is the resulting count-of-counts—how many tags were seen with each multiplicity—that Algorithm 5’s TSDLap padding makes differentially private [98].
We also provide the full description of the distributed discrete Gaussian mechanism to obtain the aggregated vector sum of distributed users [64] (other mechanisms such as [4, 28] lead to similar results). See Algorithm 6 and Algorithm 7. In short, each user locally quantizes its vector, perturbs it with discrete Gaussian noise, and then takes the modulo in order to prepare for secure aggregation [21, 87, 103]. After secure aggregation, the untrusted reconstructs an estimate for the sum by unwinding the modulo operation and the quantization. When the quantization granularity is fine, e.g., , the resulting data utility (error compared with the original, non-quantized, non-DP vector sum) is almost the same as perturbing the sum directly with continuous Gaussian noise in the centralized setting [1, 64]. In our simulation of Fre-E2T, we adopt the continuous Gaussian without loss of generality.
Theorem 9 (Distributed discrete Gaussian (complete version) [64]). Let be the parameter controlling the rounding bias, be the quantization parameter, be the parameter of the local discrete Gaussian noise. Under the same assumption as Theorem 3, define
The outcome of the perturbed sum of embedding vectors from Alg. 2 satisfies -CDP, and -DP with
Connection with [27]. Our clustering process of projecting data into a lower-dimension space and then partitioning the data into buckets is in spirit similar to the DP clustering work [27]. Our difference is in the design of the distributed algorithm. While Chang et al. [27] focuses on the local DP model, we employ the more recent sample-and-threshold privacy framework [15] which has an efficient distributed implementation [98] with the help of an untrusted randomness server. In addition, we also exploit the structure of distance-based clustering to reduce the sensitivity when computing the cluster centroid.
On Sample-and-threshold Histogram. Algorithm 1 releases two things for each heavy bucket : the pair in the heavy-hitter step (line 15) and the noisy centroid in the aggregation step (line 19). Here is not the number of users in bucket : it is the number of users that sampled themselves into the release, i.e. where is the true bucket size. The pair
Algorithm 4: Client-TaggingServer
Input: user $i$ holding $b_i \in \mathbb{Z}_q^*$; tagging server; VOPRF secret key msk; hash function $g(\cdot)$.
Output: Random string $h_i$
1 user $i$: Hash the index $u \leftarrow g(b_i)$
2 user $i$: Sample blinding $r' \xleftarrow{R} \mathbb{Z}_q^*$
3 user $i$: Compute blind $\leftarrow u^{r'}$
4 user $i$: Send blinded hash blind to the server
5 Tagging server: Compute $z \leftarrow \mathrm{blind}^{\mathrm{msk}}$
6 user $i$: Unblind the response $w \leftarrow z^{1/r'}$
7 user $i$: Obtain $h_i \leftarrow g(w,b_i)$
8 Return $h_i$
Algorithm 5: Dummy-Data-Creation
Input: A public thresholding value $\tau$; Truncated Shifted Discrete Laplace distribution $\operatorname{TSDLap}(\cdot)$ with scale $\lambda$ and shift $\gamma$.
Output: A list of dummy indices
1 Dummy $\leftarrow \{\}$
2 for $n = 1,\ldots,\tau-1$ do
3 Sample $Q \leftarrow \operatorname{TSDLap}(\lambda,\gamma)$
4 $\{\operatorname{tag}_j\}_{j=1}^{Q} \leftarrow \operatorname{UniqueIndexGenerator}(\alpha)$
5 for $j = 1,\ldots,Q$ do
6 Append $n$ copies of $\operatorname{tag}_j$ to Dummy
7 end
8 end
9 return Dummy
is precisely the output that the sample-and-threshold guarantee of Lemma 1 certifies with . The raw count itself is never released. The centroid step then divides the noise-perturbed sum by the already released (line 18); since both the numerator’s DP guarantee (Theorem 3) and the divisor’s (Lemma 1) are already accounted in Theorem 4 by linear composition, this division is post-processing and incurs no additional privacy cost [42].
Deployment Costs
We complement the cost analysis in Section 6.2 with concrete numbers. The costs are measured on an AMD EPYC 9554 (124 cores) with one NVIDIA H100 80 GB without real test on distributed environments. Parameters are , , , , , and the reported dataset is TaylorAI.
The per-operation costs in the distributed Fre-E2T are: one VOPRF evaluation 89.5 s; tag counting 1.05 s per tag; share accumulation 10.7 s per share; bucket reconstruction 60.5 s per bucket; and text embedding 0.29 ms per text on the GPU amortized at batch size 256. A user spends around 0.4 ms online in total, uploads 8.3 kB and downloads 6.1 kB. Both servers finish in a couple of minutes for VOPRF evaluations and the computation for the centroids. There is no need for GPU for the online phases. The offline vec2text inversion takes 133ms per text. The dummy traffic that protects sub-threshold buckets is around 1710 messages and 113 kB for the entire run.
Comparison with Aug-PE. Aug-PE [110] keeps a population of synthetic texts and, in each of iterations, generates rephrasings of every kept sample, embeds the resulting pool of candidates, has every private record vote for its nearest candidate, perturbs that histogram and keeps the top . Its per-iteration cost is thus generations, embeddings and for computing the embedding distance, repeated times. In addition, because the vote is over private data, the distance computation must be done on the users’ devices, which must download all candidate text embeddings first. With , , (i.e. 21,000 candidates scored per iteration), one iteration of Aug-PE takes 64.6 s on an H100 GPU. A full run takes 21.7 minutes that require users’ synchronous updates and continuous participation, much longer than Fre-E2T.
On the server side, neither method is expensive in computation or communication. The difference is on the user side: Fre-E2T’s user cost is paid once and is independent of and of , whereas Aug-PE’s recurs every iteration and scales with the candidate pool. We highlight this difference in Table 17.
| Per user | Fre-E2T | Aug-PE | ratio |
| Computation | 0.40 ms (once) | 55.9 ms (20 rounds) | 140× |
| Upload | 8.3 kB | 1.68 MB | |
| Download | 6.1 kB | 1.29 GB |
Table 17. Per-user cost of distributed Fre-E2T versus a distributed Aug-PE.
C Proof for Semantic Support Protection
We prove Theorem 5 in three steps. First, we argue that for any infrequent text that has at most data points that is -close to itself, after subsampling, not too many of its close neighbors in will end up in the same cluster, using the classic concentration inequality, and that the cluster will have a small diameter (using the results established in Sec. 6.3). Next, we focus on a single cluster, and argue that conditioned on there are not too many close neighbors to in it, the cluster centroid will be far from . Finally, we show that the DP noise will push the released centroid further away , with a high probability.
Good event . We focus on any cluster with index in the -dimensional space that has accumulated at least data points. Note that was released in the heavy hitter estimation step with DP. So here, using incur no additional privacy cost.
We denote the corresponding -dimensional embedding vectors as . We define event as “Within bucket , there are at most data points that are close to and every two data points have distance at most ”. Lemma 10 follows from the multiplicative Chernoff bound [86] and Lemma 2.
Lemma 10 (Event almost always happens). Within bucket of count , there are at most data points that are close to and every pair of data points are within distance at most . This happens with probability at least
with defined as in (7).
Distance between a centroid and . Conditioned event , we show that no bucket centroid is close to , without DP noise. Recall that each bucket contains data points (with ), so at least data points in the bucket is at least -away from . We take any such , then . We define unit vector . Now consider any other data point that is far from , written as . Let be the angle between and . Then we can obtain
since and by construction. Therefore for any , . For any such that , holds automatically. Since there are at least far data points, the centroid of , written as , must satisfy
Since , . This means that the distance from to is dominated by the majority far points.
Effect of DP noise. We consider injecting into the centroid . We define , and .
Let follow the distributed Gaussian distribution of mean with covariance . By rotation invariance, equation 25 can be computed as
where is the cumulative distribution function of non-central chi-squared distribution and . (26) is decreasing in ; hence, it is decreasing in . This in turn motivates Lemma 10, where have we bounded from below.
The overall failure probability follows from a union bound over (23) and (26). Plugging in , where is the subsampled count of items landed in the heavy hitter cluster of (namely, the denominator for the centroid computation), we obtain Theorem 5. We note that is already released through the differentially private heavy hitter histogram perturbed with the random subsampling noises; hence, using incurs no additional privacy cost.
To convert Theorem 5 to a meaningful bound on the text-level semantic protection, one also needs to quantify the error during inverting the vector to a text, namely, the distance , where is the text inverted from centroid . This can be difficult in general. However, based on our empirical observations from Figure 4, the error is not large and text-level SSP is preserved.
Remark on distributed implementation. Real-world distributed implementation of securely aggregating DP noises relies on integer-valued implementations, such as discrete Gaussian [24, 64] (used in this paper), or symmetric Skellam [4] (difference of two Poisson variables). In both cases, for moderate noise levels or in moderately high dimension, as is the case in our problem, the distribution of the squared distance can still be approximated by a noncentral chi-squared distribution with the same degrees of freedom and the almost the same noncentrality , where is the per-coordinate variance of the mechanism.
Now, we consider Algorithm 2, where each user independently contributes discrete Gaussian noise to the discretized local vector. The sum of independent discrete Gaussian noises of variance is close to a single discrete Gaussian noise of variance . Normalizing by (here ), the overall variance in the resulting centroid is . Hence, the conclusion of semantic support protection for the distributed implementation of Fre-E2T, Algorithm 2, is similar to what we have derived above for a continuous Gaussian, with an algebraic substitution, presented as follows.
For any such that there are at most data points from that has distance at most to in and any DP centroid with items sampled into the cluster, Algorithm 2 outputs the centroid such that with probability
Extensions
Each user has multiple data points.
Previously, we have considered the setting in which each user has exactly 1 data point. Now we discuss the extension when each user has more than 1 data points.
Naive solution via composition. During the heavy-hitter estimation, we can introduce a public threshold to restrict the number of buckets that each user can contribute to, say . For each bucket, we make each user contribute at most one of its embedding vectors. The overall privacy guarantee then follows from the composition argument, we can directly multiply the overall and by . Finding the optimal threshold could be an interesting future work direction [39, 58]
Naive solution via black-box group DP. The above naive solution forbids one user to submit to the same bucket index multiple times. This may hurt utility considering that some queries (associated with certain bucket indices are more common). Let’s say each user has at most data points. A straight-forward group DP argument gives -DP, where and are the original privacy parameters of the algorithm when each user has exactly one data point. When is not close to 0, the factor of can be very large.
A bespoke analysis. Next, we discuss a more bespoke analysis. Let the group size be (originally, we have considered ). We first focus on the heavy hitter estimation phase. For now, we consider two databases consisting of copies of the same index. Dataset has copies while dataset has copies. The sampled count and for and then follows the binomial distribution and , respectively.
for any , . We can obtain
which collapses to when , i.e., the expression that appears in the original [15]. We want (29) to be bounded within , with a high probability. The lower bound is easy, it suffices to make . For the upper bound, it suffices to make sure that
for each . It suffices to ensure that
holds, which is equivalent to
where we have set . Since could take value in , the can be written as
When , , which is the same as in [15]. As a sanity check, we note that is increasing in —i.e., it is more likely for the binomial variable to be lower bounded by a smaller value.
There are two cases to consider. or ; equivalently, or
Case I: . We can upper bound by .
Case II: . In this case, we upper bound . We upper bound this probability by the Chernoff bound, that is, the probability that at least out of independent trials are successful, where each trial succeeds with probability . In expectation, the number of success is , therefore, the Chernoff bound error decreases as increases—when is larger, it becomes more difficult for the off-mean event to happen. Therefore, it suffices to consider the boundary case , which also happens to be the worst case above. We obtain
with , and stands for the KL divergence between two Bernoulli trials. The first inequality holds since (this formalization unifies Case II and Case I); the second inequality is obtained from the Markov’s inequality and then solving for the optimal order, similar to [15].
In summary, when two datasets differ by copies of the same index, the overall for heavy hitter estimation multiplies by while the overall can be computed via the union bound:
where is computed via (36), and the maximum is taken over all possible sets of such that each and that . In particular, if all data points of a user are the same, then exactly one , and the rest are 0.
Next, we discuss the privacy guarantee for the DP centroid computation. When all data points are in one cluster, the sensitivity multiplies by , so does the failure probability (since each data in the bucket point may fail to stay close to the different data point in the same bucket). We can apply Lemma 2 and Theorem 3 with the sensitivity multiplied by to obtain and for any group size .
The overall parameters are expressed as
where the maximum is taken over all possible sets of such that each and that . In particular, if all data points of a user are the same, then exactly one , and the rest are 0.
Bounded Differential Privacy
Our analysis in Section 5 focuses on the unbounded DP model [40], where two datasets are called neighboring if one can be obtained from the other by adding or removing exactly one record in the dataset. Now we discuss the privacy guarantee under the bounded DP model [41], where the two datasets are called neighboring if one can be obtained from the other by altering exactly one record in the dataset (this also captures the scenario when one user’s record is zeroed out). We provide the full argument for completeness.
We say two datasets are unbounded-adjacent, denoted , if can be obtained from by adding or removing exactly one record; i.e., there exists such that either or . Accordingly, we say two datasets are bounded-adjacent, denoted , if they have the same size and differ in exactly one record. Equivalently, there exist a dataset and records such that .
Lemma 11 (Unbounded DP to bounded DP parameter conversion [42]). If a mechanism is -DP with respect to unbounded adjacency , then is -DP with respect to bounded adjacency .
Proof. Assume is -DP w.r.t. . Fix any pair . By the definition of bounded adjacency, there exist a dataset and records such that and . Note that (remove ) and (add ). Let be any measurable set. Applying -DP w.r.t. to the pair gives
Applying -DP w.r.t. to the pair gives
Substituting (41) into (40) yields
This is exactly -DP w.r.t. bounded adjacency.
Note that the above conversion is completely black box. As a result, we can also plug in the privacy parameters obtained from Section D.0.1 and obtain the corresponding DP guarantees under bounded adjacency.
Other Threat Models
When the two servers are malicious during heavy hitter estimation, the tagging server needs to provide a zero-knowledge proof on not altering the protocol, as is done in [98]. When users who submit the vectors are malicious in the aggregation phase [21], or equivalently, malicious users (say, there are of them) may submit indices computed from certain embedding vectors of interest, attempting to learn whether there exist other users with similar text embeddings (even such embeddings may not be frequent among the user population), we can make a similar argument. From the perspective of the targeted users, this act weakens their privacy protection by enforcing a smaller cut-off threshold of heavy-hitter identification—decreasing from to (see equation 5). This can be resolved by using a MPC protocol to ensure that the random submission (determined by a random coin) is strictly executed. In this case, the malicious users’ data serve as dummies to enhance the privacy protection. We leave further measures to defend against such malicious acts to future work. MPC protocols specifically designed for DP [48, 50, 67, 97] or relaxed privacy frameworks [102] may also be useful.
Simulation-Based Security Sketch
We provide a simulation-based security sketch for the distributed implementation in Algorithm 2. This argument is not intended as a new cryptographic primitive; rather, it shows that, under the same assumptions as Section 2 and using the cited primitives as black boxes, the distributed protocol reveals no information beyond the explicitly released differentially private summary and the unavoidable metadata described below.
Adversarial model. Let denote the synthesis server and denote the tagging server. We consider static probabilistic polynomial-time semi-honest adversaries: corrupted parties follow the protocol but may try to infer additional information from their views. We assume and do not collude. User-to-server submissions are sent through an anonymous channel, modeled as an ideal shuffler that reveals only the multiset of messages delivered to the recipient and not the sender identities or links between a user’s messages in different phases. We consider corruption of , corruption of , or corruption of a subset of users. If one also allows corrupted users to collude with , then the ideal leakage must include the multiplicity of the VOPRF tags known to those corrupted users; our main statement below excludes such user-server collusion.
Ideal functionality. Define an ideal functionality parameterized by the public parameters
On inputs , the functionality computes , the projected bucket index , the sampled participation coin , and an opaque tag for each bucket. Equal buckets receive equal tags, and distinct buckets receive computationally independent tags. The functionality then runs the same sample-and-threshold heavy-hitter step, including the dummy submissions drawn from , and outputs the heavy-hitter tag set and counts . For each , it computes the quantized, locally discrete-Gaussian-perturbed sum
where the coordinates of are sampled independently from the discrete Gaussian distribution used in Algorithm 2. It outputs the released centroid
The public output is
The synthesis server’s ideal leakage additionally contains the sub-threshold count-of-counts
where is the number of received non-heavy opaque tags with multiplicity , after dummy insertion. This captures exactly the information observed by from non-released pseudonymous tags; the individual tag names themselves carry no semantic information. The tagging server’s ideal leakage consists of the number of VOPRF invocations, the public output, and the public heavy-tag oracle induced by its VOPRF key. This oracle captures the fact that a tagging server holding the VOPRF key can test guessed bucket indices against the public released heavy tags, but it still does not learn which users produced those tags.
Security statement. Assume that (i) the VOPRF realizes its standard oblivious and verifiable PRF functionality, (ii) the anonymous channel realizes an ideal shuffler, and (iii) the secure aggregation protocol realizes an ideal tagged-sum functionality that reveals only the aggregate sum for each released tag. Then, for every PPT semi-honest adversary corrupting either , , or an arbitrary subset of users, there exists a PPT simulator such that
where is Algorithm 2, contains the inputs and randomness of corrupted users, and is the ideal leakage defined above for the corrupted party type. The indistinguishability is computational, with negligible distinguishing advantage in the cryptographic security parameter.
Proof sketch. We prove the statement by a sequence of standard hybrids.
Hybrid 0: the real execution. This is the execution of Algorithm 2. Each user locally computes , projects and buckets it to obtain , obtains a VOPRF tag , submits with probability , and, if , secret-shares a locally perturbed vector tagged by .
Hybrid 1: replace VOPRF by its ideal functionality. Replace the real VOPRF interface between each user and server with an ideal VOPRF call. By the VOPRF security guarantee, ’s view of each call can be simulated from the number of invocations: the blinded inputs are indistinguishable from random protocol messages and reveal neither nor the output . Users with the same bucket obtain the same PRF tag, whereas the tags for distinct buckets are computationally indistinguishable from independent random strings to any party not holding the VOPRF key. Verifiability guarantees that honest users accept only tags generated under the committed VOPRF key. Therefore, this replacement changes the adversary’s view only negligibly.
Hybrid 2: replace user submissions by an ideal shuffler. Replace each user-to-server communication channel by an ideal anonymous channel. The recipient learns only the multiset of submitted tags or tagged shares, not the identities of the senders and not whether two messages in different phases came from the same user. Thus, the synthesis server’s heavy-hitter-phase view is completely determined by the multiset
and the centroid-phase view is determined by the multiset of tagged shares for tags in . This is exactly the metadata included in , together with the released heavy tags and counts .
Hybrid 3: simulate non-heavy pseudonymous tags. For tags whose multiplicity is below , sees only opaque pseudorandom strings and their multiplicities. Since the VOPRF tags for unknown bucket indices are pseudorandom, the simulator samples fresh random strings and assigns exactly of them multiplicity , for each . This produces the same distribution as the real view up to the PRF distinguishing advantage. The dummy submissions are accounted for in the same count-of-counts leakage. The DP analysis in Section 6.3 then bounds the information contained in .
Hybrid 4: replace secure aggregation by ideal tagged sums. For each heavy tag , let be the set of sampled users with tag . Each such user contributes an integer vector
and sends additive secret shares of to the two non-colluding servers. Consider a corrupted . The share of every honest user’s vector received by is uniformly random over the aggregation group, independent of . Given the ideal output , the simulator samples all shares received by uniformly at random and programs the aggregate share sent from to make the reconstructed sum equal . This is identically distributed to the real execution because additive secret sharing is perfectly private against either single server. The case of a corrupted is symmetric. If an off-the-shelf SecAgg protocol is used instead of two-server additive sharing, the same step follows from the simulation security of the SecAgg functionality.
Hybrid 5: simulate users’ views. A corrupted user sees only its own input, local randomness, VOPRF response, participation coin, local noise, generated shares, the broadcast , and the public output. The simulator can reproduce this view directly from the corrupted user’s input and randomness plus . Because users receive no other users’ messages, no additional simulation is required.
After these replacements, the transcript is generated entirely from the corrupted parties’ inputs and randomness, the public output , and the leakage . Hence the real and ideal executions are computationally indistinguishable.
The simulation argument shows that the cryptographic implementation does not leak raw texts, bucket indices, or individual embeddings beyond the ideal released objects above. Therefore the end-to-end privacy of the distributed protocol reduces to the privacy of the ideal release. By Lemma 6 and Theorem 7, the distributed heavy-hitter step and the distributed discrete Gaussian centroid step satisfy the DP parameters analyzed in Section 6.3. Composing these components and adding the high-probability sensitivity term yields Theorem 8.
References
- [1]Martin Abadi, Andy Chu, Ian Goodfellow, H. Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. 2016. Deep Learning with Differential Privacy. In CCS.
- [2]John M. Abowd and Ian M. Schmutte. 2019. An Economic Analysis of Privacy Protection and Statistical Accuracy as Social Choices. AER (2019).DOI
- [3]Alessandro Acquisti, Laura Brandimarte, and George Loewenstein. 2015. Privacy and human behavior in the age of information. Science 347, 6221 (2015), 509–514. doi:10.1126/science.aaa1465DOI
- [4]Naman Agarwal, Peter Kairouz, and Ziyu Liu. 2021. The skellam mechanism for differentially private federated learning. In NeurIPS.
- [5]Jōel Blumberg, Anil Shelat, and Ivan V. Lëk? 2008. Collision-Free Protocols in the Mediated Model. In CRYPTO.
- [6]Miguel E. Andrés, Nicolás E. Bordenabe, Konstantinos Chatzikokolakis, and Catuscia Palamidessi. 2013. Geo-indistinguishability: Differential Privacy for Location-Based Systems. In CCS.DOI
- [7]Meenatchi Sundaram Muthu Selva Annamalai, Emiliano De Cristofaro, and Peter Kairouz. 2026. CLOWPTRA: Extracting Private Information from LLM Insights. arXiv:2603.09781 [cs.CR] https://arxiv.org/abs/2603.09781
- [8]Anthropic. 2025. Claude 3.7 Sonnet System Card. https://www-cdn.anthropic.com/9ff93df8af45c932415d335c888528ef47f1210e.pdf. Accessed 2026-02-04.
- [9]Apple. 2025. Understanding Aggregate Trends for Apple Intelligence Using Differential Privacy. Apple ML Research (2025).
- [10]Apple Differential Privacy Team. 2017. Learning with Privacy at Scale. White Paper. Apple.
- [11]Ionut Arghire. 2022. Samsung Sued Over Recent Data Breaches. https://www.securityweek.com/samsung-sued-over-recent-data-breaches/.
- [12]Borja Balle, James Bell-Clark, Albert Cheu, Adria Gascon, Jonathan Katz, Mariana Raykova, Philippe Schoppmann, and Thomas Steinke. 2025. Hash-Prune-Invert: Improved DP Heavy-Hitter Detection in the Two-Server Model. In SP.
- [13]Borja Balle and Yu-Xiang Wang. 2018. Improving the Gaussian Mechanism for Differential Privacy. In ICML.
- [14]James Bell, Adrià Gascón, Balih Ghazi, Ravi Kumar, Pasin Manurangsi, Mariana Raykova, and Phillip Schoppmann. 2022. Distributed, Private, Sparse Histograms in the Two-Server Model. In CCS.DOI
- [15]Akash Bharadwaj and Graham Cormode. 2022. Sample and Threshold Differential Privacy: Histograms and Applications. AISTATS (2022).arxiv.org/abs/2112.05693
- [16]Andrea Bittau, Úlfar Erlingsson, Petros Maniatis, Ilya Mironov, Ananth Raghunathan, David Lie, Mitch Rudominer, Udi? Y? 2017. Prochlo: Strong Privacy for Analytics in the Crowd. In SOSP.DOI
- [17]Avrim Blum, Cynthia Dwork, Frank McSherry, and Kobbi Nissim. 2005. Practical Privacy: The SuLQ Framework. In PODS.
- [18]Jonas Böhler and Florian Kerschbaum. 2020. Secure Multi-party Computation of Differentially Private Median. In USENIX Security.
- [19]Rishi Bommasani, Sitao Wu, and Xavier S. Schoenfeld. 2019. Towards Private Synthetic Text Generation. In NeurIPS Workshop on Machine Learning with Guarantees.
- [20]Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H. Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. 2017. Practical Secure Aggregation for Privacy-Preserving ML. In CCS.arxiv.org/abs/1902.01046
- [21]Keith Bonawitz, Vladimir Ivanov, Ben Kreuter, Antonio Marcedone, H. Brendan McMahan, Sarvar Patel, Daniel Ramage, Aaron Segal, and Karn Seth. 2017. Practical Secure Aggregation for Privacy-Preserving ML. In CCS.
- [22]Brave Software, Inc. 2025. How do I use Brave Leo? https://support.brave.app/hc/en-us/articles/20958609786637-How-do-I-use-Brave-Leo. Updated 2025-07-29. Accessed: 2026-02-04.
- [23]U.S. Census. Bureau. 2012. 2010 Census of Population and Housing, Technical Documentation. https://usa.ipums.org/usa/resources/voliii/pubdocs/2010/Technical%20Documentation.pdf.
- [24]Clément L. Canonne, Gautam Kamath, and Thomas Steinke. 2020. The discrete Gaussian for differential privacy. In NeurIPS.
- [25]Nicholas Carlini, Florian Tramer, Eric Wallace, Matthew Jagielski, Ariel Herbert-Voss, Katherine Lee, Adam Roberts, Tom Brown, Nicholas Roy, Dawn Song, et al. 2021. Extracting Training Data from Large Language Models. In USENIX Security 21.
- [26]S. Casper, J. Lin, D. Hadfield-Menell, and D. Krueger. 2023. Open Problems and Fundamental Limitations of Reinforcement Learning from Human Feedback. In TMLR.arxiv.org/abs/2307.15217
- [27]Alisa Chang, Badih Ghazi, Ravi Kumar, and Pasin Manurangsi. 2021. Locally Private k-Means in One Round. In ICML. 1441–1451.arxiv.org/abs/2104.09734
- [28]Wei-Ning Chen, Ayfer Ozgur, and Peter Kairouz. 2022. The Poisson Binomial Mechanism for Unbiased Federated Learning with Secure Aggregation. In icml.arxiv.org/abs/2207.09916
- [29]Albert Cheu, Artem Lagzdin, Brett McLarnon, Daniel Ramage, Katharine Daly, Marco Gruteser, Peter Kairouz, Rakshita Tandon, Stanislav Chiknavaryan, Timon Van Overveldt, and Zoe Gong. 2025. Toward provably private analytics and insights into GenAI use. arXiv:2510.21684 [cs.CR] https://arxiv.org/abs/2510.21684
- [30]Albert Cheu, Adam Smith, Jonathan Ullman, David Zeber, and Maxim Zhilyaev. 2019. Distributed Differential Privacy via Shuffling. In EUROCRYPT.DOI
- [31]Eli Chien, Yuzheng Hu, Ryan McKenna, Shanshan Wu, Zheng Xu, and Peter Kairouz. 2026. MAPLE: Metadata Augmented Private Language Evolution. arXiv:2603.19258 [cs.CL] https://arxiv.org/abs/2603.19258
- [32]Henry Corrigan-Gibbs and Dan Boneh. 2017. Prio: Private, robust, and scalable computation of aggregate statistics. In NSDI.
- [33]Sanjoy Dasgupta and Anupam Gupta. 2003. An Elementary Proof of a Theorem of Johnson and Lindenstrauss. Random Struct. Algorithms (2003).
- [34]Mayur Datar, Nicole Immorlica, Piotr Indyk, and Vahab S. Mirrokni. 2004. Locality-Sensitive Hashing Scheme Based on p-Stable Distributions. In SoCG.DOI
- [35]Alex Davidson, Peter Snyder, E. B. Quirk, Joseph Genereux, Benjamin Livshits, and Hamed Haddadi. 2022. STAR: Secret Sharing for Private Threshold Aggregation. In CCS.DOI
- [36]Soham De, Leonard Berrada, Jamie Hayes, Samuel L Smith, and Borja Balle. 2022. Unlocking High-Accuracy Differentially Private Image Classification through Scale. arXiv preprint arXiv:2204.13650 (2022).arxiv.org/abs/2204.13650
- [37]Adrien Desfontaines, James Voss, Bryant Gipson, and Chinmoy Mandayam. 2022. Differentially Private Partition Selection. PoPETS (2022).
- [38]Bolin Ding, Janardhan Kulkarni, and Sergey Yekhanin. 2017. Collecting telemetry data privately. Neu rIPS (2017).
- [39]Wei Dong, Juanyu Fang, Ke Yi, Yuqiao Tao, and Ashwin Machanavajjhala. 2022. R2T: Instance-optimal Truncation for Differentially Private Query Evaluation with Foreign Keys. In Proceedings of the 2022 International Conference on Management of Data. 759–772.
- [40]Cynthia Dwork. 2006. Differential privacy. In ICALP. 1–12.
- [41]Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam Smith. 2006. Calibrating Noise to Sensitivity in Private Data Analysis. In TCC.
- [42]Cynthia Dwork and Aaron Roth. 2014. The Algorithmic Foundations of Differential Privacy. FTCS (2014).
- [43]Úlfar Erlingsson, Vasisai Pihur, and Aleksandra Korolova. 2014. RAPPOR: Randomized Aggregatable Privacy-Preserving Ordinal Response. In CCS.
- [44]Alexandre Evfimievski, Ramakrishnan Srikant, Rakesh Agrawal, and Johannes Gehrke. 2002. Privacy preserving mining of association rules. In KDD. 217–228.
- [45]Oluwaseyi Feyisetan, Borja Balle, Thomas Drake, and Tom Diethe. 2020. Privacy- and Utility-Preserving Textual Analysis via Calibrated Multivariate Perturbations. In WSDM.
- [46]James Flemings and Murali Annavaram. 2024. Differentially Private Knowledge Distillation via Synthetic Text Generation. In ACL Findings.arxiv.org/abs/2403.00932
- [47]James Flemings, Meisam Razaviyayn, and Murali Annavaram. 2024. Differentially Private Next-Token Prediction of Large Language Models. In ACL.
- [48]Olive Franzese, Congyu Fang, Radhika Garg, Somesh Jha, Nicolas Papernot, Xiao Wang, and Adam Dziedzic. 2025. Secure Noise Sampling for Differentially Private Collaborative Learning. In CCS.DOI
- [49]Michael H. Freiman, Amy D. Lauger, and Jerome P. Reiter. 2021. Formal Privacy and Synthetic Data for the American Community Survey. Working Paper. U.S. Census Bureau. https://www.census.gov/library/working-papers/2018/adm/formal-privacy-synthetic-data-acs.html Pre-publication research report.
- [50]Yucheng Fu and Tianhao Wang. 2024. Benchmarking Secure Sampling Protocols for Differential Privacy. In CCS.DOI
- [51]Arun Ganesh, Brendan McMahan, Milad Nasr, Thomas Steinke, and Abhradeep Thakurta. 2025. Hush! Protecting Secrets During Model Training: An Indistinguishability Approach.arxiv.org/abs/2506.00201
- [52]Gemini Team. 2023. Gemini: A Family of Highly Capable Multimodal Models. arXiv preprint arXiv:2312.11805 (2023). https://arxiv.org/abs/2312.11805
- [53]Aristides Gionis, Piotr Indyk, and Rajeev Motwani. 1999. Similarity Search in High Dimensions via Hashing. In VLDB.
- [54]Briland Hitaj, Giuseppe Ateniese, and Fernando Perez-Cruz. 2017. Deep Models Under the GAN: Information Leakage from Collaborative Deep Learning. In CCS.
- [55]Charlie Hou, Akshat Shrivastava, Hongyuan Zhan, Rylan Conway, Trang Le, Adithya Sagar, Giulia Fanti, and Daniel Lazar. 2024. Pre-Text: training language models on private federated data in the age of LLMs. In ICML.arxiv.org/abs/2406.02958
- [56]Charlie Hou, Mei-Yu Wang, Yige Zhu, Daniel Lazar, and Giulia Fanti. 2025. Private Federated Learning using Preference-Optimized Synthetic Data. In ICML.arxiv.org/abs/2504.16438
- [57]Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. LoRA: Low-Rank Adaptation of LLMs. In ICLR.
- [58]Yihua Hu, Hao Ding, and Wei Dong. 2025. N2E: A General Framework to Reduce Node-Differential Privacy to Edge-Differential Privacy for Graph Analytics. Proc. ACM Manag. Data 3, 6 (Dec. 2025).
- [59]Piotr Indyk and Rajeev Motwani. 1998. Approximate Nearest Neighbors: Towards Removing the Curse of Dimensionality. In STOC.
- [60]Yuval Ishai, Arpita Patra, Sikhar Patranabis, Divya Ravi, and Akshayaram Srinivasan. 2022. Fully-Secure MPC with Minimal Trust. In TCC.
- [61]Zhu JianHao, Changze Lv, Xiaohua Wang, Muling Wu, Wenhao Liu, Tianlong Li, Zixuan Ling, Cenyuan Zhang, Xiaoqing Zheng, and Xuanjing Huang. 2024. Promoting Data and Model Privacy in Federated Learning through Quantized LoRA. In EMNLP.arxiv.org/abs/2406.10976
- [62]Thorsten Joachims. 2002. Optimizing Search Engines using Clickthrough Data. In KDD.
- [63]William B. Johnson and Joram Lindenstrauss. 1984. Extensions of Lipschitz Mappings into a Hilbert Space. Contemp. Math. (1984).
- [64]Peter Kairouz, Ziyu Liu, and Thomas Steinke. 2021. The Distributed Discrete Gaussian Mechanism for Federated Learning with Secure Aggregation. In ICML.arxiv.org/abs/2102.06387
- [65]Peter Kairouz, Brendan McMahan, Shuang Song, Om Thakkar, Abhradeep Thakurta, and Zheng Xu. 2021. Practical and Private (Deep) Learning Without Sampling or Shuffling. In ICML.
- [66]Shiva Prasad Kasiviswanathan, Homin K. Lee, Kobbi Nissim, Sofya Raskhodnikova, and Adam Smith. 2008. What Can We Learn Privately? In FOCS. 531–540.arxiv.org/abs/0803.0924
- [67]Hannah Keller, Helen Möllering, Thomas Schneider, Oleksandr Tkachenko, and Liang Zhao. 2024. Secure Noise Sampling for DP in MPC with Finite Precision. In ARES.DOI
- [68]Christopher T. Kenny, Shiro Kuriki, Cory McCartan, Evan T. R. Rosenman, Tyler Simko, and Kosuke Imai. 2021. The use of differential privacy for census data and its impact on redistricting: The case of the 2020 U.S. Census. Science Advances 7, 41 (2021).DOI
- [69]Oleksandra Klymenko, Stephen Meisenbacher, and Florian Matthes. 2022. Differential Privacy in Natural Language Processing: The Story So Far. In PrivateNLP Workshop.DOI
- [70]Jakub Konečný, Brendan McMahan, and Daniel Ramage. 2015. Federated Optimization: Distributed Optimization Beyond the Datacenter. CoRR abs/1511.03575 (2015). http://arxiv.org/abs/1511.03575
- [71]Yu-Hsuan Kuo, Cho-Chun Chiu, Daniel Kifer, Michael Hay, and Ashwin Machanavajjhala. 2018. Differentially private hierarchical count-of-counts histograms. PVLDB (2018).
- [72]Matt Lepinski, Silvio Micali, and abhi shelat. 2005. Collision-free protocols. In STOC.
- [73]Tian Li, Anit Kumar Sahu, Ameet Talwalkar, and Virginia Smith. 2020. Federated Learning: Challenges, Methods, and Future Directions. IEEE Signal Processing Magazine 37, 3 (2020), 50–60. doi:10.1109/MSP.2020.2975749DOI
- [74]Xuechen Li, Florian Tramèr, Percy Liang, and Tatsunori B. Hashimoto. 2022. Large Language Models Can Be Strong Differentially Private Learners. ICLR (2022).arxiv.org/abs/2110.05679
- [75]Xiang Lisa Li and Percy Liang. 2021. Prefix-Tuning: Optimizing Continuous Prompts for Generation. In ACL.arxiv.org/abs/2101.00190
- [76]Yuting Liang and Ke Yi. 2023. Concentrated Geo-Privacy. In CCS. Zinan Lin, Sivakanth Gopi, Janardhan Kulkarni, Harsha Nori, and Sergey Yekhanin. 2024. Differentially Private Synthetic Data via Foundation Model APIs I: Images. In ICLR.
- [78]Daoyao Liu, Edith Cohen, Badih Ghazi, Peter Kairouz, Pritish Kamath, Alexander Knop, Ravi Kumar, Pasin Manurangsi, Adam Sealfon, Da Yu, and Chiyuan Zhang. 2025. Urania: Differentially Private Insights into AI Use. In COLM.
- [79]S. Lloyd. 1982. Least Squares Quantization in PCM. IEEE TIT (1982).
- [80]Xinjiang Luo, Ting Yu, and Xiaokui Xiao. 2025. Prompt Inference Attack on Distributed Large Language Model Inference Frameworks. CCS (2025).
- [81]J. B. MacQueen. 1967. Some Methods for Classification and Analysis of Multivariate Observations. In Proceedings of the Fifth Berkeley Symposium on Mathematical Statistics and Probability, Vol. 1. University of California Press, 281–297.
- [82]Justus Mattern, Zhijing Jin, Benjamin Weggenmann, Bernhard Schölkopf, and Mrinmaya Sachan. 2022. Differentially Private Language Models for Secure Data Sharing. In EMNLP.arxiv.org/abs/2210.13918
- [83]Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. 2017. Communication-Efficient Learning of Deep Networks from Decentralized Data. In AISTATS.
- [84]Stephen Meisenbacher, Alexandra Klymenko, Andreea-Elena Bodea, and Florian Matthes. 2025. The Double-edged Sword of LLM-based Data Reconstruction. WPES @ CCS (2025).DOI
- [85]Ilya Mironov, Omkant Pandey, Omer Reingold, and Salil Vadhan. 2009. Computational Differential Privacy. In CRYPTO.
- [86]Michael Mitzenmacher and Eli Upfal. 2005. Probability and Computing: Randomized Algorithms and Probabilistic Analysis. Cambridge University Press, Cambridge, UK. doi:10.1017/CBO9780511813603DOI
- [87]Payman Mohassel and Peter Rindal. 2017. SecureML: A System for Scalable Privacy-Preserving Machine Learning. In SP.
- [88]John X. Morris, Volodymyr Kuleshov, Vitaly Shmatikov, and Alexander M. Rush. 2023. Text Embeddings Reveal (Almost) As Much As Text. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, Singapore, 12448–12460. doi:10.18653/v1/2023.emnlp-main.765DOI
- [89]John X. Morris, Wenting Zhao, Justin T. Chiu, Vitaly Shmatikov, and Alexander M. Rush. 2024. Language Model Inversion. In ICLR.
- [90]Huy Nguyen, Anamay Chaturvedi, and Eric Xu. 2021. Differentially Private k-Means via Exponential Mechanism and Max Cover. AAAI (2021).
- [91]Jianmo Ni, Chen Qu, Jing Lu, Zhuoyun Dai, Gustavo Hernández Ábrego, Ji Ma, Vincent Zhao, Yi Luan, Keith Hall, Ming-Wei Chang, et al. 2022. Large Dual Encoders Are Generalizable Retrievers. In EMNLP.
- [92]OpenAI. 2023. GPT-4 System Card. https://cdn.openai.com/papers/gpt-4-system-card.pdf.
- [93]OpenAI. 2023. March 20 ChatGPT Outage: Here’s What Happened. https://openai.com/index/march-20-chatgpt-outage/.
- [94]Mijung Park, James Foulds, Kamalika Chaudhary, and Max Welling. 2017. DP-EM: Differentially Private Expectation Maximization. In AISTATS.arxiv.org/abs/1605.06995
- [95]Alec Radford, Jeff Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language Models are Unsupervised Multitask Learners. OpenAI technical report (2019).
- [96]D. Ridgeway, M. Theofanos, T. Manley, and C. Task. 2021. Challenge Design and Lessons Learned from the 2018 Differential Privacy Challenges. NIST Technical Note 2151. National Institute of Standards and Technology. doi:10.6028/NIST.TN.2151DOI
- [97]Guy N. Rothblum, Eran Omri, Junye Chen, and Kunal Talwar. 2024. PINE: efficient verification of a euclidean norm bound of a secret-shared vector. In USENIX Security.
- [98]Ali S. Shamsabadi, Peter Snyder, Ralph Giles, Aurélien Bellet, and Hamed Haddadi. 2025. Efficient, Private and Accurate Histogram Estimation. CCS (2025).DOI
- [99]Tom Simonite. 2016. Apple’s New Privacy Technology May Pressure Competitors to Better Protect Our Data. https://www.technologyreview.com/2016/08/03/158510/
- [100]Dong Su, Jianneng Cao, Ninghui Li, Elisa Bertino, and Hongxia Jin. 2016. Differentially Private K-Means Clustering. In CODASPY.
- [101]Ziteng Sun, Peter Kairouz, Haicheng Sun, Adria Gascon, and Ananda T. Suresh. 2024. Private Federated Discovery of Out-of-Vocabulary Words for Gboard.arxiv.org/abs/2404.11607
- [102]Kunal Talwar. 2022. Differential Secrecy for Distributed Data and Applications to Robust Differentially Secure Vector Summation. In FOC.
- [103]Kunal Talwar, Shan Wang, Audra McMillan, Vitaly Feldman, et al. 2024. Sample Anonymous Aggregation for Private Federated Data Analysis. In CCS.
- [104]Alex Tamkin, Miles McCain, Kunal Handa, Esin Durmus, Liane Lovitt, Ankur Rathi, Saffron Huang, Alfred Mountfield, Jerry Hong, Stuart Ritchie, et al. 2024. Clio: Privacy-Preserving Insights into Real-World AI Use. arXiv:2412.13678 [cs.CL] https://arxiv.org/abs/2412.13678
- [105]TaylorAI. 2023. User Queries Dataset. https://huggingface.co/datasets/TaylorAI/user_queries_dataset. Hugging Face dataset.
- [106]Vishnu Vinod, Krishna Pillutla, and Abhradeep Guha Thakurta. 2025. InvisibleLink: High-Utility and Low-Cost Text Generation with Differential Privacy. arXiv:2507.02974 [cs.LG] https://arxiv.org/abs/2507.02974
- [107]Tianhao Wang, Jeremiah Blocki, Ninghui Li, and Somesh Jha. 2017. Locally Differentially Private Protocols for Frequency Estimation. In 26th USENIX Security Symposium (USENIX Security 17), 729–745.
- [108]Tianze Wang, Zhaoyou Chen, Jian Du, Yingqi Xiao, Linjun Zhang, and Qiang Yan. 2025. Secret-Protected Evolution for Differentially Private Synthetic Text Generation. arXiv:2510.10990 [cs.CR] https://arxiv.org/abs/2510.10990
- [109]Alexandra Wood, Micah Altman, Aaron Bembenek, Mark Bun, Marco Gaboardi, James Honaker, Kobbi Nissim, David O’Brien, Thomas Steinke, and Salil Vadhan. 2018. Differential Privacy: A Primer for a Non-Technical Audience. Vanderbilt Journal of Entertainment & Technology Law 21, 1 (2018), 209–276. doi:10.2139/ssrn.3338027 Available at SSRN: https://ssrn.com/abstract=3338027.DOI
- [110]Chulin Xie, Zinan Lin, Arturs Backurs, Sivakanth Gopi, Da Yu, Huseyin A. Inan, Huishui Zhang, Yin Tat Lee, Sergey Yekhanin, and Bo Li. 2024. Differentially Private Synthetic Data via Foundation Model APIs 2: Text. In ICML.
- [111]Rui Xu and Donald Wunsch. 2005. Survey of Clustering Algorithms. TNN 16, 3 (2005), 645–678.
- [112]Da Yu, Saurabh Naik, Arturs Backurs, Sivakanth Gopi, Huseyin A. Inan, Gautam Kamath, Janardhan Kulkarni, Yin Tat Lee, Andre Manoel, Lukas Wutschitz, Sergey Yekhanin, and Huishui Zhang. 2022. Differentially Private Fine-tuning of Language Models. In ICLR.
- [113]Xiang Yue, Huseyin Inan, Xuechen Li, Girish Kumar, Julia McAnallen, Hoda Shajari, Huan Sun, David Levitan, and Robert Sim. 2023. Synthetic Text Generation with Differential Privacy: A Simple and Practical Recipe. In ACL.
- [114]Xin Zhang, Yanzhao Zhang, Dingkun Long, Wen Xie, Ziqi Dai, Jialong Tang, Huan Lin, Baosong Yang, Pengjun Xie, Fei Huang, et al. 2024. mGTE: Generalized Long-Context Text Representation and Reranking Models for Multilingual Text Retrieval. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing: Industry Track. 1393–1412.
- [115]Xiang Zhang, Junbo Zhao, and Yann LeCun. 2015. Character-level Convolutional Networks for Text Classification. NeurIPS (2015).
- [116]Yonghui Zhang, Yang Liu, Xiaofeng Li, and Zhiyong Xu. 2020. Towards Privacy-Preserving Search Systems. IEEE TDSC (2020).
- [117]Zhao Zhao and Anjalie Field. 2025. Controlled Generation for Private Synthetic Text. arXiv:2509.25729 [cs.CL] https://arxiv.org/abs/2509.25729
- [118]Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Tianle Li, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zhuohan Li, Zi Lin, et al. 2023. LMSYS-Chat-1M: A Large-Scale Real-World LLM Conversation Dataset.