差分隐私和深度学习

差分隐私是深度学习领域的一个新课题。这是为了确保当我们的神经网络从敏感数据中学习时，它们只是在学习他们应该从数据中学习的内容。
Cynthia Dwork 提出的对隐私的稳健定义（来自她的《算法基础》一书）：

“Differential Privacy” describes a promise, made by a data holder, or curator, to a data subject, and the promise is like this: “You will not be affected, adversely or otherwise, by allowing your data to be used in any study or analysis, no matter what other studies, data sets, or information sources, are available.”

编程需要懂一点英语

差分隐私的总体目标是确保不同类型的统计分析不会损害隐私，并且如果在分析之后，分析器对数据集中的特征一无所知，则隐私得到保护，这意味着信息具有在其他地方公开对个人无害。
为了在简单数据库的上下文中定义隐私，我们正在对数据库执行一些查询，如果我们从数据库中删除一个人并且查询没有改变，那么这个人的隐私将得到完全保护。
让我们用一个例子来理解
给定一个数据库，其中包含一些数字“1”和“0”，这是一些敏感数据，例如个人是否患有某种疾病（也许患者不想透露这些数据）。

db = [1, 0, 1, 1, 0, 1, 0, 1, 0, 0]

现在，您的数据库删除了每个条目之一，称为并行 DBS。因此，如果原始 DB 的长度为“n”，则有“n”个并行 DBS，在我们的示例中为 10。
现在，我们考虑一个并行 DBS，让我们以第一个删除第一个个体的第一个 DBS 为例，我们得到了什么？

pdbs[0] = [0, 1, 1, 0, 1, 0, 1, 0, 0]

所以你看到现在这个数据库的长度是'n-1'。所以为了计算灵敏度，我们需要一个查询函数，所以我们假设最简单的“总和”。所以我们现在关注两个结果：

sum(db) = 5
 sum(pdbs[0]) = 4

并且上述两者之间的差异是'1'，我们知道我们需要找到所有这些差异的最大值，因为这个数据库只包含'1'和'0'所有这些差异要么是'1'（当相似时像上面一样，当 1 被删除时）或“0”（当 0 被删除时）。
因此，我们将此示例的敏感度设为“1”，这是非常高的值，因此可以使用“sum”查询轻松完成差分攻击。
敏感性应该低于，以便定量地了解差异攻击可以揭示信息/泄露隐私的级别。
在Python中实现差异隐私的代码

Python3

import torch
 
# the number of entries in our database
num_entries = 5000
 
db = torch.rand(num_entries) > 0.5
 
# generating parallel databases
def get_parallel_db(db, remove_index):
 
    return torch.cat((db[0:remove_index],
                      db[remove_index+1:]))
get_parallel_db(db, 52352)
 
def get_parallel_dbs(db):
 
    parallel_dbs = list()
 
    for i in range(len(db)):
        pdb = get_parallel_db(db, i)
        parallel_dbs.append(pdb)
     
    return parallel_dbs
 
pdbs = get_parallel_dbs(db)
 
# Creating linear and parallel databases
 
def create_db_and_parallels(num_entries):
     
    db = torch.rand(num_entries) > 0.5
    pdbs = get_parallel_dbs(db)
     
    return db, pdbs
 
db, pdbs = create_db_and_parallels(2000)
 
# Creating sensitivity function
 
def sensitivity(query, n_entries=1000):
 
    db, pdbs = create_db_and_parallels(n_entries)
     
    full_db_result = query(db)
     
    max_distance = 0
    for pdb in pdbs:
        pdb_result = query(pdb)
 
        db_distance = torch.abs(pdb_result - full_db_result)
 
        if(db_distance > max_distance):
            max_distance = db_distance
             
    return max_distance
 
# query our database and evaluate whether or not the result of the
# query is leaking "private" information
 
def query(db):
    return db.float().mean()
sensitivity(query)

Input : A randomly generated database(with the help of torch library)

Output : tensor(0.0005)

解释
首先，我们在 torch 库的帮助下创建了一个随机数据库，然后我们为线性和并行数据库定义了两个函数 get_parallel_db 和 get_parallel_dbs。现在我们定义了灵敏度函数，然后我们测量每个并行数据库的查询结果与整个数据库的查询结果之间的差异，然后计算最大值（即 1）。该值称为“灵敏度” 。