差分隐私代码实现系列（八）

写在前面的话
回顾
局部敏感度（Local Sensitivity）
均值的局部灵敏度（Local Sensitivity of the Mean）
通过局部灵敏度实现差分隐私？（Achieving Differential Privacy via Local Sensitivity?）
建议-测试-发布（Propose-test-release）
平滑灵敏度（Smooth Sensitivity）
示例和聚合（Sample and Aggregate）
总结

写在前面的话

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

回顾

1、通常要求δ\deltaδ非常小，通常为1n2\frac{1}{n^2}n21或更小，其中nnn是数据集的大小。

2、高斯机制有两个主要缺点，它需要使用宽松的(ϵ,δ)(\epsilon, \delta)(ϵ,δ)差分隐私定义，并且它不如拉普拉斯机制准确。

3、在二维空间中，L2L2L2距离总是小于或等于L1L1L1距离。

4、L2L2L2灵敏度明显低于L1L1L1灵敏度。

5、向量值拉普拉斯机制需要使用L1L1L1灵敏度，而向量值高斯机制允许使用L1L1L1或L2L2L2灵敏度。这是高斯机制的一个主要优势。对于L2L2L2灵敏度远低于L1L1L1灵敏度的应用，高斯机制允许添加更少的噪声。

6、高级组合也给出了松散的边界，它们只是比顺序合成给出的边界稍微紧致一些。

7、事实证明，标准的顺序合成击败了小于约70的kkk的高级合成。因此，高级组合只有在kkk较大（例如超过 100）时才真正有用。但是，当kkk非常大时，高级组合可以产生很大的不同。

局部敏感度！！！

局部敏感度（Local Sensitivity）

到目前为止，我们只看到了一种敏感性衡量标准：全局敏感性。

我们对全局敏感度的定义考虑了任意两个相邻数据集。这似乎是悲观的，因为我们将在实际的数据集上运行我们的差分隐私机制，我们难道不应该考虑该数据集的邻居吗？

这是局部敏感度背后的直觉：将两个数据集中的一个固定为正在查询的实际数据集，并考虑其所有邻居。形式上，函数局部敏感度定义为 f:D→Rf : \mathcal{D} \rightarrow \mathbb{R}f:D→R at x:Dx : \mathcal{D}x:D

LS(f,x)=max⁡x′:d(x,x′)≤1∣f(x)−f(x′)∣LS(f, x) = \max_{x': d(x,x') \leq 1} \lvert f(x) - f(x') \rvert LS(f,x)=x′:d(x,x′)≤1max∣f(x)−f(x′)∣
请注意，局部敏感度是查询 (fff)和实际数据集 (xxx)的函数与全局敏感度的情况不同，在讨论函数的局部灵敏度时，我们要考虑发生该局部灵敏度的数据集。

均值的局部灵敏度（Local Sensitivity of the Mean）

局部灵敏度允许我们对某些全局灵敏度难以绑定的函数的灵敏度设置有限边界。

均值函数就是一个例子。到目前为止，我们已经通过将查询拆分为两个查询来计算差分隐私均值：差分隐私总和（分子）和差分隐私计数（分母）。

通过顺序组合和后处理，这两个结果的商满足差分隐私。

我们为什么要这样做？因为在数据集中添加或删除行时，平均查询的输出量可能会发生变化，这取决于数据集的大小。

如果我们想绑定均值查询的全局敏感度，我们必须假设最差的情况：大小为 1 的数据集。

在这种情况下，如果数据属性值位于上限和下限uuu 和lll之间，则均值的全局敏感度为 ∣u−l∣\lvert u - l \lvert∣u−l∣。对于大型数据集，这是非常悲观的，"噪声总和超过噪声计数"的方法要好得多。

局部敏感性的情况有所不同。在最坏的情况下，我们可以向包含最大值(uuu)的数据集中添加一个新行。使n=∣x∣n = \lvert x \rvertn=∣x∣（即数据集的大小）。我们从平均值的值开始：
f(x)=∑i=1nxinf(x) = \frac{\sum_{i=1}^{n} x_i}{n} f(x)=n∑i=1nxi
现在，我们考虑添加行时会发生什么：
∣f(x′)−f(x)∣=∣∑i=1nxi+un+1−∑i=1nxin∣≤∣∑i=1nxi+un+1−∑i=1nxin+1∣=∣∑i=1nxi+u−∑i=1nxin+1∣=∣un+1∣\lvert f(x') - f(x) \rvert = \bigg\lvert \frac{\sum_{i=1}^{n} x_i + u}{n+1} - \frac{\sum_{i=1}^{n} x_i}{n} \bigg\rvert \\ \leq \bigg\lvert \frac{\sum_{i=1}^{n} x_i + u}{n+1} - \frac{\sum_{i=1}^{n} x_i}{n+1} \bigg\rvert \\ = \bigg\lvert \frac{\sum_{i=1}^{n} x_i + u - \sum_{i=1}^{n} x_i}{n+1}\bigg\rvert \\ = \bigg\lvert \frac{u}{n+1} \bigg\rvert \\ ∣f(x′)−f(x)∣=∣∣∣∣n+1∑i=1nxi+u−n∑i=1nxi∣∣∣∣≤∣∣∣∣n+1∑i=1nxi+u−n+1∑i=1nxi∣∣∣∣=∣∣∣∣n+1∑i=1nxi+u−∑i=1nxi∣∣∣∣=∣∣∣∣n+1u∣∣∣∣
此局部敏感度度量根据实际数据集的大小进行定义，这在全局敏感度下是不可能的。

通过局部灵敏度实现差分隐私？（Achieving Differential Privacy via Local Sensitivity?）

我们已经定义了一种替代的灵敏度衡量标准，但是我们如何使用它呢？

我们能否像使用全局敏感性一样，使用拉普拉斯机制？以下定义FFF是否满足ϵ\epsilonϵ-差分隐私？

F(x)=f(x)+Lap(LS(f,x)ϵ)F(x) = f(x) + \mathsf{Lap}(\frac{LS(f,x)}{\epsilon}) F(x)=f(x)+Lap(ϵLS(f,x))
不！不幸的是，事实并非如此，因为本身取决于数据集。

如果分析人员知道某个特定数据集的查询的局部敏感性，那么分析人员也许能够推断出有关该数据集的一些信息。

因此，不可能直接使用LS(f,x)LS(f, x)LS(f,x)局部灵敏度来实现差分隐私。例如，考虑上面定义的均值的局部灵敏度边界。如果我们知道特定xxx处的局部灵敏度，我们可以推断出没有噪声的xxx确切大小：
∣x∣=bLS(f,x)−1\lvert x \rvert = \frac{b}{LS(f, x)} - 1 ∣x∣=LS(f,x)b−1
此外，对分析师保密局部敏感性也无济于事。可以从几个查询答案中确定噪声的尺度，并且分析人员可以使用此值来推断局部灵敏度。差分隐私旨在保护其定义中使用的灵敏度测量的输出f(x)f(x)f(x) ，而不是灵敏度测量的输出。

已经提出了几种安全使用局部灵敏度的方法。后面会讨论一下~

通过辅助数据，这可以告诉我们一些非常敏感的东西。如果我们的查询是："数据集中名为 Joe 的人的平均分数为 98%，考试成绩为 98%，该怎么办？那么被平均事物的大小是敏感的！

建议-测试-发布（Propose-test-release）

局部灵敏度的主要问题是灵敏度本身揭示了有关数据的某些信息。

我们能把敏感度本身变得差分隐私吗？

直接这样做是具有挑战性的，因为函数局部灵敏度本身的全局灵敏度通常没有有限的限制。

但是，我们可以问一个间接获得此值的差分隐私问题。

Propose-test-release采用这种方法。

该框架首先要求分析人员对所应用函数的局部灵敏度提出上限。

然后，框架运行差分隐私测试，以检查所查询的数据集是否"远离"这种情况的数据集，即局部灵敏度高于建议边界的数据集。

如果测试通过，框架将释放噪声结果，并将噪声校准到建议的边界。

为了回答数据集是否"远离"具有高局部灵敏度的数据集的问题，我们定义了远距离局部灵敏度kkk，我们编写A(f,x,k)A(f, x, k)A(f,x,k)是为了表示通过从数据集xxx中采取kkk步骤可以实现的最大局部灵敏度。

正式来说：

A(f,x,k)=max⁡y:d(x,y)≤kLS(f,y)A(f,x,k) = \max_{y: d(x,y) \leq k} LS(f, y) A(f,x,k)=y:d(x,y)≤kmaxLS(f,y)
现在，我们已准备好定义一个查询来回答以下问题："需要多少步骤才能实现大于给定上限的局部灵敏度bbb？

D(f,x,b)=argminkA(f,x,k)>bD(f, x, b) = \text{argmin}_k A(f, x, k) > b D(f,x,b)=argminkA(f,x,k)>b
最后，我们定义了 propose-test-release 框架(见Barthe et al., Figure 10)，它满足了(ϵ,δ)(\epsilon, \delta)(ϵ,δ)-差分隐私：

1、提出一个以局部敏感性为界bbb的目标。

2、如果 D(f,x,b)+Lap(1ϵ)<log⁡(2/δ)2ϵD(f, x, b) + \mathsf{Lap}(\frac{1}{\epsilon}) < \frac{\log(2/\delta)}{2\epsilon}D(f,x,b)+Lap(ϵ1)<2ϵlog(2/δ), 则返回 ⊥\bot⊥.

3、否则返回 f(x)+Lap(bϵ)f(x)+Lap(\frac{b}{\epsilon})f(x)+Lap(ϵb)

请注意，D(f,x,b)D(f,x,b)D(f,x,b)全局敏感度为 1：在xxx添加或删除行可能会将距离更改为"高"局部敏感度 1。

因此，添加拉普拉斯噪声缩放1ϵ\frac{1}{\epsilon}ϵ1以产生一种测量局部灵敏度的差分隐私方法。

为什么这种方法满足(ϵ,δ)(\epsilon, \delta)(ϵ,δ)-差分隐私（而不是纯粹的ϵ\epsilonϵ-差分隐私）？这是因为意外通过测试的机会不为零。

步骤2中添加的噪声可能大到足以通过测试，即使D(f,x,b)D(f,x,b)D(f,x,b)的值实际上小于满足差分隐私所需的最小距离。

这种失败模式更接近我们从"灾难机制"中看到的灾难性失败，概率不为零，建议测试发布框架允许以太小的噪音发布查询答案，以满足差分隐私。另一方面，它并不像灾难机制那么糟糕，因为它永远不会在没有噪音的情况下释放答案。

另请注意，即使返回⊥\bot⊥，框架的隐私成本也是(ϵ,δ)(\epsilon, \delta)(ϵ,δ)（即，无论分析师是否收到答案，都会消耗隐私预算）。

让我们为平均值查询实现建议-测试-发布。回想一下，此查询的局部敏感度为∣un+1∣\big\lvert \frac{u}{n+1}\big\rvert∣∣n+1u∣∣;增加此值的最佳方法是缩小nnn值。如果我们从数据集xxx中采取kkk步骤，我们可以得到的局部灵敏度∣u(n−k)+1∣\big\lvert \frac{u}{(n-k)+1}\big\rvert∣∣(n−k)+1u∣∣。我们可以使用以下代码在Python中实现框架。

%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid')
import pandas as pd
import numpy as npadult = 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
def ls_at_distance(df, u, k):
# 预知未来的敏感度return np.abs(u/(len(df) - k + 1))def dist_to_high_ls(df, u, b):k = 0# 看走几步大于等于bwhile ls_at_distance(df, u, k) < b:k += 1return k
def ptr_avg(df, u, b, epsilon, delta, logging=False):df_clipped = df.clip(upper=u)# 给个数据集数据的上限，将大于u的修剪为uk = dist_to_high_ls(df_clipped, u, b)# 给个数据集数据的上限noisy_distance = laplace_mech(k, 1, epsilon)threshold = np.log(2/delta)/(2*epsilon)if logging:print(f"Noisy distance is {noisy_distance} and threshold is {threshold}")if noisy_distance >= threshold:return laplace_mech(df_clipped.mean(), b, epsilon)else:return Nonedf = adult['Age']
u = 100                    # set the upper bound on age to 100
epsilon = 1                # set epsilon = 1
delta = 1/(len(df)**2)     # set delta = 1/n^2
b = 0.005                  # propose a sensitivity of 0.005ptr_avg(df, u, b, epsilon, delta, logging=True)

请记住，局部敏感性并不总是更好。对于均值查询，将查询拆分为两个单独的查询（总和计数）的旧策略通常效果更好。我们可以实现具有全局敏感性的相同均值查询：

def gs_avg(df, u, epsilon):df_clipped = df.clip(upper=u)noisy_sum = laplace_mech(df_clipped.sum(), u, .5*epsilon)noisy_count = laplace_mech(len(df_clipped), 1, .5*epsilon)return noisy_sum / noisy_count

gs_avg(adult['Age'], u, epsilon)

gs_results  = [pct_error(np.mean(adult['Age']), gs_avg(df, u, epsilon)) for i in range(100)]
ptr_results = [pct_error(np.mean(adult['Age']), ptr_avg(df, u, b, epsilon, delta)) for i in range(100)]_, bins, _ = plt.hist(gs_results, label='Global sensitivity');
plt.hist(ptr_results, alpha=.7, label='PTR', bins=bins);
plt.xlabel('Percent Error')
plt.ylabel('Number of Trials')
plt.legend();

我们可能会在提案-测试-发布方面做得更好一些，但这并不是一个很大的区别。

此外，要使用提案-测试-发布，分析师必须提出一个对灵敏度的约束，我们通过"神奇地"选择一个体面的值（0.005）来作弊。在实践中，分析师需要执行多个查询来探索哪些值有效，这将消耗额外的隐私预算。

平滑灵敏度（Smooth Sensitivity）

我们利用局部灵敏度的第二种方法称为平滑灵敏度，这是由于Nissim, Raskhodnikova, and Smith。平滑灵敏度框架，用拉普拉斯噪声实例化，提供(ϵ,δ)(\epsilon, \delta)(ϵ,δ)差分隐私：

设置β=ϵ2log⁡(2/δ)\beta = \frac{\epsilon}{2\log(2/\delta)}β=2log(2/δ)ϵ
使S=max⁡k=1,…,ne−βkA(f,x,k)S = \max_{k = 1, \dots, n} e^{-\beta k} A(f, x, k)S=maxk=1,…,ne−βkA(f,x,k)
发布f(x)+Lap(2Sϵ)f(x) + \mathsf{Lap}(\frac{2S}{\epsilon})f(x)+Lap(ϵ2S)

平滑灵敏度背后的想法是使用局部灵敏度的"平滑"近似值，而不是局部灵敏度本身来校准噪声。

平滑量旨在防止在直接使用局部灵敏度时可能发生的有关数据集的信息的意外发布。

上面的步骤 2 执行平滑：它通过附近数据集与实际数据集距离的指数函数来缩放附近数据集的局部灵敏度，然后采用最大缩放的局部灵敏度。

效果是，如果xxx的邻域中存在局部灵敏度的峰值，则该峰值将反映在xxx平滑灵敏度中（因此峰值本身被"平滑"，并且不会显示有关数据集的任何信息）。

与建议-测试-发布相比，平滑灵敏度具有显著优势：它不需要分析人员提出灵敏度约束。

对于分析人员来说，使用平滑灵敏度与使用全局灵敏度一样简单。

然而，平滑灵敏度有两个主要缺点。

首先，平滑灵敏度总是大于局部灵敏度（至少2倍 - 见步骤3），因此可能需要添加比建议 - 测试 - 发布（甚至全局灵敏度）等替代框架更多的噪声。

其次，计算平滑灵敏度需要找到所有kkk可能值的最大平滑灵敏度，这在计算上可能极具挑战性。

在许多情况下，可以证明考虑少量kkk的值就足够了（对于许多函数，指数衰减e−βke^{-\beta k}e−βk迅速压倒了不断增长A(f,x,k)A(f, x, k)A(f,x,k))的值），但是对于我们想要使用的每个函数，都必须以平滑的灵敏度来证明这样的属性。

例如，让我们考虑一下我们之前定义的均值查询的平滑敏感性。

df = adult['Age']
epsilon = 1           # set epsilon = 1
delta = 1/len(df)**2  # set delta = 1/n^2# Step 1: set beta
beta = epsilon / (2*np.log(2/delta))# Step 2: compute smoothed-out sensitivity for various values of k
r = [np.exp(- beta * k) * ls_at_distance(df, u, k) for k in range(0,200)]
plt.plot(r);
plt.xlabel('Value of k')
plt.ylabel('Smoothed-out Local Sensitivity');S = np.max(r)
sensitivity = 2*S
print(f'Final sensitivity: {sensitivity}')

这里有两件事需要注意。首先，即使我们只考虑小于 200 的kkk值，很明显，随着kkk平均值查询的平滑局部灵敏度接近 0。实际上，对于这种情况，最大值出现在k=0k=0k=0。在许多情况下，这是正确的，但是如果我们想使用平滑灵敏度，我们必须证明它（我们在这里不会这样做）。其次，请注意，我们将用于向查询的答案添加噪声的最终灵敏度高于我们之前建议的灵敏度（在"建议-测试-发布"下）。这不是一个很大的区别，但它表明，有时使用建议 - 测试 - 发布比平滑灵敏度实现更低的灵敏度。

示例和聚合（Sample and Aggregate）

我们将考虑与局部灵敏度相关的最后一个框架，称为样本和聚合（也归因于Nissim, Raskhodnikova, and Smith）。对于任何函数f:D→Rf : D \rightarrow \mathbb{R}f:D→R以及上下剪辑边界uuu 和lll ，以下框架满足ϵ\epsilonϵ差分隐私：

拆解数据集 X∈DX \in DX∈D 为 kkk 个不相交的块 x1,…,xkx_1, \dots, x_kx1,…,xk
计算每个区块的剪切答案： ai=max⁡(l,min⁡(u,f(xi)))a_i = \max(l, \min(u, f(x_i)))ai=max(l,min(u,f(xi)))
计算答案的噪声平均值：A=(1k∑i=1kai)+Lap(u−lkϵ)A = (\frac{1}{k} \sum_{i=1}^k a_i) + \mathsf{Lap}(\frac{u - l}{k\epsilon})A=(k1∑i=1kai)+Lap(kϵu−l)

请注意，此框架满足纯ϵ\epsilonϵ-差分隐私，并且实际上无需使用局部灵敏度即可工作。事实上，我们不需要知道fff（全局或局部）的敏感性。我们也不需要知道任何关于块xix_ixi，除了它们是不相交这一点我们需要确定。通常，它们是随机选择的（"好"样本往往会导致更高的准确性），但它们不需要。

该框架可以通过全局灵敏度和并行组合来证明满足差分隐私。我们将数据集拆分为多个kkk块，因此每个数据集只出现在一个块中。我们不知道fff的灵敏度，但是我们将其输出裁剪为介于uuu 和lll之间，因此每个被裁剪的答案的灵敏度f(xi)f(x_i)f(xi) 都是u−lu-lu−l。由于我们取fff调用kkk的均值，则均值的全局敏感性为u−lk\frac{u-l}{k}ku−l。

请注意，我们直接声明了均值的全局敏感度的边界，而不是将其拆分为总和和计数查询。我们无法对"常规"均值查询执行此操作，因为在"常规"均值查询中平均的事物数量取决于数据集。但是，在这种情况下，平均的项目数由分析师通过kkk选择来固定，它独立于数据集。像这样的平均查询 - 其中平均事物的数量是固定的，并且可以公开 - 可以利用这种改进的全局灵敏度限制。

在这个示例和聚合框架的简单实例化中，我们要求分析师提供每个的上限和下限uuu 和lll以及每个f(xi)f(x_i)f(xi) 根据fff的定义，这可能很难做好。例如，在计数查询中，fff的输出将直接依赖于数据集。

已经提出了更高级的实例化，它们利用局部灵敏度来避免要求分析师找到uuu 和lll。然而，对于某些函数，边界fff的输出很容易 - 所以这个框架就足够了。我们将使用此属性考虑上面的示例 - 数据集中的年龄平均值。人口的平均年龄极有可能在20到80岁之间，因此设置l=20l=20l=20 和u=80u=80u=80是合理的。只要我们的区块xix_ixi都是人口的代表，我们不太可能在这种设置下丢失太多信息。

def f(df):return df.mean()def saa_avg_age(k, epsilon, logging=False):df = adult['Age']# Calculate the number of rows in each chunkchunk_size = int(np.ceil(df.shape[0] / k))if logging:print(f'Chunk size: {chunk_size}')# Step 1: split `df` into chunksxs      = [df[i:i+chunk_size] for i in range(0,df.shape[0],chunk_size)]# Step 2: run f on each x_i and clip its outputanswers = [f(x_i) for x_i in xs]u = 80l = 20clipped_answers = np.clip(answers, l, u)# Step 3: take the noisy mean of the clipped answersnoisy_mean = laplace_mech(np.mean(clipped_answers), (u-l)/k, epsilon)return noisy_meansaa_avg_age(600, 1, logging=True)

此框架中的关键参数是块数kkk 。随着kkk上升，最终噪声均值的灵敏度会下降，因此更多的块意味着更少的噪声。另一方面，随着kkk上升，每个块都会变小，因此每个答案f(xi)f(x_i)f(xi)都不太可能接近"真"答案f(X)f(X)f(X)。在上面的示例中，我们希望每个块中的平均年龄接近整个数据集的平均年龄，如果每个块仅包含少数人，则不太可能发生这种情况。

我们应该如何设置kkk？它依赖于fff和数据集，这使得它变得棘手。让我们尝试各种值kkk对于我们的均值查询。

def plot_results(k):df = adult['Age']_, bins, _ = plt.hist([pct_error(np.mean(df), saa_avg_age(k, epsilon)) for i in range(100)]);plt.hist([pct_error(np.mean(df), gs_avg(df, u, epsilon)) for i in range(100)], alpha=.7, bins=bins);

# k = 10; global sensitivity is *much* better
plot_results(10)
plt.xlabel('Percent Error')
plt.ylabel('Number of Trials')

# k = 1000; global sensitivity is still better
plot_results(1000)
plt.xlabel('Percent Error')
plt.ylabel('Number of Trials')

# k = 6000; sample and aggregate is getting close!
plot_results(6000)
plt.xlabel('Percent Error')
plt.ylabel('Number of Trials')

因此，样本和聚合无法击败我们基于全局灵敏度的方法，但是如果您为kkk选择正确的值，则可以非常接近。最大的优点是样本和集合体适用于任何函数fff，无论其灵敏度如何;如果fff表现良好，则可以从框架中获得良好的准确性。另一方面，使用样本和聚合需要分析人员设置剪切边界uuu 和lll ，以及块数kkk。

总结

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

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

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

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

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

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

【局部敏感度的问题代码实现】差分隐私代码实现系列（八）相关推荐

【敏感度，查询，裁剪代码实现】差分隐私代码实现系列（六）
差分隐私代码实现系列(六) 写在前面的话回顾敏感性(Sensitivity) 距离(Distance) 计算灵敏度(Calculating Sensitivity) 计算查询数(Counting ...
【Rényi差分隐私和零集中差分隐私（差分隐私变体）代码实现】差分隐私代码实现系列（九）
差分隐私代码实现系列(九) 写在前面的话回顾差分隐私的变体发明变体的动机最大散度和Rényi散度 Rényi差分隐私零集中差分隐私差分隐私变体的组合情况总结写在前面的话书上学来终觉浅 ...
【本地差分隐私与随机响应代码实现】差分隐私代码实现系列（十三）
差分隐私代码实现系列(十三) 写在前面的话回顾本地差分隐私随机响应一元编码总结写在前面的话书上学来终觉浅,绝知此事要躬行. 回顾 1.梯度下降是一种通过根据损失的梯度更新模型来使损失变小 ...
【机器学习与差分隐私代码实现】差分隐私代码实现系列（十二）
差分隐私代码实现系列(十二) 写在前面的话回顾机器学习与差分隐私使用 Scikit-Learn 进行逻辑回归什么是模型? 使用梯度下降训练模型梯度下降的单一步骤梯度下降算法梯度下降与差分 ...
【指数机制代码实现】差分隐私代码实现系列（十）
差分隐私代码实现系列(十) 写在前面的话回顾指数机制发明指数机制的动机指数机制的描述日期的例子指数机制的特点有限集合的指数机制报告最大噪声算法指数机制作为差分隐私的基本机制总结写 ...
【拉普拉斯机制代码实现demo】差分隐私代码实现系列（四）
差分隐私代码实现系列(四) 写在前面的话回顾差分隐私(Differential Privacy) 拉普拉斯机制(The Laplace Mechanism) 多少噪音就足够了?(How Much ...
【我们为什么用高斯机制？】差分隐私代码实现系列（七）
差分隐私代码实现系列(七) 写在前面的话回顾松弛差分隐私(Approximate Differential Privacy) 高斯机制(The Gaussian Mechanism) 矢量值函数及 ...
【差分隐私组合定理，直方图，列联表代码实现】差分隐私代码实现系列（五）
差分隐私代码实现系列(五) 写在前面的话回顾差分隐私的属性(Properties of Differential Privacy) 顺序组成(Sequential composition) 平行组 ...
【链接攻击，差分攻击，去标识化代码实现】差分隐私代码实现系列（二）
差分隐私代码实现系列(二) 写在前面的话去识别化(De-identification) 数据处理去识别化操作链接攻击 Karrie特别吗? 我们可以重新识别多少人? 聚合(Aggregation ...

【局部敏感度的问题代码实现】差分隐私代码实现系列（八）