D ISTRIBUTED D IFFERENTIAL P RIVACY IN M ULTI -A RMED B ANDITS
A BSTRACT
We consider the standard K -armed bandit problem under a distributed trust model of differential privacy (DP), which enables to guarantee privacy without a trustworthy server.
Under this trust model, previous work on private bandits largely focus on achieving privacy using a shuffle protocol, where a batch of users data are randomly permuted before sending to a central server.
This protocol achieves ( ε, δ ) or approximate-DP guarantee by sacrificing an additive O (cid:18)
[Equation]
√
[Equation] [Equation]
[Equation]
ε (cid:19) factor in T -step cumulative regret.
In contrast, the optimal privacy cost to achieve a stronger ( ε, 0 ) or pure-DP guarantee under the widely used central trust model is only Θ (cid:16) K log T ε (cid:17) , where, however, a trusted server is required.
In this work, we aim to obtain a pure-DP guarantee under distributed trust model while sacrificing no more regret than that under the central trust model.
We achieve this by designing a generic bandit algorithm based on successive arm elimination, where privacy is guaranteed by corrupting rewards with an equivalent discrete Laplace noise ensured by a secure computation protocol.
We also show that our algorithm, when instantiated with Skellam noise and the secure protocol, ensures R´enyi differential privacy – a stronger notion than approximate DP – under distributed trust model with a privacy cost of O (cid:16) K √ log T ε (cid:17) .
Our theoretical findings are corroborated by numerical evaluations on both synthetic and real-world data.
I NTRODUCTION
The multi-armed bandit (MAB) problem provides a simple but powerful framework for sequential decision-making under uncertainty with bandit feedback, which has attracted a wide range of practical applications such as online advertising (Abe et al., 2003), product recommendations (Li et al., 2010), clinical trials (Tewari & Murphy, 2017), to name a few.
Along with its broad applicability, however, there is an increasing concern of privacy risk in MAB due to its intrinsic dependence on users’ feedback, which could leak users’ sensitive information (Pan et al., 2019).
To alleviate the above concern, the notion of differential privacy , introduced by Dwork et al.
(2006) in the field of computer science theory, has recently been adopted to design privacy-preserving bandit algorithms (see, e.g., Mishra & Thakurta (2015); Tossou & Dimitrakakis (2016); Shariff & Sheffet (2018)).
Differential privacy (DP) provides a principled way to mathematically prove privacy guarantees against adversaries with arbitrary auxiliary information about users.
To achieve this, a differentially private bandit algorithm typically relies on a well-tuned random noise to obscure each user’s contribution to the output, depending on privacy levels ε, δ – smaller values lead to stronger protection but also suffer worse utility (i.e., regret).
For example, the central server of a recommendation system can use random noise to perturb its statistics on each item after receiving feedback (i.e., clicks/ratings) from users.
This is often termed as central model (Dwork et al., 2014), since the central server has the trust of its users and hence has a direct access to their raw
[Table]
data.
Under this model
[Table]
an optimal private MAB algorithm with a pure DP guarantee (i
[Table]
e., when δ = 0 ) is proposed in Sajed & Sheffet (2019)
[Table]
which only incurs an additive O (cid:16) K log T ε
[Table]
term in the cumulative regret compared to the standard setting when privacy is not sought after (Auer, 2002)
[Table]
However, this high trust model is not always feasible in practice since users may not be willing to share their raw data directly to the server.
This motivates to employ a local model (Kasiviswanathan et al., 2011) of trust, where DP is achieved without a trusted server as each user perturbs her data prior to sharing with the server.
This ensures a stronger privacy protection, but leads to a high cost in utility due to large aggregated noise from all users.
As shown in Ren et al.
(2020), under the local model, private MAB algorithms have to incur a multiplicative 1 /ε 2 factor in the regret rather than the additive one in the central model.
In attempts to recover the same utility of central model while without a trustworthy server like the local model, an intermediate DP trust model called distributed model has gained an increasing interest, especially in the context of (federated) supervised learning (Kairouz et al., 2021b; Agarwal et al., 2021; Kairouz et al., 2021a; Girgis et al., 2021; Lowy & Razaviyayn, 2021).
Under this model, each user first perturbs her data via a local randomizer, and then sends the randomized data to a secure computation function.
This secure function can be leveraged to guarantee privacy through aggregated noise from distributed users.
There are two popular secure computation functions: secure aggregation (Bonawitz et al., 2017) and secure shuffling (Bittau et al., 2017).
The former often relies on cryptographic primitives to securely aggregate users’ data so that the central server only learns the aggregated result, while the latter securely shuffle users’ messages to hide their source.
To the best of our knowledge, distributed DP model is far less studied in online learning as compared to supervised learning, with only known results for standard K -armed bandits in Tenenbaum et al.
(2021), where secure shuffling is adopted.
Despite being pioneer work, the results obtained in this paper have several limitations: (i)
The privacy guarantee is obtained only for approximate DP ( δ > 0 ) – a stronger pure DP ( δ = 0 ) guarantee is not achieved; (ii) The cost of privacy is a multiplicative (cid:
) log(1 /δ ) factor away from that of central model, leading to a higher regret bound; (iii)
The secure protocol works only for binary rewards (or communication intensive for real rewards).
Our contributions.
In this work, we design the first communication-efficient MAB algorithm that satisfies pure DP in the distributed model while attaining the same regret bound as in the central model (see Table 1).
We overcome several key challenges that arise in the design and analysis of distributed DP algorithms for bandits.
We now list the challenges and our proposed solutions below.
(a) Private and communication efficient algorithm design.
Secure aggregation (SecAgg) works only in the integer domain due to an inherent modular operation (Bonawitz et al., 2017).
Hence, leveraging this in bandits to achieve distributed DP with real rewards needs adopting data quantization, discrete privacy noise and modular summation arithmetic in the algorithm design.
To this end, we take a batch version of the successive arm elimination technique as a building block of our algorithm
and on top of it, employ a privacy protocol tailored to discrete privacy noise and modular operation (see
Algorithm
Instantiating the
protocol
at each
user
with
P´olya
random noise, we ensure that our algorithm satisfies pure DP in the distributed model.
Moreover, the communication bits per-user scale only logarithmicaly with the number of participating users in each batch.
(b) Regret analysis under pure DP with SecAgg.
While our pure DP guarantee exploits known results for discrete Laplace mechanism, the utility analysis gets challenging due to modular clipping of SecAgg.
In fact, in supervised learning, no known convergence rate exists for SGD under pure
DP with SecAgg (although the same is well-known under central model).
This is because modular clipping makes gradient estimates biased, and hence, standard convergence guarantees using unbiased estimates do not hold.
In bandits, however, we work with zeroth order observations to build estimates of arms’ rewards, and require high-confidence tight tail bounds for the estimates to analyse convergence.
To this end, relying on tail properties of discrete Laplace and a careful analysis of modular operation, we prove a sublinear regret rate of our algorithm, which matches the optimal one in the central model, and thus, achieves the optimal rate under pure DP (see Theorem 1).
(c) Improved regret bound under RDP.
While our main focus were to design the first bandit algorithm with pure distributed DP that achieves the same regret rate under central model, our template protocol is general enough to obtain different privacy guarantees by tuning the noise at each user.
We demonstrate this by achieving R´enyi differential privacy (RDP) (Mironov, 2017) using a Skellam random noise.
RDP is a weaker notion of privacy compared to pure DP, but it is still stronger than approximate DP.
It also provides a tighter privacy accounting for composition compared to approximate DP.
This is particularly useful for bandit algorithms, when users may participate in multiple rounds, necessitating the need for privacy composition.
Hence, we focus on RDP with SecAgg and and show that a tighter regret bound compared to pure DP can be achieved (see Theorem 2) by proving novel tail-bound for Skellam distribution.
We support our theoretical findings with extensive numerical evaluation over bandit instances generated from both synthetic and real-life data.
Finally, our analysis technique is also general enough to recover best-known regrets under central and local DP models while only using discrete privacy noise (see Appendix H).
This is important in practice since continuous Laplace noise might leak privacy on finite computers due to floating point arithmetic (Mironov, 2012), which is a drawback of existing central and local DP MAB algorithms.
P RELIMINARIES
In this section, we formally introduce the distributed differential privacy model in bandits.
Before that we recall the learning paradigm in multi-armed bandits and basic differential privacy definitions.
Learning model and regret in MAB.
At each time slot t ∈ [ T ] := { 1 , . .
, T } , the agent (e.g., recommender system) selects an arm a ∈ [ K ] (e.g., an advertisement), recommends it to a new user t and obtains an i.i.d reward r t (e.g., a rating indicating how much she likes it), which is sampled from a distribution over [0 , 1] with mean given by µ a .
Let a ∗ := argmax a ∈ [ K ] µ a be the arm with the highest mean and denote µ ∗ :
= µ a ∗ for simplicity.
Let ∆ a := µ ∗ − µ a be the gap of the expected reward between the optimal arm a ∗ and any other arm a .
Further, let N a ( t ) be the total number of times that arm a has been recommended to first t users.
The goal of the agent is to maximize its total reward, or equivalently to minimize the cumulative expected pseudo-regret, defined as
[Equation]
Differential privacy.
Let D =
[0 , 1] be the data universe, and n ∈ N be the number of unique users.
we say D,
D ′ ∈ D n are neighboring datasets if they only differ in one user’s reward preference for some i ∈ [ n ] .
We have the following standard definition of differential privacy (Dwork et al., 2006).
Definition 1 (Differential Privacy) .
For ε, δ > 0 , a randomized mechanism M satisfies ( ε, δ ) -DP if for all neighboring datasets D, D ′ and all events E in the range of M , we have
[Equation]
The special case of ( ε, 0) -DP is often referred to as pure differential privacy , whereas, for δ > 0 , ( ε, δ ) -DP is referred to as approximate differential privacy .
We also consider a related notion of privacy called R´enyi differential privacy (RDP) Mironov (2017), which allows for a tighter composition compared to approximate differential privacy.
Definition 2 (R´enyi Differential Privacy) .
For α > 1 , a randomized mechanism M satisfies ( α, ε ( α )) -RDP if for all neighboring datasets D, D ′ , we have D α ( M ( D ) , M ( D ′ ))
≤ ε ( α ) , where
D α ( P, Q ) is the R´enyi divergence (of order α ) of the distribution P from the distribution Q , and is given by D α ( P, Q ) :
= 1 α − 1 log (cid:16) E x ∼ Q (cid:104)(cid:16) P ( x ) Q ( x ) (cid:17)
α (cid:105)(cid:17) .
Distributed differential privacy.
A distributed bandit learning protocol P =
( R , S , A ) consists of three parts: (i) a (local) randomizer
R at each user’s side, (ii) an intermediate secure protocol
S , and (iii) an analyzer A at the central server.
Each user i first locally apply the randomizer R on its raw data (i.e., reward) D i , and sends the randomized data to a secure computation protocol S (e.g., secure aggregation or shuffling).
This intermediate secure protocol S takes a batch of users’ randomized data and generates inputs to the central server, which utilizes an analyzer A to compute the output (e.g., action) using received messages from S .
The secure computation protocol S has two main variations: secure shuffling and secure aggregation .
Both of them essentially work with a batch of users’ randomized data and guarantee that the central server cannot infer any individual’s data while the total noise in the inputs to the analyzer provides a high privacy level.
To adapt both into our MAB protocol, it is natural to divide participating users into batches.
For each batch b ∈ [ B ] with n b users, the outputs of S is given by S ◦ R n b ( D ) :
=
S ( R ( D 1 ) , . . .
, R ( D n b )) .
The goal is to guarantee that the the view of all B batches’ outputs satisfy DP.
To this end, we define a (composite) mechanism
[Equation]
where each individual mechanism S ◦ R n b operates on n b users’ rewards, i.e., on a dataset from
D n b .
With this notation, we have the following definition of distributed differential privacy.
Definition 3 (Distributed DP) .
A protocol P =
( R , S , A ) is said to satisfy DP (or RDP) in the distributed model if the mechanism
M P satisfies Definition 1 (or Definition 2).
In the central DP model, the privacy burden lies with a central server (in particular, analyzer A ), which needs to inject necessary random noise to achieve privacy.
On the other hand, in the local
DP model, each user’s data is privatized by local randomizer R .
In contrast, in the distributed DP model, privacy without a trusted central server is achieved by ensuring that the inputs to the analyzer
A already satisfy differential privacy.
Specifically, by properly designing the intermediate protocol
S and the noise level in the randomizer R , one can ensure that the final added noise in the aggregated data over a batch of users matches the noise that would have otherwise been added in the central model by the trusted server.
Through this, distributed DP model provides the possibility to achieve the same level of utility as the central model while without a trustworthy central server.
A G ENERIC A LGORITHM FOR P RIVATE B ANDITS
In this section, we propose a generic algorithmic framework (Algorithm 1) for multi-armed bandits under the distributed privacy model.
Batch-based successive arm elimination.
Our algorithm builds upon the classic idea of successive arm elimination (Even-Dar et al., 2006) with the additional incorporation of batches and a blackbox protocol P =
( R , S , A ) to achieve distributed differential privacy.
It divides the time horizon T into batches of exponentially increasing size and eliminates sub-optimal arms successively.
To this end, for each active arm a at batch b , it first prescribes arm a to a batch of l ( b ) =
b new users.
After pulling the prescribed action a , each user applies the local randomizer R to her reward and sends the randomized reward to the intermediary function S , which runs a secure computation protocol (e.g., secure aggregation or secure shuffling) over the total l ( b ) number of randomized rewards.
Then, upon receiving the outputs of S , the server applies the analyzer A to compute the the sum of rewards for batch b when pulling arm a (i.e., R a ( b ) ), which in turn gives the new mean estimate (cid:98) µ a ( b ) of arm a after being divided by the total pulls l ( b ) .
Then, upper and lower confidence bounds, UCB a ( b ) and LCB a ( b ) , respectively, are computed around the mean estimate (cid:98) µ a ( b ) with a properly chosen confidence width β ( b ) .
Finally, after the iteration over all active arms in batch b (denoted by the set Φ( b ) ), it adopts the standard arm elimination criterion to remove all obviously sub-optimal arms, i.e., it removes an arm a from Φ( b ) if UCB a ( b ) falls below LCB a ′ ( b ) of any other arm
a ′ ∈
Φ( b ) .
It now only remains to design a distributed DP protocol P .
There is one key difference between our algorithm and the VB-SDP-AE algorithm in Tenenbaum et al.
At the start of a batch, VB-SDP-AE uses all the past data to compute reward estimates.
In contrast, we adopt the idea of forgetting and use only the data of the last completed batch.
1: Parameters: # arms K , Time horizon T , privacy level ε > 0 , Confidence radii { β ( b ) } b
≥2: Initialize: Batch count b =1 , Active arm set Φ( b )= { 1 , . . .
, K } , Estimate (cid:98) µ a (1)=0 , ∀ a ∈ [ K ] 3: for batch b =1 , 2 , . . .
do 4:
Set batch size l ( b )=2 b 5: for each active arm a ∈ Φ( b ) do 6: for each new user i from 1 to l ( b ) do 7:
Pull arm a and generate reward r ia ( b ) 8:
Send randomized data y ia ( b )
=
R ( r ia ( b )) to S // randomizer 9:
If total number of pulls reaches T , exit 10: end for 11:
Send messages (cid:98)
y a ( b )=
S ( { y ia ( b ) } 1 ≤ i ≤ l ( b ) ) to A // secure computation 12:
Compute the sum of rewards R a ( b )
=
A ( (cid:98) y a ( b )) // analyzer 13:
Compute mean estimate (cid:98) µ a ( b )=
R a ( b ) /l
( b ) 14:
Compute confidence bounds UCB a ( b )= (cid:98) µ a ( b )+ β ( b ) and LCB a ( b )
= (cid:98) µ a ( b ) − β ( b ) 15: end for 16:
Update active set of arms: Φ( b +1)= (cid:8) a ∈ Φ( b ) :
UCB a ( b ) ≥ max a ′ ∈
Φ( b ) LCB a ′ ( b ) (cid:9) 17: end for 18: Subroutine: Local Randomizer R ( Input: x i ∈ [0 , 1] , Output: y i ) 19: Require: precision g ∈ N , modulo m ∈ N , batch size n ∈ N , privacy level ε 20:
Encode x i as (cid:98)
21: Generate discrete noise
23: Subroutine:
24: Require:
25: Securely compute
// black-box function 26: Subroutine:
Analyzer A
27: Require: precision g ∈ N , modulo m
N , batch size n
N , accuracy level
R 28: if (cid:98) y > ng + τ then 29: set
// correction for underflow 30: else set z
(cid:98)
Distributed DP protocol via discrete privacy noise.
Inspired by Balle et al.
(2020); Cheu & Yan (2021)
, we provide a general template protocol P for the distributed DP model, which relies only on discrete privacy noise .
Local randomizer R receives each user
i ’s real-valued data x i and encodes it as an integer via fixed-point encoding with precision g > 0 and randomized rounding.
Then, it generates a discrete noise, which depends on the specific privacy-regret trade-off requirement (to be discussed later under specific mechanisms).
Next, it adds the random noise to the encoded reward, clips the sum with modulo m ∈ N and sends the final integer y
i as input to secure computation function S .
We mainly focus on secure aggregation (SecAgg) for S here.
2 SecAgg is treated as a black-box function as in previous work on supervised learning (Kairouz et al., 2021a), which implements the following procedure: given n users and their randomized messages y i ∈
Z m (i.e., integer in { 0 , 1 , . . .
, m − 1 } ) obtained via R , the SecAgg function S securely computes the modular sum of the n messages, (cid:98) y
=
( (cid:80) ni =1 y i ) mod m , while revealing no further information on individual messages to a potential attacker, ensuring that it is perfectly secure .
Details of engineering implementations of
SecAgg is beyond the scope of this paper, see Appendix G for a brief discussion on this.
The job of analyzer A is to compute the sum of rewards within a batch as accurately as possible.
It uses an accuracy parameter τ ∈ R and g to correct for possible underflow due to modular operation and bias due to encoding.
To sum it up, the end goal of our protocol P =
( R , S , A ) is to ensure that it provides the required privacy protection while guaranteeing an output
z ≈ (cid:80) ni
=1 x i with high probability, which is the key to our privacy and regret analysis in the following sections.
A CHIEVING P URE DP IN THE D ISTRIBUTED M ODEL
In this section, we show that Algorithm 1 achieves pure-DP in the distributed DP model via secure aggregation.
To do so, we need to carefully determine the amount of (discrete) noise in R so that the total noise in a batch provides ( ε, 0) -DP.
One natural choice is the discrete Laplace noise.
Definition 4 (Discrete Laplace Distribution) .
Let b > 0 .
A random variable X has a discrete
Laplace distribution with scale parameter b , denoted by Lap Z ( b ) , if it has a p.m.f.
given by
[Equation]
A key property of discrete Laplace that we will use is its infinite divisibility , which allows us to simulate it in a distributed way (Goryczka & Xiong, 2015, Theorem 5.1).
Fact 1 (Infinite Divisibility of Discrete Laplace) .
A random variable X has a P´olya distribution with parameters r> 0 , β ∈ [0 , 1] , denoted by P´olya ( r, β ) , if it has a p.m.f.
given by
[Equation]
Now, for any n ∈ N , let { γ + i , γ − i } i ∈
[ n ] be 2 n i.i.d samples 3 from P ´ olya (1 /n, e − 1 /b ) , then the random variable (cid:80) ni
=1 ( γ + i − γ − i ) is distributed as Lap Z ( b ) .
Armed with the above fact and the properties of discrete Laplace noise (see Fact 3 in Appendix K), we are able to obtain the following main theorem, which shows that the same regret as in the central model is achieved under the distributed model via SecAgg.
Theorem 1 (Pure-DP via SecAgg) .
Fix ε > 0 and T ∈ N .
For each batch b , let noise for the i -th user in the batch be η i
= γ
+ i − γ −
i , where γ + i , γ − i i.i.d.
∼ P´olya (1 /n, e − ε/g ) , set n = l ( b ) , g = ⌈ ε √ n ⌉ , τ = ⌈ gε log(2 T )
⌉ and m =
ng + 2 τ + 1 .
Then, Algorithm 1 achieves ( ε, 0) -DP in the distributed model.
Moreover, setting β ( b )=
O (cid:18)(cid:113) log( | Φ( b ) | b 2 T ) 2 l
[Equation]
b
[Equation]
, it enjoys expected regret
[Equation]
Theorem 1 achieves optimal regret under pure DP.
Theorem 1 achieves the same regret bound as the one achieved in Sajed & Sheffet (2019) under the central trust model with continuous Laplace noise.
Moreover, it matches the lower bound obtained under pure DP in Shariff & Sheffet (2018), indicating the bound is indeed tight.
Note that, we achieve this rate under distributed trust model – a stronger notion of privacy protection than the central model – while using only discrete noise.
Communication bits.
Algorithm 1 needs to communicate O (log m ) bits per user to the secure protocol S , i.e., communicating bits scales logarithmically with the batch size.
In contrast, the number of communication bits required in existing distributed DP bandit algorithms that work with real-valued rewards (as we consider here) scale polynomially with the batch size (Chowdhury &
Zhou, 2022b; Garcelon et al., 2022).
Remark 1 (Pure DP via Secure Shuffling) .
It turns out that one can achieve same privacy and regret guarantees (orderwise) using a relaxed SecAgg protocol.
Building on this result, we also establish pure DP under shuffling while again maintaining the same regret bound as the central model (see Theorem 3 in Appendix D.2).
This improves the state-of-the-art result for MAB with shuffling (Tenenbaum et al., 2021) in terms of both privacy and regret.
A CHIEVING RDP IN THE D ISTRIBUTED M ODEL
A natural question to ask is whether one can get a better regret performance by sacrificing a small amount of privacy.
We consider the notion of RDP (see Definition 2), which is a weaker notion of privacy than pure DP.
However, it avoids the possible catastrophic privacy failure in approximate
DP, and also provides a tighter privacy accounting for composition (Mironov, 2017).
To achieve RDP guarantee using discrete noise, we consider the Skellam distribution – which has recently been introduced in private federated learning (Agarwal et al., 2021).
A key challenge in the regret analysis of our bandit algorithm is to characterize the tail property of Skellam distribution.
This is different from federated learning, where characterizing the variance renders sufficient.
In
Proposition 1, we prove that Skellam has sub-exponential tails, which not only is the key to our regret analysis, but could also be of independent interest.
Below is the formal definition of Skellam.
Definition 5 (Skellam Distribution) .
A random variable X has a Skellam distribution with mean µ and variance σ 2 , denoted by Sk ( µ, σ 2 ) , if it has a probability mass function given by
[Equation]
where I ν ( · ) is the modified Bessel function of the first kind.
To sample from Skellam distribution, one can rely on existing procedures for Poisson samples.
This is because if X = N 1 − N 2 , where N 1 , N 2 i.i.d.
∼ Poisson ( σ 2 / 2) , then X is Sk (0 , σ 2 ) distributed.
Moreover, due to this fact, Skellam is closed under summation, i.e., if X 1 ∼ Sk ( µ 1 , σ 21 ) and X 2 ∼
Sk ( µ 2 , σ 22 ) , then X 1 + X 2 ∼ Sk ( µ 1 + µ 2 , σ 21 + σ 22 ) .
Proposition 1 (Sub-exponential Tail of Skellam) .
Let X ∼ Sk
(0 , σ 2 ) .
Then, X is (2 σ 2 , √ 2 2 ) -subexponential.
Hence, for any p ∈ (0 , 1] , with probability at least 1 − p ,
[Equation]
With the above result, we can establish the following privacy and regret guarantee of Algorithm 1.
Theorem 2 (RDP via SecAgg) .
Fix ε > 0 , T ∈ N and a scaling factor s ≥ 1 .
For each batch b , let noise for the i -th user be η i ∼ Sk (0 , g 2 nε 2 ) , set n = l ( b ) , g = ⌈ sε √ n ⌉ , τ = ⌈ 2 gε (cid:112) log(2 T ) + √ 2 log(2 T )
⌉ and m =
ng + 2 τ + 1 .
Then, Algorithm 1 achieves ( α, (cid:98) ε ( α ))
-RDP in the distributed model for all α = 2 , 3 , . .
, with (cid:98) ε ( α ) =
αε 2 2 + min (cid:110) (2 α − 1)
ε 2 4 s+ 3 ε 2 s 3 , 3 ε 2 2 s (cid:111) .
Moreover, setting β ( b ) =
O (cid:16)(cid:113) log( | Φ(
[Equation]
|
[Equation]
, it enjoys the expected regret
[Equation]
Privacy-Regret-Communication Trade-off.
Observe that the scaling factor s allows us to achieve different trade-offs.
If s increases, both privacy and regret performances improve.
In fact, for a sufficiently large value of s , the third term in the regret bound becomes sufficiently small, and we obtain an improved regret bound compared to Theorem 1.
Moreover, the RDP privacy guarantee improves to (cid:98) ε ( α ) ≈
αε 2 2 , which is the standard RDP rate for Gaussian mechanism (Mironov, 2017).
However, a larger s leads to an increase of communicating bits per user, but only grows logarithmically, since
Algorithm 1 needs to communicate O (log m ) bits to the secure protocol S .
RDP to Approximate DP.
To shed more insight on Theorem 2, we convert our RDP guarantee to approximate DP for a sufficiently large s .
It holds that under the setup of Theorem 2, for sufficiently large s , one can achieve ( O ( ε ) , δ ) -DP with regret O (cid:0) (cid:80) a :∆ a > 0 log T ∆ a + K √ log T log(1 /δ )
ε (cid:1) (via Lemma 10 in Appendix K).
Implication of this conversion is three-fold.
First , this regret bound is O ( √ log T ) factor tighter than that achieved by Tenenbaum et al.
(2021) using a shuffle protocol.
Second , it yields a better regret performance compared to the bound achieved under ( ε, 0) -DP in
Theorem 1 when the privacy budget δ > 1 /T .
This observation is consistent with the fact that a weaker privacy guarantee typically warrants a better utility bound.
Third , this conversion via RDP also yields a gain of O ( (cid:112) log(1 /δ )) in the regret when dealing with privacy composition (e.g., when participating users across different batches are not unique ) as compared to Tenenbaum et al.
(2021) that only relies on approximate DP (see Appendix I for details).
This results from the fact that RDP provides a tighter composition compared to approximate DP.
Remark 2 (Achieving RDP with discrete Gaussian) .
One can also achieve RDP using discrete
Gaussian noise (Canonne et al., 2020).
Here, we work with Skellam noise since it is closed under summation and enjoys efficient sampling procedure as opposed to discrete Gaussian (Agarwal et al., 2021).
Nevertheless, as a proof of flexibility of our proposed framework, we show in Appendix F that Algorithm 1 with discrete Gaussian noise can guarantee RDP with a similar regret bound.
K EY T ECHNIQUES : O VERVIEW
Now, we provide an overview of the key techniques behind our privacy and regret guarantees.
We show that the results of Theorem 1 and 2 can be obtained via a clean generic analytical framework, which not only covers the analysis of distributed pure DP/RDP with SecAgg, but also offers a unified view of private MAB under central, local and distributed DP models.
As in many private learning algorithms, the key is to characterize the impact of added privacy noise on the utility.
In our case, this reduces to capturing the tail behavior of total noise n a ( b ) :
= R a ( b ) − (cid:80) l ( b ) i =1 r ia ( b ) added at each batch b for each active arm a .
The following lemma gives a generic regret bound of our algorithm under mild tail assumptions on n a ( b ) .
Lemma 1 (Generic regret) .
Let there exist constants σ, h > 0 such that, with probability ≥ 1 − p , | n a ( b ) |≤N := O (cid:16) σ (cid:112) log( KT/p )+ h log( KT/p ) (cid:17) for all b ≥ 1 , a ∈ [ K ] .
Then, setting confidence radius β ( b )=
O (cid:16)(cid:112) log( KT/p ) /l
( b ) + N /l ( b ) (cid:17) and p = 1 /T , Algorithm 1 enjoys expected regret
[Equation]
(cid:17) .
An acute reader may note that the bound N on the noise is the tail bound of sub-exponential distribution and it reduces to the bound for sub-Gaussian tail if h = 0 .
Our SecAgg protocol P with discrete
Laplace noise (as in Theorem 1) satisfy this bound with σ = √ 2 /ε, h = 1 /ε .
Similarly, our protocol with Skellam noise (as in Theorem 2) satisfy this bound with σ = O (1 /ε ) , h = 1 / ( sε ) .
Therefore, we can build on the above general result to directly obtain our regret bounds.
In the following, we present the high-level idea behind privacy and regret analysis in distributed DP model.
Privacy.
For distributed DP, by definition, the view of the server during the entire algorithm needs to be private.
Since each user only contributes once, 4 by parallel-composition of DP, it suffices to ensure that each view (cid:98) y a ( b ) (line 11 in Algorithm 1) is private.
To this end, under SecAgg, the distribution of (cid:98) y a ( b ) can be simulated via ( (cid:80) i y i ) mod m , which further reduces to ( (cid:80) i (cid:98) x i + η i ) mod m by the distributive property of modular sum.
Now, consider a mechanism M that accepts an input dataset { (cid:98)
x i } i and outputs (cid:80) i ( (cid:98) x
i + η i ) .
By post-processing, it suffices to show that M satisfies pure
DP or RDP.
To this end, the variance σ 2 tot of the total noise (cid:80) i
η i needs to scale with the sensitivity of (cid:80) i (cid:98) x i .
Thus, each user within a batch only needs to add a proper noise with variance of σ 2 tot /n .
Finally, by the particular distribution properties of the noise, one can show that M is pure DP or
RDP, and hence, obtain the privacy guarantees.
Regret.
Thanks to Lemma 1, we only need to focus on the tail of n a ( b ) .
To this end, fix any batch b and arm a .
We have (cid:98) y
= (cid:98) y a ( b ) , x i = r ia ( b ) , n = l ( b ) for P in Algorithm 1 and we need to establish that with probability at least 1 − p , for some σ and h ,
[Equation]
To get the bound, inspired by Balle et al.
; Cheu & Yan (2021), we divide the LHS into
Term (i) = |A
( (cid:98) y ) − (cid:80) i
(cid:98) x
i /g | and Term (ii) =
| (cid:80) i (cid:98) x
i /g − (cid:80) i x i | , where Term (i) captures the er- ror due to privacy noise and modular operation, while Term (ii) captures the error due to random rounding.
In particular, Term (ii) can be easily bounded via sub-Gaussian tail since the noise is bounded.
Term (i) needs care for the possible underflow due to modular operation by considering two different cases (see line 28-30 in Algorithm 1).
In both cases, one can show that Term (i) is upper bounded by τ/g with high probability, where τ is the tail bound on the total privacy noise (cid:80)
i η i .
Thus, depending on particular privacy noise and parameter choices, one can find σ and h such that equation 1 holds, and hence, obtain the corresponding regret bound by Lemma 1.
Remark 3.
As a by-product of our generic analysis technique, Algorithm 1 and privacy protocol P along with Lemma 1 provide a new and structured way to design and analyze private MAB algorithms under central and local models with discrete private noise (see Appendix H for details).
This enables us to reap the benefits of working with discrete noise (e.g., finite-computer representations, bit communications) in all three trust models (central, local and distributed).
[Figure]
[Figure] [Figure]
a
[Figure]
T i m e - a v e r a g
e R e g r e t
DP-SEDist-DP-SE Dist-RDP-SE(s=10)
Dist-RDP-SE(s=100) (e) ε = 5 , K =0 .0 .0 .0 .0 .1 .
Round × 100 .0 .0 .
T i m e - a v e r a g
e R e g r e t
DP-SEDist-DP-SE Dist-RDP-SE(s=10)
Dist-RDP-SE(s=100)
(f) ε = 10 , K =
S IMULATION R ESULTS
We empirically evaluate the regret performance of our successive elimination scheme with SecAgg protocol (Algorithm 1) under distributed trust model, which we abbreviate as Dist-DP-SE and DistRDP-SE when the randomizer R is instantiated with P ´ olya noise (for pure DP) and Skellam noise (for RDP), respectively.
We compare them with the DP-SE algorithm of Sajed & Sheffet (2019) that achieves optimal regret under pure DP in the central model, but works only with continuous Laplace noise.
We fix confidence level p = 0 .
1 and study comparative performances under varying privacy levels ( ε < 1 for synthetic data, ε ≥ 1 for real data).
We plot time-average regret Reg ( T ) /T
in
Figure 1 by averaging results over 20 randomly generated bandit instances.
Bandit instances.
In the top panel , similar to Vaswani et al.
(2020), we consider easy and hard
MAB instances with K = 10 arms: means are sampled uniformly
75] , while in the latter, those are sampled in [ consider real rewards – sampled from
Gaussian distribution with aforementioned means we generate means algorithm with a bandit arm with mean reward as the empirical mean of the ratings cluster.
This way, we obtain a bandit setting with number of arms = 50 .
Observations.
We observe that as T becomes large, the regret performance of Dist-DP-SE matches the regret of DP-SE.
The slight gap in small T regime is the cost that we pay to achieve distributed privacy using discrete noise without access to a trusted server (for higher ε value, this gap is even smaller).
In addition, we find that a relatively small scaling factor ( s = 10 ) provides a considerable gain in regret under RDP compared to pure DP, especially when ε is small (i.e., when the cost of privacy is not dominated by the non-private part of regret).
The experimental findings are consistent with our theoretical results.
Here, we note that our simulations are proof-of-concept only and we did not tune any hyperparameters.
More details and additional plots are given in Appendix J.
Concluding remarks.
We show that MAB under distributed trust model can achieve pure DP while maintaining the same regret under central model.
In addition, RDP is also achieved in MAB under distributed trust model for the first time.
Both results are obtained via a unified algorithm design and performance analysis.
More importantly, our work also opens the door to a promising and interesting research direction – private online learning with distributed DP guarantees, including contextual bandits and reinforcement learning
A CKNOWLEDGEMENTS
XZ is supported in part by NSF CNS-2153220.
XZ would like to thank Albert Cheu for insightful discussion on achieving pure DP via shuffling
A O THER R ELATED W ORK
Private Multi-Armed Bandits.
In addition to stochastic multi-armed bandits under the central model in Mishra & Thakurta (2015); Tossou & Dimitrakakis (2016); Sajed & Sheffet (2019), different variants of differentially private bandits have been studied, including adversarial bandits (Tossou & Dimitrakakis, 2017; Agarwal & Singh, 2017), heavy-tailed bandits (Tao et al., 2022), combinatorial semi-bandits (Chen et al., 2020), and cascading bandits (Wang et al., 2022).
MAB under the local model is first studied in Ren et al.
(2020) for pure DP and in Zheng et al.
(2020) for appromixate DP.
The local model have also been considered in Tao et al.
; Chen et al.
; Wang et al.
; Zhou & Tan (2021).
Motivated by the regret gap between the central model and local model (see Table 1), Tenenbaum et al.
(2021) consider MAB in the distributed model via secure shuffling where, however, only approximate DP is achieved and the resultant regret bound still has a gap with respect to the one under the central model.
Private Contextual Bandits.
In contextual bandits, in addition to the reward, the contexts are also sensitive information that need to be protected.
However, a straightforward adaptation of the standard central DP in contextual bandits will lead to a linear regret, as proved in Shariff & Sheffet (2018).
Thus, to provide a meaningful regret under the central model for contextual bandits, a relaxed version of DP called joint differential privacy is considered, which rougly means that the change of any user would not change the actions prescribed to all other users, but it allows the change of the action prescribed to herself.
Under this central JDP, Shariff & Sheffet (2018) establishes a regret bound of (cid:101) O ( √ T ) for a private variant of LinUCB.
On the other hand, contextual linear bandits under the local model incurs a regret bound of (cid:101)
O
( T 3 / 4 ) (Zheng et al., 2020).
Very recently, motivated by the regret gap between the central and local model, two concurrent works consider contextual linear bandits in the distributed model (via secure shuffling only)
(Chowdhury & Zhou, 2022b; Garcelon et al., 2022).
In particular, Chowdhury & Zhou (2022b) show that a (cid:101)
O
( T 3 / 5 ) regret bound is achieved under the distributed model via secure shuffling.
Private Reinforcement Learning (RL).
RL is a generalization of contextual bandits in that contextual bandits can be viewed as a finite-horizon RL with horizon H = 1 .
This not only directly means that one also has to consider JDP in the central model for RL, but implies that RL becomes harder for privacy protection due to the additional state transition (i.e., H > 1 ).
Tabular episodic RL under central JDP is first studied in Vietri et al.
with an additive privacy cost while under the local model, a multiplicative privacy cost is shown to be necessary (Garcelon et al., 2021).
In addition to valued-based algorithms considered in Vietri et al.
(2020); Garcelon et al.
(2021), similar performance is established for policy-based algorithms in tabular episodic RL under the central and local model (Chowdhury & Zhou, 2022a).
Beyond the tabular setting, differentially private LQR control is studied in Chowdhury et al.
More recently, private episodic RL with linear function approximation has been investigated in Luyo et al.
; Zhou (2022);
Liao et al.
(2021) under both central and local models, where similar regret gap as in contextual bandits exist (i.e., (cid:101) O ( √ T ) vs.
(cid:101)
O ( T 3 / 4 ) ).
We have also given more discussions on private (federated) supervised learning under the distributed model in Appendix G. For readers who are interested in the subtlety of DP definitions for bandits and RL, we refer to the blog post (Zhou, 2023).
B A P OSSIBLE A PPROACH TO R EDUCE THE C OMMUNICATION C OST
We first recall that the communication cost for RDP with SecAgg is roughly O (log( n + s/ε )) , where n is the batch size and s is the scaling factor.
A large s leads to better privacy and regret as shown in Theorem 2, but incurs a larger communication.
One can observe that the current communication cost is inverse with respect to ε .
However, we tend to believe that one can break the privacy-communication trade-off above using a very recent technique proposed in Chen et al.
(2022a).
In particular, Chen et al.
(2022a) shows that the fundamental communication cost for RDP with SecAgg for the mean estimation task scales with Ω(max(log( n 2 ε 2 ) , 1)) , where n is the batch size.
That is, for a stronger privacy guarantee (i.e., a smaller ε ), each user should send less number of bits.
The intuition is that if a user sends less bits, then she communicates less information about her local data (hence natural protection of privacy).
To achieve this improvement, Chen et al. (2022a) proposes to use a linear compression scheme based on sparse random projections and distributed discrete Gaussian noise.
Now, to apply the same technique to the private bandit problem, one needs to handle a different utility metric – that is, instead of the mean-square error in Chen et al.
(2022a), one now needs to examine the tail concentration behavior.
We leave it as an interesting future work.
C A G ENERAL R EGRET B OUND OF A LGORITHM
In this section, we present the proof of our generic regret bound in Lemma 1.
Recall that n a ( b ) :
= R a ( b ) − (cid:80) l ( b ) i =1 r ia ( b ) is the total noise injected in the sum of rewards for arm a during batch b .
We consider the following tail property on n a ( b ) .
Assumption 1 (Concentration of Private Noise) .
Fix any p ∈ (0 , 1] , a ∈ [ K ] , b ≥ 1 , there exist non-negative constants σ, h (possibly depending on b ) such that, with probability at least 1 − 2 p ,
[Equation]
We remark that this assumption naturally holds for a single ( σ 2 , h ) -sub-exponential noise and a single σ 2 -sub-Gaussian noise where h
=
(cf.
Lemma 7 and Lemma 6 in Appendix K) with constants adjustment.
Lemma 2 (Formal statement of Lemma 1) .
Let Assumption 1 hold and choose confidence radius
[Equation]
where | Φ( b ) | is the number of active arms in batch b .
Then, for any p ∈ (0 , 1] , with probability at least 1 − 3 p , the regret of Algorithm 1 satisfies
[Equation]
Taking p = 1 /T and assuming T ≥ K , yields the expected regret
[Equation]
Proof.
Let E b be the event that for all active arms | (cid:98) µ a ( b ) − µ a | ≤ β ( b ) and E = ∪ b ≥ 1 E b .
Then, we first show that with the choice of β ( b ) given by equation 2, we have P [
E ] ≥ 1 − 3 p for any p ∈ (0 , 1] under Assumption 1.
To see this, we note that
[Equation]
By Hoeffeding’s inequality (cf.
Lemma 8), we have for any p ∈ (0 , 1) , with probability at least 1 − p ,
[Equation]
Then, by the concentration of noise n a ( b ) in Assumption 1 and triangle inequality, we obtain for a given arm a and batch b , with probability at least 1 − 3 p
[Equation]
Thus, by the choice of β ( b ) and a union bound, we have P [ E ] ≥ 1 − 3 p .
In the following, we condition on the good event E .
We first show that the optimal arm a ∗ will always be active.
We show this by contradiction.
Suppose at the end of some batch b , a ∗ will be eliminated, i.e., UCB a ∗ ( b ) <
LCB a ′ ( b ) for some a ′ .
This implies that under good event E
[Equation]
which contradicts the fact that a ∗ is the optimal arm.
Then, we show that at the end of batch b , all arms such that ∆ a > 4 β ( b ) will be eliminated.
To show this, we have that under good event E
[Equation]
which implies that arm a will be eliminated by the rule.
Thus, for each sub-optimal arm a , let ˜ b a be the last batch that arm a is not eliminated.
By the above result, we have
[Equation]
Hence, we have for some absolute constants c 1 , c 2 , c 3 ,
[Equation]
Since the batch size doubles, we have N a ( T ) ≤ 4 l (˜ b a ) for each sub-optimal arm a .
Therefore,
Reg ( T ) =
(cid:80) a ∈ [ K ] N a ( T )∆ a ≤ 4 l (˜ b a )∆ a .
Moreover, choose p = 1 /T and assume T ≥ K , we have that the expected regret satisfies
[Equation]
Remark 4.
In stead of a doubling batch schedule, one can also set l ( b ) =
η b for some absolute constant η > 1 while attaining the same order of regret bound.
D A PPENDIX FOR P URE DP IN S ECTION
In this section, we provide proofs for Theorem 1 and Theorem 3, which show that pure DP can be achieved under the distributed model via SecAgg and secure shuffling, respectively.
Both results build on the generic regret bound in Lemma 2.
D. P ROOF OF T HEOREM
Proof.
Privacy: We need to show that the server’s view at each batch has already satisfies ( ε, 0) -DP, which combined with the fact of unique users and parallel composition, yields that Algorithmsatisfies ( ε, 0) -DP in the distributed model.
To this end, in the following, we fix a batch b and arm a , and hence x i = r ia ( b ) and n = l ( b ) .
Note that the server’s view for each batch is given by
[Equation]
where (a) holds by SecAgg function; (b) holds by the distributive property: ( a + b ) mod c = ( a mod c + b mod c ) mod c for any a, b, c ∈ Z .
Thus, the view of the server can be simulated as a post-processing of a mechanism H that accepts an input dataset { (cid:98) x
i } i and outputs (cid:80) i (cid:98) x
i + (cid:80) i η i .
Hence, it suffices to show that
H is ( ε, 0) -DP by post-processing of DP.
To this end, we note that the sensitivity of (cid:80) i (cid:98) x i is g , which, by Fact 3, implies that (cid:80) i
η i needs to be distributed as Lap Z ( g/ε ) in order to guarantee ε -DP.
Finally, by Fact 1, it suffices to generate η i = γ
+ i − γ −
i , where γ + i and γ − i are i.i.d samples from P´olya (1 /n, e − ε/g ) .
Regret: Thanks to the generic regret bound in Lemma 2, we only need to verify Assumption 1.
To this end, fix any batch b and arm a , we have (cid:98)
y
= (cid:98) y a ( b ) , x i = r ia ( b ) and n = l ( b ) .
Then, in the following we will show that with probability at least 1 − 2 p
[Equation]
which implies that Assumption 1 holds with σ
= O (1 /ε ) and h =
O (1 /ε ) .
Inspired by Cheu & Yan (2021); Balle et al.
(2020), we first divide the LHS of equation 4 as follows.
[Table]
[Equation]
[Table]
[Equation]
where Term (i) captures the error due to private noise and modular operation, and Term (ii) captures the error due to random rounding.
To start with, we will bound Term (ii).
More specifically, we will show that for any p ∈ (0 , 1] , with probability at least 1 − p ,
[Equation]
Let ¯ x i :=
⌊ x i · g ⌋ , then (cid:98) x i =
¯ x i + Ber
( x i g − ¯ x i ) =
x i g +¯ x
i + Ber
( x i g − ¯ x i ) − x i g =
x i g + ι i , where ι i :=
¯ x i + Ber ( x i g − ¯ x i ) − x i g .
We have E [ ι i ] =
and ι i ∈ [ − 1 , 1] .
Hence, ι i is 1 -sub-Gaussian and as a result, 1 g (cid:80) i (cid:98) x i − (cid:80) i x i = 1 g (cid:80) i ι
i is n/g 2 -sub-Gaussian.
Therefore, by the concentration of sub-Gaussian (cf.
Lemma 6), we have
[Equation]
Hence, by the choice of g = ⌈ ε √ n ⌉ , we establish equation 5.
Now, we turn to bound Term (i).
Recall the choice of parameters: g = ⌈ ε √ n ⌉ , τ = ⌈ gε log(2 /p )
⌉ , and m = ng
+ 2 τ + 1 .
We would like to show that
[Equation]
which implies that for any p ∈ (0 , 1] , with probability at least 1 − p
[Equation]
To show equation 6, the key is to bound the error due to private noise and handle the possible underflow carefully.
First, we know that the total private noise (cid:80) i η i is distributed as Lap Z ( g/ε ) .
Hence, by the concentration of discrete Laplace (cf.
Fact 3), we have
[Equation]
Let E noise denote the event that (cid:80) i (cid:98)
x
i + η i ∈ [ (cid:80) i (cid:98) x
i − τ, (cid:80) i (cid:98) x
i + τ ] , then by the above inequality, we have P [
E noise ] ≥ 1 − p .
In the following, we condition on the event of E noise to analyze the output
[Equation]
y ) .
As already shown in equation 3, the input (cid:98)
y
=
( (cid:80) i (cid:98) x i + η i ) mod m is already an integer.
We let y = (cid:98) y .
We will consider two cases of y as in the analyzer subroutine A .
Case 1: y > ng + τ .
We argue that this happens only when (cid:80) i (cid:98) x
i + η i ∈ [ − τ, 0) , i.e., underflow.
This is because for all i ∈ [ n ] , (cid:98) x i ∈
[0 , g ] , m = ng + 2 τ +
and the total privacy noise is at most τ under E noise .
Therefore,
[Equation]
That is, y − m ∈
[ (cid:80) i (cid:98) x
i − τ, (cid:80) i (cid:98) x
i + τ ] with high probability.
In other words, we have shown that when y > ng + τ , A ( (cid:98) y ) =
y − mg satisfies equation 6.
Case 2: y ≤ ng + τ .
Here, we have noisy sum (cid:80) i (cid:98) x
i + η i ∈ [0 , ng + τ ] .
Hence, y = (cid:80) i (cid:98) x
i + η i since m = ng
+ 2 τ + 1 , which implies that A ( (cid:98) y ) =
yg satisfies equation 6.
Hence, we have shown that the output of the analyzer under both cases satisfies equation 6, which implies equation 7.
Combined with the bound in equation 5, yields the bound in equation 4.
Finally, plugging in σ = O (1 /ε ) , h
= O (1 /ε ) into the generic regret bound in Lemma 2, yields the required regret bound and completes the proof.
D. P URE DP VIA S HUFFLING
As stated in the main paper (see Remark 1), one can achieve same privacy and regret guarantees (orderwise) using a relaxed SecAgg protocol, which relaxes the SecAgg protocol mentioned above in the following sense: (i) relaxed correctness – the output of S can be used to compute the correct modular sum except at most a small probability (denoted by (cid:98) q ); (ii) relaxed security – the output of
S reveals only (cid:98) ε more information than the modular sum result.
Putting the two aspects together, one obtains a relaxed protocol denoted by ( (cid:98) ε, (cid:98) q ) -SecAgg.
One important benefit of using this relaxation is that it allows us to achieve the same results of Theorem 1 via secure shuffling.
More specifically, as shown in Cheu & Yan (2021), there exists a shuffle protocol that can simulate an ( (cid:98) ε, (cid:98) q ) -SecAgg.
Hence, we can directly instantiate S using this shuffle protocol to achieve pure DP in the distributed model while obtaining the same regret bound as in the central model.
We provide more details on this shuffle protocol below.
To facilitate our discussion, we briefly give more formal definitions of a relaxed SecAgg based on Cheu & Yan (2021), which will also be used in our next proof.
We denote a perfect SecAgg as Σ .
To start with, we first need the following two distance metrics between two probability distributions.
As in Cheu & Yan (2021), for a given distribution D and event E , we write P [ D ∈ E ] for P η ∼ D [ η ∈
E ] .
We let supp ( D , D ′ ) be the union of their supports.
Definition 6 (Statistical Distance) .
For any pair of distributions D , D ′ , the statistical distance is given by
[Equation]
Definition 7 (Log-Likelihood-Ratio (LLR) Distance) .
For any pair of distributions D , D ′ , the LLR distance is given by
[Equation]
Pure DP can be defined using LLR distance.
Definition 8.
A randomized mechanism M is ( ε, 0)
-DP
if for any two neighboring datasets D, D ′ ,
LLR ( M ( D ) , M ( D ′ )) ≤ ε
Definition 9 (Relaxed SecAgg) .
We say S is an ( (cid:98) ε, (cid:98) q ) -relaxation of Σ (i.e., ( (cid:98) ε, (cid:98) q ) -relaxed
SecAgg) if it satisfies the following two conditions for any input y .
( (cid:98) q -relaxed correctness)
There exists some post-processing function POST such that SD ( POST ( S ( y )) , Σ( y ))
≤ (cid:98) q .
( (cid:98) ε -relaxed security)
There exists a simulator SIM such that LLR ( S ( y ) ,
SIM (Σ( y ))) ≤ (cid:98) ε .
Cheu & Yan (2021) show that one can simulate a relaxed SecAgg via a shuffle protocol.
We now briefly talk about the high-level idea behind this idea and refer readers to Cheu & Yan (2021) for details.
To simulate an ( (cid:98) ε, (cid:98) q ) -SecAgg via shuffling
, the key is to introduce another local randomizer on top of the original R .
More specifically, we let S :
= S ◦ R n in Algorithm 1 with n = l ( b ) , b ≥ 1 , where R denotes the additional local randomizer at each user i ∈ [ n ] that maps the output of R (i.e., y i ) into a random binary vector of a particular length d .
Then, S denotes a standard shuffler that uniformly at random permutes all the received bits from n users (i.e., a total of n · d bits).
The nice construction of R in Cheu & Yan (2021) ensures that S = S ◦ R n can simulate an ( (cid:98) ε, (cid:98) q ) -SecAgg for any (cid:98) ε, (cid:98) q ∈ (0 , 1) .
The following theorem says that a relaxed SecAgg is sufficient for the same order of expected regret bound while guaranteeing pure DP.
Theorem 3 (Pure-DP via Shuffling) .
Fix ε > 0 and T ∈ N and consider an ( (cid:98) ε, (cid:98) q ) -SecAgg (e.g., simulated via shuffling) for Algorithm 1 6 .
Let noise for i -th user be η i = γ
+ i − γ −
i , where γ + i , γ − i i.i.d.
∼
P´olya (1 /n, e − ε/g ) .
For each batch b , choose n = l ( b ) , g = ⌈ ε ′ √ n ⌉ , τ
= ⌈ g ε ′ log(2 /p
⌉ , and m = ng
+ 2 τ + 1 , (cid:98) ε = ε/ 4 , ε ′ =
ε/ 2 , (cid:98) q = p ′
=
12 T .
Then, Algorithm 1 achieves ( ε, 0) -DP in the distributed model.
Moreover, setting β ( b ) =
O (cid:18)(cid:113) log( | Φ( b ) | b 2 T ) 2 l ( b )
[Equation]
2log
[Equation]
| Φ
[Equation]
b ) | b 2 T )
[Equation]
b ) (cid:19) , it enjoys expected regret
[Equation]
Moreover, the communication per user before S is O (log m ) bits.
Proof.
This proof shares the same idea as in the proof of Theorem 1.
We only need to highlight the difference.
Privacy : As before, we need to ensure that the view of the server already satisfies ε -DP for each batch b ≥ 1 .
In the following, we fix any batch b and arm a , we have x i =
r ia ( b ) and n = l ( b ) .
Thus, by Definition 8, it suffices to show that for any two neighboring datasets
[Equation]
To this end, by the (cid:98) ε -relaxed security of S used in Algorithm 1 and triangle inequality, we have
[Equation]
where the last inequality follows from data processing inequality.
The remaining step to bound the second term above is the same as in the proof of Theorem 1.
With (cid:98) ε
= ε/ 4 and ε ′ =
ε/ 2 , we have the total privacy loss is ε .
Regret: As before, the key is to establish that with high probability
[Equation] [Equation]
where (cid:98)
y :
= (cid:98) y a ( b ) .
[Equation]
In particular, Term (ii) can be bounded by using the same method,
i
[Equation]
e., for any p ′ ∈ (0 , 1] , with probability at least 1 − p ′ ,
[Equation]
For Term (i), we would like to show that
[Equation]
This can be established by the same steps in the proof of Theorem 1 while conditioning on the high probability event that S is (cid:98) q -relaxed SecAgg.
More specifically, compared to the proof of Theorem 1, the key difference here is that (cid:98) y
=
( (cid:80) i y i ) mod m only holds with high probability 1 − (cid:98) q by the definition of (cid:98) q -relaxed SecAgg.
Thus, for any p ′ ∈ (0 , 1) , let (cid:98) q = p ′ , we have with probability at least 1 − 3 p ′ , |A
( (cid:98) y ) − (cid:80)
i x i | ≤
O (cid:16) 1 ε (cid:112) log(2 /p
+ 1 ε log(2 /p ′ ) (cid:17) , which implies that Assumption 1 holds with σ = O (1 /ε ) and
h =
O (1 /ε ) .
E A PPENDIX FOR RDP IN S ECTIONE. P ROOF OF P ROPOSITION
Proof.
We first establish the following result.
Claim 1.
For all λ ∈ R , we have
[Equation]
To show this, by the infinite product representation of the hyperbolic cosine function, we have
[Equation]
where (a) holds by the fact that 1 + x ≤ e x for all x ∈ R and (b) follows from (cid:80) ∞
k =
[Equation]
2 = π 2 8 .
Then, note that X ∼ Sk (0 , σ 2 ) , then its moment generating function (MGF) is given by E (cid:2)
e λX (cid:3) =
exp( σ 2 (cosh( λ ) − 1)) .
Hence, by the above claim, we have E (cid:2)
e λX (cid:3) ≤ exp( σ 2 ( e λ 2 / 2 − 1) .
Further, note that e x − 1 ≤ 2 x for x ∈ [0 , 1] .
Thus, for | λ | ≤ √ 2 , we have
[Equation]
Hence, by the definition of sub-exponential random variable (cf.
Lemma 7), X is (2 σ 2 , √ 22 ) -subexponential, which again by Lemma 7 implies the required concentration result, i.e., for any p ∈ (0 , 1] , with probability at least 1 − p ,
[Equation]
E. P ROOF OF T HEOREM
We will leverage the following result in (Agarwal et al., 2021, Theorem 3.5 ) to prove privacy guarantee.
Lemma 3.
For α ∈ Z , α > 1 , let X ∼ Sk (0 , σ 2 ) .
Then, an algorithm M that adds X to a sensitivity- ∆ query satisfies ( α, ε ( α )) -RDP with ε ( α ) given by
[Equation]
Proof of Theorem 2.
Privacy: As before, we fix any batch b and arm a , for simplicity, we let x i = r ia
( b ) and n = l ( b ) .
Then, it suffices to show that the mechanism H that accepts an input dataset { (cid:98)
x i } i and outputs (cid:80) i (cid:98) x
i + (cid:80) i
η i is private.
To this end, since each local randomizer R generates noise η i ∼ Sk (0 , g 2 nε 2 ) and Skellam is closed under summation, we have that the total noise (cid:80) i η i ∼
Sk (0 , g 2 ε 2 ) .
Thus, by Lemma 3 with ∆ = g , we have that for each batch b with n = l ( b ) and g = ⌈ sε √ n ⌉ , Algorithm 1 is ( α, (cid:98) ε n ( α ))
-RDP with (cid:98) ε n ( α ) given by
[Equation]
Since n = l ( b ) > 1 , we have that for all batches b ≥ 1 ,
[Equation]
Regret: We will establish the following high probability bound so that we can apply our generic regret bound in Lemma
[Equation]
where (cid:98)
y :
= (cid:98) y a ( b ) for each batch b and arm a .
We again divide the LHS of equation 9 into
[Equation]
In particular
[Equation]
Term (ii) can be bounded by using the same method before, i.e.,
[Equation]
Hence, by the choice of g = ⌈ sε √ n ⌉ , we establish that with high probability
Term (ii
[Equation]
For Term (i), as in the previous proof, the key is to show that
[Equation]
To this end, we will utilize our established result in Proposition 1.
Note that the total noise (cid:80) i η i ∼
Sk (0 , g 2 ε 2 ) , and hence by Proposition 1 and the choice of τ = ⌈ 2 gε (cid:112) log(2 /p )
+ √ 2 log(2 /p )
⌉ , we have the above result.
Following previous proof, this result implies that with high probability
[Equation]
Combining the bounds on Term (i) and Term (ii), we have that the private noise satisfies Assumption 1 with constants σ = O (1 /ε ) and
h =
O ( 1 sε ) .
Hence, by the generic regret bound in Lemma 2, we have established the required result.
F A CHIEVING CDP IN THE D ISTRIBUTED M ODEL VIA D ISCRETE G AUSSIAN
We first introduce the following definition of concentrated differential privacy Bun & Steinke (2016).
Definition 10 (Concentrated Differential Privacy) .
A randomized mechanism M satisfies 12 ε 2 -CDP if for all neighboring datasets D, D ′ and all α ∈ (1 , ∞ ) , we have D α ( M ( D ) , M ( D ′ )) ≤ 12 ε 2 α .
Remark 5 (CDP vs. RDP) .
From the definition, we can see that 12 ε 2 -CDP is equivalent to satisfying ( α, 12 ε 2 α ) -RDP simultaneously for all α > 1 .
The discrete Gaussian mechanism is first proposed and investigated by Canonne et al.
and has been recently applied to federated learning Kairouz et al.
(2021a).
We apply it to bandit learning to demonstrate the flexibility of our proposed algorithm and analysis.
Definition 11 (Discrete Gaussian Distribution) .
Let µ, σ ∈ R with σ > 0 .
A random variable X has a discrete Gaussian distribution with location µ and scale σ , denoted by N Z ( µ, σ 2 ) , if it has a probability mass function given by
[Equation]
The following result from Canonne et al.
(2020) will be useful in our privacy and regret analysis.
Fact 2 (Discrete Gaussian Privacy and Utility) .
Let ∆ , ε > 0 .
Let q : X n → Z satisfy | q ( x ) − q ( x ′ ) | ≤ ∆ for all x, x ′ differing on a single entry.
Define a randomized algorithm
M : X n → Z by M ( x ) =
q ( x )+ Y , where Y ∼ N Z (0 , ∆ 2 /ε 2 ) .
Then, M satisfies 12 ε 2 -concentrated differential privacy (CDP).
Moreover, Y is ∆ 2 /ε 2 -sub-Gaussian and hence for all t ≥ 0 ,
[Equation]
However, a direct application of above results does not work.
This is because the sum of discrete
Gaussian is not a discrete Gaussian, and hence one cannot directly apply the privacy guarantee of discrete Gaussian when analyzing the view of the analyzer via summing all the noise from users.
To overcome this, we will rely on a recent result in Kairouz et al.
(2021a), which shows that under reasonable parameter regimes, the sum of discrete Gaussian is close to a discrete Gaussian.
The regret analysis will again build on the generic regret bound for Algorithm 1.
Theorem 4 (CDP via SecAgg) .
Fix ε ∈ (0 , 1) and a scaling factor s ≥ 1 .
Let noise for i -th user be η i ∼ N Z
(0 , g 2 nε 2 ) .
For each b ≥ 1 , choose n = l ( b ) , g = ⌈ sε √ n ⌉ , τ = ⌈ gε
[Equation]
2 log(
[Equation]
p ) ⌉ , p = 1 /T and m = ng + 2 τ + 1 .
Then, Algorithm 1 achieves 12 (cid:98) ε 2 -CDP with (cid:98) ε given by
[Equation]
(cid:40)(cid:114)
[Equation]
where ξ := 10 · (cid:80) T 2 − 1 k =1 e −
π 2 s 2 · kk +1 .
Meanwhile, the regret is given by
[Equation]
and the communication messages per user before S are O (log m ) bits.
Remark 6 (Privacy-Communication Trade-off) .
We can observe an interesting trade-off between privacy and communication cost.
In particular, as s increases, ξ approaches zero and hence the privacy loss approaches the one under continuous Gaussian.
However, a larger s leads to a larger m and hence a larger communication overhead.
We will leverage the following result in (Kairouz et al., 2021a, Proposition 13) to prove privacy.
Lemma 4 (Privacy for the sum of discrete Gaussian) .
Let σ ≥ 1 / 2 .
Let X i ∼ N Z (0 , σ 2 ) independently for each i .
Let Z n = (cid:80) ni
=1 X i .
Then, an algorithm M that adds Z n to a sensitivity- ∆ query satisfies 12 ε 2 -CDP with ε given by
[Equation]
where ξ := 10 · (cid:80) n − 1 k
=1 e − 2 π 2 σ 2 kk +1 .
Proof of Theorem 4.
Privacy: As before, we fix any batch b and arm a , for simplicity, we let x i = r ia
( b ) and n = l ( b ) .
Then, it suffices to show that the mechanism H that accepts an input dataset { (cid:98)
x i } i and outputs (cid:80) i (cid:98) x
i + (cid:80) i
η i is private.
To this end, each local randomizer R generates noise η i ∼ N Z (0 , g 2 nε 2 ) , and hence by Lemma 4 with ∆ =
g , we have that H is 12 (cid:98) ε 2 n -concentrated differential privacy with (cid:98) ε n given by
[Equation]
where ξ n := 10 · (cid:80) n − 1 k =1 e − 2 π 2 g 2 nε 2 · kk +1 .
Note that g = ⌈ sε √ n ⌉ , we have τ n ≤ τ := 10 · (cid:80) T 2 − 1 k
=1 e −
π 2 s 2 · kk +1 since n = l ( b ) ≤ T/ 2 .
Thus, we have that Algorithm 1 is is 12 (cid:98) ε 2 -concentrated differential privacy with (cid:98) ε given by
[Equation]
where ξ := 10 · (cid:80) T 2 − 1 k =1 e −
π 2 s
[Equation]
kk +1 .
Regret: We will establish the following high probability bound so that we can apply our generic regret bound in Lemma
[Equation]
where (cid:98)
y :
= (cid:98) y a ( b ) .
We again divide the LHS of equation 10 into
[Equation]
In particular, Term (ii) can be bounded by using the same method before, i
[Equation]
e.,
[Equation]
≤ p.
Hence, by the choice of g = ⌈ sε √ n ⌉ , we establish that with high probability
Term (
[Equation]
O
[Equation]
For Term (i), as in the previous proof, the key is to show that
[Equation]
This follows from the fact that discrete Gaussian is sub-Gaussian and sum of sub-Gaussian is still sub-Gaussian.
Thus, by Lemma 6 and the choice of τ = gε (cid:112) 2 log(2 /p ) , we have the above result, which implies that with high probability
[Equation]
Since s ≥ 1 , combining the bounds on Term (i) and Term (ii), we have that the private noise satisfies
Assumption 1 with constants σ = O (1 /ε ) and h = 0 .
Hence, by the generic regret bound in
Lemma 2, we have established the required result.
G M ORE D ETAILS ON S ECURE A GGREGATION AND S ECURE S HUFFLING
In this section, we provide more details about secure aggregation (SecAgg) and secure shuffling including practical implementations and recent theoretical results for DP guarantees.
We will also discuss some limitations of both protocols, which in turn highlights that both have some advantages over the other and thus how to select them really depends on particular applications.
G. S ECURE A GGREGATION
Practical implementations: SecAgg is a lightweight instance of secure multi-party computation (MPC) based on cryptographic primitives such that the server only learns the aggregated result (e.g., sum) of all participating users’ values.
This is often achieved via additive masking over a finite group (Bonawitz et al., 2017; Bell et al., 2020).
The high-level idea is that participating users add randomly sampled zero-sum mask values by working in the space of integers modulo m , which guarantees that each user’s masked value is indistinguishable from a random value.
However, when all masked values are summed modulo m by the server, all the masks will be cancelled out and the server observes the true modulo sum.
Bonawitz et al.
(2017) proposed the first scalable SecAgg protocol where both communication and computation costs of each user scale linearly with the number of all participating users.
Recently, Bell et al.
(2020) presents a further improvement where both client computation and communication depend logarithmically on the number of participating clients.
SecAgg for distributed DP: First note that the fact that the server only learns the sum of values under SecAgg does not necessarily imply differential privacy since this aggregated result still has the risk of leaking each user’s sensitive information.
To provide a formal DP guarantee under SecAgg, each participating user can first perturb her own data with a moderate random noise such that in the aggregated sum, the total noise is large enough to provide a high privacy guarantee.
Only until recently, SecAgg with DP has been systematically studied, mainly in the context of private (federated) supervised learning (Kairouz et al., 2021a; Agarwal et al., 2021) while SecAgg in the context of private online learning remains open until our work.
More importantly, there exist no formal convergence guarantees of SGD in Kairouz et al.
(2021a);
Agarwal et al.
(2021) due to the biased gradient estimates.
To the best of our knowledge, the very recent work (Chen et al., 2022b) is the only one that derives upper bound on the convergence rate when working with SecAgg in private supervised learning.
However, the privacy guarantee in it is only approximated DP rather than pure
DP considered in our paper.
Limitations of SecAgg: As pointed out in Kairouz et al.
(2021b), several limitations of SecAgg still exist despite of recent advances.
For example, it assumes a semi-honest server and allows it to see the per-round aggregates.
Moreover, it is not efficient for sparse vector aggregation.
G. S ECURE S HUFFLING
Practical implementations: Secure shuffling ensures that the server only learns an unordered collection (i.e., multiset) of the messages sent by all the participating users.
This is often achieved by a third party shuffling function via cryptographic onion routing or mixnets (Dingledine et al., 2004) or oblivious shuffling with a trusted hardware (Bittau et al., 2017).
Secure shuffling for distributed DP: The additional randomness introduced by the shuffling function can be utilized to achieve a similar utility as the central model while without a trustworthy server.
This particular distributed model via secure shuffling is also often called shuffle model .
In particular, Cheu et al.
(2019) first show that for the problem of summing n real-valued numbers within [0 , 1] , the expected error under shuffle model with ( ε, δ ) -DP guarantee is O ( 1 ε log nδ ) .
For comparison, under the central model, the standard Laplace mechanism achieves ( ε, 0) -DP
(i.e., pure DP) with an error O (1 /ε )
(Dwork et al., 2006) while an error Ω( √ n/ε ) is necessary under the local model (Chan et al., 2012;
Beimel et al., 2008).
Subsequent works on private scalar sum under the shuffle model have improved both the communication cost and accuracy in Cheu et al.
More specifically, instead of sending O ( ε √ n ) bits per user as in Cheu et al.
, the protocols proposed in Balle et al.
Ghazi et al.
(2020b) achieve ( ε, δ ) -DP with an error O (1 /ε ) while each user only sends O (log n + log(1 /δ ))
bits.
A closely related direction in the shuffle model is privacy amplification bounds (Erlingsson et al., 2019; Balle et al., 2019; Feldman et al., 2022).
That is, the shuffling of n locally private data yields a gain in privacy guarantees.
In particular, Feldman et al.
(2022) 7 show that randomly shuffling of n ε
-DP locally randomized data yields an ( ε, δ ) -DP guarantee with ε =
O (cid:18) ε 0 √ log
[Table]
√ n
[Table] [Table]
=
[Table] [Table]
[Table] [Table]
>
Shuffle model has also been studied in the context of empirical risk minimization (ERM) (Girgis et al., 2021) and stochastic convex optimization (Cheu et al., 2021; Lowy & Razaviyayn, 2021), in an attempt to recover some of the utility under the central model while without a trusted server.
To the best of our knowledge, Tenenbaum et al.
; Chowdhury & Zhou (2022b); Garcelon et al.
(2022) are the only works that study shuffle model in the context of bandit learning.
In all the above mentioned works on shuffle model, only approximate DP is achieved.
To the best of our knowledge, there are only two existing shuffling protocols that can attain pure DP (Ghazi et al., 2020a; Cheu & Yan, 2021).
In particular, by simulating a relaxed SecAgg via a shuffle protocol, Cheu & Yan (2021) are the first to show that there exists a shuffle protocol for bounded sums that satisfies ( ε, 0) -DP with an expected error of O (1 /ε ) .
This is main inspiration for us to achieve pure DP in MAB with secure shuffling.
Limitations of secure shuffling: As pointed out in Kairouz et al.
(2021b), one of the limitations is the requirement of a trusted intermediary for the shuffling function.
Another is that the privacy guarantee under the shuffle model degrades in proportion to the number of adversarial users.
H A LGORITHM 1 UNDER C ENTRAL AND L OCAL M ODELS
In this section, we will show that Algorithm 1 and variants of our template protocol P allow us to achieve central and local DP using only discrete noise while attaining the same optimal regret bound as in previous works using continuous noise (Sajed & Sheffet, 2019; Ren et al., 2020).
H. C ENTRAL M ODEL
For illustration, we will mainly consider S as a SecAgg, while secure shuffling can be applied using the same way as in the main paper.
In the central model, we just need to set η i = 0 in the local randomizer R and add central noise in the analyzer
A (see Algorithm 2 and Algorithm 3).
Then, we have the following privacy and regret guarantees.
Theorem 5 (Central Pure-DP via SecAgg) .
Let P =
( R , S , A ) be a protocol such that R given by Algorithm 2,
S is any SecAgg protocol and A is given by Algorithm 3 with η ∼ Lap Z ( g/ε ) .
Fix any ε ∈ (0 , 1) , for each b ≥ 1 , choose n = l ( b ) ,
g = ⌈ ε √ n ⌉ , τ = ⌈ gε log(2 /p )
⌉ , p = 1 /T and m = ng + 2 τ + 1 .
Then, Algorithm 1 instantiated with protocol
P is able to achieve ( ε, 0)
-DP in the central model with expected regret given by
[Equation]
Moreover, the communication messages per user before S are O (log m ) bits.
Remark 7.
We can generate η ∼ Lap Z ( g/ε ) as η = η 1 − η 2 , where η 1 , η 2 is independent and polya (1 , e − ε/g ) distributed.
Proof of Theorem 5.
Privacy: By the definition of central DP and post-processing, it suffices to show that y in Algorithm 3 is private.
To this end, we again apply the distributive property of modular sum to obtain that
[Equation]
Since the sensitivity of (cid:80) i (cid:98) x i is g and η ∼ Lap Z ( g/ε ) , by Fact 3, we have obtained ( ε, 0)
-DP in the central model.
Regret: As before, the key is to establish that with high probability
[Equation]
where (cid:98)
y :
= (cid:98) y a ( b ) .
Then, we can apply our generic regret bound in Lemma 2.
We again can divide the LHS of equation 11 into
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
In particular, Term (ii) can be bounded by using the same method, i.e., for any p ∈ (0 , 1] , with probability at least 1 − p ,
[Equation]
For Term (i), we would like to show that
[Equation]
As before, let E noise denote the event that ( (cid:80) i (cid:98) x i ) + η ∈ [ (cid:80) i (cid:98) x i − τ, (cid:80) i (cid:98) x
i + τ ] , then by the concentration of discrete Laplace, we have P [
E noise ] ≥ 1 − p .
In the following, we condition on the event of
E noise to analyze the output A ( (cid:98) y ) .
Note that y
=
(( (cid:80) i (cid:98) x i ) + η ) mod m and hence we can use the same steps as in the proof of Theorem 1 to conclude that
[Equation]
Finally, by our generic regret bound in Lemma 2, we have the regret bound.
[Equation]
In the local model, each local randomizer R needs to inject discrete Laplace noise to guarantee pure
DP while the analyzer A is simply the same as in the main paper (see Algorithm 4 and Algorithm 5).
To analyze the regret, we need the concentration of the sum of discrete Laplace.
To this end, we have the following result.
Lemma 5 (Concentration of discrete Laplace) .
Let { X i } ni
=1 be i.i.d random variable distributed according to Lap Z (1 /ε ) .
Then, we have X i is ( c 2 1 ε 2 , c
1 ε ) -sub-exponential for some absolute con-
[Table] [Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]
[Table] [Table]
set
[Table]
6: else
[Table] [Table]
stant c > 0 .
As a result, we have for any p ∈ (0 , 1] , with probability at least 1 − p , | (cid:80) ni =1 X
i | ≤ v , where v ≥ max { cε (cid:112) 2 n log(2 /p ) , 2 cε log(2 /p ) } .
Proof.
First, we note that if X ∼ Lap Z (1 /ε ) , then it can rewritten as X = N 1 − N 2 where N 1 , Nis geometrically distributed, i.e., P [ N 1 = k ] =
P [ N 2 = k ] =
β k (1 − β ) with β = e − ε .
We can also write it as X = ˜ N 1 − ˜ N 2 , where ˜ N 1 = N 1 − E [ N 1 ] and ˜ N 1 = N 2 − E [ N 2 ] , since E [ N 1 ] =
E [ N 2 ] .
Then, by (Hillar & Wibisono, 2013, Lemma 4.3) and the equivalence of different definitions of sub-exponential (cf.
Proposition 2.7.1 in Vershynin (2018)), we have ˜ N 1 , ˜ N 2 are ( c 21 1 ε 2 , c 1 1 ε ) -subexponential for some absolute constant c 1 > 0 .
Now, since X = ˜ N 1 − ˜ N 2 , by the weighted sum of zero-mean sub-exponential (cf.
Corollary 4.2 in Zhang & Chen (2020)), we have X is ( c 2 1 ε 2 , c 1 ε ) - sub-exponential for some absolute constant c > 0 .
Thus, by Lemma 9, we have for any p ∈ (0 , 1] , let v ≥ max { cε (cid:112) 2 n log(2 /p ) , 2 cε log(2 /p ) } , with probability at least 1 − p , | (cid:80) i X i | ≤ v .
Theorem 6 (Local Pure-DP via SecAgg) .
Let P =
( R , S , A ) be a protocol such that R given by Algorithm 4 with η i ∼ Lap Z
( g/ε ) , S is any SecAgg protocol and A is given by Algorithm 5.
Fix any ε ∈ (0 , 1) , for each b ≥ 1 , choose n = l ( b ) , g = ⌈ ε √ n ⌉ , τ = ⌈ cgε (cid:112) 2 n log(2 /p )
⌉ ( c is the constant in Lemma 5), p = 1 /T and m =
ng + 2 τ + 1 .
Then, Algorithm 1 instantiated with protocol P is able to achieve ( ε, 0)
-DP in the local model with expected regret given by
[Equation]
Moreover, the communication messages per user before S are O (log m ) bits.
Proof.
Privacy: By the privacy guarantee of discrete Laplace and the sensitivity of (cid:98) x i , we directly have the local pure DP for our algorithm.
Regret: The first step is to show that with high probabilit, for a large batch size n = l ( b ) ≥ 2 log(2 /p ) , (cid:12)(cid:12)(cid:12)(cid:12)(cid:12)
[Equation]
where (cid:98)
y :
= (cid:98) y a ( b ) .
[Table]
In particular, Term (ii) can be bounded by using the same method,
i
[Table]
e., for any p ∈ (0 , 1] , with probability at least 1 − p ,
[Table]
To bound Term (i)
[Table]
the key is again to bound the total noise (cid:80) i
η i , i
[Table]
e.,
[Table]
To this end, by Lemma 5, when n = l ( b ) ≥ 2 log(2 /p ) and τ = cgε (cid:112) 2 n log(2 /p ) , the above concentration holds.
Then, following the same steps as before, we can conclude that Term ( i ) ≤
O ( 1 ε (cid:112) 2 l ( b ) log(1 /p ))
when l ( b ) ≥ 2 log(2 /p ) .
We then make a minor modification of the proof of Lemma 2.
The idea is simple: we divide the batches into two cases – one is that l ( b ) ≥ 2 log(2 T ) (noting p = 1 /T ) and the other is that l ( b ) ≤ 2 log(2 T ) .
First, one can easily bound the total regret for the second case.
In particular, during all the batches such that l ( b ) ≤ 2 log(2 T ) , the total regret is bounded by O (( K − 1) log T ) .
For the first case where l ( b ) is large, by equation 13 and the same steps in the proof of Lemma 2, we can conclude that
[Equation]
where ˜ b a is the last batch such that the suboptimal arm a is still active.
Thus, putting everything together and noting that ∆ a ≤ 1 and ε ∈ (0 , 1) , we have
[Equation]
I T IGHT P RIVACY A CCOUNTING FOR R ETURNING U SERS VIA RDP
In this section, we demonstrate the key advantages of obtaining RDP guarantees compared to approximate DP in the context of MAB.
The key idea here is standard in privacy literature and we provide the details for completeness.
The key message is that using the conversion from RDP to approximate DP allows us to save additional logarithmic factor in δ in the composition compared to using advanced composition theorem.
In the main paper, as in all the previous works on private bandit learning, we focus on the case where the users are unique, i.e., no returning users.
However, if some user returns and participates in multiple batches, then the total privacy loss needs to resort to composition.
In particular, let us consider the following returning situations.
Assumption 2 (Returning Users) .
Any user can participate in at most B batches, but within each batch b , she only contributes once.
Note that the total B batches can even span multiple learning process, each of which consists of a
T -round MAB online learning.
Let’s first consider approximate DP in the distributed model, e.g., binomial noise in Tenenbaum et al.
(2021) via secure shuffling.
To guarantee that each user is ( ε, δ ) -DP during the entire learning process, by advanced composition theorem (cf.
Theorem 7), we need to guarantee that each batch b ∈ [ B ] , it is ( ε i , δ i ) -DP, where ε i = ε 2 √ 2 B log(1 /δ ′ ) , δ i =
δ 2 B and δ ′ =
δ 2 .
Thus, for each batch the variance of the privacy noise is
[Equation]
Now, we turn to the case of RDP, (e.g., obtained via Skellam mechanism in Theorem 2 or via discrete
Gaussian in Theorem 4).
To gain the insight, we again consider the case that the scaling factor s is large enough such that for each batch b , it is ( α, αε 2 2 ) -RDP for all α , i.e., it is approximately ε 2 2 -CDP.
Thus, B composition of it yields that it is now Bε 2 2 -CDP, and by the conversion lemma (cf.
Lemma 10), it is ( ε ′ , δ ) -DP with ε ′ =
O ( ε (cid:112) B log(1 /δ )) .
Thus, in order to guarantee ( ε, δ ) -DP in the distributed model, the variance of the privacy noise at each batch is
[Equation]
Comparing equation 14 and equation 15, one can immediately see the gain of log( B/δ ) in the variance, which will translate to a gain of O ( (cid:112) log( B/δ )) in the regret bound.
Remark 8.
For a more accurate privacy accounting, a better way is to consider using numeric evaluation rather than the above loose bound.
Remark 9.
If one is interested in pure DP, then by simple composition, the privacy loss scales linearly with respect to B rather than √ B .
J M ORE D ETAILS ON S IMULATIONS
We numerically compare the performance of Algorithm 1 under pure-DP and RDP guarantees in the distributed model (named Dist-DP-SE and Dist-RDP-SE, respectively) with the DP-SE algorithm of
Sajed & Sheffet (2019), which achieves pure-DP under the central model.
We vary the privacy level as ε ∈ { 0 . 1 , 0 . 5 , 1 } , where a lower value of ε indicates higher level of privacy.
In Figure 2, we consider the easy instance, i.e., where arm means are sampled uniformly in [0 . 25 , 0 .
In Figure 3, we consider the hard instance, i.e., where arm means are sampled uniformly in [0 . 45 , 0 . 55] .
The sampled rewards are Gaussian distributed with the given means and truncated to [0 , 1] .
We plot results for K = 10 arms.
We see that, for higher value of time horizon T , the time-average regret of Dist-DP-SE is order-wise same to that of DP-SE, i.e., we are able to achieve similar regret performance in the distributed trust model as that is achieved in the central trust model.
As mentioned before, we observe a gap for small value of T , which is the price we pay for discrete privacy noise (i.e., additional data quantization error on the order of O ( 1 ε (cid:112) log(1 /p )) ) and not requiring a trusted central server.
Hence, if we lower the level of privacy (i.e., higher value of ε ), this gap becomes smaller, which indicates an inherent trade-off between privacy and utility.
We also observe that if we relax the requirement of privacy from pure-DP to RDP, then we can achieve a considerable gain in regret performance; more so when privacy level is high (i.e., ε is small).
This gain depends on the scaling factor s – the higher the scale, the higher the gain in regret.
In Figure 4, we compare regret achieved by our generic batch-based successive arm elimination algorithm
(Algorithm 1) instantiated with different protocols P under different trust models and privacy guarantees: (i) central model with pure-DP (CDP-SE), (ii) local model with pure-DP (LDP-SE), (iii) Distributed model with pure-DP (Dist-DP-SE), Renyi-DP (Dist-RDP-SE) and ConcentratedDP (Dist-CDP-SE).
First, consider the pure-DP algorithms.
We observe that regret performance of
CDP-SE and Dist-DP-SE is similar (with a much better regret than LDP-SE).
Now, if we relax the pure-DP requirement, then we achieve better regret performance both for Dist-RDP-SE and DistCDP-SE.
Furthermore, Dist-CDP-SE performs better in terms of regret than Dist-RDP-SE.
This is due to the fact that under CDP, we use discrete Gaussian noise (which has sub-Gaussian tails) as opposed to the Skellam noise (which has sub-exponential tails) used under RDP.
In Figure 5, we show clear plots for our experiment on bandit instances generated from Microsoft
Learning to Rank dataset MSLR-WEB10K (Qin & Liu, 2013).
Round × 100 .0 .0 .0 .0 .
T i m ea v e r a g e
R e g r e t
DP-SE
Dist-DP-SE
Dist-RDP-SE(s=10) Dist-RDP-SE(s=100) 0 .0 .0 .0 .0 .1 . Round × 100 .0 .0 .0 .0 . T i m ea v e r a g e
R e g r e t
DP-SE Dist-DP-SE Dist-RDP-SE(s=10) Dist-RDP-SE(s=100) 0 .0 .0 .0 .0 .1 .
Round × 100 .0 .0 .0 .0 .
T i m ea v e r a g e
R e g r e t
DP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-RDP-SE(s=100)
Round × 100 .0 .0 .0 .0 .
T i m ea v e r a g e R e g r e t
DP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-RDP-SE(s=100) 0 .0 .0 .0 .0 .1 .
Round × 100 .0 .0 .0 .0 .
T i m ea v e r a g e
R e g r e t
DP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-RDP-SE(s=100) 0 .0 .0 .0 .0 .1 .
Round × 100 .0 .0 .0 .0 . T i m ea v e r a g e
R e g r e t
DP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-RDP-SE(s=100)
Round × 100 .0 .0 .0 .0 .
T i m ea v e r a g e
R e g r e t
CDP-SE
LDP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-CDP-SE(s=10) 0 .0 .0 .0 .0 .1 .
Round × 100 .0 .0 .0 .0 .
T i m ea v e r a g e
R e g r e t
CDP-SE
LDP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-CDP-SE(s=10) 0 .0 .0 .0 .0 .1 .
Round × 100 .0 .0 .0 .0 .
T i m ea v e r a g e
R e g r e t
CDP-SE
LDP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-CDP-SE(s=10)
Round × 100 .0 .0 .
T i m ea v e r a g e
R e g r e t
DP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-RDP-SE(s=100) 0 .0 .0 .0 .0 .1 .
Round × 100 .0 .0 .
T i m ea v e r a g e
R e g r e t
DP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-RDP-SE(s=100) 0 .0 .0 .0 .0 .1 .
Round × 100 .0 .0 .
T i m ea v e r a g e
R e g r e t
DP-SE
Dist-DP-SE
Dist-RDP-SE(s=10)
Dist-RDP-SE(s=100)
K A UXILIARY L EMMAS
In this section, we summarize some useful facts that have been used in the paper.
Fact 3 (Discrete Laplace Mechanism) .
Let ∆ , ε > 0 .
Let q : D n → Z satisfy | q ( D ) − q ( D ′ ) | ≤ ∆ for all D, D ′ differing on a single user’s data.
Define a mechansim M :
D n → Z by M ( D ) =
q ( D ) + Y , where Y ∼ Lap Z (∆ /ε ) .
Then, M satisfies ( ε, 0) -DP.
Moreover, for all m ∈ N ,
[Equation]
Lemma 6 (Concentration of sub-Gaussian) .
A mean-zero random variable X is σ 2 -sub-Gaussian if for all λ ∈ R
[Equation]
Then, it satisfies that for any p ∈ (0 , 1] , with probability at least 1 − p ,
[Equation]
Lemma 7 (Concentration of sub-exponential) .
A mean-zero random variable X is ( σ 2 , h ) -subexponential if for | λ | ≤ 1 /h
[Equation]
Then, we have
[Equation]
Thus, it satisfies that for any p ∈ (0 , 1] , with probability at least 1 − p , |
[Equation]
| ≤
[Equation]
2 σ (cid:112) log(
[Equation]
(2 /p ) .
Lemma 8 (Hoeffding’s Inequality) .
Let X 1 , . . .
, X n be independent and identically distributed (i.i.d) random variables and X i ∈ [0 , 1] with probability one.
Then, for any p ∈ (0 , 1] , with probability at least 1 − p ,
[Equation]
Lemma 9 (Sum of sub-exponential) .
Let { X i } ni
=1 be independent zero-mean ( σ 2 i , h i )
-subexponential random variables.
Then, (cid:80) i
X i is ( (cid:80) i σ
i , h ∗ ) -sub-exponential, where h ∗ := max i h i .
Thus, we have
[Equation]
In other words, for any p ∈ (0 , 1] , if v ≥ max { (cid:112) 2 (cid:80) i σ 2 i log(2 /p ) , 2 h ∗ log(2 /p ) } , with probability at least 1 − p , | (cid:80) i
X i | ≤ v .
Lemma 10 (Conversion Lemma) .
If M satisfies ( α, ε ( α ))
-RDP, then for any δ ∈ (0 , 1) , M satisfies ( ε, δ ) -DP where
[Equation]
If M satisfies 12 ε 2 -CDP, then for for any δ ∈ (0 , 1) , M satisfies ( ε ′ , δ ) -DP where
[Equation]
Moreover, if M satisfies ( ε, 0) -DP, then it satisfies ( α, 12 ε 2 α ) -RDP simultaneously for all α ∈ (1 , ∞ ) .
Theorem 7 (Advanced composition) .
Given target privacy parameters ε ′ ∈ (0 , 1) and δ ′ > 0 , to ensure ( ε ′ , kδ + δ ′ )
-DP for the composition of k (adaptive) mechanisms, it suffices that each mechanism is ( ε, δ ) -DP with ε =
[Equation]