【Rényi差分隐私和零集中差分隐私（差分隐私变体）代码实现】差分隐私代码实现系列（九）

写在前面的话

书上学来终觉浅，绝知此事要躬行。

回顾

1、全局敏感度具有局限性，一个是不好估计，另一个是不太贴近实际情况。就拿均值的敏感度举例，全局敏感度考虑最极端情况就是上限减去下限，同时这个上下限不好估计。并且实际情况肯定不是如此，要考虑具体数据集。

2、但是呢局部敏感度又不能像全局敏感度直接用拉普拉斯机制，因为当攻击者知道局部敏感度时（就算不知道多查几次也能推出来）会推测数据集信息，看均值的例子就行。为什么会这样？因为差分隐私只保护查询结果，不保护敏感度。这么说来我们不能直接用局部敏感度，但不代表它没用~

3、局部敏感度的全局敏感度~欸，我们可以从这个点考虑。那这就是一个估计全局敏感度的工作了。前文提到的框架就是设置一个局部敏感度的界限，看这个界限是否大于实际情况的局部敏感度，能成就释放结果。这是一个预知未来的事情哈哈哈哈哈。

4、怎么做？我们不是说一条记录不同的相邻数据集嘛，我们现在预知未来，考虑多条记录不同数据集的局部敏感度。在这些局部敏感度里面取最大值。问题来了~我们需要多少步才能得到这样的最大值大于我们设定的上限？通过设定询问解决这个问题。

5、我们先看看这个局部敏感度的变化程度，因为我们是增加或者减少行，所以对于局部敏感度来说其敏感度就是1。由此我们的噪声尺度就确定下来，由此在我们询问这个最大值时都会加上敏感度为1的拉普拉斯噪声，当不满足条件时返回假，满足则返回原查询结果加上设定的敏感度拉普拉斯噪声。

6、值得注意的是这种方法不是纯DP，因为第2步的噪声足够大的时候可能会满足条件，从而导致本应k步远离原始数据集的情况，在前面就确定下来了。这样的情况就是我们前面提到的灾难机制，简单来说这个方法允许攻击者的查询结果之加入很少的噪声。更极端一点，甚至不加噪声。同时注意，这框架不管攻击者有没有收到答案都会一直消耗隐私预算，直到耗尽。具体的例子代码实现了，小伙伴看就完事了~

差分隐私的变体

现在差分隐私的变体多种多样，相信大家阅读论文也接触了很多。这篇博客主要讲一下瑞丽差分隐私【Rényi differential privacy】和零集中差分隐私【zero-concentrated differential privacy】。

发明变体的动机

回想一下，我们展示的大多数隐私成本边界都是有上限的，但它们有时代表非常宽松的上限，即真正的隐私成本远低于上限。开发差分隐私的新变体的主要动机是实现更严格的隐私成本限制，特别是对于迭代算法，同时保持在实践中有用的隐私定义。

例如，灾难模式的宽松$(ϵ,\delta )$-差分隐私是不可取的。

ps.灾难模式前面提到过~

这些变体为某些类型的查询提供了更紧密的组合，同时消除了灾难模式。

我们一起来看一下$ϵ$-差分隐私的顺序组合。事实证明，$ϵ$-差分隐私的顺序组合很紧密。

这是什么意思？这意味着顺序组合有一个反例无法满足任何下限：

存在一种满足$ϵ$-差分隐私的机制$F$

当组合$k$次时，$F$满足$kϵ$-差分隐私

但是$F$不满足$c<k$-任何$cϵ$的差分隐私

是不是还没理解什么意思？

就是查看当我们"矢量化"查询时隐私成本会发生什么变化！

也就是说，我们将大量查询合并到一个查询中，该查询返回各个答案的矢量。

因为答案是向量，所以我们可以只使用一次向量值拉普拉斯机制，而完全避免组合。

为了让大家更好理解，将绘制$k$查询需要多少噪声的图，首先在顺序组合下，然后使用"矢量化"形式。

在顺序组合情况下，每个查询的敏感度为 1，因此每个查询的噪声小数位数为$\frac{1}{{ϵ}_i}$。如果我们想要一个总的隐私成本$ϵ$，那么${ϵ}_i$必须加起来就是$ϵ$，所以${ϵ}_i=\frac{ϵ}{k}$。

这意味着每个查询都获取带有尺度（scale）$\frac{k}{ϵ}$ 的拉普拉斯噪声。在"矢量化"的情况下，只有一个查询，但它的 L1 敏感度为 ${\sum }_{i=1}^{k}1=k$，因此在这种情况下，噪声的比例也是$\frac{k}{ϵ}$。

%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid')
import pandas as pd
import numpy as np

adult = pd.read_csv("adult_with_pii.csv")
def laplace_mech(v, sensitivity, epsilon):
    return v + np.random.laplace(loc=0, scale=sensitivity / epsilon)
def pct_error(orig, priv):
    return np.abs(orig - priv)/orig * 100.0

ks = np.linspace(1, 10, 20)
epsilon = .1

# L1 sensitivity of each query: 1
# noise per query: 1/epsilon
# number of queries: k
noises_seq = [k*(1/epsilon) for k in ks]
plt.plot(ks, noises_seq, label='Sequential Composition')

# number of queries: 1
# L1 sensitivity of each query: k
# noise per query: k / epsilon
noises_l1 = [1*(k/epsilon) for k in ks]
plt.plot(ks, noises_l1, label='Vectorized')
plt.title('Laplace Mechanism: Vectorized vs. Composition')
plt.xlabel('Number of Queries')
plt.ylabel('Scale of Noise')
plt.legend();

这两条线完全重叠。

这意味着，无论我们运行多少个查询，在$ϵ$-差分隐私下，我们都不会比顺序组合做得更好。这是因为顺序组合与矢量化查询一样好，我们不能做得比这更好。

那么$(ϵ,\delta )$-差分隐私呢？这就有些不同了。

在顺序组合的情况下，我们可以使用高级组合定理。这里必须小心一点，以确保总隐私成本正好是$(ϵ,\delta )$。

具体来说，我们设置${ϵ}_i=\frac{ϵ}{2\sqrt{2k\log (1/{\delta }^{\prime })}}$，${\delta }_i=\frac{\delta }{2k}$和${\delta }^{\prime }=\frac{\delta }{2}$（拆分$\delta$ 50% 用于查询，50% 用于高级组合）。

通过高级组合，所有$k$查询的总隐私成本为$(ϵ,\delta )$。

根据高斯机制，噪声的尺度为：
$$\begin{gathered} {\sigma }^2=\frac{2\log (\frac{1.25}{{\delta }_i})}{{ϵ}_i^2} \\ =\frac{16k\log (\frac{1}{{\delta }^{\prime }})\log (\frac{1.25}{{\delta }_i})}{{ϵ}^2} \\ =\frac{16k\log (\frac{2}{\delta })\log (\frac{2.5k}{\delta })}{{ϵ}^2} \end{gathered}$$
在"矢量化"的情况下，我们只有一个查询，L2 敏感度为$\sqrt{k}$。

根据高斯机制，噪声的尺度是${\sigma }^2=\frac{2k\log (1.25/\delta )}{{ϵ}^2}$。

这种差异在实践中意味着什么？

这两者在$k$中在渐近方向上表现相同，但具有不同的常量，并且高级复合情况在$\delta$中具有额外的对数因子。

所有这些加起来，在高级组合定理的情况下，界限要宽松得多。

ks = np.linspace(1, 100, 20)
epsilon = .1
delta = 1e-5

# L2 sensitivity of each query: 1
# number of queries: k
noises_seq = [16*k*np.log(1.25/delta)*np.log(1/delta)/(epsilon**2) for k in ks]
plt.plot(ks, noises_seq, label='Advanced Composition')

# number of queries: 1
# L2 sensitivity of each query: sqrt(k)
noises_l1 = [2*k*np.log(1.25/delta)/(epsilon**2) for k in ks]
plt.title('Gaussian Mechanism: Vectorized vs. Composition')
plt.xlabel('Number of Queries')
plt.ylabel('Scale of Noise')
plt.plot(ks, noises_l1, label='Vectorized')
plt.legend();

相比较而言"矢量化"版本增长得更慢。这是什么意思？我们应该能够在顺序组合方面做得更好！

最大散度和Rényi散度

事实证明，差分隐私的定义可以直接用称为最大散度的东西来表示。

在统计学中，散度是测量两个概率分布之间距离的一种方式 ，这正是我们想要为差分隐私做的事情。

最大散度是KL散度的最坏情况，是最常见的度量之一。

两个概率分布$Y$和$Z$之间的最大散度定义为：
$$D_{\infty }(Y\Vert Z)=\underset{S\subseteq \text{Supp}(Y)}{\max }\left[\log \frac{Pr[Y\in S]}{Pr[Z\in S]}\right]$$
这看起来已经很像$ϵ$-差分隐私的条件！

特别是，事实证明，在以下情况下，$F$满足$ϵ$-差分隐私：
$$D_{\infty }(F(x)\Vert F(x^{\prime }))\le ϵ$$
差分隐私研究的一个有趣方向是探索其他变种的替代隐私定义。

其中，Rényi散度特别有趣，因为它也（像最大散度一样）允许我们恢复差分隐私的原始定义。

概率分布$P$ 和 $Q$之间的阶$\alpha$的 Rényi 发散定义为（其中$P(x)$表示$P$在点$x$的概率密度）：
$$D_{\alpha }(P\Vert Q)=\frac{1}{\alpha -1}\log E_{x\sim Q}(\frac{P(x)}{Q(x)}{)}^{\alpha }$$
如果我们设置$\alpha =\infty$，那么我们立即恢复$ϵ$-差分隐私的定义！

一个显而易见的问题是：如果我们把$\alpha$设置为其他什么东西，会发生什么？

正如我们将看到的，可以使用Rényi发散来获得非常有趣的松弛差分隐私，从而允许更好的组合定理，同时避免在$(ϵ,\delta )$-差分隐私下可能发生的"灾难"的可能性。

Rényi差分隐私

2017年，Ilya Mironov提出了Rényi差分隐私（RDP）。 随机机制$F$满足$(\alpha ,\overline{ϵ})$-RDP 如果对于所有相邻数据集$x$和$x^{\prime }$
$$D_{\alpha }(F(x)\Vert F(x^{\prime }))\le \overline{ϵ}$$
换句话说，RDP 要求$F(x)$和$F(x^{\prime })$之间的顺序$\alpha$的 Rényi 发散受$\overline{ϵ}$的约束。请注意，我们将使用$\overline{ϵ}$来表示 RDP 的$ϵ$参数，以便将其与纯$ϵ$ -差分隐私和$(ϵ,\delta )$-差分隐私中的$ϵ$区分开来。

Rényi 差分隐私的一个关键属性是，满足 RDP 的机制也满足$(ϵ,\delta )$-差分隐私。具体来说，如果$F$满足$(\alpha ,\overline{ϵ})$-RDP，则对于$\delta >0$，$F$满足$(ϵ,\delta )$-差分隐私$ϵ=\overline{ϵ}+\frac{\log (1/\delta )}{\alpha -1}$。分析人员可以自由选择$\delta$的任何值;在实践中应选取有意义的值（例如$\delta \le \frac{1}{n^2}$)）。

实现 Rényi 差分隐私的基本机制是高斯机制。具体来说，对于具有$L2$敏感性$\Delta f$的函数$f:\mathcal{D}\to {\mathbb{R}}^k$，以下机制满足$(\alpha ,\overline{ϵ})$-RDP：
$$F(x)=f(x)+\mathcal{N}({\sigma }^2)\text{ where }{\sigma }^2=\frac{\Delta f^2\alpha }{2ϵ}$$
我们可以实现 Rényi 差分隐私的高斯机制，如下所示：

def gaussian_mech_RDP_vec(vec, sensitivity, alpha, epsilon):
    sigma = np.sqrt((sensitivity**2 * alpha) / (2 * epsilon))
    return [v + np.random.normal(loc=0, scale=sigma) for v in vec]

Rényi差分隐私的主要优点是高斯机制的紧密组合，而这种组合优势不需要特殊的高级组合定理。

Rényi差分隐私的顺序组成定理指出：

如果$F_1$满足$(\alpha ,\overline{{ϵ}_1})$-RDP

并且$F_2$满足$(\alpha ,\overline{{ϵ}_2})$-RDP

则它们的组合满足$(\alpha ,\overline{{ϵ}_1}+\overline{{ϵ}_2})$-RDP

基于这个顺序组合定理，运行$(\alpha ,\overline{ϵ})$-RDP 机制$k$次得到$(\alpha ,k\overline{ϵ})$-RDP.对于给定的噪声水平（即${\sigma }^2$的给定值），使用 RDP 的顺序组合限制重复应用高斯机制的隐私成本，然后转换为$(ϵ,\delta )$-差分隐私，通常会产生比直接在$(ϵ,\delta )$差分隐私中执行合成（即使使用高级合成）低得多的隐私成本。

因此，Rényi差分隐私背后的思想已被用于在最近的许多迭代算法中大大改善隐私成本会计，包括Google的Detensorflow的差异私有版本。

最后，与差分隐私的其他变体一样，RDP 提供了后处理属性。

零集中差分隐私

在2016年发布的工作中，Mark Bun和Thomas Steinke提出了零集中差分隐私（zCDP）。 与 RDP 一样，zCDP 是根据 Rényi 散度来定义的，但它只包含一个隐私参数 （$\rho$）。随机机制$F$满足$\rho$-zCDP，如果对于所有相邻数据集$x$和$x^{\prime }$，以及所有$\alpha \in (1,\infty )$：
$$D_{\alpha }(F(x)\Vert F(x^{\prime }))\le \rho \alpha$$
这是一个比RDP更强的要求，因为它限制了许多阶数$\alpha$的Rényi散度。但是，随着$\alpha$的增长，边界会变得更加宽松。与 RDP 一样，zCDP 可以转换为$(ϵ,\delta )$-差分隐私：如果$F$满足$\rho$-zCDP，那么对于$\delta >0$， $F$满足$(ϵ,\delta )$-差分隐私 $ϵ=\rho +2\sqrt{\rho \log (1/\delta )}$。

zCDP也与RDP相似，因为高斯机制可以用作基本机制。具体来说，对于具有L2敏感性$\Delta f$的函数$f:\mathcal{D}\to {\mathbb{R}}^k$，以下机制满足$\rho$-zCDP：
$$F(x)=f(x)+\mathcal{N}({\sigma }^2)\text{ where }{\sigma }^2=\frac{\Delta f^2}{2\rho }$$
与 RDP 一样，此机制易于实现：

def gaussian_mech_zCDP_vec(vec, sensitivity, rho):
    sigma = np.sqrt((sensitivity**2) / (2 * rho))
    return [v + np.random.normal(loc=0, scale=sigma) for v in vec]

与RDP的另一个相似之处是，zCDP的顺序组成对于高斯机制的重复应用也是渐近紧密的。这也很简单：$\rho$加起来。具体说来：

顺序组成：

如果$F_1$满足${\rho }_1$-zCDP

并且$F_2$满足${\rho }_2$-zCDP

则它们的组成满足${\rho }_1+{\rho }_2$-zCDP

最后，zCDP 还提供了后处理属性。

差分隐私变体的组合情况

我们应该使用哪种变体，何时使用？

在以下情况下，这些变体将显著收紧隐私成本的界限：

使用高斯机制（特别是在高维向量上）

所讨论的算法多次应用该机制（例如数百或数千次）

为了使用 RDP 和 zCDP，我们通常会根据要使用的变体实现一个算法，然后将运行该算法的总隐私开销转换回$(ϵ,\delta )$-差分隐私，以便我们可以将其与其他算法进行比较。

为了了解此策略的效果，让我们想象一个应用高斯机制$k$次的算法。我们将修复$\sigma$（即在每次$k$迭代中使用高斯机制添加的噪声量）和$\delta$的值，然后比较每个变体的最终$ϵ$。

我们将看到，对于添加的相同数量的噪声，RDP 和 zCDP 下的合成会导致$ϵ$的值变小。该算法在所有变体下都是相同的（即，它在每种情况下都会添加相同数量的噪声） - 因此这意味着RDP和zCDP为同一算法提供了更严格的隐私成本限制。

sigma = 200.0
delta = 1e-5
lap_eps = 2*sigma**2
xs = np.linspace(0, 500, 100)

gauss_eps = np.sqrt(2 * np.log(1.25/delta) / sigma**2)

ys_gauss_adv = [2 * gauss_eps * np.sqrt(2 * x * np.log(1/delta)) for x in xs]

rho = 1/(2*sigma**2)
ys_gauss_zcdp = [(x*rho) + 2*np.sqrt((x*rho) * np.log(1/delta)) for x in xs]

alpha = 60
rdp_eps = alpha / (2*sigma**2)

ys_gauss_rdp = [(x*rdp_eps) + np.log(1/delta)/(alpha-1) for x in xs]

ys_moments = [4*np.sqrt(x*np.log(1/delta))/sigma for x in xs]

plt.plot(xs, ys_gauss_adv, label="Gaussian+Adv. Comp.")
plt.plot(xs, ys_gauss_zcdp, label="Gaussian+zCDP")
plt.plot(xs, ys_gauss_rdp, label="Gaussian+RDP")
#plt.plot(xs, ys_moments, label="Moments Accountant")

plt.xlabel('Number of Iterations')
plt.ylabel('Epsilon')
plt.ylim(0, 3.0)


plt.legend()
plt.show();

首先要注意的是，在 zCDP 或 RDP 下使用顺序组合比使用带有$(ϵ,\delta )$-差分隐私的高级组合要好得多。使用高斯机制构建迭代算法时，应始终使用这些变体。

要注意的第二件事是zCDP（橙色）和RDP（绿色）之间的区别。

RDP 的$ϵ$在$k$中线性增长，因为我们已经固定了$\alpha$的值。zCDP 的$ϵ$在$k$中是亚线性的，因为 zCDP 有效地考虑了许多$\alpha$。两条线的触点为$k$，具体取决于为 RDP 选择的$\alpha$ （对于$\alpha =20$，它们大致接触$k=300$）。

这种差异的实际效果是，在使用RDP时必须仔细选择$\alpha$，以便尽可能严格地约束隐私成本。这通常很容易做到，因为算法通常由$\alpha$参数化。结果，我们可以简单地测试$\alpha$的多个值，看看哪一个值导致最小的相应$ϵ$。

由于此测试独立于数据（它主要取决于我们选择的隐私参数以及我们要运行的迭代次数），因此我们可以根据需要测试任意数量的$\alpha$值，而无需支付额外的隐私费用。我们只需要测试$\alpha$的一小部分值 （ 通常在 2 到 100 之间的范围内，即可找到最小值。这是大多数实际实现中采用的方法，包括Google的Tensorflow隐私保护版本。

总结

1、大多数隐私成本边界都是有上限的，但它们有时代表非常宽松的上限，即真正的隐私成本远低于上限。开发差分隐私的新变体的主要动机是实现更严格的隐私成本限制，特别是对于迭代算法，同时保持在实践中有用的隐私定义。

2、无论我们运行多少个查询，在$ϵ$-差分隐私下，我们都不会比顺序组合做得更好。这是因为顺序组合与矢量化查询一样好，我们不能做得比这更好。

3、在顺序组合的情况下，我们可以使用高级组合定理。所有这些加起来，在高级组合定理的情况下，界限要宽松得多。相比较而言"矢量化"版本增长得更慢。我们应该能够在顺序组合方面做得更好！

4、事实证明，差分隐私的定义可以直接用称为最大散度的东西来表示。在统计学中，散度是测量两个概率分布之间距离的一种方式 ，这正是我们想要为差分隐私做的事情。

5、Rényi差分隐私的主要优点是高斯机制的紧密组合，而这种组合优势不需要特殊的高级组合定理。

6、基于这个顺序组合定理，运行$(\alpha ,\overline{ϵ})$-RDP 机制$k$次得到$(\alpha ,k\overline{ϵ})$-RDP.对于给定的噪声水平（即${\sigma }^2$的给定值），使用 RDP 的顺序组合限制重复应用高斯机制的隐私成本，然后转换为$(ϵ,\delta )$-差分隐私，通常会产生比直接在$(ϵ,\delta )$差分隐私中执行合成（即使使用高级合成）低得多的隐私成本。因此，Rényi差分隐私背后的思想已被用于在最近的许多迭代算法中大大改善隐私成本会计，包括Google的Detensorflow的差异私有版本。

7、zCDP这是一个比RDP更强的要求，因为它限制了许多阶数$\alpha$的Rényi散度。但是，随着$\alpha$的增长，边界会变得更加宽松。

8、对于添加的相同数量的噪声，RDP 和 zCDP 下的合成会导致$ϵ$的值变小。该算法在所有变体下都是相同的（即，它在每种情况下都会添加相同数量的噪声），因此这意味着RDP和zCDP为同一算法提供了更严格的隐私成本限制。

9、首先要注意的是，在 zCDP 或 RDP 下使用顺序组合比使用带有$(ϵ,\delta )$-差分隐私的高级组合要好得多。使用高斯机制构建迭代算法时，应始终使用这些变体。

10、这种差异的实际效果是，在使用RDP时必须仔细选择$\alpha$，以便尽可能严格地约束隐私成本。这通常很容易做到，因为算法通常由$\alpha$参数化。结果，我们可以简单地测试$\alpha$的多个值，看看哪一个值导致最小的相应$ϵ$。