隐私保护的机器学习-全-

隐私保护的机器学习（全）

原文：Privacy-Preserving Machine Learning True

译者：飞龙

协议：CC BY-NC-SA 4.0

前置内容

前言

鉴于社交媒体和在线流媒体服务的普及，您可能已经体验到了机器学习（ML）在提供个性化服务方面的潜力。尽管这个令人兴奋的领域为许多新的可能性打开了大门，并已成为我们生活中不可或缺的一部分，但训练机器学习模型需要使用大量通过各种方式收集的数据。当这些数据通过机器学习模型进行处理时，保护个人信息的机密性和隐私性以及维护使用这些模型的人的信任至关重要。

在机器学习中保护隐私至关重要，但也极具挑战性。2014 年底，张博士和他的前博士生，穆罕默德·阿尔鲁比博士，开始研究机器学习技术中的隐私泄露问题，并探索减轻这种泄露的可能性。随着他们研究的深入，国防高级研究计划局（DARPA）在 2015 年初启动了一个名为“布兰代斯”（BAA-15-29）的新研究项目，初始预算为 5000 万美元。该项目以 1890 年在《哈佛法学评论》杂志上发表“隐私权”论文的美国最高法院大法官路易斯·布兰代斯的名字命名。布兰代斯项目的主要目标是寻求和开发技术手段，通过实现数据的安全和可预测共享来保护个人信息，同时保持隐私。张博士及其团队参与了布兰代斯项目，并基于压缩隐私和差分隐私技术开发了几个隐私保护技术。

2019 年，美国特种作战司令部（USSOCOM）又授予了张、庄、萨马拉维拉博士及其团队一项研究奖项，他们利用最新的机器学习模型和工具，试图将这些增强机器学习隐私和安全性的技术应用于实践。自 2015 年以来，他们参与了布兰代斯项目以及许多其他国防部资助的研究项目，积累了丰富的实践经验。他们认为，现在是时候将他们开发的技术整合在一起了。因此，这本书与其他技术书籍不同：它讨论了机器学习的根本概念和机器学习的隐私保护技术，并提供了直观的示例和实现代码，展示了如何在实践中使用它们。

他们认为，这本书是第一本全面介绍隐私保护机器学习的书籍。在这里，他们将带您进行一次激动人心的旅程，涵盖所有基本概念、技术和实践细节。如果您在阅读本书后还想了解更多，可以参考每章中引用的参考文献和本书末尾列出的参考文献。

致谢

我们还要感谢 DARPA Brandeis 项目以及我们愉快地与他们一起开发隐私保护机器学习新范例的项目经理们。我们也非常感谢我们的团队，他们在 Brandeis 项目中工作，特别是 Sun-Yuan Kung 博士和 Pei-yuan Wu 博士。此外，如果没有美国南佛罗里达大学 Chang 博士研究组的以前和当前博士生，特别是 Mohammad Al-Rubaie 博士和 Sen Wang，这本书可能无法完成。

我们还要向 Manning 出版社的编辑和生产团队表示衷心的感谢，感谢他们为出版这本书所付出的辛勤努力。最后，我们还要感谢所有审稿人，感谢他们对改进手稿讨论的支持和宝贵的反馈：Abe Taha, Aditya Kaushik, Alain Couniot, Bhavani Shankar Garikapati, Clifford Thurber, Dhivya Sivasubramanian, Erick Nogueira do Nascimento, Frédéric Flayol, Harald Kuhn, Jaganadh Gopinadhan, James Black, Jeremy Chen, Joseph Wang, Kevin Cheung, Koushik Vikram, Mac Chambers, Marco Carnini, Mary Anne Thygesen, Nate Jensen, Nick Decroos, Pablo Roccatagliata, Raffaella Ventaglio, Raj Sahu, Rani Sharim, Richard Vaughan, Rohit Goswami, Satej Sahu, Shankar Garikapati, Simeon Leyzerzon, Simon Tschöke, Simone Sguazza, Sriram Macharla, Stephen Oates, Tim Kane, Vidhya Vinay, Vincent Ngo, Vishwesh Ravi Shrimali, 和 Xiangbo Mao——你们的建议帮助使这本书更加完善。

关于这本书

《隐私保护机器学习》是一本综合指南，旨在帮助机器学习（ML）爱好者通过他们的 ML 应用程序避免数据隐私泄露。它从涉及现代数据驱动应用程序中隐私考虑的一些实际用例和场景开始。然后介绍了构建隐私保障 ML 应用程序的不同技术。

应该阅读这本书的人

《隐私保护机器学习》是为中级数据科学爱好者（即有 ML 经验的人）以及希望了解如何将隐私保护技术集成到他们应用程序中的人而设计的。尽管隐私和安全概念通常是数学性的，难以理解，但本书试图将复杂的算法分解成易于理解的片段，并提供了一系列动手练习和示例。

本书是如何组织的：一个路线图

本书分为三部分，共 10 章。

第一部分解释了隐私保护机器学习是什么，以及如何在实际用例中使用差分隐私：

• 第一章讨论了 ML 中的隐私考虑，重点讨论当私有数据泄露时隐私威胁的严重性。

• 第二章介绍了差分隐私的核心概念，并阐述了今天广泛使用的差分隐私机制，这些机制已成为各种隐私保护算法和应用的基本构建块。

• 第三章主要涵盖了差分隐私机器学习算法的高级设计原则。在章节的后半部分，我们介绍了一个案例研究，引导您了解设计和分析差分隐私算法的过程。

第二部分通过讨论另一个名为局部差分隐私的差分隐私级别，扩展了讨论，并讨论了如何为隐私保证目的生成合成数据：

• 第四章介绍了局部差分隐私的核心概念和定义。

• 第五章通过考虑各种数据类型和现实世界的应用场景，涵盖了局部差分隐私的高级机制。我们还提供了一个关于局部差分隐私的案例研究，引导您了解设计和分析算法的过程。

• 第六章通过讨论如何为机器学习任务设计一个保护隐私的合成数据生成方案，介绍了合成数据生成涉及的概念和技术。

第三部分涵盖了构建隐私保证的机器学习应用所需的更高级的核心概念：

• 第七章介绍了在数据挖掘应用中保护隐私的重要性，广泛使用的隐私保护机制及其在数据挖掘操作中的特性。

• 第八章通过涵盖常见的隐私模型、在处理和发布数据时在数据挖掘操作中的特性以及各种威胁和漏洞，扩展了数据挖掘中隐私保证的讨论。

• 第九章介绍了机器学习的压缩隐私及其设计和实现。

• 第十章将这些概念结合起来，设计了一个用于研究数据保护和共享的隐私增强平台。

通常，我们鼓励您仔细阅读前几章，以便理解核心概念以及隐私保护对机器学习应用的重要性。其余章节讨论了不同层次的核心概念和最佳实践，它们可以根据您的特定需求无序阅读。在每个核心主题的结尾，都会引入一个案例研究，对选定的算法进行更全面和深入的分析，这将特别吸引那些想了解更多关于设计和分析隐私增强机器学习算法过程的人。

关于代码

本书包含许多源代码示例，无论是编号列表还是与普通文本并列。在这两种情况下，源代码都使用固定宽度字体格式化，如这样，以将其与普通文本区分开来。大部分代码是用 Python 语言编写的，但一些用例实验是用 Java 展示的。读者应了解基本语法以及如何编写和调试 Python 和 Java 代码。读者还必须熟悉某些 Python 科学计算和机器学习包，如 NumPy、scikit-learn、PyTorch、TensorFlow 等。

在许多情况下，原始源代码已经被重新格式化；我们添加了换行符并重新调整了缩进，以适应书籍中可用的页面空间。在某些情况下，即使这样也不够，列表中还包括了行续接标记（➥）。此外，当代码在文本中描述时，源代码中的注释通常已被从列表中移除。许多列表旁边都有代码注释，突出显示重要概念。

您可以从本书的 liveBook（在线）版本中获取可执行的代码片段，网址为livebook.manning.com/book/privacy-preserving-machine-learning。书中示例的完整代码可以从 Manning 网站www.manning.com/books/privacy-preserving-machine-learning和 GitHubgithub.com/nogrady/PPML/下载。

liveBook 讨论论坛

购买《隐私保护机器学习》（Privacy-Preserving Machine Learning）包括免费访问 liveBook，Manning 的在线阅读平台。使用 liveBook 的独特讨论功能，您可以在全球范围内或特定章节或段落中附加评论。为自己做笔记、提出和回答技术问题以及从作者和其他用户那里获得帮助都非常简单。要访问论坛，请访问livebook.manning.com/book/privacy-preserving-machine-learning/discussion。您还可以在livebook.manning.com/discussion了解更多关于 Manning 论坛和行为准则的信息。

Manning 对我们读者的承诺是提供一个场所，让读者之间以及读者与作者之间可以进行有意义的对话。这不是对作者参与特定数量活动的承诺，作者对论坛的贡献仍然是自愿的（且未付费）。我们建议您尝试向他们提出一些挑战性的问题，以免他们的兴趣转移！只要本书有售，论坛和以前讨论的存档将可通过出版社的网站访问。

关于作者

张迪摩自 2016 年以来一直担任美国南佛罗里达大学电气工程系的教授，在此之前曾在爱荷华州立大学（2001-2016 年）、伊利诺伊理工学院（1995-2001 年）和罗切斯特理工学院（1993-1995 年）担任教职。加入学术界之前，他在 AT&T 贝尔实验室担任计算机工程师（1988-1990 年）。他最近的研究工作涵盖了网络安全领域的广泛主题，从身份验证到恶意软件检测、增强隐私技术以及机器学习中的安全性，并得到了不同国防部（DoD）机构的资助。张博士在北卡罗来纳州立大学获得了计算机工程博士学位。他在 1999 年获得了伊利诺伊理工学院大学卓越教学奖，并于 2019 年被选入北卡罗来纳州立大学 ECE 校友名人堂。在过去 10 年中，他担任了由国防部机构资助的多个项目的首席研究员。莫里斯在同行评审期刊和会议论文集中发表了 196 多篇论文。此外，他还曾在电气和电子工程师协会（IEEE）担任多个职位，包括 IEEE 的《IT 专业》杂志的首席副主编（2014-2018 年）、《IEEE 可靠性交易》期刊的副主编（2022 年）以及 COMPSAC 2019（2019 年 IEEE 计算机协会关于计算机、软件和应用的标志性会议）的程序委员会主席。

庄迪是 Snap Inc.的安全工程师。他的学历包括中国天津南开大学的网络安全学士和法学学士，以及南佛罗里达大学的电气工程博士学位。他是一位充满活力、技术娴熟的安全和隐私研究员，对设计隐私、差分隐私、隐私保护机器学习、社交网络科学和网络安全有浓厚的兴趣、专业知识和经验。他从 2015 年到 2018 年在 DARPA Brandeis 项目下进行了隐私保护机器学习研究。

Dumindu Samaraweera是南佛罗里达大学的研究助理教授。Dumindu 在澳大利亚科廷大学获得了计算机系统和网络学士学位；在斯里兰卡信息科技大学获得了信息技术学士学位；在英国谢菲尔德哈勒姆大学获得了企业应用开发硕士学位。他在南佛罗里达大学（USF）获得了电气工程博士学位，专注于网络安全和数据科学的研究。他的博士论文“深度学习时代的安全和隐私增强技术”针对当今数据驱动应用中识别出的隐私和安全问题，提供了深入解决方案以减轻这些问题。多年来，他参与了多个由美国国防部资助的大型网络安全研究项目。在加入 USF 之前，他在业界担任软件工程师/电气工程师超过六年，负责管理和部署企业级解决方案。

这本书的技术编辑Wilko Henecka是 Ambiata 的高级软件工程师，致力于构建保护隐私的软件。他拥有阿德莱德大学的数学博士学位和波鸿鲁尔大学的 IT 安全硕士学位。

关于封面插图

《隐私保护机器学习》封面上的插图是“Femme Acadienne”，或称“阿卡迪亚妇女”，取自雅克·格拉塞·德·圣索沃尔于 1788 年出版的作品集。每一幅插图都是手工精心绘制和着色的。

在那些日子里，人们通过他们的服饰就能轻易识别出他们的居住地以及他们的职业或社会地位。曼宁通过基于几个世纪前丰富多样的地区文化的封面设计，庆祝计算机行业的创新和主动性，这些文化通过如这一系列图片般的作品得以重现。

第一部分：差分隐私的隐私保护机器学习基础知识

第一部分涵盖了隐私保护机器学习和差分隐私的基础知识。第一章讨论了机器学习中的隐私考虑因素，重点强调了私人数据泄露的危险。第二章介绍了差分隐私的核心概念，以及一些广泛采用的差分隐私机制，这些机制作为各种隐私保护算法和应用的构建块。第三章涵盖了差分隐私机器学习算法的高级设计原则，并呈现了一个案例研究。

1 机器学习中的隐私考虑

本章涵盖

• 在大数据人工智能时代隐私保护的重要性

• 机器学习中的隐私相关威胁、漏洞和攻击类型

• 可以在机器学习任务中利用的技术，以最小化或规避隐私风险和攻击

我们的搜索查询、浏览历史、购买交易、观看视频和电影偏好是每天收集和存储的一些信息类型。人工智能的进步增加了利用和从收集的私人数据中获益的能力。

这种数据收集发生在我们的移动设备和计算机上，在街道上，甚至在我们的办公室和家中，这些数据被不同领域的各种机器学习（ML）应用使用，例如市场营销、保险、金融服务、移动性、社交网络和医疗保健。例如，越来越多的基于云的数据驱动 ML 应用正在由不同的服务提供商（可以归类为数据用户，如 Facebook、LinkedIn 和 Google）开发。这些应用中的大多数都利用从每个个人（数据所有者）收集的大量数据为用户提供有价值的服务。这些服务通常通过促进各种用户推荐、活动识别、健康监测、定向广告甚至选举预测，使用户获得一些商业或政治优势。然而，另一方面，相同的数据可能被重新用于推断敏感（私人）信息，这可能会危及个人的隐私。此外，随着机器学习即服务（MLaaS）的日益普及，其中基于云的 ML 和计算资源捆绑在一起，以提供高效的分析平台（如 Microsoft Azure Machine Learning Studio、AWS Machine Learning 和 Google Cloud Machine Learning Engine），在它们与敏感数据集一起使用之前，有必要采取措施来强制执行这些服务的隐私。

1.1 人工智能时代的隐私问题

让我们先来看一个真实世界的私人数据泄露的例子，以便可视化这个问题。在 2018 年 4 月的 Facebook-Cambridge Analytica 丑闻中，大约 8700 万 Facebook 用户的资料被一个 Facebook 测验应用（一个基于云的数据驱动应用）收集，然后与从这些用户的社交媒体资料中获取的信息（包括他们的性别、年龄、关系状况、位置和“点赞”）配对，除了匿名化之外，没有采取任何保护隐私的操作。这是怎么发生的？

这个名为“这是你的数字生活”的测验最初由剑桥大学的俄罗斯心理学教授亚历山大·科甘创建。这个测验旨在收集个性信息，大约有 27 万人为此获得了报酬。然而，除了测验旨在收集的信息之外，它还从参与者的朋友资料中提取了数据，形成了一个庞大的数据集。后来，科甘与剑桥分析公司达成商业合作，剑桥分析公司从这些数据集中提取了个人信息，例如用户的居住地和他们喜欢的页面，最终帮助剑桥分析公司构建心理档案，并推断出每个个体的某些敏感信息，如图 1.1 所示。

图 1.1 Facebook-Cambridge Analytica 丑闻引起了人们对隐私问题的警觉。

那只是一个事件！2020 年，在另一起隐私丑闻之后，Facebook 同意支付 5.5 亿美元来解决因公司使用基于机器学习的面部识别技术而引发的集体诉讼。这再次引发了人们对社交网络数据挖掘实践的质疑。诉讼称，该公司未经用户同意，也未告知他们数据将保留多长时间，就收集了该州数百万用户的照片中的面部数据，用于标签建议，违反了伊利诺伊州的生物识别隐私法。最终，Facebook 在隐私问题担忧之下禁用了标签建议功能。

这些前所未有的数据泄露丑闻引起了人们对基于云的数据驱动应用程序隐私问题的警觉。人们在提交任何数据到云服务之前开始三思而后行。因此，数据隐私已经成为学术界和技术公司比以往任何时候都更热门的话题，它们投入了巨大的努力来开发隐私保护技术，以防止私人数据泄露。例如，谷歌开发了随机可聚合隐私保护序数响应（RAPPOR）技术，这是一种从终端用户客户端软件中收集统计数据的众包技术。苹果也声称它首先在 iOS 11 中引入了其成熟的隐私技术，用于从 iPhone 用户那里收集表情符号偏好和使用分析统计数据。2021 年，谷歌通过替换第三方 cookies 并在广告公司如何与浏览器中使用的私人数据互动方面设置边界，将其隐私沙盒倡议引入 Chrome 网络浏览器。当人们使用互联网时，出版商和广告商希望提供与他们相关且有趣的内容，包括广告。人们的兴趣通常通过观察他们访问的网站或页面来衡量，依赖于第三方 cookies 或更不透明且不受欢迎的机制，如设备指纹识别。通过这一隐私沙盒倡议，谷歌引入了一种新的方式，通过将具有相似浏览模式的大量人群进行聚类，隐藏个体在人群中的身份，并保留他们在浏览器中的网络历史记录，而不使用第三方 cookies，来提供相关的内容和广告。

1.2 超出预期目的的学习威胁

机器学习可以被视为算法模仿智能人类行为的能力，通过从不同角度观察数据并跨领域分析数据来执行复杂任务。这一学习过程被我们日常生活中的各种应用所利用，从在线门户网站的产品推荐系统到互联网安全应用中的复杂入侵检测机制。

1.2.1 动态使用私人数据

机器学习应用需要从各种来源收集大量数据以产生高度可信的结果。网络搜索查询、浏览历史、在线购买交易历史、电影偏好以及个人位置签到是一些每天收集和存储的信息，通常在用户不知情的情况下进行。其中一些信息对个人来说是私密的，但它们通常以明文格式上传到高端集中式服务器，以便机器学习算法从中提取模式和构建机器学习模型。

问题不仅限于不同机器学习应用收集这些私有数据。由于信息对数据挖掘公司的员工是可用的，数据还可能受到内部攻击。例如，数据库管理员或应用程序开发者可能在没有太多限制的情况下访问这些数据。这些数据还可能受到外部黑客攻击，私人信息可能泄露给外界。例如，2015 年，Twitter 解雇了一名工程师，因为情报官员发现他可能通过访问用户详情（如电话号码和 IP 地址）来监视沙特异议人士的账户。据《纽约时报》报道，这些账户属于安全和隐私研究人员、监控专家、政策学者和记者。这一事件是另一个例子，说明了问题的严重性。最重要的是，即使数据被转换为不同的嵌入（匿名化），或者数据集和机器学习模型不可访问，只透露测试结果，也可能从私有数据中提取更多信息。

1.2.2 机器学习算法内部如何处理数据

要了解数据隐私与机器学习算法之间的关系，了解机器学习系统如何处理它们处理的数据至关重要。通常，我们可以将机器学习算法的输入数据（从各种来源捕获）表示为一组样本值，每个样本可以是一组特征。以一个面部识别算法为例，该算法在人们上传图像到 Facebook 时识别人员。考虑一个 100 × 100 像素的图像，其中每个像素由 0 到 255 之间的单个值表示。这些像素可以连接起来形成一个特征向量。每个图像都可以表示为机器学习算法的数据向量，以及与该数据相关联的标签。在训练阶段，机器学习算法会使用多个特征向量和它们的相关标签来生成机器学习模型。然后，该模型将用于新鲜、未见的数据（测试样本）来预测结果——在这种情况下，识别一个人。

衡量机器学习模型的性能

机器学习模型准确预测最终结果的能力是衡量该模型如何将泛化到未见数据或首次引入的数据的程度。这种准确性通常通过经验方法进行衡量，并且会根据训练样本数量、构建模型所使用的算法、训练样本的质量以及为机器学习算法选择的超参数等因素而变化。在某些使用不同机制从原始数据中提取基本特征的应用中，在将原始数据输入到机器学习模型之前进行预处理同样重要。这些机制可能涉及各种技术（如主成分分析），以将数据投影到较低维度。

1.2.3 为什么在机器学习中保护隐私很重要

当个人信息被用于错误或不正当的目的时，它可以被操纵以获得竞争优势。当大量个人记录与机器学习算法相结合时，没有人能够预测它们可能会产生什么新的结果，或者这些结果可能会揭示多少私人信息。之前讨论过的 Facebook-Cambridge Analytica 丑闻就是个人数据被错误使用的完美例子。

因此，在设计应用于机器学习的算法时，确保隐私保护至关重要。首先，它确保其他方（数据使用者）不能利用个人数据为自己谋取利益。其次，每个人都有他们不想让别人知道的事情。例如，他们可能不希望别人知道他们医疗历史的细节。但机器学习应用是数据驱动的，我们需要训练样本来构建模型。我们希望使用私有数据来构建模型，但我们也希望防止机器学习算法学习到任何敏感信息。我们该如何做到这一点呢？

让我们考虑一个场景，在这个场景中我们使用了两个数据库：一个是列出患者用药历史的清洁医疗数据库，另一个是包含用户信息和访问过的药店的数据库。当这些来源被链接在一起时，相关的数据库可以拥有额外的知识，例如哪些患者从哪些药店购买了他们的药物。假设我们正在使用这个相关数据集与一个机器学习应用来提取患者、药物和药店之间的关系。虽然它将提取不同疾病和所开具药物之间的明显关系，但它也可能仅仅通过参考患者最常访问的药店的邮编，粗略地学习到患者的居住地，即使数据中不包含患者的地址。这是一个简单的例子，但你可以想象如果隐私没有得到保护，后果可能会多么严重。

1.2.4 监管要求与效用与隐私权衡

传统上，数据安全和隐私要求由数据所有者（如组织）设定，以保护他们提供的产品和服务的竞争优势。然而，在大数据时代，数据已成为数字经济中最有价值的资产，政府实施了众多隐私法规，以防止敏感信息被用于其预期目的之外。例如，像 1996 年的《健康保险可携带性和问责法案》（HIPAA）、《支付卡行业数据安全标准》（PCI DSS）、《家庭教育权利和隐私法案》（FERPA）以及欧盟的《通用数据保护条例》（GDPR）这样的隐私标准，是组织通常遵守的一些隐私法规。例如，无论实践规模大小，大多数医疗保健提供者都会通过电子方式传输健康信息，如索赔、药物记录、福利资格查询、转诊授权请求等。然而，HIPAA 法规要求这些医疗保健提供者在没有患者同意或知情的情况下，保护敏感的患者健康信息不被泄露。

无论数据是否标记，或原始数据是否预处理，机器学习模型本质上是基于训练数据集的非常复杂的统计模型，机器学习算法被优化以从数据中榨取每一丝效用。因此，在大多数情况下，它们能够学习数据集中的敏感属性，即使这不是预期的任务。当我们试图保护隐私时，我们希望防止这些算法学习敏感属性。因此，正如你所看到的，效用和隐私处于光谱的两端。当你加强隐私时，可能会影响效用的性能。

真正的挑战是在机器学习应用中平衡隐私和性能，以便我们更好地利用数据，同时确保个人的隐私。由于监管和特定应用的要求，我们不能仅仅为了提高应用的效用而降低隐私保护。另一方面，隐私必须系统地实施，而不使用任意机制，因为必须考虑许多额外的威胁。机器学习应用容易受到不同的隐私和安全攻击。我们将在下一节详细探讨这些潜在攻击，并探讨我们如何通过设计隐私保护机器学习（PPML）算法来减轻它们。

1.3 机器学习系统的威胁和攻击

我们在上一节讨论了一些隐私泄露事件，但文献中提出了许多其他针对机器学习系统的威胁和攻击，这些攻击可能被部署在实际场景中。例如，图 1.2 是一个显示机器学习系统威胁和攻击列表的时间线，包括去匿名化（重新识别）攻击、重建攻击、参数推断攻击、模型反演攻击和成员推断攻击。我们将简要探讨这些威胁或攻击的细节。

图 1.2 为机器学习系统识别的威胁和攻击的时间线

尽管一些领先的公司，如谷歌和苹果，开始设计和使用他们自己的用于机器学习任务的隐私保护方法，但提高公众对这些隐私技术的认识仍然是一个挑战，这主要是因为缺乏组织良好的教程和书籍，这些教程和书籍系统地解释了概念。

1.3.1 明文中的私有数据问题

图 1.3 说明了典型的客户端/服务器应用程序场景。如图所示，当应用程序收集私有信息时，该信息通常通过加密渠道传输，转移到云服务器上进行学习。在该图中，一个移动应用程序连接到云服务器以执行推理任务。

图 1.3 存储私有数据为明文格式的问题

例如，一个停车应用可能会将用户的位置数据发送以寻找附近的可用停车场。即使通信渠道是安全的，数据很可能会以原始未加密的形式或作为从原始记录中提取的特征存储在云中。这是对隐私的最大挑战之一，因为该数据容易受到各种内部和外部攻击。

1.3.2 重建攻击

正如你所看到的，在服务器上以加密形式存储私有数据是至关重要的，我们不应该以原始形式直接将原始数据发送到服务器。然而，重建攻击提出了另一个可能的威胁：攻击者甚至在没有访问服务器上完整原始数据集的情况下重建数据。在这种情况下，对手通过对外部特征向量（用于构建机器学习模型的数据）的了解而获得优势。

对手通常需要直接访问服务器上部署的机器学习模型，这被称为白盒访问（见表 1.1）。然后他们试图通过使用对模型中特征向量的了解来重建原始的私有数据。当在训练阶段用于构建机器学习模型的特征向量在模型构建后未从服务器清除时，这些攻击是可能的。

表 1.1 白盒、黑盒和灰盒访问的区别

白盒访问	黑盒访问	灰盒访问
具有完全访问内部细节的 ML 模型，如参数和损失函数	没有访问内部细节的 ML 模型	具有部分访问内部细节的 ML 模型

重建工作原理：攻击者的视角

现在你已经对重建攻击的工作原理有了高级概述，让我们来看看它是如何可能的细节。重建数据的方法取决于攻击者可用以准确重现数据的背景知识（信息）。我们将考虑以下两个基于生物识别的认证系统的用例示例：

• 指纹图像的细节点模板重建——如今，基于指纹的认证在许多组织中都很普遍：用户通过将新获取的指纹图像与用户认证系统中已保存的指纹图像进行比较来进行认证。通常，这些指纹匹配系统使用四种不同的表示方案，称为灰度、骨架、相位和细节点（图 1.4）。基于细节点的表示法由于表示的紧凑性而被广泛采用。正因为这种紧凑性，许多人错误地认为细节点模板不包含足够的信息供攻击者重建原始指纹图像。

  2011 年，一个研究团队成功地演示了一种可以从细节点模板直接重建指纹图像的攻击[1]。他们从细节点重建了一个相位图像，然后将其转换为原始（灰度）图像。接下来，他们针对指纹识别系统发起攻击，以推断私人数据。

  

  图 1.4 指纹匹配系统中使用的四种不同表示方案：（a）灰度图像，（b）骨架图像，（c）相位图像和（d）细节点

• 针对基于移动的连续认证系统的重建攻击——Al-Rubaie 等人调查了使用基于移动的连续认证系统中用户认证配置文件的手势原始数据进行的重建攻击的可能性[2]。连续认证是一种在整个会话期间（如 iPhone 中的 Face ID）不断验证用户的方法，而不仅仅是验证一次。如果没有连续认证，组织更容易受到许多攻击向量的攻击，例如，当系统不再使用但会话仍然打开时，系统可能会被接管。在这种情况下，重建攻击可能会使用泄露给对手的可用私人信息。从高层次来看，Al-Rubaie 等人使用存储在用户配置文件中的特征向量来重建原始数据，然后使用这些信息来入侵其他系统。

在大多数这些情况下，隐私威胁源于对认证系统的安全威胁，重建的原始数据误导了机器学习系统，迫使它认为原始数据属于特定用户。例如，在基于移动的持续认证系统案例中，攻击者获得了对移动设备和其个人记录的访问权限；因此，认证机制未能保护用户的隐私。另一类重建攻击可能会直接揭示私人信息，正如你接下来将看到的。

涉及重建攻击的真实场景

在 2019 年，西蒙·加芬克尔及其在美国人口普查局的团队展示了一个详细的例子，说明了攻击者如何仅利用公开数据来启动重建攻击[3]。他们进一步解释说，发布按少数人口统计分组的人口频率计数、平均值和中位数年龄，允许任何拥有这些统计数据和个人电脑的人准确重建几乎整个调查人群的个人数据。这一事件引发了人们对人口普查数据隐私的关注。基于这一发现，美国人口普查局对 2010 年的人口普查数据进行了系列实验。在 800 亿条统计数据中，每人 25 个数据点允许成功重建超过 40%的美国人口的机密记录。

尽管这与机器学习算法没有直接关系，但你可能已经理解了这个问题有多么可怕。统计机构每年发布的庞大敏感数据量可能为决心攻击者提供足够的信息来重建某些或全部目标数据库，并侵犯数百万人的隐私。美国人口普查局已经识别了这一风险，并实施了正确的措施来保护 2020 年美国人口普查，但重要的是要注意，重建不再是一个理论上的危险。它是真实的。

现在的问题是，我们如何防止此类攻击成功？在减轻针对机器学习模型的重建攻击方面，最佳方法是避免在机器学习模型中存储显式特征向量。如果必须存储特征向量（例如，支持向量机需要存储特征向量和模型元数据），它们应该对机器学习模型的用户不可访问，以便难以重建。特征名称至少可以被匿名化。为了减轻针对数据库或数据挖掘操作（如美国人口普查案例）的重建攻击，可以使用不同的和已建立的数据净化和披露避免技术。

这场讨论只是对重建攻击工作原理的总结。我们将在接下来的章节中更详细地讨论这些技术和其他缓解策略。

1.3.3 模型反演攻击

虽然一些机器学习模型存储显式特征向量，但其他机器学习算法（如神经网络和岭回归）不保留模型内部的特征向量。在这些情况下，攻击者的知识有限，但他们可能仍然可以访问机器学习模型，正如在白盒访问场景中讨论的那样。

在另一种黑盒访问场景中，攻击者没有直接访问机器学习模型：当用户提交新的测试样本时，他们可以监听对机器学习模型的请求，以及模型生成的响应。在模型反演攻击中，攻击者以类似于创建机器学习模型时使用的原始特征向量方式利用机器学习模型生成的响应[4]。图 1.5 展示了模型反演攻击的工作原理。

图 1.5 白盒访问和黑盒访问的区别。白盒访问需要直接访问和权限来推断数据；黑盒访问通常涉及监听通信通道。

通常，此类攻击利用从机器学习模型收到的置信度值（如概率决策分数）来生成特征向量。例如，让我们考虑一个人脸识别算法。当你向算法提交人脸图像时，算法会根据它在图像中识别的特征生成一个包含类别和相应置信度分数的结果向量。现在，假设算法生成的结果向量是

[John:.99, Simon:.73, Willey:.65]

这个结果的意义是什么？算法有 99%的信心（决策分数）认为这张图像属于 John（类别），有 73%的信心认为它属于 Simon，等等。

如果攻击者可以监听所有这些通信呢？即使他们没有输入图像或不知道图像属于谁，他们也可以推断，如果输入一个相似的图像，他们将在这个范围内获得一个置信度分数。通过在一定时期内累积结果，攻击者可以生成代表机器学习模型中某个类别的平均分数。如果这个类别代表一个单独的个人，如在人脸识别算法中，识别这个类别可能导致隐私泄露的威胁。在攻击开始时，攻击者不知道这个人是谁，但随着时间的推移累积数据，他们将能够识别这个人，这是非常严重的。

因此，模型反演攻击对基于机器学习的系统构成了严重威胁。请注意，在某些情况下，模型反演攻击可以根据特征在原始数据中的排列方式被归类为重建攻击的一个子类。

在缓解模型反演攻击时，限制攻击者仅限于黑盒访问很重要，因为它限制了攻击者的知识。在我们的基于人脸识别的认证示例中，我们不是提供某个机器学习类别的确切置信度值，而是将其四舍五入。或者，我们可以只返回最终的预测类别标签，这样攻击者就难以学习到特定预测之外的信息。

1.3.4 成员推理攻击

与模型反演攻击不试图从训练数据集中重现实际样本不同，成员推理攻击试图根据机器学习模型的输出推断一个样本，以确定它是否在原始训练数据集中。成员推理攻击背后的想法是，给定一个机器学习模型、一个样本和领域知识，攻击者可以确定该样本是否是构建机器学习模型所使用的训练数据集的成员，如图 1.6 所示。

图 1.6 成员推理攻击的工作原理

让我们通过分析输入的医疗信息和条件来考虑一个基于机器学习的疾病诊断系统。例如，假设一位患者参与了一项研究，该研究诊断了一个旨在识别患有阿尔茨海默病的复杂游戏的正确难度级别。如果攻击者成功执行了成员推理，他们将知道这位患者是否在构建模型所使用的原始数据集中。不仅如此，通过了解游戏的难度级别，攻击者可以推断出这位患者是否患有阿尔茨海默病。这种情况描述的是一种严重的信息泄露，这些信息可能后来被用于针对患者的针对性行动。

如何进行成员推理

在这种攻击中，攻击者的意图是了解个人的个人记录是否被用于训练原始机器学习模型。为此，攻击者首先通过利用模型的领域知识生成一个二级攻击模型。通常，这些攻击模型是使用基于实际数据噪声版本、从模型反演攻击中提取的数据或基于统计的综合生成的影子模型进行训练的。为了训练这些影子模型，攻击者需要黑盒或白盒访问原始机器学习模型和样本数据集。

通过这种方式，攻击者可以访问机器学习服务以及攻击模型。攻击者观察在训练阶段使用的机器学习模型预测产生的输出数据与训练集中未包含的数据之间的差异，如图 1.6 所示。成员推理尝试学习特定记录是否在训练数据集中，而不是数据集本身。

有几种缓解成员推理攻击的策略，例如正则化或预测值的粗略精度。我们将在第八章中讨论这些正则化策略。然而，仅将机器学习模型的输出限制为类别标签是降低威胁的最有效方法。此外，差分隐私（DP）是抵抗成员推理攻击的有效机制，我们将在第二章中讨论。

1.3.5 反匿名化或重新识别攻击

在将数据集发布给第三方用户之前对其进行匿名化是一种典型的保护用户隐私的方法。简单来说，匿名化通过删除或更改将个人与存储数据连接的标识符来保护私人或敏感信息。例如，您可以通过保留数据但保持来源匿名的数据匿名化过程来匿名化个人身份信息，如姓名、地址和社会安全号码。一些组织采用各种策略，只为公众使用发布其数据集的匿名版本（例如，公共选民数据库、Netflix 奖项数据集、AOL 搜索数据等）。例如，Netflix 通过邀请不同的参赛者进行数据挖掘并提出构建更好的电影推荐系统的算法，发布了一个包含 50 万 Netflix 订阅者的大型数据集，其中包含了匿名化的电影评分。

然而，即使数据被清除了标识符，攻击仍然可能通过反匿名化进行。反匿名化技术可以轻松地交叉引用公开可用的来源并揭示原始信息。在 2008 年，Narayanan 等人证明了即使在k匿名等数据匿名化技术下，也有可能推断出个人的私人信息[6]。在他们攻击场景中，他们利用互联网电影数据库（IMDb）作为背景知识来识别已知用户的 Netflix 记录，显然揭示了用户的政治偏好。因此，基于简单语法的匿名化不能可靠地保护数据隐私免受强大对手的攻击。我们需要依赖类似差分隐私的东西。我们将在第八章中更详细地讨论重新识别攻击。

1.3.6 大数据分析中隐私保护面临的挑战

除了针对机器学习模型和框架的特定威胁和攻击之外，在机器学习和隐私光谱的另一端也出现了一个隐私挑战。那就是，我们如何保护静态数据，例如在输入机器学习任务之前存储在数据库系统中的数据，以及传输中的数据，其中数据在底层机器学习框架的各个元素中流动？向更大、更互联的数据存储库的持续转变使得数据库系统和数据分析工具在保护数据免受隐私威胁方面变得更加困难。

数据库系统中一个显著的隐私威胁是将不同的数据库实例链接起来以探索个人的独特指纹。这种攻击可以归类为重识别攻击的一个子类，并且在数据库应用中通常是内部攻击。基于数据的形成和识别，这些攻击可以进一步分为两种类型：相关攻击和识别攻击。

相关攻击

相关攻击的最终目的是在数据库或一组数据库实例中找到两个或更多数据字段之间的关联，以创建独特且信息丰富的数据元组。正如您所知，在某些情况下，我们可以将来自外部数据源的主题知识引入识别过程。例如，让我们以一个列出用户信息以及药物处方历史的医疗记录数据库为例。考虑另一个包含用户信息以及访问过的药房的数据库。一旦这些来源被连接起来，相关的数据库可以包括一些额外的知识，例如哪些患者从哪些药房购买了药物。此外，如果足够智能地探索常去的药房，攻击者可能能够获得患者居住的大致估计。因此，最终的关联数据集可能比原始数据集包含更多关于每个用户的私人信息。

识别攻击

当相关攻击试图提取更多私人信息时，识别攻击试图通过链接数据库实例中的条目来识别目标个人。其想法是探索有关特定个人的更多个人信息以进行识别。我们可以将这种攻击视为对数据集中最具威胁的数据隐私攻击之一，因为它对个人的隐私影响更大。例如，假设雇主调查了其员工在医疗记录或药房客户数据库中的所有出现情况。这可能会揭示有关员工药物记录、医疗治疗和疾病的大量额外信息。因此，这种攻击对个人隐私构成了日益增长的威胁。

到目前为止，应该很清楚，我们需要在数据分析和应用机器学习中有复杂的机制来保护个人免受不同针对性攻击的隐私。使用多层数据匿名化和数据假名化技术使得在链接不同数据集的同时保护隐私成为可能，但通过分析数据记录来识别个人则具有挑战性。第七章和第八章对不同的隐私保护技术进行了全面评估，详细分析了它们如何在现代数据驱动应用中使用，并展示了如何在 Python 中实现它们。

1.4 在从数据中学习的同时保护隐私：隐私保护机器学习

许多增强隐私的技术集中在允许多个输入方协作训练机器学习模型，同时不泄露原始形式的私有数据。这种协作可以通过使用加密方法（例如，安全多方计算）或差分隐私数据发布（扰动技术）来实现。差分隐私在防止成员推理攻击方面特别有效。最后，正如之前讨论的，通过限制模型的预测输出（例如，仅限类别标签）可以降低模型反演和成员推理攻击的成功率。

本节从高层次介绍了几种增强隐私的技术，以使您对它们的工作原理有一个一般性的了解。这些技术包括差分隐私、局部差分隐私（LDP）、隐私保护合成数据生成、隐私保护数据挖掘技术以及压缩隐私。这些内容将在本书的后续章节中进一步展开。

1.4.1 差分隐私的使用

数据爆炸导致个人和实体（如个人图像、财务记录、人口普查数据等）持有的数据量大幅增加。然而，当这些数据离开数据所有者的控制并用于某些计算时，就会引发隐私担忧。AOL 搜索引擎日志攻击[7]和 Netflix 奖项竞赛攻击[8]证明了这种威胁的存在，并强调了具有隐私意识机器学习算法的重要性。

差分隐私（DP）是提供数据隐私保护的一个有希望的解决方案。它试图保护个体的敏感信息，防止针对个体统计数据或聚合数据的任何推理攻击。在许多情况下，仅发布数据集中多个人群的统计数据或聚合数据并不一定能确保隐私保护。让我们考虑一个简单的零售用例，忠诚度卡场景。假设我们有两组聚合统计数据：特定一天所有顾客的总消费额以及其中一部分——当天使用忠诚度卡的顾客的总消费额。假设恰好有一位顾客没有使用忠诚度卡进行购买。在这种情况下，通过简单地比较这两组统计数据之间的差异，某人可以很容易地推断出这位顾客的总消费额，仅基于这些聚合统计数据。

DP（差分隐私）基于这样一个理念：统计数据或聚合数据（包括机器学习模型）不应揭示个体是否出现在原始数据集中（机器学习模型的训练数据）。例如，给定两个相同的数据库，一个包含个体的信息，另一个则没有，DP 确保在第一个或第二个数据库上生成特定统计数据或聚合值的概率几乎相同。

更具体地说，考虑一个可信的数据管理员，他从多个数据所有者那里收集数据并对数据进行计算，例如计算平均值或找到最大值或最小值。为了确保没有人可以从计算结果中可靠地推断出任何单个样本，DP 要求管理员向结果添加随机噪声，使得如果任何底层数据样本发生变化，发布的数据将不会改变。由于没有单个样本可以显著影响分布，对手无法自信地推断出与任何单个样本对应的信息。因此，如果数据的计算结果是针对任何单个样本变化的鲁棒的，那么该机制就是差分隐私的。

由于其底层机制，差分隐私技术通过向输入数据、特定机器学习算法的迭代或算法输出中添加随机噪声来抵抗成员推断攻击。在第二章和第三章中，我们将详细分析我们如何在隐私保护机器学习（PPML）应用中采用差分隐私。

1.4.2 本地差分隐私

当输入方没有足够的信息来训练一个机器学习模型时，利用依赖于本地差分隐私（LDP）的方法可能更好。例如，多个癌症研究机构希望构建一个机器学习模型来诊断皮肤病变，但没有一个机构拥有足够的数据来训练模型。LDP 是他们可以用来在不侵犯个人隐私的情况下协作训练机器学习模型的一种解决方案。

在 LDP 中，个人在通过扰动对数据进行隐私化处理后，将他们的数据发送给数据聚合器。因此，这些技术为个人提供了合理的否认可能性（对手无法证明原始数据存在）。数据聚合器收集所有扰动值并估计诸如人口中每个值的频率等统计数据。与 DP 相比，LDP 将扰动从中心站点转移到本地数据所有者。它考虑了一个没有可信第三方且不可信的数据管理员需要从数据所有者那里收集数据并执行某些计算的场景。数据所有者仍然愿意贡献他们的数据，但数据的隐私必须得到强制执行。

本地隐私的一个古老且广为人知的版本是随机响应（RR），它为受访者对敏感查询提供了合理的否认可能性。例如，受访者抛一枚公平的硬币：

1. 如果是反面，受访者将如实回答。

2. 如果是正面，他们将抛第二枚硬币，如果正面则回答“是”，如果反面则回答“否”。

一个面向机器学习的工作，AnonML，利用了 RR 的思想从多个输入方生成直方图[9]。AnonML 使用这些直方图来创建用于训练机器学习模型的合成数据。与其他 LDP 方法一样，当没有输入方有足够的数据自己构建机器学习模型（且没有可信的聚合器）时，AnonML 是一个不错的选择。在第四章和第五章中，我们将详细分析 LDP 与差分隐私的不同之处以及它在不同的机器学习应用中的使用方法。

1.4.3 隐私保护合成数据生成

尽管已经提出了许多用于各种机器学习算法的隐私保护技术，但有时数据用户可能想要执行新的机器学习算法和分析程序。当没有预定义的算法用于请求的操作时，数据用户可能要求使用数据本地化。为此，过去已经提出了不同的隐私保护数据共享技术，如k-匿名、l-多样性、t-接近性和数据扰动。这些技术可以被微调，从同一原始数据集中生成一个新的匿名化数据集。然而，在某些情况下，仅匿名化可能会损害底层机器学习算法的效用。因此，数据共享的一个有希望的解决方案是生成既合成又具有代表性的数据，可以安全地与他人共享。

合成数据是通过人工生成而非通过高级别现实世界事件产生的。它通常是通过算法生成的，并且经常被用作训练和测试机器学习模型的替代品。然而，在实践中，以与原始数据集相同的格式（保留相同的统计特征）共享合成数据集，为数据用户提供更大的灵活性，同时隐私担忧最小化。

不同的研究在不同的维度上调查了隐私保护合成数据生成。例如，合理否认是这样一个方法，在生成合成数据后进行隐私测试。在 2012 年，Hardt 等人提出了一种结合乘性权重方法和差分隐私数据发布指数机制的算法[10]。另一方面，Bindschaedler 等人提出了一种生成模型，这是一种基于相关特征选择的概率模型，它捕捉了特征联合分布[11]。在 2017 年，Domingo-Ferrer 等人提出了一种基于微聚合的差分隐私数据发布方法，它基于k-匿名减少了差分隐私所需的噪声[12]。总的来说，隐私保护合成数据生成在机器学习社区中越来越受欢迎。

使用合成数据的好处，例如在使用敏感数据时减少约束以及能够针对某些无法通过真实数据获得的特定条件定制数据的能力，已经在许多现实世界的实际应用案例中引起了关注。在第六章中，我们将介绍用于合成数据生成的不同机制，目标是实现隐私保护机器学习。

1.4.4 隐私保护数据挖掘技术

到目前为止，在本章中，我们已经探讨了针对机器学习算法的不同隐私保护方法。现在，让我们专注于在执行数据挖掘操作时保护隐私。对机器学习算法、存储和敏感信息流动的进步不断增长的兴趣引发了重大的隐私问题。因此，在过去十年中，已经提出了不同的处理和发布敏感数据的方法。

在隐私保护数据挖掘（PPDM）技术中，绝大多数依赖于修改数据或删除部分原始内容以保护隐私。这种净化或转换导致的质量下降是数据质量与隐私水平之间的权衡。尽管如此，所有这些 PPDM 技术背后的基本思想是在保护个人隐私的同时高效地挖掘数据。根据数据收集、发布和处理的各个阶段，处理 PPDM 的技术可以分为三个主要类别。让我们简要地看看这些方法。

隐私保护数据收集技术

第一类 PPDM 技术确保在数据收集阶段保护隐私。它通常在数据收集阶段结合不同的随机化技术，生成私有化值，因此原始值从未被存储。最常用的随机化方法是通过添加已知分布的噪声来修改数据。每当涉及数据挖掘算法时，可以重现原始数据分布，但不是个别值。加性和乘性噪声方法是这一类别中最常见的两种数据随机化技术。

数据发布和处理的不同方法

PPDM 的第二类技术处理的是当数据被发布给第三方（公开）而未披露敏感信息所有权的情况。仅从数据集中移除可以明确识别个人的属性是不够的，因为用户可能仍然可以通过组合非敏感属性或记录来被识别。例如，考虑一个来自医院的病人记录数据集。在发布之前，我们可以从这个数据集中移除可识别的属性，如姓名和地址，但如果有人知道一个病人的年龄、性别和邮政编码，他们可能能够结合这些信息来追踪数据集中的特定病人记录，即使没有访问到姓名属性。

因此，PPDM 技术通常包含一个或多个数据清洗操作，例如泛化、抑制、解剖和扰动。基于这些清洗操作，可以提出一系列隐私模型，这些模型现在广泛应用于不同的应用领域以实现隐私保护。我们将在第七章中讨论这些技术和隐私模型。

保护数据挖掘算法输出的隐私

即使只有对原始数据集的隐式访问，数据挖掘算法的输出也可能揭示底层数据集的隐私信息。一个活跃的攻击者可能访问这些算法并查询数据以推断一些隐私信息。因此，已经提出了不同的技术来保护数据挖掘算法输出的隐私：

• 关联规则隐藏——在数据挖掘中，关联规则挖掘是一种基于规则的流行数据挖掘方法，用于发现数据集中不同变量之间的关系。然而，这些规则有时可能会泄露个人的隐私或敏感信息。关联规则隐藏的想法是仅挖掘非敏感规则，确保不会发现任何敏感规则。最直接的方法是对条目进行扰动，使得所有敏感但非敏感的规则都被隐藏。

• 降低分类器有效性——正如我们在成员推理攻击的上下文中讨论的那样，分类器应用可能会泄露信息，使得攻击者可以确定特定记录是否在训练数据集中。回到我们用于诊断疾病的 ML 服务示例，攻击者可以设计攻击来学习特定个人的记录是否被用于训练 ML 模型。在这种情况下，降低分类器的准确性是保护隐私的一种方法。

• 查询审计和限制——在某些应用中，用户可以查询原始数据集，但具有有限的查询功能，例如聚合查询（SUM、AVERAGE 等）。然而，攻击者仍然可以通过查看查询序列及其对应的结果来推断一些隐私信息。查询审计通常用于此类场景的隐私保护，通过扰动查询结果或拒绝查询序列中的一或多个查询来实现。然而，这种方法计算复杂度远高于其他方法。

这只是一个关于 PPDM 工作原理的概述。在第七章和第八章中，我们将详细分析 PPDM 技术，以及数据库系统中的隐私增强数据管理技术。

1.4.5 压缩隐私

压缩隐私通过压缩和降维技术将数据投影到低维超平面来扰动数据。这些转换技术中的大多数都是有损的。刘等人建议，压缩隐私将加强敏感数据的隐私保护，因为从转换版本（即压缩或降维数据）中恢复精确的原始数据是不可能的 [13]。

在图 1.7 中，x^i 是原始数据，而是对应的转换数据——x^i 在维度 U¹上的投影。我们知道可以被映射回与 U¹垂直的无限多个点。换句话说，可能的解是无限的，因为方程的数量少于未知数的数量。因此，刘等人提出了应用随机矩阵来降低输入数据的维度。由于随机矩阵可能会降低效用，其他方法使用了无监督和监督的降维技术，如主成分分析、判别成分分析和多维尺度。这些技术试图找到最佳投影矩阵以实现效用目的，同时依靠降低的维度来增强隐私。

图 1.7 压缩隐私通过将数据投影到低维超平面来工作。

定义：什么是低维超平面？一般来说，超平面是其原始空间维度少一的子空间。例如，在图 1.7 中，原始环境空间是二维的；因此，其超平面是一维线，如图所示。

压缩隐私保证原始数据永远无法完全恢复。然而，我们仍然可以从降低的维度中获得原始数据的近似值。因此，一些方法，如江等人[14]，将压缩隐私技术（降维）与差分隐私技术相结合，以发布差分隐私数据。

尽管某些实体可能试图完全隐藏他们的数据，压缩隐私对隐私还有另一个好处。对于具有两个标签的样本集——效用标签和隐私标签——Kung [15] 提出了一种降维方法，允许数据所有者以最大化学习效用标签的准确性的方式投影他们的数据，同时降低学习隐私标签的准确性。尽管这种方法不能消除所有数据隐私风险，但它控制了当隐私目标已知时数据的滥用。第九章将介绍压缩隐私的不同方法和应用。

1.5 这本书是如何结构的？

本书接下来的章节结构如下。第二章和第三章将讨论如何利用差分隐私（DP）在 PPML 中，包括不同的用例场景和应用。如果你对了解如何在实际应用中使用 DP，以及一系列真实世界示例感兴趣，这些章节将为你提供所需的内容。

在第四章和第五章中，我们将介绍在本地设置中应用差分隐私的方法和应用程序，并增加一个限制条件，即使对手能够访问个别响应，他们仍然无法了解超出这些响应之外的信息。

第六章将研究合成数据生成技术如何在 PPML 范式中使用。正如我们之前讨论的，合成数据生成在 ML 社区中越来越受欢迎，尤其是在作为训练和测试 ML 模型的替代品。如果你对寻找生成合成数据的方法和手段以实现 PPML 感兴趣，这是你的章节。

在第七章和第八章中，我们将探讨隐私增强技术如何在数据挖掘任务中应用，以及如何在数据库系统中使用和实现。我们知道，最终，所有东西都必须存储在某个地方的数据库中，无论是关系型、NoSQL 还是 NewSQL 数据模型。如果这些数据库或数据挖掘应用在访问或发布数据时容易受到隐私攻击，怎么办？这两章将调查不同的技术、方法和成熟的行业实践，以减轻这种隐私泄露。

接下来，我们将探讨另一种可能的 PPML 方法，即通过将数据投影到另一个超平面来压缩或降低数据的维度。为此，在第九章中，我们将讨论不同的压缩隐私方法及其应用。如果你正在设计或开发针对压缩数据的受限环境的隐私应用，我们建议你在这章上投入更多时间。我们将使用数据压缩技术的实际例子来实现不同应用场景的隐私保护。

最后，在第十章中，我们将把所有内容整合起来，通过强调设计挑战和实施考虑，设计一个用于研究数据保护和共享的平台。

摘要

• 在重建攻击中，对手通过对外部知识（特征向量或用于构建 ML 模型的数据）的了解获得优势。

• 重建攻击通常需要直接访问服务器上部署的 ML 模型；我们称之为白盒访问。

• 有时，对手可以监听 ML 模型的新测试样本提交时的传入请求以及模型为给定样本生成的响应。这可能导致模型反演攻击。

• 成员推理攻击是模型反演攻击的扩展版本，其中对手试图根据机器学习模型的输出推断样本，以确定该样本是否在训练数据集中。

• 即使数据集被匿名化，确保系统可靠地保护数据隐私仍然具有挑战性，因为攻击者可以利用背景知识通过去匿名化或重新识别攻击来推断数据。

• 将不同的数据库实例链接起来以探索个人的独特指纹，对数据库系统来说是一个重大的隐私威胁。

• 差分隐私（DP）通过添加随机噪声来尝试保护敏感信息，防止针对个人统计数据或聚合数据的推理攻击。

• 本地差分隐私（LDP）是 DP 的本地设置，其中个人在通过扰动对数据进行隐私化处理后，将数据发送给数据聚合器，从而提供合理的否认可能性。

• 压缩隐私通过压缩和降维技术将数据投影到低维超平面，从而扰动数据。

• 生成合成数据是数据共享的一个有希望的解决方案，它以与原始数据相同的格式生成和共享合成数据集，这为数据用户如何使用数据提供了更大的灵活性，同时无需担心基于查询的隐私预算。

• 隐私保护数据挖掘（PPDM）可以通过不同的技术实现，这些技术可以分为三个主要类别：数据收集、数据发布和修改数据挖掘输出的隐私保护方法。

2 机器学习的差分隐私

本章节涵盖

• 差分隐私是什么

• 在算法和应用中使用差分隐私机制

• 实现差分隐私的性质

在上一章中，我们探讨了机器学习（ML）中各种与隐私相关的威胁和漏洞以及隐私增强技术的概念。从现在开始，我们将关注一些基本且流行的隐私增强技术的细节。在本章和下一章中，我们将讨论的是差分隐私（DP）。

差分隐私是目前在应用中使用的最受欢迎且最有影响力的隐私保护方案之一。它基于使数据集足够健壮的概念，以至于数据集中任何单个替换都不会泄露任何私人信息。这通常是通过计算数据集中组别的模式来实现的，我们称之为复杂统计学，同时保留数据集中个人的信息。

例如，我们可以将一个机器学习模型视为描述其训练数据分布的复杂统计学描述。因此，差分隐私使我们能够量化算法在其操作的（私有）数据集上提供的隐私保护程度。在本章中，我们将探讨差分隐私是什么以及它如何在实际应用中得到广泛采用。你还将了解其各种基本性质。

2.1 什么是差分隐私？

许多现代应用生成了一堆属于不同个人和组织的个人数据，当这些数据离开数据所有者的控制时，会引发严重的隐私担忧。例如，AOL 搜索引擎日志数据泄露[1]和 Netflix 推荐竞赛隐私诉讼[2]展示了威胁以及对于机器学习算法严格隐私增强技术的需求。为了应对这些挑战，差分隐私（DP）作为一种有前景的隐私增强技术已经发展起来，它提供了一个严格的隐私定义[3]，[4]。

2.1.1 差分隐私的概念

在介绍差分隐私的定义之前，让我们来看一个例子，如图 2.1 所示。

图 2.1 个人信息泄露问题

假设 Alice 和 Bob 是来自不同新闻机构的新闻记者，他们想要报道一家私营公司的平均薪水。这家公司有一个包含所有员工个人信息（如职位、工资和联系方式）的数据库。由于数据库包含受隐私关注的数据，直接访问数据库受到限制。Alice 和 Bob 被要求通过接受保密培训和签署数据使用协议（禁止使用和披露从数据库中获得的个人信息的用途和披露）来证明他们计划遵循公司处理个人数据的协议。公司授予 Alice 和 Bob 访问查询公司数据库中某些汇总统计数据的权限，包括员工总数和平均薪水，但不能访问任何个人信息，如姓名或年龄。

2020 年 1 月，Alice 基于从数据库中获得的信息撰写了一篇文章，报道称该私营公司有 100 名员工，平均薪水为 55,000 美元。2020 年 2 月，Bob 基于他从同一数据库中获得的信息撰写了一篇文章，报道称该私营公司有 101 名员工，平均薪水为 56,000 美元。唯一的区别是 Alice 在 1 月访问了数据库，而 Bob 在 2 月访问了数据库。

Eve 是一家第三家新闻机构的新闻记者。在阅读了 Alice 和 Bob 的文章后，Eve 得出结论，认为在 1 月到 2 月之间公司新加入了一名员工，他们的薪水是 156,000 美元（即 $56,000 × 101 − $55,000 × 100）。Eve 匿名地采访了公司的员工，有人告诉 Eve Mallory 在那个时期加入了公司。随后，Eve 写了一篇报道，称 Mallory 加入了一家私营公司，年薪为 156,000 美元，这比公司的平均薪水要高得多。

Mallory 的私人信息（她的薪水）已经泄露，因此她向相关当局投诉，并计划起诉该公司和记者。然而，Alice 和 Bob 并没有违反政策——他们只是报道了汇总信息，这些信息不包含任何个人信息。

这个例子说明了典型的隐私泄露场景。即使研究、分析或计算只从数据集中发布汇总统计信息，这些信息仍然可以导致关于个人的有意义的但敏感的结论。我们如何以简单但严谨的方式处理这些问题？这就是差分隐私的用武之地。

差分隐私量化了算法从对底层数据集的计算中泄露的信息，在隐私研究领域引起了广泛关注。让我们考虑图 2.2 中的例子。在差分隐私的一般设置中，一个受信任的数据管理员从多个数据所有者那里收集数据以形成一个数据集。在我们之前的例子中，私有公司是数据管理员，数据所有者是该公司的员工。差分隐私的目标是对收集到的数据集进行某些计算或分析，例如找到平均值（例如，平均工资），以便数据用户可以访问这些信息，而不会泄露数据所有者的私人信息。

图 2.2 差分隐私框架

差分隐私的美丽之处在于，它旨在通过发布数据库或数据集的汇总或统计信息来加强隐私保护，而不透露该数据库中任何个人的存在。正如前一个例子中讨论的，我们可以认为一月份和二月份的数据库彼此相同，除了二月份的数据库包含 Mallory 的信息。差分隐私确保无论分析是在哪个数据库上进行的，得到相同汇总或统计信息或得出特定结论的概率都是相同的（如图 2.3 所示）。

图 2.3 使用差分隐私保护个人数据

如果某个数据所有者的私人数据不会显著影响某些汇总统计信息的计算，数据所有者应该对在数据库中共享他们的数据不太担心，因为分析结果不会区分他们。简而言之，差分隐私是关于差异的——如果一个系统几乎不会因为你的数据是否在系统中而有所不同，那么这个系统就是差分隐私的。这就是我们在“差分隐私”这个术语中使用“差分”一词的原因。

到目前为止，我们只讨论了差分隐私的一般概念。接下来，我们将探讨差分隐私在现实场景中的工作方式。

2.1.2 差分隐私是如何工作的

如图 2.2 所示，数据管理员通过差分隐私净化器向计算结果添加随机噪声，使得即使底层数据中的个人信息发生变化，发布的结果也不会改变。由于没有单个个人的信息可以显著影响分布，对手无法自信地推断任何信息对应于任何个人。

让我们看看如果我们的例子中的私有公司在将查询结果（即员工总数和平均工资的总数）发送给新闻记者 Alice 和 Bob 之前添加了随机噪声（如图 2.3 所示）会发生什么。

在一月，爱丽丝会基于从数据库（一月访问）获得的信息撰写文章，报告称私人公司有 103 名员工（其中 100 是实际数字，3 是添加的噪声）和平均工资为 55,500 美元（其中 55,000 美元是真实值，$500 是添加的噪声）。

在二月，鲍勃会用同样的方式（但使用二月获取的数据）撰写文章，报告称这家私人公司有 99 名员工（其中 101 是实际数字，-2 是添加的噪声）和平均工资为 55,600 美元（其中 56,000 美元是真实值，-$400 是添加的噪声）。

员工数量和平均工资的噪声版本对新闻文章中出现的私人公司信息（员工数量约为 100，平均工资约为 55,000-56,000 美元）的影响不大。然而，这些结果将阻止伊芙得出结论，即一月份到二月份之间私人公司增加了一名新员工（因为 99 - 104 = -5），并确定他们的工资，从而降低莫利个人隐私信息泄露的风险。

这个例子展示了 DP 是如何通过在发布之前向汇总数据添加随机噪声来工作的。接下来要问的问题是，每个 DP 应用应该添加多少噪声？为了回答这个问题，我们将在 DP 应用中介绍敏感性和隐私预算的概念。

DP 应用的敏感性

DP 中的一个核心技术问题是在发布之前确定要添加到汇总数据中的随机噪声量。随机噪声不能来自任意随机变量。

如果随机噪声太小，它无法为每个个体的隐私信息提供足够的保护。例如，如果爱丽丝报告称公司有 100.1 名员工（即+0.1 噪声）和平均工资为 55,000.10 美元（即+$0.10 噪声），而鲍勃在二月报告称这家私人公司有 101.2 名员工（即+0.2 噪声）和平均工资为 55,999.90 美元（即-$0.10 噪声），那么伊芙仍然可以推断出可能有一名新员工加入了公司，他们的工资大约是 155,979.90 美元，这几乎与实际值 156,000.00 美元相同。

同样，如果随机噪声太大，发布的汇总数据将会失真且没有意义；它将无法提供任何效用。例如，如果爱丽丝报告称私人公司有 200 名员工（即+100 噪声）和平均工资为 65,000 美元（即+$10,000 噪声），而鲍勃报告称公司有 51 名员工（即-50 噪声）和平均工资为 50,000 美元（即-$6,000 噪声），几乎不会泄露任何员工的隐私信息，但报告不会提供关于真实情况的任何有意义的信息。

我们如何可能以一种有意义和科学的方式决定添加到聚合数据中的随机噪声的数量？粗略地说，如果你有一个需要从数据集中发布聚合数据的应用或分析，那么需要添加的随机噪声的数量应该与单个个体的私人信息（例如，数据库表中的一行）对聚合数据可能造成最大差异成比例。在差分隐私（DP）中，我们将“单个个体的私人信息可能造成的最大差异”称为 DP 应用的敏感性。敏感性通常衡量每个个体的信息对分析输出可能产生的最大影响。

例如，在我们的私人公司场景中，我们有两个要发布的聚合数据集：员工总数和平均工资。由于老员工离职或新员工加入公司最多只会对员工总数造成+1 或-1 的差异，其敏感性为 1。对于平均工资，由于不同工资的员工（具有不同的工资）离职或加入公司可能会对平均工资产生不同的影响，最大可能差异将来自具有最高可能工资的员工。因此，平均工资的敏感性应该与最高工资成比例。

对于任意应用，通常很难计算确切的敏感性，我们需要估计一些敏感性。我们将在第 2.2 节中讨论更复杂场景的数学定义和敏感性计算。

对于差分隐私（DP）来说，没有免费的午餐：dp 的隐私预算

正如你所看到的，确定在应用 DP 时添加的随机噪声的适当数量是至关重要的。随机噪声应该与应用的敏感性（均值估计、频率估计、回归、分类等）成比例。但“成比例”这个词是模糊的，可能指小比例或大比例。在确定添加的随机噪声数量时，我们还应该考虑什么其他因素？

让我们先回顾一下我们的私人公司场景，在这个场景中，随机噪声被添加到数据库的查询结果中（在 Mallory 加入公司之前和之后）。理想情况下，在应用 DP 时，平均工资的估计应该保持不变，无论像 Mallory 这样的员工是离开还是加入公司。然而，确保估计“完全相同”需要排除 Mallory 的信息来进行这项研究。然而，我们可以继续使用相同的论点，并排除公司数据库中每位员工的个人信息。但如果估计的平均工资不能依赖于任何员工的信息，那么它将没有太多意义。

为了避免这种困境，DP 要求分析结果的输出在有无 Mallory 信息的情况下都保持“大致相同”，而不是“完全相同”。换句话说，DP 允许在有无任何个人信息的分析输出之间存在轻微的偏差。这种允许的偏差被称为 DP 的隐私预算。如果你在包含或排除个人数据时可以容忍更大的允许偏差，那么你可以容忍更多的隐私泄露，因此你有更多的隐私预算可以花费。

希腊字母ϵ（epsilon）用于表示这种隐私预算，在量化允许偏差的程度时。隐私预算ϵ通常由数据所有者设置，以调整所需的隐私保护水平。较小的ϵ值会导致较小的允许偏差（更少的隐私预算），因此与更强的隐私保护但更低的效用准确性相关。在 DP 中没有免费的午餐。例如，我们可以将ϵ设置为 0，这允许零隐私预算并提供完美的隐私保护，即在 DP 的定义下没有隐私泄露。分析输出将始终相同，无论是否添加或删除了信息。然而，正如我们之前讨论的，这也需要忽略所有可用的信息，因此不会提供任何有意义的成果。如果我们把ϵ设置为 0.1，一个很小的数但大于零呢？有无任何个人信息的允许偏差将会很小，提供更强的隐私保护，并使数据用户（如新闻记者）能够了解一些有意义的成果。

在实践中，ϵ通常是一个很小的数。对于如均值或频率估计之类的统计分析任务，ϵ通常设置在 0.001 和 1.0 之间。对于机器学习或深度学习任务，ϵ通常设置在 0.1 和 10.0 之间。

为我们的私有公司场景制定 DP 解决方案

你可能现在对 DP（差分隐私）以及如何根据应用的敏感性和数据所有者的隐私预算推导随机噪声有一个大致的了解。让我们看看我们如何将这些技术应用到我们之前的私有公司示例中，从数学上进行阐述。

在图 2.4 中，私有公司的一月数据库（在 Mallory 加入公司之前）位于左侧，这是 Alice 查询的内容。右侧是私有公司二月的数据库（在 Mallory 加入公司之后），这是 Bob 查询的内容。我们想要推导出差分隐私解决方案，以便私有公司可以与公众（Alice 和 Bob）共享两个汇总值：员工总数和平均工资。

图 2.4 我们私有公司数据库的摘录

让我们从更容易的任务开始，发布员工总数。首先，我们将推导出敏感性。正如我们之前解释的，无论员工是离职还是加入公司，对员工总数的总影响都是 1，因此这个任务的敏感性是 1。其次，我们需要设计在发布之前添加到员工总数中的随机噪声。如前所述，噪声的量应该与敏感性正相关，与隐私预算负相关（因为更少的隐私预算意味着更强的隐私保护，因此需要更多的噪声）。随机噪声应该与△f/ϵ成正比，其中△f 是敏感性，ϵ是隐私预算。

在本例中，我们可以从零均值拉普拉斯分布中抽取我们的随机噪声，这是一种“双边”指数分布，如图 2.5 所示。

拉普拉斯分布

以尺度 b 为中心的拉普拉斯分布（通常我们使用μ = 0）由概率密度函数定义为

其中方差为σ² = 2b²。我们还可以将拉普拉斯分布视为指数分布的对称版本。

图 2.5 拉普拉斯分布

有了这个，我们可以计算出 b = △f/ϵ，并从拉普拉斯分布（x|△f/ϵ）中抽取随机噪声添加到员工总数中。图 2.6 展示了在应用不同的隐私预算（即ϵ）的情况下，1 月和 2 月发布的员工总数。根据差分隐私（DP）的定义，更好的隐私保护通常意味着 1 月和 2 月发布的员工人数更有可能接近。换句话说，结果有更低的概率向看到这两个发布值的人泄露 Mallory 的信息。效用性能通常指的是某些聚合数据或统计计算的准确性。在这种情况下，它指的是发布扰动值与其真实值之间的差异，差异越小意味着效用性能越好。对于任何数据匿名化算法，包括 DP，通常在隐私保护和效用性能之间有一个权衡。例如，当ϵ减小时，将添加更多的噪声，两个发布值之间的差异将更接近，从而提供更强的隐私保护。相反，指定较大的ϵ值可以提供更好的效用但较少的隐私保护。

图 2.6 隐私与效用之间的权衡

现在，让我们考虑发布差异隐私平均工资的情况。无论任何个别员工是否离职或加入公司，最大的可能差异应来自可能最高工资的员工（在这种情况下是 CEO 杰克，他年薪 290,000 美元）。例如，在极端情况下，数据库中只有一名员工，而且恰好是 CEO 杰克，他有最高的可能工资，290,000 美元，他的离职将导致公司平均工资的最大可能差异。因此，敏感性应为 290,000 美元。现在我们可以遵循与总员工数相同的程序，添加从 Lap（x|△f/ϵ）抽取的随机噪声。

我们将在下一节中详细探讨从拉普拉斯分布中抽取随机噪声的应用。有关 DP 的数学和正式定义的更多信息，请参阅附录 A.1 节。

2.2 差分隐私机制

在上一节中，我们介绍了 DP 的定义和用法。在本节中，我们将讨论 DP 中最受欢迎的一些机制，这些机制也将成为我们将在本书中介绍的许多 DP ML 算法的构建块。您也可以将这些机制用于您自己的设计和开发。

我们将从一种古老但简单的 DP 机制——二进制机制（随机响应）开始。

2.2.1 二进制机制（随机响应）

二进制机制（随机响应）[5]是一种长期以来被社会科学家在社会科学研究中使用的方法（自 20 世纪 70 年代以来），它比 DP 公式的制定要早得多。尽管随机响应很简单，但它满足了 DP 机制的所有要求。

假设我们需要对 100 人进行调查，了解他们在过去 6 个月内是否使用过大麻。从每个人那里收集到的答案将是是或否，这被视为二元响应。我们可以将每个“是”答案赋予值 1，每个“否”答案赋予值 0。因此，我们可以通过计算 1 的数量来获得调查组中大麻使用率的百分比。

为了保护每个个体的隐私，我们可以在收集提交答案之前对每个真实答案应用少量噪声。当然，我们也希望添加的噪声不会改变最终的调查结果。为了设计一个差异隐私解决方案来收集调查数据，我们可以使用平衡硬币（即，p = 0.5）作为随机响应机制，其过程如下，并在图 2.7 中展示：

1. 抛一个公平的硬币。

2. 如果硬币正面朝上，提交的答案与真实答案相同（0 或 1）。

3. 如果硬币反面朝上，再抛一次公平的硬币，如果正面朝上则回答 1，如果反面朝上则回答 0。

图 2.7 二进制机制（随机响应）的工作原理

该算法中的随机化来自两次抛硬币。这种随机化产生了关于真实答案的不确定性，这为隐私提供了来源。在这种情况下，每个数据所有者有 3/4 的概率提交真实答案，有 1/4 的机会提交错误答案。对于单个数据所有者，他们的隐私将得到保护，因为我们永远无法确定他们是否在说真话。但进行调查的数据用户仍然会得到期望的答案，因为预计有 3/4 的参与者会说出真相。

让我们回顾一下 ϵ-DP 的定义（更详细和正式的 DP 定义可以在 A.1 节找到）。假设我们有一个简单的随机响应机制，我们暂时将其称为 M。这个 M 对于每对相邻数据库或数据集 x、y 以及对于每个子集 S ⊆ Range(M)，都满足 ϵ-DP。

在我们的两个抛硬币的例子中，数据要么是 1 要么是 0，M 的输出也是要么是 1 要么是 0。因此，我们有以下结果：

我们可以推断出我们的简单随机响应机制 M 满足 ln(3)-DP，其中 ln(3) 是隐私预算（ln(3) ≈ 1.099）。

随机响应的基本思想是，在回答一个二元问题时，一个人可以以更高的概率说出真相，以更低的概率给出错误答案。可以通过稍微提高说出真相的概率来维持效用，而隐私则通过随机化个人的回答在理论上得到保护。在先前的例子中，我们假设硬币是平衡的。如果我们使用一个不平衡的硬币，我们可以制定一个满足其他差分隐私预算的随机响应机制。

基于图 2.7 中的机制，假设硬币以概率 p 出现正面，以概率 (1 − p) 出现反面，其中 p > 1/2：

• 对于任意一个调查参与者，他们的答案将是 0 或 1，这取决于参与者是否以“否”或“是”的方式诚实地回答。

• 我们随机响应机制 M 的输出也可以是 0 或 1。

根据 DP 的定义，我们有

然后，我们有

由于我们假设 p > 1/2，因此我们有

因此，使用不平衡硬币的隐私预算为

这就是计算随机响应机制隐私预算的一般公式。

现在我们尝试用伪代码来表述这个概念，其中 x 表示真实值，可以是 0 或 1：

def randomized_response_mechanism(x, p):
    if random() < p:
        return x
    elif random() < p:
        return 1
    else:
        return 0

让我们更仔细地看看我们二进制机制在不同 p 值（即硬币出现正面的概率）下的隐私预算。根据前面的分析，如果 p = 0.8，我们二进制机制的隐私预算将是 ln(1 + 0.8/(0.2 × 0.2))，即 ln(21)，大约是 3.04。我们可以将其与之前的 p = 0.5 的例子进行比较，其隐私预算是 ln(3) = 1.099。

如前所述，隐私预算可以被视为对隐私泄露容忍度的度量。在这个例子中，更高的 p 值意味着添加的噪声更少（因为它更有可能生成正确答案），导致更多的隐私泄露和更高的隐私预算。本质上，通过这个二进制机制，用户可以调整 p 值以适应他们自己的隐私预算。

2.2.2 拉普拉斯机制

在二进制机制中，隐私预算由抛硬币的概率决定。相比之下，拉普拉斯机制通过向目标查询或函数添加来自拉普拉斯分布的随机噪声来实现 DP [6]。我们已经在私有公司场景的解决方案中提到了拉普拉斯机制。在本节中，我们将更系统地介绍拉普拉斯机制，并通过一些例子进行说明。

让我们回到我们的私有公司场景。要设计一个使用拉普拉斯机制的不同隐私解决方案，我们只需用来自拉普拉斯分布的随机噪声扰动查询函数 f 的输出（例如，员工总数或平均工资），其尺度与查询函数 f 的敏感性相关（除以隐私预算 ϵ）。

根据拉普拉斯机制的设计，给定一个返回数值的查询函数 f(x)，以下扰动函数满足 ϵ-DP，

其中 △f 是查询函数 f(x) 的敏感性，Lap (△f/ϵ) 表示从以 0 为中心、尺度为 △f/ϵ 的拉普拉斯分布中抽取的随机噪声。

我们在上一个章节中建立了 敏感性 的概念，但让我们来回顾一下！直观地说，一个函数的敏感性提供了对其输出进行扰动以保护个体隐私的上限。例如，在我们之前的例子中，数据库包含所有员工的薪水，查询函数旨在计算所有员工的平均薪水，查询函数的敏感性应由数据库中的最高薪水（例如，CEO 的薪水）决定。这是因为特定员工的薪水越高，它对数据库中查询输出（即平均薪水）的影响就越大。如果我们能够保护最高薪水的员工的隐私，其他员工的隐私就得到了保障。这就是为什么在设计差分隐私算法时识别敏感性很重要的原因。

现在，让我们探索一些应用拉普拉斯机制的伪代码：

def laplace_mechanism(data, f, sensitivity, epsilon):
    return f(data) + laplace(0, sensitivity/epsilon)

DP 通常被设计和用于应用程序中以回答特定的查询。在我们深入探讨更多细节之前，让我们探索一些可能应用拉普拉斯机制的查询示例。

示例 1：差分隐私计数查询

计数查询是形式为“数据库中有多少元素满足给定的属性 P？”的查询。许多问题都可以被视为计数查询。让我们首先考虑一个未应用 DP 的关于人口普查数据的计数查询。

在下面的列表中，我们正在计算数据集中年龄超过 50 岁的个体数量。

列表 2.1 计数查询

import numpy as np
import matplotlib.pyplot as plt
ages_adult = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data", usecols=0, delimiter=", ")

count = len([age for age in ages_adult if age > 50])      ❶
print(count)

❶ 人口普查数据集中有多少个体年龄超过 50 岁？

输出将为 6,460。

现在，让我们看看如何将 DP 应用到这种计数查询。要应用 DP 到这个查询，我们首先需要确定查询任务（查询超过 50 岁的个体数量）的敏感性。由于任何单个个体离开或加入人口普查数据集最多只能改变计数 1，因此这种计数查询任务的敏感性为 1。根据我们之前对拉普拉斯机制的描述，我们可以在发布之前向每个计数查询添加从拉普(1/ϵ)抽取的噪声，其中 ϵ 是数据所有者指定的隐私。我们可以通过使用 NumPy 的 random.laplace 来实现这种计数查询的 DP 版本，如下所示（使用 ϵ= 0.1，loc=0 作为中心）：

sensitivity = 1
epsilon = 0.1

count = len([i for i in ages_adult if i > 50]) + np.random.laplace
➥ (loc=0, scale=sensitivity/epsilon)

print(count)

输出为 6,472.024,453,709,334。如您所见，使用 ϵ= 0.1 时，差分隐私计数查询的结果仍然接近真实值 6,460。让我们尝试使用一个更小的 ϵ（这意味着将添加更多噪声），ϵ= 0.001：

sensitivity = 1
epsilon = 0.001

count = len([i for i in ages_adult if i > 50]) + np.random.laplace
➥ (loc=0, scale=sensitivity/epsilon)

print(count)

输出为 7,142.911,556,855,243。如您所见，当我们使用 ϵ= 0.001 时，结果与真实值（6,460）相比增加了更多噪声。

示例 2：差分隐私直方图查询

我们可以将直方图查询视为计数查询的一种特殊情况，其中数据被划分为不相交的单元格，查询询问每个单元格中有多少数据库元素。例如，假设一个数据用户想要查询人口普查数据中的年龄直方图。我们如何设计一个差分隐私直方图查询来研究年龄分布而不损害单个个体的隐私？

首先，让我们先探索在无 DP 的情况下对人口普查数据中年龄的直方图查询。

列表 2.2 无 DP 的直方图查询

import numpy as np
import matplotlib.pyplot as plt

ages_adult = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data",
                        usecols=0, delimiter=", ")
hist, bins = np.histogram(ages_adult)
hist = hist / hist.sum()

plt.bar(bins[:-1], hist, width=(bins[1]-bins[0]) * 0.9)
plt.show()

我们将得到类似于图 2.8 的输出。

图 2.8 无 DP 的直方图查询输出

要应用 DP 于这个直方图查询，我们首先需要计算敏感性。由于直方图查询的敏感性为 1（添加或删除单个个体的信息最多可以改变单元格中的元素数量 1 个），因此直方图查询任务的敏感性为 1。接下来，我们需要在发布之前向每个直方图单元格添加从 Lap(1/ϵ)抽取的噪声，其中ϵ是数据所有者指定的隐私预算。

我们可以很容易地使用 NumPy 的 random.laplace 实现这个直方图查询的 DP 版本，就像我们之前的例子一样。在这里，我们将探索使用 IBM 的差分隐私库 diffprivlib 的实现。

首先，安装 diffprivlib 并导入 diffprivlib.mechanisms.Laplace：

!pip install diffprivlib
Laplace

现在，我们可以使用 diffprivlib .mechanisms.Laplace 实现直方图查询的 DP 版本。

列表 2.3 直方图查询的 DP 版本

def histogram_laplace(sample, epsilon=1, bins=10, range=None, normed=None,
➥  weights=None, density=None):
  hist, bin_edges = np.histogram(sample, bins=bins, range=range, 
  ➥ normed=None, weights=weights, density=None)
  dp_mech = Laplace(epsilon=1, sensitivity=1)
  dp_hist = np.zeros_like(hist)

  for i in np.arange(dp_hist.shape[0]):
    dp_hist[i] = dp_mech.randomise(int(hist[i]))

  if normed or density:
    bin_sizes = np.array(np.diff(bin_edges), float)
    return dp_hist / bin_sizes / dp_hist.sum(), bin_edges

  return dp_hist, bin_edges

然后，差分隐私直方图查询的工作方式如下（ϵ = 0.01）：

dp_hist, dp_bins = histogram_laplace(ages_adult, epsilon=0.01)
dp_hist = dp_hist / dp_hist.sum()

plt.bar(dp_bins[:-1], dp_hist, width=(dp_bins[1] - dp_bins[0]) * 0.9)
plt.show()

输出将类似于图 2.9 的右侧。你能看到在应用 DP 前后直方图查询之间的差异吗？即使应用了 DP，分布的形状仍然基本上是相同的，不是吗？

图 2.9 比较应用 DP 前后的直方图查询

前两个例子表明，在应用拉普拉斯机制时，最重要的步骤是为给定的应用推导出适当的敏感性。让我们通过一些练习来学习如何在不同情况下确定拉普拉斯机制的敏感性。

练习 1：差分隐私频率估计

假设我们有一个学生班级，其中一些学生喜欢踢足球，而另一些则不喜欢（见表 2.1）。老师想知道哪一组学生人数最多。这个问题可以被视为直方图查询的特殊情况。这个应用的敏感性是多少？

表 2.1 爱踢足球和不踢足球的学生

学生姓名	是否喜欢足球
Alice	是
Bob	否
Eve	是
...	...

提示：班上的每个学生要么喜欢足球，要么不喜欢，所以敏感性是 1。根据我们对拉普拉斯机制的描述，我们可以通过向每个频率添加从Lap(1/ϵ)抽取的噪声来同时计算喜欢或不喜欢的学生的频率，其中ϵ是学生指定的隐私预算。你可以基于以下伪代码实现来构建你的解决方案：

sensitivity = 1
epsilon = 0.1

frequency[0] is the number of students who like football
frequency[1] is the number of students do not like football

dp_frequency = frequency[i] + np.random.laplace(loc=0,
➥ scale=sensitivity/epsilon)

练习 2：COVID-19 最常见的医疗状况

假设我们希望知道在患者（如表 2.2 所示）的医疗历史中，哪种状况（在多种症状中）大约是最常见的：

• 这个应用的敏感性是多少？

• 如果我们想生成 COVID-19 医疗状况的直方图，敏感性应该是多少？

表 2.2 COVID-19 患者的症状

患者	发热	咳嗽	呼吸困难	疲劳	头痛	喉咙痛	腹泻
艾丽斯	X	X	X
鲍勃	X	X	X		X		X
伊芙	X	X		X		X
马洛里	X		X	X		X	X
...	...	...	...	...	...	...	...

提示：

• 由于个人可能会经历许多状况，这一系列问题的敏感性可能很高。然而，如果我们只报告最常见的医疗状况，每个人最多只会导致 1 个数字的差异。因此，最常见的医疗状况的敏感性仍然是 1。我们可以通过向最常见的医疗状况的每个输出添加从Lap（1/ϵ）抽取的噪声来获得ϵ-差分隐私结果。

• 如果我们想生成 COVID-19 医疗状况的直方图，敏感性应该是多少？由于每个人可能会经历多种状况（最多可能经历所有状况），敏感性远大于 1——它可能是报告的 COVID-19 不同医疗状况的总数。因此，COVID-19 医疗状况直方图的敏感性应该等于医疗状况的总数，即 7，如表 2.2 所示。

2.2.3 指数机制

拉普拉斯机制对于大多数产生数值输出的查询函数效果良好，并且向输出添加噪声不会破坏查询函数的整体效用。然而，在特定场景中，如果查询函数的输出是分类的或离散的，或者直接向输出添加噪声会导致无意义的结果，拉普拉斯机制就会失去其神奇的力量。

例如，给定一个返回乘客性别（男性或女性，这是分类数据）的查询函数，添加来自拉普拉斯机制的噪声会产生无意义的结果。有许多这样的例子，例如拍卖中的出价价值[4]，其目的是优化收入。即使拍卖价格是实数，即使添加少量正噪声到价格（以保护出价的隐私）也可能破坏对结果的评估。

指数机制[7]是为那些目标是为了选择“最佳”响应，但直接向查询函数的输出添加噪声会破坏效用的场景而设计的。因此，指数机制是使用 DP 从集合（数值或分类）中选择一个元素的自然解决方案。

让我们看看如何使用指数机制为查询函数 f 提供ϵ-DP。以下是步骤：

1. 分析师应该定义查询函数 f 的所有可能输出的集合 A。

2. 分析师应该设计一个效用函数 H（也称为得分函数），其输入是数据 x 和 f(x) 的潜在输出，表示为 a ∈ A。H 的输出是一个实数。△H 表示 H 的敏感性。

3. 给定数据 x，指数机制以 exp(ϵ ⋅H(x, a)/(2ΔH)) 为比例输出 A 中的元素 a。

让我们探索一些可以应用指数机制的示例，这样您可以看到如何定义效用函数并推导出敏感性。

示例 3：差分隐私中最常见的婚姻状况

假设一个数据用户想知道人口普查数据集中最常见的婚姻状况。如果您加载数据集并快速浏览“婚姻状况”列，您将注意到记录包括七个不同的类别（已婚-civ-spouse、离婚、未婚、分居、丧偶、已婚配偶缺席、已婚-AF-配偶）。

让我们先看看数据集中每个类别的数据人数。在继续列出 2.4 之前，您需要从书籍代码仓库下载 adult.csv 文件，该仓库位于 github.com/nogrady/PPML/。

列表 2.4 每个婚姻状况组的人数

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

adult = pd.read_csv("adult.csv")

print("Married-civ-spouse: "+ str(len([i for i in adult['marital-status']
➥ if i == 'Married-civ-spouse'])))
print("Never-married: "+ str(len([i for i in adult['marital-status']
➥ if i == 'Never-married'])))
print("Divorced: "+ str(len([i for i in adult['marital-status']
➥ if i == 'Divorced'])))
print("Separated: "+ str(len([i for i in adult['marital-status']
➥ if i == 'Separated'])))
print("Widowed: "+ str(len([i for i in adult['marital-status']
➥ if i == 'Widowed'])))
print("Married-spouse-absent: "+ str(len([i for i in adult['marital-
➥ status'] if i == 'Married-spouse-absent'])))
print("Married-AF-spouse: "+ str(len([i for i in adult['marital-status']
➥ if i == 'Married-AF-spouse'])))

结果将如下所示：

Married-civ-spouse: 22379
Never-married: 16117
Divorced: 6633
Separated: 1530
Widowed: 1518
Married-spouse-absent: 628
Married-AF-spouse: 37

如您所见，已婚-civ-spouse 是这个人口普查数据集中最常见的婚姻状况。

要使用指数机制，我们首先需要设计效用函数。我们可以将其设计为 H(x, a)，它与每种婚姻状况 x 的人数成正比，其中 x 是七个婚姻类别之一，a 是最常见的婚姻状况。因此，包含更多人数的婚姻状况应该有更好的效用。我们可以将此效用函数实现如下代码片段所示：

adult = pd.read_csv("adult.csv")
sets = adult['marital-status'].unique()

def utility(data, sets):
    return data.value_counts()[sets]/1000

在此基础上，我们可以设计一个使用指数机制的差分隐私中最常见的婚姻状况查询函数。

列表 2.5 使用指数机制每个婚姻状况组的成员数

def most_common_marital_exponential(x, A, H, sensitivity, epsilon):
    utilities = [H(x, a) for a in A]                                     ❶

    probabilities = [np.exp(epsilon * utility / (2 * sensitivity))
    ➥ for utility in utilities]                                         ❷

    probabilities = probabilities / np.linalg.norm(probabilities, ord=1) ❸

    return np.random.choice(A, 1, p=probabilities)[0]                    ❹

❶ 计算 A 中每个元素的效用。

❷ 根据每个元素的效用计算其概率。

❸ 将概率标准化，使它们的总和为 1。

❹ 根据概率从 A 中选择一个元素。

在使用此查询之前，我们需要确定敏感度和隐私预算。对于灵敏度，由于添加或删除单个个人的信息最多可以改变任何婚姻状况的效用分数 1 分，灵敏度应为 1。对于隐私预算，让我们先尝试ϵ = 1.0：

most_common_marital_exponential(adult['marital-status'], sets,
➥ utility, 1, 1)

如您所见，输出结果是已婚-civ-spouse。为了更好地说明 most_common_marital_exponential 的性能，让我们检查查询 10,000 次后的结果：

res = [most_common_marital_exponential(adult['marital-status'], sets,
➥ utility, 1, 1) for i in range(10000)]
pd.Series(res).value_counts()

您将得到类似以下输出的结果：

Married-civ-spouse       9545
Never-married             450
Divorced                    4
Married-spouse-absent       1

根据这些结果，most_common_marital_exponential 可以通过随机化最常见的婚姻状况的输出来提供隐私保护。然而，它也产生了提供最高效用概率的实际结果（已婚-civ-spouse）。

您也可以通过使用不同的隐私预算来检查这些结果。您会观察到，随着隐私预算的提高，更有可能得到真正的答案已婚-civ-spouse。

练习 3：从有限集合中选择差分隐私选择

假设一个城市里的人们想要投票决定他们在夏天想要哪种体育比赛。由于城市的预算有限，只能从四个选择（足球、排球、篮球和游泳）中选一个，如表 2.3 所示。市长希望使投票具有差分隐私性，每个人有一票。我们如何通过使用指数机制以差分隐私的方式发布投票结果？

表 2.3 不同体育项目的投票

体育项目	投票数
足球	49
排球	25
篮球	6
游泳	2

提示：要使用指数机制，我们首先需要确定效用函数。我们可以设计效用函数为H(x, a)，它与每个类别x的投票数成正比，其中x是四种体育中的一种，而a是获得最高投票的体育。因此，投票数更多的体育应该有更好的效用。然后，我们可以将指数机制应用于投票结果以实现ϵ-DP。

效用函数的伪代码可能定义如下：

def utility(data, sets):
    return data.get(sets)

然后，我们可以使用以下伪代码实现使用指数机制的差分隐私投票查询函数。

列表 2.6 差分隐私投票查询

def votes_exponential(x, A, H, sensitivity, epsilon):
    utilities = [H(x, a) for a in A]                                      ❶

    probabilities = [np.exp(epsilon * utility / (2 * sensitivity))
    ➥ for utility in utilities]                                          ❷

    probabilities = probabilities / np.linalg.norm(probabilities, ord=1)  ❸

    return np.random.choice(A, 1, p=probabilities)[0]                     ❹

❶ 计算 A 中每个元素的效用。

❷ 根据每个元素的效用计算其概率。

❸ 将概率标准化，使它们的总和为 1。

❹ 根据概率从 A 中选择一个元素。

与任何机制一样，在使用此查询之前，我们需要确定敏感度和隐私预算。对于敏感性，由于每个投票者只能为一种类型的运动投票，每个个人最多可以改变任何运动的效用分数 1 分。因此，敏感性应该是 1。对于隐私预算，我们首先尝试ϵ = 1.0。

我们可以将 DP 查询函数称为以下伪代码所示：

A = ['Football', 'Volleyball', 'Basketball', 'Swimming']
X = {'Football': 49, 'Volleyball': 25, 'Basketball': 6, 'Swimming':2}
votes_exponential(X, A, utility, 1, 1)

给定这种实现，你的结果应该与示例 3 相似，它以更高的概率输出足球（得票最高的运动）。当你使用更高的隐私预算时，正确选择足球的可能性会更大。

在本节中，我们介绍了 DP 中目前最流行的三种机制，它们是许多差分隐私机器学习算法的构建块。附录 A.2 列出了一些在特殊场景中可以使用的更高级机制，其中一些是拉普拉斯和指数机制的变体。

到目前为止，在我们的私有公司示例中，我们已经为满足 DP 的任务（员工总数和平均工资）设计了解决方案。然而，这些任务并不是相互独立的。同时进行这两项任务（共享员工总数和平均工资）需要在 DP 属性方面进行进一步的分析。这就是我们接下来要做的。

2.3 差分隐私的属性

到目前为止，你已经学习了 DP 的定义，并看到了如何为简单场景设计差分隐私解决方案。DP 还具有许多有价值的属性，使其成为在敏感个人信息上实现隐私保护数据分析的灵活且完整的框架。在本节中，我们将介绍应用 DP 的三个最重要且最常用的属性。

2.3.1 差分隐私的后处理属性

在大多数数据分析与机器学习任务中，需要经过几个处理步骤（数据收集、预处理、数据压缩、数据分析等）才能完成整个任务。当我们希望我们的数据分析与机器学习任务具有差分隐私时，我们可以在任何处理步骤中设计我们的解决方案。在应用 DP 机制之后的步骤被称为后处理步骤。

图 2.10 展示了典型的差分隐私数据分析与机器学习场景。首先，私有数据（D[1]）存储在由数据所有者控制的安全数据库中。在发布任何关于私有数据的信息（如总和、计数或模型）之前，数据所有者将应用 DP 净化器（添加随机噪声的 DP 机制）以生成差分隐私数据（D[2]）。数据所有者可以直接发布 D[2]或进行后处理步骤以获得 D[3]，然后将 D[3]发布给数据使用者。

图 2.10 差分隐私的后处理属性

值得注意的是，后处理步骤实际上可以减少 DP 清洗器添加到私有数据中的随机噪声量。让我们继续使用我们的私有公司场景作为一个具体的例子。

如您之前所见，这家私有公司通过添加从拉普拉斯分布中抽取的随机噪声（该分布按 △f/ϵ 缩放，其中 △f 是敏感性，ϵ 是隐私预算）为发布其员工总数和平均工资设计了差分隐私解决方案。这个解决方案完美地满足了 DP 的概念。然而，在添加随机噪声后直接发布数据可能会导致潜在问题，因为从零均值的拉普拉斯分布中抽取的噪声是一个实数，也可能是负实数（概率为 50%）。例如，将拉普拉斯随机噪声添加到员工总数可能会导致非整数，如 100 → 100.5（+0.5 噪声），以及负数，如 5 → -1（-6 噪声），这是没有意义的。

解决这个问题的简单自然的方法是通过后处理将负值向上取整到零，并将大于 n 的值向下取整到 n（下一个整数）：100.5 → 100（将实值向下取整到下一个整数），-1 → 0（将负值向上取整到零）。

如您所见，这个后处理步骤解决了问题，但与未进行后处理相比，它也可能减少添加到私有数据中的噪声量。例如，假设 y 是私有数据，而 ȳ 是扰动数据，其中 ȳ = y + Lap(Δf/ϵ)，y' 是向上取整的扰动数据。如果 y 由于添加拉普拉斯噪声而为正，则 ȳ 为负。通过将 ȳ 向上取整到零（即，ŷ' = 0），我们可以清楚地看到它变得更接近真实答案，因此添加的噪声量已经减少。对于 ȳ 是实数但大于 y 的情况，也可以得出相同的结论。

到目前为止，可能会有人提出一个问题：在执行之前描述的后处理步骤之后，这个解决方案是否仍然保持差分隐私？简短的答案是肯定的。DP 对后处理具有免疫力 [3]，[4]。后处理属性保证，给定一个差分隐私算法的输出（满足 ϵ-DP 的算法），任何其他数据分析师，没有关于原始私有数据库或数据集的额外知识，都不能提出任何后处理机制或算法来使输出变得不那么差分隐私。总结一下：如果一个算法 M(x) 满足 ϵ-DP，那么对于任何（确定性的或随机的）函数 F(⋅)，F(M(x)) 满足 ϵ-DP。

基于 DP 的后处理属性，一旦个人的敏感数据被声明由随机算法保护，其他数据分析师就无法增加其隐私损失。我们可以将后处理技术视为任何对 DP 私有数据进行去噪、聚合、数据分析甚至 ML 操作的技术，这些操作不直接涉及原始私有数据。

2.3.2 差分隐私的组隐私属性

在我们之前的例子中，我们只讨论了单个个体的隐私保护或泄露。现在让我们看看一个可能涉及一组人的隐私保护或泄露的例子。

图 2.11 展示了这样一个场景，其中 k 位科学家通过相互分享结果来共同进行一项研究。一个现实世界的例子是不同癌症研究机构合作开展一项研究以发现新药。由于隐私问题，他们不能共享患者的记录或公式，但他们可以共享清洗后的结果。

图 2.11 差分隐私的组隐私属性

现在假设新闻记者爱丽丝想通过采访每位 k 位科学家来报道研究的亮点，而不泄露研究的秘密。为了确保没有科学家泄露关于他们研究的信息，科学家们设计了一个协议，在记者采访每位科学家时遵循，以确保关于研究的任何交换信息都应由ϵ-DP 随机机制进行清洗。

爱丽丝对每位 k 位科学家进行了访谈并发表了她的报告。然而，最近发现，一位竞争对手科学家伊芙仅基于爱丽丝的报告就了解了关于研究细节的信息，超出了与爱丽丝交换的内容。可能发生了什么？

从 DP 的定义回顾，ϵ是控制随机机制输出与真实世界场景差异的隐私预算。可以证明，k 位科学家输出的ϵ-差分隐私随机机制与真实世界场景之间的差异增长到最多 k ⋅ ϵ的隐私预算。因此，尽管对每位科学家进行访谈只花费了ϵ的隐私预算，但由于 k 位科学家共享相同的秘密，对全部科学家进行访谈实际上花费了 k ⋅ ϵ的隐私预算。因此，随着群体规模的增加，隐私保证适度下降。如果 k 足够大，伊芙就能了解关于研究的所有信息，尽管每位 k 位科学家在访谈时都遵循了ϵ-差分隐私随机机制。可以为大小约为 k ≈ 1/ϵ的个人群体提供有意义的隐私保证。然而，对于 k ≈ 100/ ϵ的群体几乎没有任何保护保证。

k 科学家示例说明了 DP（差分隐私）的群体属性，其中有时一组成员（如家庭或公司的员工）会希望一起加入一个分析研究，因此敏感数据可能与所有群体成员有关。总结来说：如果算法 M(x)满足ϵ-DP，则将 M(x)应用于 k 个相关个体满足 k ⋅ ϵ-DP。

DP（差分隐私）的群体隐私性质使研究人员和开发者能够为个体群体设计高效且有用的 DP 算法。例如，考虑联邦学习（即协作学习）的场景。一般来说，联邦学习允许数据所有者以去中心化的方式协作学习共享模型，同时保持所有训练数据本地化。本质上，这个想法是在不需要共享训练数据的情况下执行机器学习。在这个阶段，保护拥有数据样本群体的每个数据所有者的隐私非常重要，而不是每个样本本身，此时 DP 可以发挥重要作用。

2.3.3 差分隐私的组合性质

DP（差分隐私）的另一个非常重要且有用的性质是其组合定理。DP 的严谨数学设计使得可以分析和控制多个不同差分隐私计算累积的隐私损失。理解这些组合性质将使您能够更好地设计和分析基于更简单构建块的更复杂 DP 算法。主要有两个组合性质，我们将在下面探讨。

顺序组合

在数据分析与机器学习中，相同的信息（统计数据、汇总数据、机器学习模型等）通常会被多次查询。例如，在我们之前的私有公司场景中，员工总数和平均工资可能会被不同的人（如 Alice 和 Bob）多次查询。尽管每次查询的结果都会添加随机噪声，但更多的查询将消耗更多的隐私预算，并可能导致更多的隐私泄露。例如，如果 Alice 或 Bob 能够从当前的（静态）数据库中收集足够的噪声查询结果，他们可以通过计算这些噪声查询结果的平均值来消除噪声，因为随机噪声始终来自相同的零均值拉普拉斯分布。因此，在设计需要多次顺序查询的私有数据差分隐私解决方案时，我们应该谨慎行事。

为了说明 DP 的顺序组合属性，让我们考虑另一个场景。假设 Mallory 的个人信息（她的薪水）包含在私人公司使用的员工信息数据库中，该数据库被潜在的商业分析师在两个不同的差分隐私查询中使用。第一个查询可能是关于公司平均薪水的，而第二个查询可能是关于有多少人的薪水高于 50,000 美元。Mallory 担心这两个查询，因为当两个结果进行比较（或合并）时，它们可能会泄露个人的薪水。

DP 的顺序组合属性证实了从数据上的多个查询中累积的隐私泄露总是高于单个查询的泄露。例如，如果第一个查询的 DP 分析是在隐私预算 ϵ[1] = 0.1 下进行的，而第二个查询的隐私预算为 ϵ[2] = 0.2，那么这两个分析可以被视为一个具有可能大于 ϵ[1] 或 ϵ[2] 但最多为 ϵ[3] = ϵ[1] + ϵ[2] = 0.3 的隐私损失参数的单个分析。总结一下：如果算法 F1 满足 ϵ[1]-DP，并且 F2 满足 ϵ[2]-DP，那么 F1 和 F2 的顺序组合满足 (ϵ[1] + ϵ[2])-DP。

现在，让我们探索一个示例，该示例演示了 DP 的顺序组合属性。

示例 4：差分隐私计数查询的顺序组合

让我们重新考虑示例 1 中的场景，其中我们想要确定人口普查数据集中有多少人年龄超过 50 岁。不同的是，现在我们有两个具有不同隐私预算的 DP 函数。让我们看看在依次应用不同的 DP 函数后会发生什么。

在下面的列表中，我们定义了四个 DP 函数，其中 F[1] 满足 0.1-DP（ϵ[1] = 0.1），F[2] 满足 0.2-DP（ϵ[2] = 0.2），F[3] 满足 0.3-DP（ϵ[3] = ϵ[1] + ϵ[2]），而 F[seq] 是 F[1] 和 F[2] 的顺序组合。

列表 2.7 应用顺序组合

import numpy as np
import matplotlib.pyplot as plt
ages_adult = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data", usecols=0, delimiter=", ")

sensitivity = 1
epsilon1 = 0.1
epsilon2 = 0.2
epsilon3 = epsilon1 + epsilon2

def F1(x):                                                            ❶
    return x+np.random.laplace(loc=0, scale=sensitivity/epsilon1)     ❶

def F2(x):                                                            ❷
    return x+np.random.laplace(loc=0, scale=sensitivity/epsilon2)     ❷

def F3(x):                                                            ❸
    return x+np.random.laplace(loc=0, scale=sensitivity/epsilon3)     ❸

def F_seq(x):                                                         ❹
    return (F1(x)+F2(x))/2                                            ❹

❶ 满足 0.1-DP

❷ 满足 0.2-DP

❸ 满足 0.3-DP

❹ F1 和 F2 的顺序组合

现在，假设 x 是“人口普查数据集中有多少人年龄超过 50 岁？”的实数值，让我们比较 F[1]、F[2] 和 F[3] 的输出：

x = len([i for i in ages_adult if i > 50])

plt.hist([F1(x) for i in range(1000)], bins=50, label='F1');            ❶

plt.hist([F2(x) for i in range(1000)], bins=50, alpha=.7, label='F2');  ❷

plt.hist([F3(x) for i in range(1000)], bins=50, alpha=.7, label='F3');  ❸

plt.legend();

❶ 图 F1

❷ 图 F2（应该看起来相同）

❸ 图 F3（应该看起来相同）

在图 2.12 中，你可以看到 F[3] 的输出分布看起来比 F[1] 和 F[2] 的“更尖锐”，因为 F[3] 具有更高的隐私预算（ϵ），这表明更多的隐私泄露，因此有更高的概率输出接近真实答案（6,460）的结果。

图 2.12 不同差分隐私计数查询的顺序组合输出

现在，让我们比较 F[3] 和 F[seq] 的输出，如下面的代码片段所示：

plt.hist([F_seq(x) for i in range(1000)], bins=50, alpha=.7,
➥ label='F_seq');                                                       ❶

plt.hist([F3(x) for i in range(1000)], bins=50, alpha=.7, label='F3');   ❷

plt.legend();

❶ 图 F_seq

❷ 图 F3

如图 2.13 所示，F[3] 和 F[seq] 的输出大致相同，这证明了 DP 的顺序组合属性。但值得注意的是，顺序组合仅定义了几个 DP 函数顺序组合的总 ϵ 的上界（即最坏情况的隐私泄露）。对隐私的实际累积影响可能更低。有关 DP 顺序组合的数学理论更多信息，请参阅章节 A.3。

图 2.13 比较输出 F[3] 和 F[seq] 的分布

并行组合

到目前为止，一个明显的问题是，如果有人将几个不同的 DP 算法并行组合会发生什么。为了说明 DP 的并行组合属性，考虑以下场景。

假设公司 A 维护着其员工薪资信息的数据库。Alice 想要了解公司 A 中薪资高于 $150,000 的员工数量，而 Bob 则想研究公司 A 中薪资低于 $20,000 的员工数量。为了满足公司的隐私保护要求，Alice 被要求使用 ϵ[1]-DP 机制访问数据库，而 Bob 则需要应用 ϵ[2]-DP 机制从同一数据库中获取信息。Alice 和 Bob 访问数据库的总隐私泄露是多少？

由于高于 $150,000 的薪资和低于 $20,000 的薪资的员工是两个不相交的个体集合，因此同时发布这两组信息不会导致同一员工两次隐私泄露。例如，如果 ϵ[1] = 0.1 且 ϵ[2] = 0.2，根据 DP 的并行组合属性，Alice 和 Bob 访问数据库所使用的总隐私预算为 ϵ[3] = max(ϵ[1], ϵ[2]) = 0.2。

总结：如果算法 F1 满足 ϵ[1]-DP，且 F2 满足 ϵ[2]-DP，其中 (x[1], x[2]) 是整个数据集 x 的非重叠划分，那么 F1 和 F2 的并行组合满足 max(ϵ[1], ϵ[2])-DP。max(ϵ[1], ϵ[2]) 定义了几个 DP 函数并行组合的总 ϵ 的上界（即最坏情况的隐私泄露）；对隐私的实际累积影响可能更低。有关 DP 并行组合背后的数学理论更多信息，请参阅章节 A.4。

DP 的顺序和并行组合属性被认为是 DP 的固有属性，其中数据聚合者不需要在组合多个 DP 算法时进行任何特殊计算以确定隐私界限。DP 的这种组合属性使得研究人员和开发者可以更多地关注更简单的差分隐私构建块（即机制）的设计，而这些简单的构建块可以直接组合起来解决更复杂的问题。

总结

• DP 是一种有前途且流行的隐私增强技术，它为隐私提供了一个严格的定义。

• DP 旨在通过发布数据库或数据集的汇总或统计信息来加强隐私保护，同时不透露该数据库中任何个人的存在。

• 敏感性通常衡量每个个体信息对分析输出可能产生的最大影响。

• 隐私预算 ϵ 通常由数据所有者设置，以调整所需的隐私保护级别。

• DP 可以通过使用不同的 DP 机制扰动敏感信息的汇总或统计来实现。

• 在二元机制中，随机化来源于二元响应（抛硬币），这有助于扰动结果。

• 拉普拉斯机制通过向目标查询或函数添加从拉普拉斯分布中抽取的随机噪声来实现 DP。

• 指数机制有助于应对那些需要选择最佳响应但直接向查询函数的输出添加噪声会完全破坏效用的情况。

• DP 对后处理免疫：一旦个人的 DP 敏感数据声称被随机化算法保护，没有其他数据分析师可以在不涉及原始敏感数据信息的情况下增加其隐私损失。

• DP 可以应用于分析和控制来自群体（如家庭和组织）的隐私损失。

• DP 还具有顺序和并行组合属性，这使得可以从更简单的差分隐私构建块设计和分析复杂的差分隐私算法。

3 机器学习差分隐私的高级概念

本章涵盖

• 差分隐私机器学习算法的设计原则

• 设计和实现差分隐私监督学习算法

• 设计和实现差分隐私无监督学习算法

• 设计和分析差分隐私机器学习算法的步骤

在上一章中，我们研究了差分隐私（DP）的定义和一般用途，以及在不同场景下差分隐私的性质（后处理属性、分组属性和组合属性）。我们还探讨了常见且广泛采用的差分隐私机制，这些机制在各种隐私保护算法和应用中作为基本构建块。本章将介绍如何使用这些构建块来设计和实现多个差分隐私机器学习算法，以及如何在现实场景中应用这些算法。

3.1 在机器学习中应用差分隐私

在第二章中，我们研究了不同的差分隐私机制及其性质。本章将展示如何使用这些差分隐私机制来设计和实现各种差分隐私机器学习算法。

如图 3.1 所示，我们考虑的是一个两方机器学习训练场景，包括数据所有者和数据用户。数据所有者提供私有数据，即输入或训练数据。通常，训练数据将经过数据预处理阶段以清理数据并去除任何噪声。然后，数据用户将对这些个人数据执行特定的机器学习算法（回归、分类、聚类等），以训练并生成机器学习模型，即输出。

图 3.1 差分隐私机器学习的设计原则

正如我们所知，差分隐私（DP）在过去十年中受到了越来越多的关注。因此，工业和学术研究人员都提出了各种不同的差分隐私机器学习算法，并进行了设计、实现。差分隐私可以应用于防止数据用户通过分析机器学习模型来推断私有数据。如图 3.1 所示，扰动可以在机器学习过程的各个步骤中应用，以提供差分隐私保证。例如，输入扰动方法直接向干净私有数据或数据预处理阶段添加噪声。算法扰动方法在训练机器学习模型期间添加噪声。目标扰动方法向机器学习模型的目标损失函数添加噪声。最后，输出扰动直接向训练好的机器学习模型（即机器学习算法的输出）添加噪声。

图 3.2 识别了在本章中作为示例展示的机器学习算法中应用的几种流行扰动策略。当然，还有其他可能的例子，但我们将坚持这些方法，并在下一节详细讨论这些扰动方法。

图 3.2 DP 扰动策略及其讨论的章节

让我们逐一探讨这些针对差分隐私机器学习算法的四个常见设计原则，从输入扰动开始。

3.1.1 输入扰动

在输入扰动中，噪声直接添加到输入数据（训练数据）中，如图 3.3 所示。在清洗数据上执行所需的非隐私机器学习算法计算（机器学习训练过程）后，输出（机器学习模型）将是差分隐私的。例如，考虑主成分分析（PCA）机器学习算法。它的输入是私有数据的协方差矩阵，它的输出是一个投影矩阵（PCA 的输出模型）。在对方差矩阵（输入）进行特征分解之前，我们可以在协方差矩阵中添加一个对称的高斯噪声矩阵[1]。现在输出将是一个差分隐私投影矩阵（记住，这里的目的是不发布投影数据，而是 DP 投影矩阵）。

图 3.3 输入扰动的原理

输入扰动易于实现，并且可以用来生成适用于不同类型机器学习（ML）算法的清洗数据集。由于这种方法侧重于扰动输入数据以应用于机器学习模型，因此相同的程序可以推广到许多不同的机器学习算法。例如，扰动协方差矩阵也可以作为许多不同的成分分析算法的输入，例如主成分分析（PCA）、线性判别分析（LDA）和多重判别分析（MDA）。此外，大多数差分隐私（DP）机制都可以在输入扰动方法中利用，具体取决于输入数据的属性。

然而，输入扰动通常需要向机器学习输入数据添加更多的噪声，因为原始输入数据通常具有更高的敏感性。正如第二章所讨论的，差分隐私中的敏感性是一个个体私人信息可能造成的最大可能差异。具有更高敏感性的数据需要我们添加更多的噪声以提供相同级别的隐私保证。在第 3.2.3 节中，我们将讨论差分隐私线性回归，以展示在设计差分隐私机器学习算法时如何利用输入扰动。

3.1.2 算法扰动

在算法扰动中，私有数据被输入到机器学习算法中（可能经过非私有数据预处理程序），然后采用差分隐私机制生成相应的净化模型（见图 3.4）。对于需要多次迭代或多个步骤的机器学习算法，差分隐私机制可以用来扰动每个迭代或步骤中的中间值（即模型参数）。例如，PCA 的特征分解可以使用幂迭代方法执行，这是一个迭代算法。在带噪声的幂方法中，可以在算法的每个迭代中添加高斯噪声，该算法作用于未扰动的协方差矩阵（即输入），从而实现差分隐私 PCA [2]。同样，Abadi 提出了一种差分隐私深度学习系统，该系统修改了随机梯度下降算法，使其在每个迭代中添加高斯噪声 [3]。

图 3.4 算法扰动的原理：输入是私有数据。然后我们预处理数据（非私有）。接下来，我们在机器学习算法的训练迭代过程中扰动中间值。最后，我们得到一个差分隐私机器学习模型。

如您所见，算法扰动方法通常应用于需要多次迭代或多个步骤的机器学习模型，例如线性回归、逻辑回归和深度神经网络。与输入扰动相比，算法扰动需要对不同的机器学习算法进行特定设计。然而，由于训练机器学习模型中的中间值通常比原始输入数据具有更少的敏感性，因此它通常在相同的差分隐私预算下引入更少的噪声。更少的噪声通常会导致差分隐私机器学习模型具有更好的效用。在 3.3.1 节中，我们将介绍差分隐私k-均值聚类，进一步讨论如何在差分隐私机器学习的设计中利用算法扰动。

3.1.3 输出扰动

使用输出扰动时，我们采用非私有学习算法，然后对生成的模型添加噪声，如图 3.5 所示。例如，我们可以通过使用指数机制（即采样一个随机k-维子空间，该子空间近似于前k个 PCA 子空间）来净化 PCA 算法生成的投影矩阵，从而实现差分隐私 PCA。

图 3.5 输出扰动的原理：输入是私有数据。然后我们预处理数据（非私有）。接下来，我们对非私有机器学习算法应用差分隐私扰动。最后，我们得到一个差分隐私机器学习模型。

通常，输出扰动方法适用于产生复杂统计数据的机器学习算法。例如，特征提取和降维算法通常发布提取的特征。因此，使用投影矩阵进行降维是使用输出扰动的合适场景。然而，许多需要发布模型并与测试数据多次交互的监督机器学习算法，如线性回归、逻辑回归和支持向量机，不适合输出扰动。在 3.2.1 节中，我们将通过差分隐私朴素贝叶斯分类来讨论如何利用输出扰动在差分隐私机器学习中。

3.1.4 目标扰动

如图 3.6 所示，目标扰动涉及向学习算法（如经验风险最小化）的目标函数添加噪声，这些算法使用噪声函数的最小/最大值作为输出模型。经验风险最小化的核心思想是，由于我们不知道算法在实际数据上的表现如何，因为我们不知道算法将要处理的数据的真实分布。然而，我们可以测量它在已知训练数据集上的性能，我们称这种测量为经验风险。因此，在目标扰动中，可以设计一个向量机制来适应噪声的添加。要了解更多关于如何具体操作的细节，请参阅附录 A.2。

图 3.6 目标扰动的工作原理：输入是私有数据。然后我们对数据进行预处理（非私有）。接下来，我们在训练过程中扰动机器学习模型的目标函数。最后，我们得到一个差分隐私机器学习模型。

什么是目标函数？

在数学优化中，目标函数试图根据一组约束条件和一或多个决策变量之间的关系，最大化成本（或最小化损失）。通常，损失函数（或成本函数）将一个或多个变量的值映射到一个实数（一个数值），然后可以表示为与事件相关的“成本”。在实践中，它可能是项目的成本、利润率，甚至是生产线上的数量。有了目标函数，我们试图达到输出、利润、资源使用等目标。

用数学术语来说，目标函数可以表示如下。

考虑一个最大化产品利润的例子，其中我们有一些变量可以直接影响利润。在这个公式中，X[i]是这些变量中的第i个变量，c[i]是第i个变量的系数。我们在这里想要实现的是，在试图达到最大利润的过程中，确定这些变量的最佳设置。

正如你所知，样本空间是事件或实验所有可能结果的集合。现实世界的样本空间有时包括有界值（位于特定范围内的值）和无界值，覆盖无限多的可能结果。然而，大多数扰动机制假设样本空间是有界的。当样本空间是无界的，它会导致无界敏感性，从而导致无界噪声的增加。因此，如果样本空间是无界的，我们可以假设每个样本的值在预处理阶段将被截断，并且截断规则与私有数据无关。例如，我们可以使用常识或额外的领域知识来决定截断规则。在第 3.2.2 节中，我们将讨论差分隐私逻辑回归和 DP ML 中的目标扰动。

3.2 差分隐私监督学习算法

监督学习使用标记数据，其中每个特征向量都与一个输出值相关联，该输出值可能是一个类别标签（分类）或连续值（回归）。标记数据用于构建模型，这些模型可以预测新特征向量的标签（在测试阶段）。在分类中，样本通常属于两个或多个类别，机器学习算法的目标是确定新样本属于哪个类别。一些算法可能通过在不同类别之间找到分离的超平面来实现这一点。一个示例应用是面部识别，其中可以测试面部图像以确定它属于特定的人。

多种分类算法可以用于之前提到的每个应用，例如支持向量机（SVMs）、神经网络或逻辑回归。当样本标签是一个连续值（也称为因变量或响应变量）而不是离散值时，该任务被称为回归。样本由也称为自变量的特征组成。回归的目标是将预测模型（如直线）拟合到观察数据集，使得观察数据点与直线之间的距离最小化。例如，可以根据房屋的位置、邮编和房间数量来估计房屋价格。

在以下小节中，我们将制定三种最常见监督学习算法的 DP 设计：朴素贝叶斯分类、逻辑回归和线性回归。

3.2.1 差分隐私朴素贝叶斯分类

首先，让我们了解一下差分隐私朴素贝叶斯分类是如何工作的，以及一些数学解释。

朴素贝叶斯分类

在概率论中，贝叶斯定理描述了基于先前对可能相关事件的条件的知识来描述事件的概率。它表述如下：

• A 和 B 是事件。

• P(A|B)是在 B 为真的条件下 A 的概率。

• P(B|A)是在 A 为真的条件下 B 的概率。

• P(A)和 P(B)是 A 和 B 的独立概率。

朴素贝叶斯分类技术使用贝叶斯定理以及每对特征之间相互独立的假设。

首先，让待分类的实例为 n 维向量 X = [x[1], x[2],...,x[n]]，特征的名称为[F[1], F[2],...,F[n]]，可以分配给实例的可能类别为 C = [c[1], c[2],...,c[n]]。

朴素贝叶斯分类器将实例X分配到类别 F[S]，当且仅当 P(C[s]|X) P(C[j]|X)对于 1 ≤ j ≤ k 且 j ≠ s。因此，分类器需要计算所有类别的 P(C[j]│X)并比较这些概率。

我们知道在使用贝叶斯定理时，概率 P(C[j]│X)可以计算为

由于 P(X)对所有类别都是相同的，因此找到具有最大 P(X|C[j]) ∙ P(C[j])的类别就足够了。假设特征是独立的，那么这个类别等于 P(C[j]) ⋅ Π^n[i=1] P(F[i] = x[i]|C[j])。因此，将 C[j]分配给给定实例 X 的概率与 P(C[1]) ⋅ Π³[i=1] P(F[i]= x[i]|C[j])成正比。

这就是目前朴素贝叶斯分类的数学背景。接下来，我们将通过示例演示如何应用朴素贝叶斯对离散和连续数据进行分类。

离散朴素贝叶斯

为了演示朴素贝叶斯分类器在离散（分类）数据上的概念，让我们使用表 3.1 中的数据集。

表 3.1 这是从一个抵押贷款支付数据集中提取的部分。年龄、收入和性别是独立变量，而未支付款项代表预测任务的因变量。

数量	年龄	收入	性别	未支付款项（是或否）
1	年轻	低	男	是
2	年轻	高	女	是
3	中等	高	男	否
4	老年	中等	男	否
5	老年	高	男	否
6	老年	低	女	是
7	中等	低	女	否
8	中等	中等	男	是
9	年轻	低	男	否
10	老年	高	女	否

在这个例子中，分类任务是预测客户是否会错过抵押贷款支付。因此，有两个类别，C[1]和 C[2]，分别代表是否错过支付。P(C[1]) = 4⁄10 和 P(C[2]) = 6⁄10。此外，年龄特征的条件下概率如图 3.7 所示。我们可以类似地计算其他特征的条件下概率。

图 3.7 示例数据集中 F[1]（即年龄）的条件概率

为了预测一个中等收入的年轻女性是否会错过付款，我们可以设置 X = (Age = Young, Income = Medium, Gender = Female)。然后，使用表 3.1 中的原始数据计算结果，我们将得到 P(Age = Young|C[1]) = 2/4, P(Income = Medium|C[1]) = 1/4, P(Gender = Female|C[1]) = 2/4, P(Age = Young|C[2]) = 1/6, P(Income = Medium|C[2]) = 1/6, P(Gender = Female|C[2]) = 2/6, P(C[1]) = 4/10, 和 P(C[2]) = 6/10。

要使用朴素贝叶斯分类器，我们需要比较 P(C[1]) ⋅ Π³[i=1] P(F[i] = x[i]|C[1]) 和 P(C[2]) ⋅ Π³[i=1] P(F[i] = x[i]|C[2])。由于前者等于 0.025（即，4/10 × 2/4 × 1/4 × 2/4 = 0.025）而后者等于 0.0056（即，6/10 × 1/6 × 1/6 × 2/6 = 0.0056），可以确定朴素贝叶斯分类器将实例 X 分配给 C[1]。换句话说，可以预测一个中等收入的年轻女性会错过她的付款。

高斯朴素贝叶斯

当涉及到连续数据（任何两个数值数据点之间有无限可能的值）时，一种常见的方法是假设这些值是按照高斯分布分布的。然后我们可以使用这些值的均值和方差来计算条件概率。

假设一个特征 F[i] 具有连续域。对于每个类别 C[j] ∈ C，计算训练集中 F[i] 的值的均值 μ[i,j] 和方差 σ[i,j]²。然后，对于给定的实例 X，使用高斯分布计算条件概率 P(F[i] = x[i]│C[j])，如下所示：

你可能已经注意到，在离散朴素贝叶斯中，由于训练集中未看到的值的数量很高，在大离散域中准确性可能会降低。然而，高斯朴素贝叶斯也可以用于具有大离散域的特征。

实现差分隐私朴素贝叶斯分类

现在，让我们看看我们如何使朴素贝叶斯分类具有差分隐私。这种设计遵循输出扰动策略 [4]，其中推导出朴素贝叶斯模型参数的敏感性，然后直接将拉普拉斯机制（即，添加拉普拉斯噪声）应用于模型参数（如第 2.2.2 节所述）。

首先，我们需要确定模型参数的敏感性。离散和高斯朴素贝叶斯模型参数有不同的敏感性。在离散朴素贝叶斯中，模型参数是概率

其中 n 是总训练样本数，其中 C = C[j]，而 n[i,j] 是具有 F[i] = x[i] 的此类训练样本的数量。

因此，DP 噪声可以添加到训练样本数量（即 n[i,j]）。我们可以看到，无论我们添加还是删除一条新记录，n[i,j] 的差异总是 1。因此，对于离散朴素贝叶斯，每个模型参数 n[i,j] 的敏感性为 1（对于所有特征值 F[i] = x[i] 和类别值 C[j]）。

对于高斯朴素贝叶斯，模型参数 P(F[i] = x[i]│C[j]) 依赖于均值 μ[i,j] 和方差 σ[i,j]²，因此我们需要找出这些均值的敏感性。假设特征 F[i] 的值被范围 [l[i], u[i]] 所限制。那么，正如 Vaidya 等人 [4] 所建议的，均值 μ[i,j] 的敏感性是 (μ[i] − l[i] ) /(n + 1)，方差 σ[i,j]² 的敏感性是 n ∙ (μ[i] − l[i]) / (n + 1)，其中 n 是 C = C[j] 的训练样本数量。

为了设计我们的差分隐私朴素贝叶斯分类算法，我们将使用输出扰动策略，其中每个特征的敏感性根据其是否为离散或数值来计算。根据第 2.2.2 节中关于拉普拉斯机制的讨论，添加适当尺度的拉普拉斯噪声（参数为离散特征的样本数量和数值特征的均值与方差）。图 3.8 展示了我们的算法伪代码，大部分内容都是自我解释的。

图 3.8 差分隐私朴素贝叶斯分类的工作原理

现在我们将实现一些这些概念，以获得一些实际操作经验。让我们考虑一个场景，其中我们正在训练一个朴素贝叶斯分类模型，根据人口普查数据集预测一个人是否年收入超过 50,000 美元。您可以在 archive.ics.uci.edu/ml/datasets/adult 找到更多关于数据集的详细信息。

首先，我们需要从 adult 数据集中加载训练和测试数据。

列表 3.1 加载数据集

import numpy as np

X_train = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data",                          
➥ usecols=(0, 4, 10, 11, 12), delimiter=", ")

y_train = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data", 
➥ usecols=14, dtype=str, delimiter=", ")

X_test = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.test",
➥ usecols=(0, 4, 10, 11, 12), delimiter=", ", skiprows=1)

y_test = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.test", 
➥ usecols=14, dtype=str, delimiter=", ", skiprows=1)
y_test = np.array([a[:-1] for a in y_test])

接下来，我们将训练一个常规（非隐私）的朴素贝叶斯分类器，并测试其准确性，如下所示。

列表 3.2 无隐私的朴素贝叶斯

from sklearn.naive_bayes import GaussianNB
nonprivate_clf = GaussianNB()
nonprivate_clf.fit(X_train, y_train)

from sklearn.metrics import accuracy_score

print("Non-private test accuracy: %.2f%%" % 
     (accuracy_score(y_test, nonprivate_clf.predict(X_test)) * 100))

输出将类似于以下内容：

> Non-private test accuracy: 79.64%

为了应用差分隐私朴素贝叶斯，我们将使用 IBM 差分隐私库 diffprivlib：

!pip install diffprivlib

使用 diffprivlib 的 models.GaussianNB 模块，我们可以在满足 DP 的同时训练朴素贝叶斯分类器。如果我们不指定任何参数，模型默认为 epsilon = 1.00。

import diffprivlib.models as dp
dp_clf = dp.GaussianNB()

dp_clf.fit(X_train, y_train)

print("Differentially private test accuracy (epsilon=%.2f): %.2f%%" %
➥ (dp_clf.epsilon, accuracy_score(y_test, 
➥ dp_clf.predict(X_test)) * 100))

输出将类似于以下内容：

> Differentially private test accuracy (epsilon=1.00): 78.59%

如您从前面的输出准确率中可以看到，常规（非隐私）朴素贝叶斯分类器产生了 79.64%的准确率；通过设置 epsilon=1.00，差分隐私朴素贝叶斯分类器达到了 78.59%的准确率。值得注意的是，（非隐私）朴素贝叶斯分类器和差分隐私朴素贝叶斯分类器的训练过程是非确定性的。因此，您可能获得的数字与我们所列的准确率略有不同。尽管如此，DP-朴素贝叶斯的结果略低于其非隐私版本。

使用较小的 epsilon 通常会导致更好的隐私保护，但准确性较低。例如，让我们设置 epsilon=0.01：

import diffprivlib.models as dp
dp_clf = dp.GaussianNB(epsilon=float("0.01"))
dp_clf.fit(X_train, y_train)

print("Differentially private test accuracy (epsilon=%.2f): %.2f%%" %
➥ (dp_clf.epsilon, accuracy_score(y_test, 
➥ dp_clf.predict(X_test)) * 100))

现在的输出将看起来像这样：

> Differentially private test accuracy (epsilon=0.01): 70.35%

3.2.2 差分隐私逻辑回归

上一小节探讨了差分隐私监督学习算法的朴素贝叶斯方法。现在让我们看看在差分隐私设置下如何应用逻辑回归。

逻辑回归

逻辑回归（LR）是二元分类的模型。LR 通常被表述为通过最小化训练集（X, Y）上的负对数似然来训练参数 w。

其中 X = [x[1], x[2], ...,x[n]] 和 Y = [y[1], y[2], ...,y[n]]。

与标准 LR 相比，正则化 LR 在其损失函数中有一个正则化项。因此，它被表述为通过最小化来训练参数 w。

在训练集（X, Y）上，其中 X = [x[1], x[2],...,x[n]], Y = [y[1], y[2],...,y[n]], λ是一个超参数，用于设置正则化的强度。

为什么逻辑回归中需要正则化？

过度拟合是机器学习任务中常见的问题。通常，我们会在一组数据上训练一个模型，它似乎在那组数据上表现良好，但当我们用一组未见过的数据对其进行测试时，性能会下降。导致这个问题的原因之一是过度拟合，即模型过于紧密地符合训练集，从而错过了更通用的趋势。

正则化被称为收缩方法，因为它们“收缩”了结果回归中的系数。这种系数的收缩减少了模型中的方差，有助于避免过度拟合。用更简单的话说，有了正则化，当输入变量改变时，模型的预测变化小于没有正则化时的变化。

实现差分隐私逻辑回归

我们可以在设计差分隐私逻辑回归时采用目标扰动策略，其中向学习算法的目标函数中添加噪声。我们将使用基于经验风险最小化的向量机制来决定噪声函数的最小值和最大值，以产生 DP 噪声输出模型。

Chaudhuri 等人提出的定理 3.1 为正则化逻辑回归公理化了敏感性 [5]。训练数据输入 {(x[i], y[i]) ∈ X × Y:i = 1,2,...,n} 由 n 个数据标签对组成。此外，我们将使用符号 ‖A‖[2] 来表示 A 的 L[2] 范数。我们正在训练参数 w，λ 是一个超参数，用于设置正则化的强度。

定理 3.1

您可以参考原文以获取数学证明和细节。现在我们关注的是敏感度的计算，即 ‖f(X) − f(X')‖[2] 的差，它小于或等于 2/λ ∙ n。

现在，我们将使用目标扰动策略来设计我们的差分隐私逻辑回归算法，其中敏感性是根据定理 3.1 计算的。图 3.9 展示了伪代码。有关基于经验风险最小化的向量机制的更多细节，请参阅原文 [5]。

图 3.9 差分隐私逻辑回归的工作原理

基于我们之前使用的 adult 数据集，让我们继续之前的场景，通过训练逻辑回归分类模型来预测一个人是否每年收入超过 50,000 美元。首先，让我们从 adult 数据集中加载训练和测试数据。

列表 3.3 加载测试和训练数据

import numpy as np

X_train = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data", 
➥ usecols=(0, 4, 10, 11, 12), delimiter=", ")

y_train = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data", 
➥ usecols=14, dtype=str, delimiter=", ")

X_test = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.test", 
➥ usecols=(0, 4, 10, 11, 12), delimiter=", ", skiprows=1)

y_test = np.loadtxt("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.test", 
➥ usecols=14, dtype=str, delimiter=", ", skiprows=1)

y_test = np.array([a[:-1] for a in y_test])

对于 diffprivlib，当特征缩放到控制数据范数时，逻辑回归表现最佳。为了简化此过程，我们将在 sklearn 中创建一个 Pipeline：

from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler

lr = Pipeline([
    ('scaler', MinMaxScaler()),
    ('clf', LogisticRegression(solver="lbfgs"))
])

现在我们首先训练一个常规（非隐私）逻辑回归分类器并测试其准确性：

lr.fit(X_train, y_train)

from sklearn.metrics import accuracy_score

print("Non-private test accuracy: %.2f%%" % (accuracy_score(y_test,
➥ lr.predict(X_test)) * 100))

您将得到如下输出：

> Non-private test accuracy: 81.04%

要应用差分隐私逻辑回归，我们首先安装 IBM 差分隐私库：

!pip install diffprivlib

使用 diffprivlib.models.LogisticRegression 模块，我们可以在满足 DP 的同时训练逻辑回归分类器。

如果我们没有指定任何参数，模型默认为 epsilon = 1 和 data_norm = None。如果在初始化时没有指定数据的范数（如本例所示），则在第一次调用 .fit() 时会在数据上计算范数，并会抛出一个警告，因为这会导致隐私泄露。为了确保没有额外的隐私泄露，我们应该显式地指定数据范数作为参数，并选择与数据无关的界限。例如，我们可以使用领域知识来做到这一点。

列表 3.4 训练逻辑回归分类器

import diffprivlib.models as dp
dp_lr = Pipeline([
    ('scaler', MinMaxScaler()),
    ('clf', dp.LogisticRegression())
])

dp_lr.fit(X_train, y_train)

print("Differentially private test accuracy (epsilon=%.2f): %.2f%%" %
➥ (dp_lr['clf'].epsilon, accuracy_score(y_test, 
➥ dp_lr.predict(X_test)) * 100))

输出将类似于以下内容：

> Differentially private test accuracy (epsilon=1.00): 80.93%

如前所述的输出准确率所示，常规（非隐私）逻辑回归分类器产生了 81.04%的准确率；通过设置 epsilon=1.00，差分隐私逻辑回归可以达到 80.93%的准确率。使用较小的 epsilon 通常会导致更好的隐私保护，但准确性会降低。例如，如果我们设置 epsilon=0.01：

import diffprivlib.models as dp
dp_lr = Pipeline([
    ('scaler', MinMaxScaler()),
    ('clf', dp.LogisticRegression(epsilon=0.01))
])

dp_lr.fit(X_train, y_train)

print("Differentially private test accuracy (epsilon=%.2f): %.2f%%" %
➥ (dp_lr['clf'].epsilon, accuracy_score(y_test, 
➥ dp_lr.predict(X_test)) * 100))

如预期的那样，结果将看起来像这样：

> Differentially private test accuracy (epsilon=0.01): 74.01%

3.2.3 差分隐私线性回归

与逻辑回归不同，线性回归模型在数据集中定义了观察到的目标变量与多个解释变量之间的线性关系。它通常用于回归分析中的趋势预测。计算此类模型的最常见方法是使数据集中观察到的目标（解释变量）与线性近似预测的目标（解释变量）之间的残差平方和最小化。

让我们深入研究理论基础。我们可以将线性回归的标准问题表述为寻找 β = arg min[β]‖Xβ − y‖²，其中 X 是解释变量矩阵，y 是解释变量向量，β 是待估计的未知系数向量。

岭回归是线性回归的正则化版本，可以表示为 β^R= arg min[β]‖Xβ − y‖² + w²‖β‖²，它有一个封闭形式的解：β^R = (X^TX + w²I[p×p])X^Ty，其中 w 被设置为最小化 β^R 的风险。

设计差分隐私线性回归的问题变成了设计第二矩矩阵的差分隐私近似。为了实现这一点，Sheffet [6] 提出了一种算法，使用 Wishart 机制向第二矩矩阵添加噪声。有关更多详细信息，您可以参考原始论文，但这对我们继续前进已经足够了。

让我们考虑在糖尿病数据集上训练线性回归的场景。这是机器学习研究人员中另一个流行的数据集，您可以在以下链接中找到更多关于它的信息：archive.ics.uci.edu/ml/datasets/diabetes。我们将使用 scikit-learn 提出的示例（scikit-learn.org/stable/auto_examples/linear_model/plot_ols.xhtml），并使用糖尿病数据集来训练和测试线性回归器。

我们首先加载数据集，并将其分为训练样本和测试样本（80/20 的分割）：

from sklearn.model_selection import train_test_split
from sklearn import datasets

dataset = datasets.load_diabetes()
X_train, X_test, y_train, y_test = train_test_split(dataset.data,
➥ dataset.target, test_size=0.2)
print("Train examples: %d, Test examples: %d" % (X_train.shape[0],
➥ X_test.shape[0]))

你将得到类似以下的结果，显示训练集和测试集中的样本数量：

> Train examples: 353, Test examples: 89

我们现在将使用 scikit-learn 的原生 LinearRegression 函数为我们的实验建立一个非隐私基线。我们将使用 r 平方分数来评估模型的拟合优度。r 平方分数是一个统计量，表示回归模型中由独立变量或变量解释的因变量的方差比例。r 平方分数越高，线性回归模型越好。

from sklearn.linear_model import LinearRegression as sk_LinearRegression
from sklearn.metrics import r2_score

regr = sk_LinearRegression()
regr.fit(X_train, y_train)
baseline = r2_score(y_test, regr.predict(X_test))
print("Non-private baseline: %.2f" % baseline)

结果将类似于以下内容：

> Non-private baseline: 0.54

要应用差分隐私线性回归，让我们首先安装 IBM Differential Privacy Library，如果您还没有这样做的话：

!pip install diffprivlib

现在让我们训练一个差分隐私线性回归器（epsilon=1.00），其中训练模型对训练数据是差分隐私的：

from diffprivlib.models import LinearRegression

regr = LinearRegression()
regr.fit(X_train, y_train)

print("R2 score for epsilon=%.2f: %.2f" % (regr.epsilon, 
➥ r2_score(y_test, regr.predict(X_test))))

你将得到一个类似于以下 R2 分数：

> R2 score for epsilon=1.00: 0.48

3.3 差分隐私无监督学习算法

无监督学习是一种从未标记数据中学习模式的算法。在这种学习类型中，特征向量不包含类标签或响应变量。在这种情况下，目标是找到数据结构。

聚类可能是最常见的无监督学习技术，它的目的是将一组样本分组到不同的聚类中。同一聚类中的样本应该相对相似，并且与其他聚类中的样本不同（相似度度量可以是欧几里得距离）。k-means 聚类是最受欢迎的聚类方法之一，它被用于许多应用。本节将介绍 k-means 聚类的差分隐私设计，并带您了解设计过程。

3.3.1 差分隐私 k-means 聚类

我们现在将转向差分隐私无监督学习算法。我们将首先检查 k-means 聚类及其工作原理。

什么是 k-means 聚类？

在高层次上，k-means 聚类尝试将相似的项目分组或分组。假设我们有一组数据点，我们希望根据它们的相似性将它们分配到组（或聚类）中；组数用 k 表示。

k-means 有多种不同的实现，包括 Lloyd 的、MacQueen 的和 Hartigan-Wong 的 k-means。我们将查看 Lloyd 的 k-mean 算法 [7]，因为它是 k-means 最广为人知的实现。

在训练 k-means 模型过程中，算法从 k 个随机选择的质心点开始，这些点代表 k 个聚类。然后算法迭代地将样本聚类到最近的质心点，并通过计算聚类到质心点的样本的平均值来更新质心点。

让我们来看一个例子。在你的超市新鲜食品区，你会看到不同种类的水果和蔬菜。这些商品按其类型分组排列：所有的苹果都在一个地方，橙子放在一起，等等。你很快会发现它们形成组或聚类，其中每个项目都在其类型的组内，形成聚类。

实现差分隐私k-均值聚类

现在我们已经概述了k-均值聚类，接下来让我们开始探讨差分隐私k-均值聚类。这种设计遵循一种称为 DPLloyd [8]（Lloyd 的k-均值的扩展）的算法扰动策略，其中在 Lloyd 算法的迭代更新步骤中应用拉普拉斯机制（即添加拉普拉斯噪声）。本质上，它向中间质心和聚类大小添加拉普拉斯噪声，从而产生差分隐私k-均值模型。

假设k-均值聚类的每个样本是一个d-维点，并假设k-均值算法有一个预定的运行迭代次数，表示为 t。在k-均值算法的每次迭代中，计算两个值：

• 每个聚类 C[i]的样本总数，表示为 n[i]（即计数查询）

• 每个聚类 C[i]的样本总和（用于重新计算质心），表示为 s[i]（即求和查询）

然后，在k-均值中，每个样本将涉及 d ⋅ t 次求和查询和 t 次计数查询。添加或删除一个新样本将使 n[i]增加 1，这种操作可能在每次迭代中发生，因此 n[i]的敏感性是 t。假设每个样本的每个维度（即特征）的大小被限制在范围[−r,r]内。那么，通过添加或删除一个新样本，x[i]的变化将是 d ⋅ r ⋅ t。

如前所述，我们将使用算法扰动策略来设计我们的差分隐私k-均值聚类算法，其中计算计数查询和求和查询的敏感性。拉普拉斯机制（即添加拉普拉斯噪声）通过向中间质心和聚类大小添加噪声，应用于 Lloyd 算法的迭代更新步骤。图 3.10 展示了算法的伪代码，大部分都是自我解释的。

图 3.10 差分隐私k-均值聚类的工作原理

让我们在 scikit-learn 的 load_digits 数据集上训练一个k-means 聚类模型。我们将遵循 scikit-learn 给出的示例，并使用 load_digits 数据集来训练和测试一个k-means 模型。如图 3.5 所示，我们将使用几个不同的指标来评估聚类性能。评估聚类算法的性能并不像计算错误数量或监督分类算法的精确率和召回率那样简单。因此，我们将查看同质性、完整性和 V-measure 评分，以及调整后的兰德指数（ARI）和调整后的互信息（AMI）评分。请参阅 scikit-learn 文档以获取详细步骤和数学公式：scikit-learn.org/stable/modules/clustering.xhtml#clustering-evaluation。

列表 3.5 训练一个k-means 聚类模型

import numpy as np
from time import time
from sklearn import metrics
from sklearn.cluster import KMeans
from sklearn.datasets import load_digits
from sklearn.preprocessing import scale

X_digits, y_digits = load_digits(return_X_y=True)
data = scale(X_digits)

n_samples, n_features = data.shape
n_digits = len(np.unique(y_digits))
labels = y_digits

sample_size = 1000

print("n_digits: %d, \t n_samples %d, \t n_features %d"
      % (n_digits, n_samples, n_features))
> n_digits: 10,  n_samples 1797,  n_features 64

print('init\t\ttime\tinertia\thomo\tcompl\tv-meas\tARI\tAMI\tsilhouette')
> nit time inertia homo compl v-meas ARI AMI silhouette

def bench_k_means(estimator, name, data):
    t0 = time()
    estimator.fit(data)
    print('%-9s\t%.2fs\t%i\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f'
          % (name, (time() - t0), estimator.inertia_,
             metrics.homogeneity_score(labels, estimator.labels_),
             metrics.completeness_score(labels, estimator.labels_),
             metrics.v_measure_score(labels, estimator.labels_),
             metrics.adjusted_rand_score(labels, estimator.labels_),
             metrics.adjusted_mutual_info_score(labels,
             estimator.labels_),
             metrics.silhouette_score(data, estimator.labels_,
                                      metric='euclidean',
                                      sample_size=sample_size)))

我们现在将使用 scikit-learn 的本地 KMeans 函数来为我们的实验建立一个非私有的基线。我们将使用 k-means++和随机初始化：

bench_k_means(KMeans(init='k-means++', n_clusters=n_digits, n_init=100),
              name="k-means++", data=data)

bench_k_means(KMeans(init='random', n_clusters=n_digits, n_init=100),
              name="random", data=data)

结果可能看起来像图 3.11。如图所示，前面的代码涵盖了不同的结果评分指标，如同质性、完整性等。同质性、完整性和 V-measure 评分的下限是 0.0，上限是 1.0，数值越高越好。直观上，可以通过使用同质性和完整性评分来定性分析具有较差 V-measure 的聚类，以更好地确定分配过程中所犯的错误类型。对于 ARI、AMI 和轮廓系数评分，范围是-1 到 1。同样，数值越高越好。最后，较低的值通常表示两个几乎独立的标签，而接近 1 的值表示有显著的一致性。

图 3.11 比较结果：k-means++与随机初始化

现在让我们为 k-means 聚类应用差分隐私：

!pip install diffprivlib 
from diffprivlib.models import KMeans

bench_k_means(KMeans(epsilon=1.0, bounds=None, n_clusters=n_digits,
➥ init='k-means++', n_init=100), name="dp_k-means", data=data)

一旦应用了差分隐私k-means 聚类，你将看到如图 3.12 所示的结果。如图所示，dp_k-means 提供了比 k-means++和随机初始化更多样化的结果，提供了更好的隐私保障。当你比较不同评分指标的数值时，你会看到差分隐私如何影响最终结果。

图 3.12 应用差分隐私k-means 聚类后的结果比较

我们现在已经研究了几个不同差分隐私机器学习算法的设计和使用，并进行了一些实际实验。在下一节中，我们将使用差分隐私主成分分析（PCA）作为案例研究应用，并引导你了解设计差分隐私机器学习算法的过程。

3.4 案例研究：差分隐私主成分分析

在前面的章节中，我们讨论了当今应用中常用的 DP 机制以及各种差分隐私机器学习算法的设计和用法。在本节中，我们将讨论如何设计作为案例研究的差分隐私主成分分析（PCA），以向您介绍设计差分隐私机器学习算法的过程。本节的内容部分发表在我们的论文[9]中，您可以参考以获取更多详细信息。本案例研究的实现可以在本书的 GitHub 仓库中找到：github.com/nogrady/PPML/blob/main/Ch3/distr_dp_pca-master.zip。

注意：本节旨在向您介绍我们案例研究的所有数学公式和实证评估，以便您了解如何从头开始开发一个差分隐私应用。如果您目前不需要了解所有这些实现细节，您可以跳到下一章，稍后再回到这一节。

3.4.1 PCA 在水平分区数据中的隐私性

PCA 是一种统计过程，它从底层数据中计算出一个低维子空间，并生成一组新的变量，这些变量是原始变量的线性组合。它在各种数据挖掘和机器学习应用中得到了广泛应用，例如网络入侵检测、推荐系统、文本和图像处理等。

在 2016 年，Imtiaz 等人提出了一种前所未有的隐私保护分布式 PCA 协议[10]。他们的主要想法是通过聚合每个数据所有者的本地 PCA 来近似全局 PCA，其中数据所有者持有水平分区数据。然而，他们的工作存在运行时间过长和效用退化的缺点，而局部主成分无法很好地表示数据。更具体地说，他们的解决方案要求所有数据所有者都在线，并且逐个传输本地 PCA 数据。这种序列化计算使得他们的协议依赖于数据所有者的数量，这严重降低了效率和可扩展性。此外，当数据量远小于其特征数量时，局部主成分无法很好地表示主成分的效用。

数据水平分区和垂直分区的区别

在许多实际的大规模解决方案中，数据通常被划分为可以单独管理和访问的分区。分区可以提高可扩展性和性能，同时减少竞争。水平分区（通常称为分片）将行分区到具有相同模式和列的多个数据存储中。垂直分区将列分割到包含相同行的多个数据存储中。

在我们的案例研究中，我们将假设数据是水平划分的，这意味着所有数据共享相同的特征。数据所有者的数量将超过数百。我们将假设一个不可信的数据用户想要学习分布式数据的主成分。一个诚实但好奇的中间方，称为 proxy，在数据用户和数据所有者之间工作。

数据所有者同时加密自己的数据份额并将其发送给代理。代理在加密数据上运行差分隐私聚合算法，并将输出发送给数据用户。然后，数据用户从输出中计算主成分，而不了解底层数据的内容。

在我们的实验中，我们将研究所提出协议的运行时间、效用和隐私权衡，并将其与先前的工作进行比较。

“诚实但好奇”是什么意思？

通常，在通信协议中，一个诚实但好奇的对手是一个合法的参与者或用户，他不会偏离协议定义的限制，但会尝试从合法接收的消息中学习所有可能的信息。

在继续我们的协议设计之前，让我们简要回顾一下主成分分析（PCA）和同态加密的概念。

主成分分析是如何工作的

让我们快速浏览一下主成分分析（PCA）的数学公式。给定一个方阵 A，A 的一个特征向量 v 是一个非零向量，当 A 作用于它时不会改变方向，即

Av = λv

其中 λ 是一个实数标量，称为特征值。假设 A ∈ ℝ^((n×n))，那么它最多有 n 个特征向量，每个特征向量都与一个不同的特征值相关联。

考虑一个包含 N 个样本 x[1], x[2],...,x[N] 的数据集，其中每个样本有 M 个特征（x^i ∈ ）。一个中心调整的散点矩阵 计算如下，

其中 μ 是均值向量，μ = 1/N ∑^N[(i=1)]x[i]。通过在  上进行特征值分解（EVD），我们将得到 Λ 和 U，其中 Λ = diag(λ[1], λ[2],...,λ[M]) 是一个特征值对角矩阵。

这可以按绝对值非递增的顺序排列；换句话说，‖λ[1]‖ ≥ ‖λ[2]‖ ≥ ⋯ ≥ ‖λ[M]‖，U = [u[1] u[2] ... u[M] ] 是一个 M × M 矩阵，其中 u[j] 表示  的第 j 个特征向量。

在主成分分析（PCA）中，每个特征向量代表一个主成分。

同态加密是什么？

同态加密是这个工作的一个基本构建块。简单来说，它允许在加密数据上执行计算，其中生成的结果的解密与在明文上执行的操作的结果相匹配。在本节中，我们将使用 Paillier 密码系统来实现协议。

为了刷新你的记忆，Paillier 密码系统是由 Pascal Paillier 提出的一种用于公钥密码学的概率非对称算法（一种部分同态加密方案）。

让我们考虑函数 ε[pk][⋅]，它是一个具有公钥 pk 的加密方案，函数 D[sk][⋅]是一个具有私钥 sk 的解密方案。加法同态加密可以定义为

其中 ⊗ 表示加密域中的模乘法运算符，a 和 b 是明文消息。乘法同态加密定义为

由于密码系统只接受整数作为输入，实数应该被离散化。在这个例子中，我们将采用以下公式，

其中 e 是位数，min[F]，max[F]是特征 F 的最小值和最大值，x 是要离散化的实数，Discretize(e,F)取值在[0,2^((e-1))].

3.4.2 在水平划分的数据上设计差分隐私 PCA

让我们首先回顾一下我们在这里想要实现的目标（见图 3.13）。假设有 L 个数据所有者，每个数据所有者 l 有一个数据集，其中 M 是维数数量，N^l 是数据所有者 l 持有的样本数量。X^l 的横向聚合生成一个数据矩阵 X ∈ ℝ^((N×M))，其中 N = ∑^l[(i=1)]*N*i。现在假设一个数据用户想要对 X 执行 PCA。为了保护原始数据的隐私，数据所有者不会以明文形式与数据用户共享原始数据。

图 3.13 分布式 PCA 的高级概述

为了适应这一点，我们需要设计一个差分隐私分布式 PCA 协议，允许数据用户执行 PCA，但除了主成分之外，不学习任何信息。图 3.14 说明了差分隐私分布式 PCA 协议的一个设计方案。在这种情况下，假设数据所有者是诚实的，并且不会相互勾结，但假设数据用户是不可信的，并且会想要学习比主成分更多的信息。代理作为一个诚实但好奇的中间方，不会与数据用户或所有者勾结。

图 3.14 协议的设计和工作原理

为了学习 X 的主成分，需要计算 X 的散布矩阵。在提出的协议中，每个数据所有者 l 计算 X^l 的数据份额。为了防止代理学习数据，每个数据份额在发送到代理之前都会被加密。一旦代理从每个数据所有者那里收到加密的数据份额，代理就会运行差分隐私聚合算法，并将聚合结果发送给数据用户。然后数据用户从结果中构建散布矩阵并计算主成分。图 3.14 概述了这些步骤。

计算散布矩阵

让我们来看看分布式散布矩阵的计算。

假设有 L 个数据所有者，每个数据所有者 l 有一个数据集，，其中 M 是维度数，N^l 是 l 持有的样本数。每个数据所有者本地计算一个包含

其中 x[i] = [x[i1] x[i2]... x[iM]]^Te。散布矩阵 可以通过对每个数据所有者的数据份额求和来计算：

其中

分布式散布矩阵的计算允许每个数据所有者同时计算部分结果。与其它方法[10]不同，这种方法减少了数据所有者之间的依赖性，并允许它们同时发送数据份额。

设计协议

防止通过代理泄露任何可能的数据泄露至关重要，因此每个数据份额应由数据所有者加密。然后代理对收到的加密份额进行聚合。为了防止从 PCA 中进行推断，代理向聚合结果添加一个噪声矩阵，使得散布矩阵的近似满足(ϵ, δ)-DP。然后，聚合结果被发送给数据用户。

什么是(ϵ, δ)-DP？δ是另一个隐私预算参数，其中，当δ = 0 时，算法满足ϵ-DP，这比δ > 0 的(ϵ, δ)-DP 提供了更强的隐私保证。你可以在附录 A.1 中找到关于δ的更多详细信息。

这可以看作是ϵ-DP 的最一般松弛，它通过允许一个额外的微小δ概率密度来放宽定义，这个概率密度上的上界ε不成立。如果你考虑 DP 的实际应用，这会导致数据发布的困境。你不可能总是忠实于数据并保护所有个人的隐私。输出效用和隐私之间存在权衡。特别是在异常值的情况下，ε隐私发布将几乎没有效用（因为敏感性很大，导致添加了很多噪声）。

或者，你可以移除异常值或修剪它们的值以实现更合理的敏感性。这样，输出将具有更好的效用，但它不再是数据集的真实表示。

所有这些最终导致 (ϵ, δ) 隐私。数据用户解密结果，构建散点矩阵的近似，然后计算 PCA，正如你之前看到的。让我们一步一步来：

1. 数据用户为 Paillier 密码系统生成一个公钥对（pk 和 sk），并将 pk 发送给代理和数据所有者。在实践中，安全地分发密钥很重要，但在这里我们不强调这一点。

   此后，数据所有者计算份额 R^l，vl，l = 1,2,..., L，并将 ε[pk][R^{l]，ε[pk][v}l]，ε[pk][N^l] 发送到代理。

2. 在收到来自每个数据所有者的加密数据份额后，代理聚合份额并应用对称矩阵噪声以满足 DP。这个过程如图 3.15 中的算法 1 所示。

让我们看看算法 1 来了解这里发生了什么：

1. 第 2-4 行：聚合来自每个数据所有者的数据份额。

   

2. 第 5-7 行：构建噪声 ε[pk][v ']。为了防止数据用户从 v 中学习信息，代理通过将随机向量 ε[pk][b] 与 ε[pk][v] 相加来生成噪声 ε[pk][v']，使得 ε[pk][v'] = ε[pk][v] ⊗ ε[pk][b]。可以证明，v'v'^T 的元素 v'[ij] 是

   

   方程式的两边都除以 N，得到

   

   

   因此，我们有

   

   回想一下，在 Paillier 密码系统中，乘法同态性质定义为

   

   然后，ε[pk][G[ij]] 是

   

   在这一点上，我们可以通过将 b 与 N 相乘来使指数成为整数。需要注意的是，在加密过程中，代理必须学习 N。为了实现这一点，代理将 ℇ[pk][N] 发送到数据用户，数据用户在解密后以明文形式返回 N。

3. 第 8-10 行：应用对称矩阵以满足 (ϵ, δ)-DP。代理根据 DP 参数 (ϵ, δ) 生成 G’ ∈ ℝ^(M×M)，并获取 ℇ[pk][R’]，ℇ[pk][v’]，其中

   

   

   然后，将 ℇ[pk][R’]，ℇ[pk][v’] 发送到数据用户。

   在从代理收到聚合结果 ε[pk][N]，ε[pk][R’]，ε[pk][v’] 后，数据用户对每个结果进行解密并计算 。

   

   使用，数据用户可以继续计算特征向量并得到主成分。

图 3.15 算法 1：DPAggregate

分析安全性和隐私性

现在我们来确定协议是否足够安全。在我们的例子中，假设数据用户是不可信的，代理假设是诚实但好奇的。此外，我们假设代理不会与数据用户或数据所有者勾结。

为了保护数据免受代理的侵害，数据所有者加密了 R^l、vl 和 N^l。在协议执行过程中，代理只学习到明文中的 N，它不会泄露单个数据所有者的隐私。在没有与数据用户勾结的情况下，代理不能学习到 R^l、vl 和 N^l 的值。另一方面，代理将 R 和 v 与随机噪声混合，以防止数据用户获取除了主成分之外的信息。

从代理接收到的数据中，数据用户解密了ε[pk][N]、ε[pk][R’]、ε[pk][v’]，然后继续构建散点矩阵的近似值，，其中 G’是 R’携带的高斯对称矩阵。对于的后处理算法，(ϵ, δ)-DP 是封闭的。由于代理没有与数据用户勾结，数据用户不能学习 R 和 v 的值。因此，数据用户只能学习到计算出的主成分。

作为一种灵活的设计，这种方法可以与不同的对称噪声矩阵合作，以满足(ϵ, δ)-DP。为了向您展示协议，我们实现了算法 2（图 3.16）中的高斯机制。

图 3.16 算法 2：高斯机制

值得注意的是，一旦数据用户从协议中学习到私有主成分，他们可能会将这些主成分公开以供进一步使用，这将允许代理访问这些组件。在这种情况下，代理仍然没有足够的信息从完整的主成分集中恢复协方差矩阵，这意味着代理不能从发布的数据中恢复协方差矩阵的近似值。此外，数据用户可能会发布主成分的子集（前 K 个），而不是完整的组件集，这将使代理恢复协方差矩阵变得更加困难。不知道协方差矩阵的近似值，代理不能通过去除添加的噪声来推断原始数据。

3.4.3 实验评估协议的性能

我们已经讨论了所提议协议的理论背景，现在让我们实现差分隐私分布式主成分分析（DPDPCA）协议，并从效率、效用和隐私等方面对其进行评估。为了评估效率，我们将测量 DPDPCA 的运行时间效率，并将其与文献[10]中的类似工作进行比较；这将表明 DPDPCA 优于先前的工作。

此实验将使用 Python 和发布在github.com/mikeivanov/paillier的 Python Paillier 同态密码系统库进行开发。

数据集和评估方法

我们将使用六个数据集进行实验，如表 3.2 所示。Aloi 数据集是小型物体彩色图像的集合，Facebook 评论量数据集包含从 Facebook 帖子中提取的特征，而百万歌曲数据集由音频特征组成。Aloi、Facebook 和百万歌曲的基数超过 100,000，每个的维度小于 100。CNAE 数据集是从商业文档中提取的文本数据集，属性是词频。GISETTE 数据集包含用于 NIPS 2003 特征选择挑战的高度混淆的数字 4 和 9 的灰度图像。ISOLET 是一个语音字母数据集，记录了 150 个受试者的 26 个英语字母，并具有如频谱系数和轮廓特征等特征组合。所有数据集（除 Aloi 外）均来自 UCI ML 存储库，而 Aloi 来自 LIBSVM 数据集存储库。我们将通过 CNAE、GISETTE 和 ISOLET 数据集上的 SVM 分类来评估 DPDPCA 的性能。

表 3.2 实验数据集摘要

数据集	特征	基数
Aloi	29	108,000
Facebook	54	199,030
百万歌曲	90	515,345
CNAE	857	1,080
ISOLET	617	7,797
GISETTE	5,000	13,500

对于分类结果，我们将测量精确度、召回率和 F1 分数，因为数据集是不平衡的。您可以参考以下数学公式以了解这些测量的详细信息。此外，所有实验将运行 10 次，并将结果的平均值和标准差绘制在图中。

提出方法的高效性

正如我们所提到的，先前的工作存在两个主要问题：协议运行时间过长以及当局部主成分无法提供良好的数据表示时，效用下降。在本节中，我们将从这两个方面比较这两种协议。为了简洁起见，我们将所提议的协议称为“DPDPCA”，而 Imtiaz 和 Sarwate[11]所做的工作称为“PrivateLocalPCA”。

首先，我们将查看 DPDPCA 和 PrivateLocalPCA 的运行时间结果。DPDPCA 的总运行时间包括以下部分：

• 数据所有者的平均局部计算时间

• 代理中私有聚合算法的时间

• 数据用户执行 PCA 的时间

• 各方之间的数据传输时间

对于 PrivateLocalPCA，运行时间从第一个数据所有者开始，到最后一个数据所有者结束，包括局部 PCA 计算和传输时间。我们使用 I/O 操作而不是本地网络来模拟数据传输，以使通信一致且稳定。我们测量了不同数量数据所有者的协议运行时间，并且所有样本都被均匀分配到每个数据所有者。实验在一台台式机上运行（i7-5820k，64 GB 内存）。

结果如图 3.17 所示。横坐标指定数据所有者的数量，纵坐标指定运行时间（秒）。您可以看到 PrivateLocalPCA 的运行时间几乎与数据所有者的数量呈线性关系。这是因为 PrivateLocalPCA 要求将局部主成分逐个通过数据所有者传输，下一个数据所有者必须等待前一个数据所有者的结果。因此，它的时间复杂度为 O(n)，其中n是数据所有者的数量。相比之下，DPDPCA 在相同数量的数据所有者下所需时间远少于 PrivateLocalPCA。原因是，首先，分布式散度矩阵计算允许每个数据所有者同时计算他们的局部份额，其次，代理可以并行实现局部份额的聚合，其运行时间与数据所有者的数量呈对数线性关系。总的来说，DPDPCA 在数据所有者数量方面比 PrivateLocalPCA 具有更好的可扩展性。

图 3.17 DPDPCA 与 PrivateLocalPCA 的运行时间比较，∈ = 0.3

对应用程序效用的影响

接下来，我们将探讨当数据量远小于特征数量时，PrivateLocalPCA 和 DPDPCA 的效用退化。我们考虑一个场景，即每个数据所有者持有包含基数可能远小于特征数量的数据集，例如图像、音乐和电影的评分以及个人活动数据。为了模拟这种情况，我们在实验中将不同大小的样本分配给每个数据所有者。对于 PrivateLocalPCA，由于只使用了前几个主成分来表示数据，因此方差并未完全保留。

与之相反，DPDPCA 不受每个数据拥有者持有的样本数量的影响，并且局部描述性统计被汇总以构建散点矩阵。因此，总方差不会丢失。在本实验中，我们测量了关于不同数量的私有主成分的转换数据的 F1 分数。主成分的数量由每个数据拥有者对数据的排名决定。训练和测试数据被投影到一个低维空间，其中包含来自每个协议的组件。然后我们使用转换后的训练数据训练一个具有 RBF 核的 SVM 分类器，并使用未见过的数据测试分类器。为了提供真实情况，还对训练数据执行了无噪声 PCA。此外，相同的对称矩阵噪声机制[10]也被应用于 DPDPCA，以进行公平的比较。

图 3.18 显示了结果。水平轴指定每个数据拥有者持有的样本数量，垂直轴显示 F1 分数。你可以看到 DPDPCA 的 F1 分数对数据拥有者的样本数量不变，结果与无噪声 PCA 兼容，这意味着保持了高效用。相比之下，PrivateLocalPCA 的 F1 分数受到每个数据拥有者样本数量的严重影响，并且它不能仅通过少量样本来保持效用。总的来说，对于 CNAE 和 GISETTE 数据集，在所有设置下，DPDPCA 的 F1 分数都优于 PrivateLocalPCA。

图 3.18 DPDPCA 与 PrivateLocalPCA 之间的主成分效用比较，∈ = 0.5

效用与隐私之间的权衡

另一个重要的关注点是效用与隐私之间的权衡。让我们通过使用高斯机制来测量私有主成分的捕获方差来研究 DPDPCA 的权衡，其中加性噪声的标准差与∈成反比。∈越小，添加的噪声越多，获得的隐私越多。结果如图 3.19 所示，其中水平轴指定∈，垂直轴显示捕获方差的比率。在图中，你可以看到高斯机制捕获的方差在给定的∈范围内几乎保持相同的水平。此外，比率的值表明高斯机制捕获了大部分方差。

图 3.19 捕获的方差，δ = 1/N

总之，本案例研究提出了一种高度高效且可大规模扩展的 (ϵ, δ)-DP 分布式 PCA 协议，DPDPCA。正如你所见，我们考虑了数据水平分区且不可信的数据用户希望在短时间内学习分布式数据的主成分的场景。我们可以想到实际应用，例如灾害管理和应急响应。与先前的工作相比，DPDPCA 提供了更高的效率和更好的效用。此外，它还可以结合不同的对称矩阵方案来实现 (ϵ, δ)-DP。

摘要

• DP 技术通过向输入数据、算法迭代或算法输出添加随机噪声来抵抗成员推理攻击。

• 对于基于输入扰动的 DP 方法，噪声被添加到数据本身，在执行所需的非隐私计算后，输出将是差分隐私的。

• 对于基于算法扰动的 DP 方法，噪声被添加到迭代机器学习算法的中间值中。

• 基于输出扰动的 DP 方法涉及运行非隐私学习算法并向生成的模型添加噪声。

• 目标扰动 DP 方法包括向学习算法（如经验风险最小化）的目标函数添加噪声。

• 差分隐私朴素贝叶斯分类基于贝叶斯定理以及每对特征之间独立性的假设。

• 我们可以在设计差分隐私逻辑回归时采用目标扰动策略，其中向学习算法的目标函数添加噪声。

• 在差分隐私的 k-means 聚类中，拉普拉斯噪声被添加到中间质心和聚类大小中，最终产生差分隐私的 k-means 模型。

• DP 的概念可以应用于许多分布式机器学习场景，例如 PCA，以设计高度高效且可大规模扩展的 (ϵ, δ)-DP 分布式协议。

第二部分 本地差分隐私与合成数据生成

第二部分探讨了差分隐私的另一个层次，称为本地差分隐私，以及生成合成数据以确保隐私。第四章介绍了本地差分隐私的核心概念和定义。第五章探讨了本地差分隐私的更高级机制，重点关注各种数据类型和实际应用，然后提供了一个案例研究。第六章专注于为机器学习任务生成合成数据。

4 本地微分隐私在机器学习中的应用

本章涵盖

• 本地微分隐私 (LDP)

• 为 LDP 实现随机响应机制

• 用于一维数据频率估计的 LDP 机制

• 实现和实验不同 LDP 机制以处理一维数据

在前两章中，我们讨论了集中式微分隐私 (DP)，其中有一个可信的数据管理员从个人那里收集数据并应用不同的技术来获取关于人口的微分隐私统计量。然后，管理员发布关于这个人口的隐私保护统计信息。然而，当个人不完全信任数据管理员时，这些技术是不适用的。因此，为了在本地设置中满足 DP 而消除对可信数据管理员的需求，已经研究了各种技术。在本章中，我们将介绍本地 DP 版本的原理、机制和应用，即本地微分隐私 (LDP)。

本章将主要探讨如何通过查看不同的示例和实现代码来在机器学习算法中实现 LDP。在下一章中，我们还将向您介绍一个案例研究，展示如何将 LDP 应用到朴素贝叶斯分类以处理现实世界的数据集。

4.1 什么是本地微分隐私？

DP 是一个广泛接受的用于量化个人隐私的标准。在 DP 的原始定义中，有一个可信的数据管理员从个人那里收集数据并应用技术来获取不同的隐私统计量。然后，该数据管理员发布关于人口的隐私保护统计信息。我们在第二章和第三章中探讨了如何在机器学习的背景下满足 DP。然而，当个人不完全信任数据管理员时，这些技术不能应用。

已经提出了不同的技术来确保在本地设置中实现 DP 而无需可信的数据管理员。在 LDP 中，个人在通过扰动对数据进行隐私化处理后，将数据发送给数据聚合器（见图 4.1）。这些技术为个人提供了合理的否认可能性。数据聚合器收集所有扰动值并对统计量进行估计，例如人口中每个值的频率。

图 4.1 集中式与本地 DP 对比

4.1.1 本地微分隐私的概念

许多现实世界的应用，包括来自谷歌和苹果的应用，已经采用了 LDP。在我们讨论 LDP 的概念及其工作原理之前，让我们看看它是如何应用于现实世界产品的。

谷歌和苹果如何使用 LDP

2014 年，谷歌推出了随机可聚合的隐私保护序数响应（RAPPOR）[1]，这是一种从终端用户客户端软件匿名收集统计数据的技术，具有强大的隐私保障。这项技术最近已被集成到 Chrome 网络浏览器中。在过去五年中，RAPPOR 以保证 LDP 的方式处理了数十亿个每日的随机报告。这项技术旨在收集大量客户端的客户端值和字符串的统计数据，例如类别、频率、直方图和其他统计数据。对于任何报告的值，RAPPOR 为报告客户端提供强大的否认保证，严格限制由 DP 衡量的私人信息泄露，甚至对于经常报告同一值的单个客户端也是如此。

2017 年，苹果也发布了一篇关于它是如何使用 LDP 通过了解许多用户的做法来改善其产品用户体验的研究论文。例如，哪些新词正在流行，可能会提供最相关的建议？哪些网站的问题可能会影响电池寿命？哪些表情符号被选择得最频繁？苹果使用的 DP 技术源于这样一个想法：轻微的统计噪声可以在与苹果共享之前掩盖用户数据。如果许多人提交相同的数据，添加的噪声可以在大量数据点上平均，苹果可以看到有意义的信息出现。苹果详细介绍了两种在保护用户隐私的同时收集数据的技术：计数均值草图和哈达玛德计数均值草图。这两种方法都将随机信息插入正在收集的数据中。这种随机信息有效地掩盖了数据的任何识别特征，因此无法追溯到个人。

如您在这些示例中所见，LDP 通常用于均值或频率估计。在调查（或类似调查的问题）中进行频率估计是利用 LDP 在日常应用中最常见的方法之一。例如，公司、组织和研究人员经常使用调查来分析行为或评估思想和观点，但由于隐私原因，从个人那里收集研究信息具有挑战性。个人可能不相信数据收集者不会共享敏感或私人信息。尽管个人可以匿名参与调查，但有时仍然可以通过提供的信息识别出这个人。另一方面，尽管进行调查的人更感兴趣的是调查答案的分布，而不是特定个人的信息，但在涉及敏感信息时，他们很难赢得调查参与者的信任。这就是 LDP 发挥作用的地方。

LDP 的详细说明

现在你已经对 LDP 的使用有了背景知识，让我们来看看细节。LDP 是在数据收集者不可信时衡量个人隐私的一种方式。LDP 旨在保证当个人提供值时，识别原始值应该具有挑战性，这提供了隐私保护。许多 LDP 机制还旨在尽可能准确地根据从所有个人收集到的扰动数据的聚合来估计人口分布。

图 4.2 说明了 LDP 的典型用法。首先，每个个人（数据所有者）生成或收集自己的数据，例如调查答案或个人数据。然后，每个个人使用特定的 LDP 机制（我们将在第 4.2 节中讨论）在本地扰动他们的数据。扰动后，每个个人将他们的数据发送给数据收集者，数据收集者将执行数据聚合和统计或模型估计。最后，估计的统计数据或模型将被发布。根据这样的发布信息推断个人的数据将极其困难（如 LDP 定义所保证的）。

图 4.2 展示了局部差分隐私的工作原理

LDP 表明，对于任何使用ϵ-LDP 机制的发布估计统计数据或模型，数据收集者（或任何公共领域的其他对手）通过区分两个输入值（即个人的数据）的概率至多为 e^(-ϵ)。

协议 P 满足 ϵ-LDP，如果对于任何两个输入值 v[1] 和 v[2] 以及 P 的输出空间中的任何输出 o，我们有

其中 Pr[⋅] 表示概率。Pr[P(v[1]) = o] 是给定输入 v[1] 到 P，它输出 o 的概率。定义中的 ϵ 参数是隐私参数或隐私预算。它有助于调整定义提供的隐私量。小的 ϵ 值要求 P 在给定相似输入时提供非常相似的输出，因此提供更高的隐私级别；大的 ϵ 值允许输出之间的相似性更少，因此提供更少的隐私。例如，如图 4.3 所示，对于小的 ϵ 值，给定一个扰动值 o，它几乎同样可能是由任何输入值产生的，即在这个例子中的 v[1] 或 v[2]。通过这种方式，仅仅通过观察输出，就很难推断出其对应的输入；因此，数据隐私得到了保证。

图 4.3 展示了 ϵ-LDP 的工作原理。给定一个扰动值 o，它几乎同样可能是由任何输入值产生的——在这个例子中是 v[1] 或 v[2]。

我们现在已经讨论了 LDP 的概念和定义，并探讨了它与集中式 DP 的不同之处。在介绍任何 LDP 机制之前，让我们先看看一个我们将应用 LDP 的场景。

一个包含调查的 LDP 场景

通过像 SurveyMonkey 这样的工具在线调查或社交网络测验中回答问题，现在是一种普遍的做法。LDP 可以在这些调查的答案离开数据所有者之前保护这些答案。在本章中，我们将使用以下场景来展示 LDP 机制的设计和实现。

假设公司 A 想要确定其客户（针对定向广告活动）的分布。它进行了一次调查，样本调查问题可能如下所示：

• 你已婚吗？

• 你的职业是什么？

• 你多大了？

• 你的种族类别是什么？

然而，这些问题非常敏感且私密。为了鼓励其客户参与调查，公司 A 应在进行调查的同时，尽可能保持其客户估计分布的准确性，并提供隐私保证。

并不出奇，LDP 是公司可以使用的几种技术之一。有几种不同的 LDP 机制可以处理不同的场景（例如，数据类型、数据维度等）。例如，对于“你已婚吗？”这个问题，答案只是一个分类的二进制结果：“是”或“否”。随机响应机制适合解决此类场景。另一方面，对于“你的职业是什么？”和“你的种族类别是什么？”这两个问题，答案仍然是分类的，但将是可能答案集合中的单个项目。对于此类场景，直接编码和一元编码机制会更好。此外，对于像“你多大了？”这样的问题，答案是数值的，所有答案的汇总看起来像直方图。在这种情况下，我们可以使用直方图编码。

在简单概述了 LDP 如何在实践中使用之后，我们将通过介绍如何设计和实现适用于不同调查问题的不同 LDP 机制来解决的实际场景来介绍 LDP 的工作原理。我们将从最直接的 LDP 机制——随机响应开始。

4.1.2 随机响应用于本地差分隐私

如第二章所述，随机响应（二进制机制）是最古老和最简单的 DP 机制之一，但它也满足 LDP。在本节中，你将学习如何使用随机响应来设计和实现一个用于保护二进制调查隐私的 LDP 解决方案。

假设我们想要调查一组人，以确定 50 岁以上的人数。每个个体将被问及，“你超过 50 岁了吗？”从每个个体收集到的答案将是“是”或“否”。答案被视为对调查问题的二元响应，其中我们对每个“是”答案给出二元值 1，对每个“否”答案给出二元值 0。因此，最终目标是通过对个体发送的作为其答案的 1 的数量进行计数，来确定超过 50 岁的人数。我们如何使用随机响应机制来设计和实现一个局部差分隐私调查来收集这个简单的“是”或“否”问题的答案？

接下来是隐私保护。如列表 4.1 所示，每个个体将根据算法以真实答案或提供随机答案进行响应。因此，个人的隐私将得到很好的保护。此外，由于每个个体将以 0.75 的概率（即 1/2 + 1/4 = 0.75）提供真实答案，以 0.25 的概率提供错误答案，因此将有更多个体提供真实答案。因此，我们将保留足够的基本信息来估计人口统计分布（即 50 岁以上的人数）。

列表 4.1 基于随机响应的算法

def random_response_ages_adult(response):
    true_ans = response > 50

    if np.random.randint(0, 2) == 0:            ❶
        return true_ans                         ❷
    else:
        return np.random.randint(0, 2) == 0     ❸

❶ 抛掷第一枚硬币。

❷ 返回真实答案。

❸ 抛掷第二枚硬币并返回随机答案。

让我们在列表 4.2 中展示的美国人口普查数据集上实现并测试我们的算法。在下一节中，我们将讨论更多实际用例，但现在我们将使用人口普查数据集来演示您如何估计汇总值。

列表 4.2 玩转美国人口普查数据集

import numpy as np
import matplotlib.pyplot as plt

ages_adult = np.loadtxt("https://archive.ics.uci.edu/ml/machine-
➥ learning-databases/adult/adult.data", usecols=0, delimiter=", ")

total_count = len([i for i in ages_adult]) 
age_over_50_count= len([i for i in ages_adult if i > 50]) 

print(total_count)
print(age_over_50_count)
print(total_count-age_over_50_count)

输出结果如下：

32561
6460
26101

如您所见，美国人口普查数据集中有 32,561 个个体：6,460 个个体超过 50 岁，26,101 个个体低于或等于 50 岁。

现在我们来看看如果我们将我们的基于随机响应的算法应用于相同的应用程序会发生什么。

列表 4.3 数据扰动

perturbed_age_over_50_count = len([i for i in ages_adult 
➥ if random_response_ages_adult(i)]) 
print(perturbed_age_over_50_count)
print(total_count-perturbed_age_over_50_count)

结果如下：

11424
21137

如您所见，应用我们的随机响应算法后，50 岁以上个体的扰动数量变为 11,424，50 岁以下或等于 50 岁的个体扰动数量为 21,137。在这个结果中，50 岁以上的人数仍然少于 50 岁以下或等于 50 岁的人数，这与原始数据集的趋势一致。然而，这个结果，11,424，似乎与我们想要估计的实际结果 6,460 有些差距。

现在的问题是，如何根据我们的基于随机响应的算法和迄今为止的结果来估计 50 岁以上实际人数。显然，直接使用 1 或“是”的值并不能精确估计实际值。

为了精确估计 50 岁以上人数的实际值，我们应该考虑基于随机回答的算法中随机性的来源，并估计来自实际上 50 岁以上的人的 1 的数量，以及来自随机回答结果的 1 的数量。在我们的算法中，每个人以 0.5 的概率说实话，并以 0.5 的概率再次进行随机回答。每次随机回答将以 0.5 的概率产生 1 或“是”。因此，个人仅基于随机性（而不是因为他们实际上超过 50 岁）回答 1 或“是”的概率是 0.5 × 0.5 = 0.25。因此，正如你所见，我们总共有 1 或“是”值的 25%是错误肯定回答。

另一方面，由于硬币的第一次翻转，我们将说实话的人和随机回答的人分开。换句话说，我们可以假设两组中 50 岁以上的人数大致相同。因此，50 岁以上的人数大约是说实话的人组中 50 岁以上人数的两倍。

现在我们知道了问题，我们可以使用以下实现来估计 50 岁以上总人数。

列表 4.4 数据聚合和估计

answers = [True if random_response_ages_adult(i) else False 
➥ for i in ages_adult ]                                       ❶

def random_response_aggregation_and_estimation(answers):       ❷
    false_yesses = len(answers)/4                              ❸

    total_yesses = np.sum([1 if r else 0 for r in answers])    ❹

    true_yesses = total_yesses - false_yesses                  ❺

    rr_result = true_yesses*2                                  ❻
    return rr_result

estimated_age_over_50_count = 
➥ random_response_aggregation_and_estimation(answers)
print(int(estimated_age_over_50_count))
print(total_count-int(estimated_age_over_50_count))

❶ 扰动

❷ 数据聚合和估计

❸ 预计有四分之一（0.25）的回答是 1 或肯定回答，这些来自随机回答（由抛硬币产生的错误肯定回答）。

❹ 收到的肯定回答总数

❺ 真正的肯定回答数是总肯定回答数与错误肯定回答数之差。

❻ 因为真正的肯定回答估计了说实话的组中肯定回答的总数，所以肯定回答的总数可以估计为真正肯定回答的两倍。

你将得到以下输出：

6599
25962

现在我们对 50 岁以上人数的估计更加精确。估计有多接近？相对误差仅为（6599 - 6460）/ 6460 = 2.15%。我们的基于随机回答的算法似乎在估计 50 岁以上人数方面做得很好。此外，根据我们在第二章的分析，该算法的隐私预算是ln(3)（即ln(3) ≈ 1.099）。换句话说，我们的算法满足ln(3)-LDP。

在本节中，我们通过设计和实现一个隐私保护的二选一调查应用，回顾了在 LDP 背景下随机回答机制。正如你所见，随机回答机制仅擅长处理基于单个二进制问题的难题，即“是”或“否”问题。

在实践中，大多数问题或任务并非仅仅是“是”或“否”的问题。它们可能涉及从有限集合中选择值（例如“你的职业是什么？”）或返回数据集的直方图（例如一组人的年龄分布）。我们需要更通用和高级的机制来解决这类问题。在下一节中，我们将介绍更多常见的 LDP 机制，这些机制可以在更广泛和复杂的情况下使用。

4.2 本地差分隐私的机制

我们已经讨论了 LDP 的概念和定义，以及它是如何通过随机响应机制来工作的。在本节中，我们将讨论一些在更通用和复杂场景下常用的 LDP 机制。这些机制也将作为下一章案例研究中 LDP 机器学习算法的构建块。

4.2.1 直接编码

随机响应机制适用于具有 LDP 的二进制（是或否）问题。但对于有多个答案的问题怎么办？例如，如果我们想确定美国人口普查数据集中每个职业的人数，该怎么做？职业可能包括销售、工程、金融、技术支持等。已经提出了相当数量的不同算法来解决在本地差分隐私模型中的这个问题[2]，[3]，[4]。在这里，我们将从一个最简单的机制开始，称为直接编码。

在一个需要利用 LDP 的问题中，第一步是定义不同答案的域。例如，如果我们想了解美国人口普查数据集中每个职业的人数，域将是数据集中可用的职业集合。以下列出了人口普查数据集中的所有职业。

列表 4.5 每个职业领域的数量

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import sys
import io
import requests
import math

req = requests.get("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data").content             ❶
adult = pd.read_csv(io.StringIO(req.decode('utf-8')), 
➥ header=None, na_values='?', delimiter=r", ")
adult.dropna()
adult.head()

domain = adult[6].dropna().unique()                 ❷
domain.sort()
domain

❶ 加载数据。

❷ 领域

结果将如下所示：

array(['Adm-clerical', 'Armed-Forces', 'Craft-repair', 'Exec-managerial',
       'Farming-fishing', 'Handlers-cleaners', 'Machine-op-inspct',
       'Other-service', 'Priv-house-serv', 'Prof-specialty',
       'Protective-serv', 'Sales', 'Tech-support', 'Transport-moving'],
      dtype=object)

如我们在上一节所讨论的，LDP 机制通常包含三个功能：编码，用于编码每个答案；扰动，用于扰动编码后的答案；以及聚合和估计，用于聚合扰动后的答案并估计最终结果。让我们为直接编码机制定义这三个功能。

在直接编码机制中，通常不需要对输入值进行编码。我们可以使用每个输入在域集中的索引作为其编码值。例如，“Armed-Forces”是域的第二个元素，因此“Armed-Forces”的编码值是 1（索引从 0 开始）。

列表 4.6 应用直接编码

def encoding(answer):
    return int(np.where(domain == answer)[0])

print(encoding('Armed-Forces'))     ❶
print(encoding('Craft-repair'))
print(encoding('Sales'))
print(encoding('Transport-moving'))

❶ 测试编码。

列表 4.6 的输出将如下所示：

1
2
11
13

如前所述，“Armed-Forces”被分配值为 1，“Craft-repair”被分配值为 2，依此类推。

图 4.4 直接编码的扰动

我们的下一步是扰动。让我们回顾直接编码的扰动（如图 4.4 所示）。每个人以以下概率正确报告他们的值 v：

或者他们以 d - 1 个剩余值的概率报告其中一个

其中 d 是域集的大小。

例如，在我们的例子中，由于美国人口普查数据集中列出了 14 种不同的职业，域集的大小是 d = 14。如列表 4.7 所示，如果我们选择 ϵ = 5.0，则 p = 0.92 和 q = 0.0062，这将以更高的概率输出实际值。如果我们选择 ϵ = 0.1，则 p = 0.078 和 q = 0.071，这将以更低的概率生成实际值，从而提供更多的隐私保障。

列表 4.7 直接编码中的扰动算法

def perturbation(encoded_ans, epsilon = 5.0):
    d = len(domain)                                           ❶
    p = pow(math.e, epsilon) / (d - 1 + pow(math.e, epsilon))
    q = (1.0 - p) / (d - 1.0)

    s1 = np.random.random()
    if s1 <= p:
        return domain[encoded_ans]                            ❷
    else:
        s2 = np.random.randint(0, d - 1)
        return domain[(encoded_ans + s2) % d]

print(perturbation(encoding('Armed-Forces')))                 ❸
print(perturbation(encoding('Craft-repair')))
print(perturbation(encoding('Sales')))
print(perturbation(encoding('Transport-moving')))
print()

print(perturbation(encoding('Armed-Forces'), epsilon = .1))   ❹
print(perturbation(encoding('Craft-repair'), epsilon = .1))
print(perturbation(encoding('Sales'), epsilon = .1))
print(perturbation(encoding('Transport-moving'), epsilon = .1))

❶ 域集的大小

❷ 以概率 p 返回自身

❸ 测试扰动，epsilon = 5.0。

❹ 测试扰动，epsilon = .1。

输出将看起来如下：

Armed-Forces
Craft-repair
Sales
Transport-moving

Other-service
Handlers-cleaners
Farming-fishing
Machine-op-inspct

让我们尝试理解这里发生了什么。当你将 epsilon 值设置为 5.0（查看输出中的前四个结果）时，你将以很高的概率得到实际值。在这种情况下，准确率为 100%。然而，当你将 epsilon 设置为一个更小的数字（在这种情况下为 0.1）时，算法将以更低的概率生成实际值；因此，隐私保障更好。从输出中的后四个结果可以看出，我们得到了不同的职业作为结果。您可以在代码中尝试分配不同的 epsilon 值，以查看它如何影响最终结果。

让我们看看在将扰动应用于调查问题“你的职业是什么？”的答案后会发生什么。

列表 4.8 扰动后直接编码的结果

perturbed_answers = pd.DataFrame([perturbation(encoding(i)) 
➥ for i in adult_occupation])
perturbed_answers.value_counts().sort_index()

应用直接编码后的结果将看起来像这样：

Adm-clerical         3637
Armed-Forces          157
Craft-repair         3911
Exec-managerial      3931
Farming-fishing      1106
Handlers-cleaners    1419
Machine-op-inspct    2030
Other-service        3259
Priv-house-serv       285
Prof-specialty       4011
Protective-serv       741
Sales                3559
Tech-support         1021
Transport-moving     1651

现在我们有了扰动结果，让我们将它们与实际结果进行比较。

列表 4.9 实际结果与扰动值的比较

adult_occupation = adult[6].dropna()         ❶
adult_occupation.value_counts().sort_index()

❶ 每个职业类别的从业人员数量

这些是每个职业类别人数的实际结果：

Adm-clerical         3770
Armed-Forces            9
Craft-repair         4099
Exec-managerial      4066
Farming-fishing       994
Handlers-cleaners    1370
Machine-op-inspct    2002
Other-service        3295
Priv-house-serv       149
Prof-specialty       4140
Protective-serv       649
Sales                3650
Tech-support          928
Transport-moving     1597

为了清晰起见，让我们将结果并排比较，如图 4.1 所示。可以看出，与实际值相比，一些扰动答案的聚合误差非常高。例如，对于职业为“Armed-Forces”的人数，扰动值为 157，但实际值为 9。

表 4.1 扰动前后每个职业的人数

数量	职业	人数
原始值	扰动后
1	Adm-clerical	3770
2	Armed-Forces	9
3	Craft-repair	4099
4	Exec-managerial	4066
5	农业-渔业	994
6	处理员-清洁工	1370
7	机械操作检查员	2002
8	其他服务	3295
9	私人住宅服务	149
10	专业教授	4140
11	保护服务	649
12	销售	3650
13	技术支持	928
14	运输移动	1597

为了克服这些错误，我们需要一个聚合和估计函数，以及直接编码机制。在聚合和估计过程中，当聚合器从 n 个个体收集扰动值时，它将估计每个职业 I ∈ {1,2,...,d } 的频率如下：首先，c[i] 是 i 被报告的次数。在人口中值 i 的估计出现次数为 E[i] = (c[i] - n ⋅q)/(p - q)。为了确保估计的数值始终为非负值，我们设 E[i] = max(E[i], 1)。你可以尝试实现列表 4.10 来查看其工作原理。

列表 4.10 将聚合和估计应用于直接编码

def aggregation_and_estimation(answers, epsilon = 5.0):
    n = len(answers)
    d = len(domain)
    p = pow(math.e, epsilon) / (d - 1 + pow(math.e, epsilon))
    q = (1.0 - p) / (d - 1.0)

    aggregator = answers.value_counts().sort_index()

    return [max(int((i - n*q) / (p-q)), 1) for i in aggregator]  

estimated_answers = aggregation_and_estimation(perturbed_answers)    ❶
list(zip(domain, estimated_answers))

❶ 数据聚合和估计

你将得到以下类似的结果作为输出：

[('Adm-clerical', 3774),
 ('Armed-Forces', 1),
 ('Craft-repair', 4074),
 ('Exec-managerial', 4095),
 ('Farming-fishing', 1002),
 ('Handlers-cleaners', 1345),
 ('Machine-op-inspct', 2014),
 ('Other-service', 3360),
 ('Priv-house-serv', 103),
 ('Prof-specialty', 4183),
 ('Protective-serv', 602),
 ('Sales', 3688),
 ('Tech-support', 909),
 ('Transport-moving', 1599)]

使用这个结果，让我们将估计结果与表 4.2 中所示的实际结果进行比较。如图所示，当使用隐私预算 x = 5.0 时，直接编码机制的估计结果比使用扰动结果的精度要高得多。你可以尝试更改此代码中的隐私预算或将其应用于其他数据集以查看其工作情况。

表 4.2 每个职业的人数，聚合和估计前后

数量	职业	人数
原始值	聚合和估计后
1	行政-文职	3770
2	武装部队	9
3	手工艺-修理	4099
4	执行-管理	4066
5	农业-渔业	994
6	处理员-清洁工	1370
7	机械操作检查员	2002
8	其他服务	3295
9	私人住宅服务	149
10	专业教授	4140
11	保护服务	649
12	销售	3650
13	技术支持	928
14	运输移动	1597

你现在已经看到了一个使用直接编码的 LDP 机制。这些步骤可以总结为以下三个组件：

• 编码：直接编码（二进制随机响应的推广）

• 扰动： 用于 ε-LDP

• 估计： 其中 q = (1 - p)/(>d - 1)

4.2.2 直方图编码

直接编码机制使我们能够将 LDP 应用于分类和离散问题。相比之下，直方图编码使我们能够将 LDP 应用于数值和连续数据。

考虑一个具有数值和连续答案的调查问题。例如，假设有人想知道一组人群中年龄的分布或直方图，而这无法通过直接编码实现。他们可以开展调查，询问每个人一个问题：“你的年龄是多少？”让我们以美国人口普查数据集为例，绘制人群年龄的直方图。

列表 4.11 使用人群年龄绘制直方图

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import sys
import io
import requests
import math

req = requests.get("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data").content                   ❶
adult = pd.read_csv(io.StringIO(req.decode('utf-8')), 
➥ header=None, na_values='?', delimiter=r", ")
adult.dropna()
adult.head()

adult_age = adult[0].dropna()                             ❷
ax = adult_age.plot.hist(bins=100, alpha=1.0)

❶ 加载数据。

❷ 人群的年龄

输出将类似于图 4.5 中的直方图，表示每个年龄类别中的人数。正如您所看到的，最多的人数在 20 到 40 岁的年龄范围内，而在其他值中报告的人数较少。直方图编码机制旨在处理此类数值和连续数据。

图 4.5 来自美国人口普查数据集的人群年龄直方图

我们首先需要定义输入域（即调查答案）。在这里，我们假设所有参加调查的人的年龄将在 10 到 100 岁之间。

列表 4.12 调查人群年龄的输入域

domain = np.arange(10, 101)    ❶
domain.sort()
domain

❶ 域的范围在 10 到 100 之间。

因此，域将看起来像这样：

array([ 10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,
        23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,
        36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
        49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,
        62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,
        75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,
        88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98,  99, 100])

在直方图编码中，个人将他们的值 v 编码为一个长度-d 的向量 [0.0,0.0,...,0.0,1.0,0.0,...,0.0]，其中只有 v 个分量是 1.0，其余分量是 0.0。例如，假设总共有 6 个值（{1,2,3,4,5,6}），即 d = 6，实际要编码的值是 6。在这种情况下，直方图编码将输出向量 ({0.0,0.0,0.0,0.0,0.0,1.0})，其中向量的第六位是 1.0，其他所有位置都是 0.0（见图 4.6）。

图 4.6 直方图编码的工作原理

下面的列表展示了编码函数的实现。

列表 4.13 直方图编码

def encoding(answer):
    return [1.0 if d == answer else 0.0 for d in domain]

print(encoding(11))                                           ❶

answers = np.sum([encoding(r) for r in adult_age], axis=0)    ❷
plt.bar(domain, answers)

❶ 测试输入年龄 11 的编码。

❷ 数据编码图

列表 4.13 的输出如下，直方图结果如图 4.7 所示：

[0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

图 4.7 编码年龄的直方图

数据所有者通过向编码值中的每个分量添加 Lap(2/ϵ) 来扰动他们的值，其中 Lap(2/ϵ) 是来自拉普拉斯分布的样本，均值为 0，尺度参数为 2/ϵ。如果您需要复习拉普拉斯分布及其性质，请回顾第 2.1.2 节。

当数据聚合器收集所有扰动值后，聚合器有两种估计方法可供选择：

• 直方图编码求和（SHE）

• 直方图编码阈值（THE）

直方图编码求和（SHE）

直方图编码求和（SHE）计算个人报告的所有值的总和。为了估计人口中值 i 的发生次数，数据聚合器将所有报告值中的 i 个分量求和。

以下列表显示了使用 SHE 进行扰动的实现。

列表 4.14 使用直方图编码的求和

def she_perturbation(encoded_ans, epsilon = 5.0):
    return [she_perturb_bit(b, epsilon) for b in encoded_ans]

def she_perturb_bit(bit, epsilon = 5.0):
    return bit + np.random.laplace(loc=0, scale = 2 / epsilon)

print(she_perturbation(encoding(11)))                         ❶
print()

print(she_perturbation(encoding(11), epsilon = .1))           ❷

she_estimated_answers = np.sum([she_perturbation(encoding(r)) 
➥ for r in adult_age], axis=0)                               ❸
plt.bar(domain, she_estimated_answers)

❶ 测试扰动，ε = 5.0。

❷ 测试扰动，ε = .1。

❸ 数据扰动、聚合和估计

列表 4.14 的输出如下，图 4.8 显示了结果的直方图。

[0.4962679135705772, 0.3802597925066964, -0.30259173228948666, 
   ➥ -1.3184657393652501, ......, 0.2728526263450592, 
   ➥ 0.6818717669557512, 0.5099963270758622, 
   ➥ -0.3750514505079954, 0.3577214398174087]

[14.199378030914811, 51.55958531259166, -3.168607913723072, 
   ➥ -14.592805035271969, ......, -18.342283098694853, 
   ➥ -33.37135136829752, 39.56097740265926, 
   ➥ 15.187624540264636, -6.307239922495188, 
   ➥ -18.130661553271608, -5.199234599011756]

图 4.8 使用 SHE 估计年龄的求和

从图 4.8 中可以看出，使用 SHE 估计的值与图 4.7 中原始编码直方图的形状相似。然而，图 4.8 中的直方图是使用估计函数生成的。这些估计值中存在噪声，因此它们不是真实的，并且可能导致负值。对于这个例子，负年龄频率是无效的，因此我们可以丢弃这些值。

使用直方图编码的阈值处理（THE）

在使用直方图编码（THE）进行阈值处理的情况下，数据聚合器将所有大于阈值θ的值设置为 1，其余值设置为 0。然后它估计人口中的i数量为E[i] = (c[i] - n ⋅ q)/(p - q)，其中p = 1 − 1/2e^((ϵ⋅(1-θ)/2))，q = e^((ϵ⋅(0-θ)/2))，而c[i]是应用阈值后所有报告值中第i个分量的 1 的数量。

以下列表显示了使用 THE 进行扰动的实现。

列表 4.15 使用直方图编码的阈值处理

def the_perturbation(encoded_ans, epsilon = 5.0, theta = 1.0):
    return [the_perturb_bit(b, epsilon, theta) for b in encoded_ans]

def the_perturb_bit(bit, epsilon = 5.0, theta = 1.0):
    val = bit + np.random.laplace(loc=0, scale = 2 / epsilon)

    if val > theta:
        return 1.0
    else:
        return 0.0

print(the_perturbation(encoding(11)))                                     ❶
print()

print(the_perturbation(encoding(11), epsilon = .1))                       ❷

the_perturbed_answers = np.sum([the_perturbation(encoding(r)) 
➥ for r in adult_age], axis=0)                                           ❸
plt.bar(domain, the_perturbed_answers)
plt.ylabel('Frequency')
plt.xlabel('Ages')

def the_aggregation_and_estimation(answers, epsilon = 5.0, theta = 1.0):  ❹
    p = 1 - 0.5 * pow(math.e, epsilon / 2 * (1.0 - theta))
    q = 0.5 * pow(math.e, epsilon / 2 * (0.0 - theta))

    sums = np.sum(answers, axis=0)
    n = len(answers)

    return [int((i - n * q) / (p-q)) for i in sums]  

❶ 测试扰动，ε = 5.0。

❷ 测试扰动，ε = .1。

❸ 总扰动

❹ THE—聚合和估计

对于不同的ε值，输出将如下所示。图 4.9 显示了 THE 估计函数前的总扰动。

[0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

[1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]

图 4.9 使用 THE 扰动答案的直方图

估计值可以通过以下代码片段获得：

# Data aggregation and estimation
the_perturbed_answers = [the_perturbation(encoding(r)) for r in adult_age]
estimated_answers = the_aggregation_and_estimation(the_perturbed_answers)
plt.bar(domain, estimated_answers)
plt.ylabel('Frequency')
plt.xlabel('Ages')

输出的直方图显示在图 4.10 中。THE 的估计值与图 4.7 中原始编码直方图的形状相似。

图 4.10 阈值估计年龄

总结来说，直方图编码使我们能够对数值和连续数据应用 LDP，我们讨论了在直方图编码下的 LDP 的两个估计机制：SHE 和 THE。SHE 汇总了所有用户报告的噪声直方图，而 THE 将阈值以上的每个噪声计数解释为 1，阈值以下的每个计数解释为 0。当你将直方图编码与直接编码进行比较时，你会发现当域集大小d变大时，直接编码的方差更大。使用 THE，通过固定ε，你可以选择一个θ值以最小化方差。这意味着 THE 可以通过限制大量噪声的影响来提高 SHE 的估计：

• 使用直方图编码的求和（SHE）：

  • 编码：Encode(v) = [0.0, 0.0,...,1.0,...,0.0]，其中只有 v 个分量是 1.0。

  • 扰动：将 Lap(2/ε) 添加到每个分量。

  • 估计：将所有个人报告的噪声直方图的总和。

• 历史编码阈值（THE）：

  • 编码：Encode(v) = [0.0, 0.0,...,1.0,...,0.0]，其中只有 v 个分量是 1.0。

  • 扰动：将 Lap(2/ε) 添加到每个分量。将值 > θ 设置为 1，其余值设置为 0。

  • 估计：，其中 和 。

4.2.3 一元编码

一元编码机制是一种更通用且高效的 LDP 机制，适用于分类和离散问题。在此方法中，个人将他们的值 v 编码为一个长度-d 的二进制向量 [0, ..., 1, ..., 0]，其中只有 v 位是 1，其余位是 0。然后，对于编码向量中的每个位，如果输入位是 1，他们将以概率 p 正确报告值，以概率 1 - p 错误报告。否则，他们可以以概率 1 - q 正确报告，以概率 q 错误报告。

在一元编码中，我们再次有两个不同的选项进行操作：

• 对称一元编码（SUE）

• 最优一元编码（OUE）

在对称一元编码的情况下，p 被选为 ，而 q 被选为 1 - p。在最优一元编码中，p 被选为 1/2，而 q 被选为 1/(e^ε + 1)。然后数据聚合器估计人口中 1 的数量为 E[i] = (c[i] - m ∙ q)/(p - q)，其中 c[i] 表示所有报告值中第 i 位的 1 的数量。

作为一元编码机制的示例，假设有人想确定不同种族的人数。他们需要询问每个人，“你的种族是什么？”让我们尝试在 US Census 数据集上实现 SUE。OUE 的实现将是 SUE 实现的扩展，需要对实现中 p 和 q 的定义进行更改。（您也可以参考我们代码仓库中的 OUE 示例实现。）

首先，让我们加载数据并检查领域。

列表 4.16 在数据集中检索不同的种族类别

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import sys
import io
import requests
import math

req = requests.get("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data").content               ❶
adult = pd.read_csv(io.StringIO(req.decode('utf-8')), 
➥ header=None, na_values='?', delimiter=r", ")
adult.dropna()
adult.head()

domain = adult[8].dropna().unique()                   ❷
domain.sort()
domain

❶ 加载数据。

❷ 领域

列表 4.16 的输出将如下所示

array(['Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other',
       'White'], dtype=object)

如您所见，数据集中有五种不同的种族。

现在，让我们看看美国人口普查数据集中不同种族的实际人数。

列表 4.17 每个种族的人数

adult_race = adult[8].dropna()
adult_race.value_counts().sort_index()

这里是数据集中实际数字的输出：

Amer-Indian-Eskimo      311
Asian-Pac-Islander     1039
Black                  3124
Other                   271
White                 27816

如您所见，我们类别“美洲印第安人-爱斯基摩人”中有 311 人，类别“亚洲-太平洋岛民”中有 1,039 人，等等。

现在，让我们看看 SUE 机制的实现。

列表 4.18 对称单值编码

def encoding(answer):
    return [1 if d == answer else 0 for d in domain]

print(encoding('Amer-Indian-Eskimo'))       ❶
print(encoding('Asian-Pac-Islander'))
print(encoding('Black'))
print(encoding('Other'))
print(encoding('White'))

❶ 测试编码。

你应该得到以下类似的输出：

[1, 0, 0, 0, 0]
[0, 1, 0, 0, 0]
[0, 0, 1, 0, 0]
[0, 0, 0, 1, 0]
[0, 0, 0, 0, 1]

正如我们在本节开头讨论的那样，想法是每个个体将他们的值v编码为一个长度d的二进制向量[0,...,1,...,0]，其中只有v位是 1，其余位是 0。

下面的列表显示了如何实现 SUE 机制的扰动。它主要是一目了然的。

列表 4.19 对称单值编码的扰动

def sym_perturbation(encoded_ans, epsilon = 5.0):                        ❶
    return [sym_perturb_bit(b, epsilon) for b in encoded_ans]

def sym_perturb_bit(bit, epsilon = 5.0):
    p = pow(math.e, epsilon / 2) / (1 + pow(math.e, epsilon / 2))
    q = 1 - p

    s = np.random.random()
    if bit == 1:
        if s <= p:
            return 1
        else:
            return 0
    elif bit == 0:
        if s <= q:
            return 1
        else: 
            return 0

print(sym_perturbation(encoding('Amer-Indian-Eskimo')))                  ❷
print(sym_perturbation(encoding('Asian-Pac-Islander')))
print(sym_perturbation(encoding('Black')))
print(sym_perturbation(encoding('Other')))
print(sym_perturbation(encoding('White')))
print()

print(sym_perturbation(encoding('Amer-Indian-Eskimo'), epsilon = .1))    ❸
print(sym_perturbation(encoding('Asian-Pac-Islander'), epsilon = .1))
print(sym_perturbation(encoding('Black'), epsilon = .1))
print(sym_perturbation(encoding('Other'), epsilon = .1))
print(sym_perturbation(encoding('White'), epsilon = .1))

❶ 对称单值编码—扰动

❷ 测试扰动，epsilon = 5.0。

❸ 测试扰动，epsilon = .1。

列表 4.19 的输出将如下所示：

[1, 0, 0, 0, 0]
[0, 1, 0, 0, 0]
[0, 0, 1, 0, 0]
[0, 0, 0, 1, 0]
[0, 0, 0, 0, 1]

[1, 1, 0, 0, 1]
[0, 1, 1, 0, 1]
[1, 0, 1, 0, 0]
[1, 0, 0, 0, 1]
[1, 0, 0, 0, 1]

这显示了两组向量，类似于我们在早期机制中拥有的。第一组是 epsilon 分配为 5.0，另一组是 epsilon 分配为 0.1。

现在我们可以测试它以查看扰动的答案：

sym_perturbed_answers = np.sum([sym_perturbation(encoding(r)) 
➥ for r in adult_race], axis=0)
list(zip(domain, sym_perturbed_answers))

你将得到类似的结果：

[('Amer-Indian-Eskimo', 2851),
 ('Asian-Pac-Islander', 3269),
 ('Black', 5129),
 ('Other', 2590),
 ('White', 26063)]

记住，这些只是扰动后的值。我们还没有完成！

接下来是 SUE 机制的聚合和估计。

列表 4.20 对称单值编码的估计

def sym_aggregation_and_estimation(answers, epsilon = 5.0):                ❶
    p = pow(math.e, epsilon / 2) / (1 + pow(math.e, epsilon / 2))
    q = 1 - p

    sums = np.sum(answers, axis=0)
    n = len(answers)

    return [int((i - n * q) / (p-q)) for i in sums]  

sym_perturbed_answers = [sym_perturbation(encoding(r)) for r in adult_race]❷
estimated_answers = sym_aggregation_and_estimation(sym_perturbed_answers)
list(zip(domain, estimated_answers))

❶ 对称单值编码—聚合和估计

❷ 数据聚合和估计

估计的最终值将如下所示：

[('Amer-Indian-Eskimo', 215),
 ('Asian-Pac-Islander', 1082),
 ('Black', 3180),
 ('Other', 196),
 ('White', 27791)] 

现在你已经知道了 SUE 是如何工作的。让我们将实际值和估计值并排比较，看看差异是什么样子。如果你仔细查看表 4.3，你会理解 SUE 在这种类型的分类数据上工作得更好。

表 4.3 在应用 SUE 之前和之后每个种族的人数

数字	种族	人数
原始值	应用 SUE 后
1	美洲印第安人-爱斯基摩人	311
2	亚洲-太平洋岛民	1039
3	黑人	3124
4	其他	271
5	白人	27816

在本节中，我们介绍了两种具有单值编码的 LDP 机制：

• 对称单值编码（SUE）：

  • 编码：Encode(v) = [0, 0, ..., 1, ..., 0]，其中只有v位是 1。

  • 扰动：每个位都像在二元随机响应机制中那样扰动。对于ε-LDP。

  • 估计：对于每个值，使用二元随机响应机制中的估计公式。

• 优化的单值编码（OUE）：

  • 编码：Encode(v) = [0, 0, ..., 1, ..., 0]，其中只有v位是 1。

  • 扰动：p = 1/2，q = 1/(e^ε + 1)（如图 4.11 所示）。

  • 估计：。

图 4.11 优化单值编码的扰动

本章主要关注不同 LDP 机制的工作方式，特别是对于一维数据。在第五章中，我们将扩展我们的讨论，看看我们如何使用更高级的机制来处理多维数据。

摘要

• 与集中式 DP 不同，LDP 消除了对可信数据管理者的需求；因此，个人可以在使用扰动技术对数据进行隐私化处理后，将其发送给数据聚合器。

• 在许多实际应用场景中，LDP 用于均值或频率估计。

• 随机响应机制也可以通过设计和实现隐私保护算法与 LDP 结合使用。

• 虽然直接编码有助于我们为分类和离散数据应用 LDP，但直方图编码可以用于应用 LDP 到数值和连续变量。

• 当数据聚合器收集扰动值时，聚合器有两种估计方法可供选择：使用直方图编码（SHE）的求和和阈值处理（THE）。

• 使用直方图编码（SHE）的求和计算个人报告的所有值的总和。

• 在使用直方图编码（THE）进行阈值处理的情况下，数据聚合器将所有大于阈值 θ 的值设置为 1，其余的值设置为 0。

• 单值编码机制是一种更通用且高效的 LDP 机制，适用于分类和离散问题。

5 适用于机器学习的高级 LDP 机制

本章涵盖

• 高级 LDP 机制

• 使用朴素贝叶斯进行机器学习分类

• 使用 LDP 朴素贝叶斯处理离散特征

• 使用 LDP 朴素贝叶斯处理连续特征和多维数据

• 设计和分析 LDP 机器学习算法

在上一章中，我们探讨了局部微分隐私（LDP）的基本概念和定义，以及其底层机制和一些示例。然而，大多数这些机制都是专门为处理一维数据和频率估计技术而设计的，包括直接编码、直方图编码、一元编码等。在本章中，我们将进一步扩展我们的讨论，并探讨如何处理多维数据。

首先，我们将介绍一个使用朴素贝叶斯分类的机器学习（ML）用例示例。然后，我们将通过设计和分析一个 LDP ML 算法来探讨 LDP 朴素贝叶斯案例研究的实现。

5.1 局部微分隐私快速回顾

正如我们在上一章所讨论的，当数据收集者不可信时，LDP 是一种衡量个人隐私的方式。LDP 的目标是确保当个人提供特定值时，难以识别该个人，从而提供隐私保护。许多 LDP 机制还旨在尽可能准确地估计人群的分布，基于从多个个体收集的扰动数据的聚合。

图 5.1 总结了在不同应用场景中应用 LDP 的步骤。有关 LDP 如何工作的更多信息，请参阅第四章。

图 5.1 LDP 的工作原理：每个数据所有者对其数据进行局部扰动，并将其提交给聚合器。

现在我们已经回顾了 LDP 的工作原理，让我们来看看一些更高级的 LDP 机制。

5.2 高级 LDP 机制

在第四章中，我们探讨了直接编码、直方图编码和一元编码 LDP 机制。这些算法都适用于一维分类数据或离散数值数据。例如，调查问题“你的职业是什么？”的答案将是一个职业类别，这是一维分类数据。调查问题“你的年龄是多少？”的答案将是一个一维离散数值。然而，许多其他数据集，尤其是在处理机器学习任务时，更为复杂，包含多维连续数值数据。例如，基于像素的图像通常是高维的，而移动设备传感器数据（如陀螺仪或加速度计传感器）是多维的，通常是连续的数值数据。因此，了解在机器学习任务中处理此类场景的 LDP 机制至关重要。

在本节中，我们将关注三种为多维连续数值数据设计的不同机制：Laplace 机制、Duchi 机制和分段机制。

5.2.1 LDP 的 Laplace 机制

在第二章中，我们介绍了用于集中式差分隐私的 Laplace 机制。我们可以类似地实现用于 LDP 的 Laplace 机制。不过，首先，让我们回顾一些基础知识。

为了简单起见，让我们假设 LDP 机制中的每个参与者是 u[i]，并且每个 u[i] 的数据记录是 t[i]。这个 t[i] 通常是一个在-1 到 1 范围内的单维数值（如前一章所述），我们可以用数学表示为 t[i] ∈ [-1,1]^d。然而，在本节中，我们将讨论多维数据，因此 t[i] 可以定义为在-1 到 1 范围内的 d-维数值向量，即 t[i] ∈ [-1, 1]^d。此外，我们将使用 Laplace 机制扰动 t[i]，因此我们将让 t[i]^* 表示应用 LDP 后 t[i] 的扰动数据记录。

在掌握了这些基础知识之后，我们现在可以深入探讨 LDP 的 Laplace 机制。假设我们有一个参与者 u[i]，他们的数据记录是 t[i] ∈ [-1,1]^d。记住，这个数据记录现在是多维的。为了满足 LDP，我们需要扰动这个数据记录，在这种情况下，我们将使用来自 Laplace 分布的噪声。我们将定义一个随机函数 t[i]^* = t[i] + Lap(2 * d/ϵ) 来生成一个扰动值 t[i]^*，其中 Lap(λ) 是来自尺度为 λ 的 Laplace 分布的随机变量。

小贴士：当你提到差分隐私时，为什么我们总是关注 Laplace 机制？原因在于高斯扰动并不总是令人满意，因为它们不能用来实现纯 DP（ϵ-DP），这需要重尾分布。因此，最流行的分布是 Laplace 机制，其尾部“恰到好处”，可以用来实现纯 DP。

以下列表展示了实现 LDP 的 Laplace 机制的 Python 代码。

列表 5.1 LDP 的 Laplace 机制

def getNoisyAns_Lap(t_i, epsilon):
    loc = 0
    d = t_i.shape[0]
    scale = 2 * d / epsilon
    s = np.random.laplace(loc, scale, t_i.shape)
    t_star = t_i + s
    return t_star

Laplace 机制为 LDP 扰动多维连续数值数据提供了基本功能。然而，如 Wang 等人[1]所研究，当使用较小的隐私预算 ϵ（即，ϵ < 2.3）时，Laplace 机制往往会导致扰动数据中更多的方差，从而提供较差的效用性能。在下一节中，我们将探讨 Duchi 机制，它在使用较小的隐私预算时表现更好。

5.2.2 LDP 的 Duchi 机制

虽然 Laplace 机制是生成用于 LDP 扰动的噪声的一种方法，但 Duchi 等人[2]介绍了一种另一种方法，称为 Duchi 机制，用于扰动多维连续数值数据以实现 LDP。这个概念与 Laplace 机制类似，但数据处理方式不同。

让我们先看看 Duchi 机制是如何处理一维数值数据的扰动的。给定一个参与者 u[i]，他们的一个维数据记录 t[i] ∈ [-1,1]，以及隐私预算 ϵ，Duchi 机制执行如下：

1. 从 中采样一个伯努利变量 u。

2. 然后，如果 u = 1，扰动的数据将是 ；否则，它是 。

3. 扰动的数据 将是 Duchi 机制的输出。

该算法的 Python 实现如下所示。

列表 5.2 Duchi 的一维数据机制

def Duchi_1d(t_i, eps, t_star):
    p = (math.exp(eps) - 1) / (2 * math.exp(eps) + 2) * t_i + 0.5
    coin = np.random.binomial(1, p)
    if coin == 1:
        return t_star[1]
    else:
        return t_star[0]

伯努利分布是什么？

在概率论中，伯努利分布是理解起来最简单的分布之一，它经常被用作更复杂分布的构建块。从高层次来看，伯努利分布是一个只有随机变量两个可能值的离散概率分布，其中它以概率 p 取值为 1，以概率 q = 1 - p 取值为 0。

简单来说，如果一个实验只有两种可能的结果，“成功”和“失败”，并且如果 p 是成功的概率，那么

在这种情况下，我们通常将“成功”视为我们想要跟踪的结果。

现在你已经知道了 Duchi 机制在一维数据上的工作原理，让我们将其扩展到多维数据。给定一个 d-维数据记录 t[i] ∈ [-1,1]^d 和隐私预算 ϵ，Duchi 机制的多维数据执行如下：

1. 通过独立地从以下分布中采样每个 v[A[j]]，生成一个随机的 d-维数据记录 v ∈ [-1,1]^d。

   

   v[A[j]] 表示 v 的第 j 个值。

2. 定义 T^{+（相应地，*T*}-）为所有数据记录 t ^* ∈ {-B, B}^d 的集合，使得 t^* ⋅ v ≥ 0（相应地，t^* ⋅ v ≤ 0），其中我们得到

   

   

3. 从 中采样一个伯努利变量 u。

4. 最后，如果 u = 1，输出从 T^+ 中均匀选择的数据记录；否则，输出从 T^- 中均匀选择的数据记录。

以下列表显示了该算法的 Python 实现。如果你仔细遵循我们刚才讨论的步骤，你会很快理解代码中的操作。

列表 5.3 Duchi 的多维数据机制

def Duchi_md(t_i, eps):
    d = len(t_i)
    if d % 2 != 0:
        C_d = pow(2, d - 1) / comb(d - 1, (d - 1) / 2)
    else:
        C_d = (pow(2, d - 1) + 0.5 * comb(d, d / 2)) / comb(d - 1, d / 2)

    B = C_d * (math.exp(eps) + 1) / (math.exp(eps) - 1)
    v = []
    for tmp in t_i:
        tmp_p = 0.5 + 0.5 * tmp
        tmp_q = 0.5 - 0.5 * tmp
        v.append(np.random.choice([1, -1], p=[tmp_p, tmp_q]))
    bernoulli_p = math.exp(eps) / (math.exp(eps) + 1)
    coin = np.random.binomial(1, bernoulli_p)

    t_star = np.random.choice([-B, B], len(t_i), p=[0.5, 0.5])
    v_times_t_star = np.multiply(v, t_star)
    sum_v_times_t_star = np.sum(v_times_t_star)
    if coin == 1:
        while sum_v_times_t_star <= 0:
            t_star = np.random.choice([-B, B], len(t_i), p=[0.5, 0.5])
            v_times_t_star = np.multiply(v, t_star)
            sum_v_times_t_star = np.sum(v_times_t_star)
    else:
        while sum_v_times_t_star > 0:
            t_star = np.random.choice([-B, B], len(t_i), p=[0.5, 0.5])
            v_times_t_star = np.multiply(v, t_star)
            sum_v_times_t_star = np.sum(v_times_t_star)
return t_star.reshape(-1)

当使用较小的隐私预算（即，ϵ < 2.3）时，Duchi 机制表现良好。然而，当使用较大的隐私预算时，它在效用方面不如拉普拉斯机制。是否可能存在一个更通用的算法，无论隐私预算是较小还是较大，都能表现良好？我们将在下一节中查看分段机制。

5.2.3 LDP 的分段机制

到目前为止，在本章中你已经学习了可用于 LDP 的机制。第三种机制，称为分段机制[1]，已被提出用于处理在使用 LDP 时多维连续数值数据，并且它可以克服拉普拉斯和 Duchi 机制的缺点。其思路是对多维数值进行扰动，并具有渐近最优误差界限。因此，每个个体只需报告一个比特给数据聚合器。

首先，让我们看看一维数据的分段机制。给定参与者 u[i] 的一维数据记录 t[i] ∈ [-1,1] 和隐私预算 ϵ，分段机制执行如下：

1. 在 0 到 1 的范围内选择一个值 x，均匀随机。

2. 如果 ，我们从 [l(t[i]), r(t[i])] 中均匀随机抽取 t[i]^；否则，我们从 [-C, l(t[i]) ∪ r(t[i]), C] 中均匀随机抽取 t[i]^，其中

   

   

   和

   

3. 扰动数据 t[i]^* ∈{-C,C} 将是分段机制的输出。

分段机制由三部分组成：中心部分、右侧部分 r() 和左侧部分 l()。中心部分计算为 t[i]* ∈ [l(t[i]), r(t[i])]，最右侧部分为 t[i]* ∈ [r(t[i]),C]，最左侧部分为 t[i]* ∈ [-C, l(t[i])]。你可以在下面的列表中看到一个该算法的 Python 实现。

列表 5.4 一维数据的分段机制

def PM_1d(t_i, eps):
    C = (math.exp(eps / 2) + 1) / (math.exp(eps / 2) - 1)
    l_t_i = (C + 1) * t_i / 2 - (C - 1) / 2
    r_t_i = l_t_i + C - 1

    x = np.random.uniform(0, 1)                              ❶
    threshold = math.exp(eps / 2) / (math.exp(eps / 2) + 1)
    if x < threshold:
        t_star = np.random.uniform(l_t_i, r_t_i)
    else:
        tmp_l = np.random.uniform(-C, l_t_i)
        tmp_r = np.random.uniform(r_t_i, C)
        w = np.random.randint(2)
        t_star = (1 - w) * tmp_l + w * tmp_r

    return t_star

❶ 在 uniform() 中提供大小参数将产生一个 ndarray。

我们如何处理多维数据？我们可以简单地将分段机制从其一维版本扩展到处理多维数据。给定一个 d-维数据记录 t[i] ∈ [-1,1]^d 和隐私预算 ϵ，多维数据的分段机制执行如下：

1. 从 {1, 2, ..., d} 中均匀无放回地抽取 k 个值，其中

   

2. 对于每个采样的值 j，将 t[i][A[j]] 和 作为分段机制的一维版本的输入，并得到一个噪声值 x[i,j]。

3. 输出 t[i]^*，其中。

以下列表展示了该算法的 Python 实现。

列表 5.5 多维数据的分段机制

def PM_md(t_i, eps):
    d = len(t_i)
    k = max(1, min(d, int(eps / 2.5)))
    rand_features = np.random.randint(0, d, size=k)
    res = np.zeros(t_i.shape)
    for j in rand_features:
        res[j] = (d * 1.0 / k) * PM_1d(t_i[j], eps / k)
    return res

现在我们已经研究了多维数值数据的三个高级 LDP 机制，让我们来看一个案例研究，展示如何使用真实世界的数据集实现 LDP。

5.3 实现 LDP 朴素贝叶斯分类的案例研究

在上一章中，我们介绍了一系列可以用来实现 LDP 协议的机制。在本节中，我们将以 LDP 朴素贝叶斯分类设计作为一个案例研究，来讲解设计 LDP 机器学习算法的过程。本节内容部分已发表在我们的研究论文[3]中。本案例研究的实现和完整代码可以在github.com/nogrady/PPML/tree/main/Ch5找到。

注意：本节将向您介绍本案例研究的数学公式和实证评估，以便您可以从零开始学习如何开发 LDP 应用。如果您目前不需要了解这些实现细节，您可以跳到下一章。

5.3.1 使用朴素贝叶斯进行机器学习分类

在 3.2.1 节中，您学习了差分隐私朴素贝叶斯分类的工作原理及其数学公式。在本节中，我们将扩展讨论，探讨如何使用 LDP 结合朴素贝叶斯。正如前一章所述，LDP 涉及个人在通过扰动对数据进行隐私化后，将数据发送给数据聚合器。这些技术为个人提供了合理的否认可能性。数据聚合器随后收集所有扰动值并估计诸如人口中每个值的频率等统计数据。

为了保证在分类任务中提供训练数据的个人的隐私，可以在数据收集阶段使用 LDP 技术。在本章中，我们将应用 LDP 技术到朴素贝叶斯分类器上，这些分类器是基于贝叶斯定理的一组简单概率分类器。为了快速回顾，朴素贝叶斯分类器假设每对特征之间相互独立。最重要的是，这些分类器具有高度的可扩展性，特别适合特征数量多或训练数据量小的情况。尽管朴素贝叶斯分类器很简单，但它通常可以比更复杂的分类方法表现得更好或接近。

现在我们来详细探讨一下。给定一个新实例（一个已知的类别值），朴素贝叶斯计算每个类别标签的条件概率，然后将最大似然类标签分配给给定的实例。其想法是，使用贝叶斯定理和特征独立性的假设，每个条件概率可以分解为几个概率的乘积。我们需要使用训练数据计算这些概率，以实现朴素贝叶斯分类。由于训练数据必须通过保护隐私从个人那里收集，我们可以利用 LDP 频率和统计估计方法从个人那里收集扰动数据，然后使用朴素贝叶斯分类估计条件概率。

在这个案例研究中，我们首先将探讨如何使用 LDP 朴素贝叶斯分类器处理离散特征，同时保持类别标签和特征之间的关系。其次，我们将讨论连续特征的情况。我们将讨论如何对数据进行离散化，并在向数据添加拉普拉斯噪声以满足 LDP 后应用高斯朴素贝叶斯。我们还将向您展示如何处理连续数据的扰动方法。最后，我们将通过一系列实验场景和真实数据集来探索和实现这些技术，展示如何在保持分类器准确性的同时，LDP 保证是如何得到满足的。

离散特征与连续特征

离散变量是两个值之间具有可数个值的数值变量。离散变量始终是数值的。例如，缺陷部件的数量或错过付款的数量可以被视为离散值。

相比之下，连续变量是两个值之间具有无限个值的数值变量。连续变量可以是数值的，也可以是日期/时间，例如部件的长度或收到付款的日期/时间。

然而，我们有时会根据应用的不同，将离散数据视为连续数据，将连续数据视为离散数据。

5.3.2 使用具有离散特征的 LDP 朴素贝叶斯

在深入理论之前，让我们先来看一个例子。一个独立分析师想要训练一个机器学习分类器来预测“一个人错过抵押贷款支付的可能性”。想法是使用来自不同抵押贷款和金融公司的数据，训练一个模型，并使用这个模型来预测未来客户的行为了。问题是，没有任何一家金融公司愿意参与，因为他们不想分享他们客户的私人或敏感信息。对他们来说，最好的选择是分享他们数据的扰动版本，这样就能保护客户的隐私。但如何扰动数据，使其可以用于训练朴素贝叶斯分类器同时保护隐私呢？这正是我们要弄清楚的问题。

我们在第 3.2.1 节中讨论了朴素贝叶斯分类的工作原理，所以这里我们只回顾一下关键点。更多细节请参阅第三章。

在概率论中，贝叶斯定理描述了基于与事件可能相关的前置知识的事件概率。它表述如下：

基于贝叶斯定理和每对特征之间独立性的假设，朴素贝叶斯分类技术使用贝叶斯定理。假设要分类的实例是 n-维向量 X = {x[1], x[2], ..., x[n]}，特征的名称是 F[1], F[2], ..., F[n]，可以分配给实例的可能类别是 C = {C[1], C[2], ..., C[k]}。朴素贝叶斯分类器将实例 X 分配到类别 C[s]，当且仅当 P(C[s]|X) > P(C[j]|X) 对于 1 ≤ j ≤ k 且 j ≠ s。因此，分类器需要计算所有类别的 P(C[j]|X) 并比较这些概率。使用贝叶斯定理，概率 P(C[j]|X) 可以计算如下

由于 P(X) 对于所有类别都是相同的，因此找到具有最大 P(X|C[j]) ∙ P(C[j]) 的类别就足够了。

让我们首先考虑所有特征都是数值和离散的情况。假设有 m 个不同的记录或个人（在这些金融公司中）可以用来训练这个分类器。表 5.1 显示了我们在第三章中讨论的抵押贷款支付数据集的一个摘录。

表 5.1 来自抵押贷款支付数据集的一个摘录。年龄、收入和性别是独立变量，而错过付款代表预测任务中的因变量。

编号	年龄	收入	性别	是否错过付款（是或否）
1	年轻	低	男	是
2	年轻	高	女	是
3	中等	高	男	否
4	老年	中等	男	否
5	老年	高	男	否
6	老年	低	女	是
7	中等	低	女	否
8	中等	中等	男	是
9	年轻	低	男	否
10	老年	高	女	否

我们的目的是使用这些数据来训练一个分类器，该分类器可以用来预测未来的客户，并确定特定客户是否有可能错过抵押贷款付款。因此，在这种情况下，分类任务是预测客户的行为（他们是否会错过抵押贷款付款），这使得它成为二元分类——我们只有两个可能的类别。

就像我们在第三章中所做的那样，让我们将这两个类别定义为 C[1] 和 C[2]，其中 C[1] 表示错过前一次付款，而 C[2] 表示其他情况。根据表 5.1 中报告的数据，这些类别的概率可以按以下方式计算：

同样，我们可以计算条件概率。表 5.2 总结了我们在第三章中计算的年龄特征的已计算条件概率。

表 5.2 计算的年龄特征条件概率总结

条件概率	结果
P(Age = Young	C[1])P(Age = Young
P(Age = Medium	C[1])P(Age = Medium
P(Age = Old	C[1])P(Age = Old

一旦我们有了所有条件概率，我们就可以预测例如一个收入中等的年轻女性是否会错过付款。为此，首先我们需要将 X 设置为 X = (Age = Young, Income = Medium, Gender = Female)。第三章介绍了使用朴素贝叶斯分类器的剩余步骤和计算，如果需要可以参考。

基于这些计算的结果，朴素贝叶斯分类器将为实例 X 分配 C[2]。换句话说，一个收入中等的年轻女性不会错过付款。

和

在了解了朴素贝叶斯分类器如何工作的基本原理之后，让我们看看如何使用之前讨论过的 LDP 频率估计方法来计算朴素贝叶斯分类器所需的概率。记住，在 LDP 中，数据聚合器负责计算类别概率 P(C[j]) 对于类别 C = {C[1], C[2], ..., C[k]} 中的所有类别，以及对于所有可能的 x[i] 值的条件概率 P(F[i] = x[i]|C[j])。

假设某个个体的数据，爱丽丝的数据，是 (a[1], a[2], ..., a[n])，并且她的类别标签是 C[v]。为了满足 LDP，她需要准备她的输入并对其进行扰动。让我们看看爱丽丝的数据如何准备和扰动，以及数据聚合器如何估计类别概率和条件概率。

计算类别概率

对于计算类别概率，由于爱丽丝的类别标签是 C[v]，她的输入变为 v ∈ {1, 2, ..., k}。然后爱丽丝对她的值 v 进行编码和扰动，并向数据聚合器报告。我们可以使用之前讨论过的任何 LDP 频率估计方法。同样，其他个人也会向数据聚合器报告他们扰动的类别标签。

数据聚合器收集所有扰动的数据，并估计每个值 j ∈ {1, 2, ..., k} 的频率为 E[j]。现在，概率 P(C[j]) 被估计为

让我们通过一个例子来使问题更清晰。在表 5.1 的示例数据集中，类别标签只有两种选择：缺失付款或未缺失付款。假设 Alice 有缺失付款。那么 Alice 的输入v变为 1，并报告给数据聚合器。同样，如果她没有缺失付款，她将报告 2 作为她的输入给数据聚合器。图 5.2 显示了三个人向数据聚合器提交他们的扰动值。然后数据聚合器估计每个值的频率并计算类别概率。

图 5.2 展示如何计算类别概率的示例

计算条件概率

为了估计条件概率P(F[i] = x[i]|C[j])，直接报告特征值是不够的。为了计算这些概率，必须保留类别标签和特征之间的关系，这意味着个体需要使用特征值和类别标签的组合来准备他们的输入。

我们将F[i]的可能值的总数设为n[i]。如果 Alice 在第i个维度的值是a[i] ∈ {1, 2, ..., n[i]}，并且她的类别标签值是v ∈ {1, 2, ..., k}，那么 Alice 对特征F[i]的输入变为v[i] = (a[i] - 1)∙k + v。因此，每个个体都会在她的第i个特征的[1, k∙n[i]]范围内计算她的输入。

这有点难以理解，不是吗？但别担心。让我们通过一个例子来看看。例如，假设表 5.1 中的年龄值被枚举为（年轻 = 1），（中等 = 2），（老年 = 3）。对于这个年龄特征，个人的输入可以是 1 到 6 之间的任何值，如表 5.3 所示，其中 1 表示年龄年轻且存在缺失付款，而 6 表示年龄老年且没有缺失付款。

表 5.3 准备输入作为特征值和类别标签的组合

类别标签与特征之间的关系	枚举值
(年龄 = 年轻 | C[1])	1
(年龄 = 年轻 | C[2])	2
(年龄 = 中等 | C[1])	3
(年龄 = 中等 | C[2])	4
(年龄 = 老年 | C[1])	5
(年龄 = 老年 | C[2])	6

你可能已经注意到，在表 5.2 中每一行都有一个输入值。同样，收入的可能输入值有 6 个，性别的可能输入值有 4 个。在确定她的第i个特征的输入后，Alice 会对她的值v[i]进行编码和扰动，并将扰动后的值报告给数据聚合器。为了估计F[i]的条件概率，数据聚合器通过估计具有值y ∈ {1, 2, ..., n[i]}和类别标签z ∈ {1, 2, ..., k}的个体的频率E[y,z]，来估计输入(y - 1)∙ k + z的频率。因此，条件概率P(F[i] = x[i]|C[j])被估计为

对于表 5.3 中的示例，为了估计概率 P(Age = Medium|C[2])，数据聚合器估计了 2、4 和 6 的频率为 E[1,2]、E[2,2] 和 E[3,2]。然后，P(Age = Medium|C[2]) 可以估计为

值得注意的是，为了有助于计算类概率和条件概率，每个个体可以准备 n + 1 个输入（即，Alice 的 {v, v[1], v[2], ..., v[n]}），这些输入可以在扰动后报告。然而，报告相互依赖的多个值通常会降低隐私级别。因此，每个个体只报告一个输入值。

最后，当数据聚合器估计一个值，例如 E[j] 或 E[(y,z)] 时，估计值可能是负数。我们可以将所有负估计值设为 1，以获得一个有效且合理的概率。

使用 LDP 与多维数据

上述频率和均值估计方法仅适用于一维数据。但如果我们有更高维度的数据呢？如果个体拥有的数据是多维的，使用这些方法报告每个值可能会因为特征之间的依赖性而导致隐私泄露。

为了达到这个目的，可以使用三种常见的方法与 n-维数据一起使用：

• 方法 1—如果噪声与维度 n 成比例缩放，则可以使用 LDP 与拉普拉斯机制（在第三章中讨论）一起使用。因此，如果个体的输入是 V = (v[1], ..., v[n])，且对所有 i ∈ {1, ..., n}，v[i] ∈ [-1,1]，则个体可以在添加 Lap(2n/ε) 后报告每个 v[i]。然而，如果维度 n 较高，这种方法不适用，因为大量的噪声会降低准确性。

• 方法 2—我们可以利用第 5.2.3 节中描述的 Piecewise 机制。Piecewise 机制可以用 LDP 协议扰动多维数值。

• 方法 3—数据聚合器可以从每个个体请求一个扰动输入以满足 ϵ-LDP。每个个体可以随机均匀选择要报告的输入，或者数据聚合器可以将个体分成 n 组，并从每组请求不同的输入值。结果，每个特征大约由 m/n 个个体报告。当个体数量 m 相对于特征数量 n 较高时，这种方法是合适的。否则，由于每个特征的报告值数量较低，准确性会降低。

现在我们已经了解了多维数据如何与 LDP 一起工作，让我们看看 LDP 在连续数据朴素贝叶斯分类中的细节。

5.3.3 使用具有连续特征的 LDP 朴素贝叶斯

到目前为止，我们已经看到了如何应用 LDP（拉普拉斯离散化）来处理离散特征。现在我们将探讨如何将相同的概念应用于连续特征。在朴素贝叶斯分类中，对于连续数据，LDP 可以采用两种不同的方法：

• 我们可以将连续数据离散化，并应用上一节中概述的离散朴素贝叶斯解决方案。在这种情况下，连续数值数据被分为桶，使其有限且离散。每个个体在离散化后都会扰动其输入。

• 数据聚合器可以使用高斯朴素贝叶斯来估计概率。

让我们从第一种方法，离散朴素贝叶斯开始。

离散朴素贝叶斯

对于离散朴素贝叶斯，我们需要将连续数据离散化，并使用 LDP 频率估计技术来估计频率。基于连续域内的已知特征，数据聚合器确定桶的区间以对域进行离散化——可以使用等宽离散化（EWD）或等宽分箱（EWB）来等分域。EWD 计算每个桶的宽度为 (max - min)/n[b]，其中 max 和 min 是最大和最小特征值，n[b] 是期望的桶数。在第 5.3.4 节中，我们将使用 EWD 方法在一些实验中进行离散化。

什么是等宽分箱？

通常，分箱是一种数据预处理方法，通过将原始数据值分为称为“桶”的小区间来最小化小观察误差的影响。然后，原始值被替换为该桶计算出的一个一般值。基本上，分箱方法将数值变量转换为分类对应物，但不使用目标（或类别）信息。在较小数据集的情况下，这有更好的机会减少过拟合。

将数据分为桶有两种基本方法：

• 等频分箱 (EFB) —在这种情况下，所有桶具有相同的频率。

  • 示例输入数据：[0,4,12,16,16,18,24,26,28]

  • 分箱 1：[0,4,12]

  • 分箱 2：[16,16,18]

  • 分箱 3：[24,26,28]

• 等宽分箱 (EWB) —在这种情况下，数据被分为大小相等的区间，其中区间（或宽度）定义为 w = (max - min)/(number of bins)。

  • 示例输入数据：[0,4,12,16,16,18,24,26,28]

  • 分箱 1：[0,4]

  • 分箱 2：[12,16,16,18]

  • 分箱 3：[24,26,28]

当数据聚合器与个体共享区间时，每个个体将他们的连续特征值离散化，并应用类似于我们讨论的 LDP 朴素贝叶斯离散特征的程序。数据聚合器也会使用与 LDP 朴素贝叶斯离散数据相同的程序来估计概率。每个个体应只报告一个扰动值以确保 ϵ-LDP。如您所见，通过分箱进行离散化是一种数据预处理方法。实际的隐私保护是通过离散朴素贝叶斯实现的。

高斯朴素贝叶斯

对于连续数据的第二种方法是使用高斯朴素贝叶斯。在这种情况下，最常见的方法是假设数据呈正态分布。对于 LDP 高斯朴素贝叶斯，计算类别概率与离散特征相同。为了计算条件概率，数据聚合器需要具有每个特征在给定类别标签下的训练值的均值和方差。换句话说，为了计算 P(F[i] = x[i]|C[j])，数据聚合器需要使用具有类别标签 C[j] 的个体的 F[i] 值来估计均值 μ[(i,j)] 和方差 σ²[i,j]。这意味着特征与类别标签之间的关联必须保持（类似于离散朴素贝叶斯分类器）。

我们已经讨论了均值估计过程，但要同时计算均值 μ[(i,j)] 和方差 σ²[i,j]，数据聚合器可以将个体分为两组。一组通过扰动他们的输入并与数据聚合器共享来为均值估计（即 μ[(i,j)]) 贡献。另一组通过扰动他们输入的平方并与之共享来为平方均值（即 μ^S[i,j]）的估计做出贡献。

让我们考虑另一个例子。假设鲍勃有一个类别标签 C[j] 和一个特征 F[i]，其值为 b[i]。我们还可以假设每个特征的域被归一化，使其值介于 [-1,1] 之间。如果鲍勃属于第一组，他会向他的值 b[i] 添加拉普拉斯噪声，从而获得扰动后的特征值 b'[i]。当数据聚合器收集到第一组具有类别标签 C[j] 的个体扰动后的特征值时，它会计算扰动特征值的平均值，这给出了均值 μ[(i,j)] 的估计，因为个体添加的噪声平均值是 0。第二组可以采用类似的方法。如果鲍勃属于第二组，他会向他的平方值 b²[i] 添加噪声，以获得 *b^{(2')*[i]，并将其与数据聚合器共享。同样，数据聚合器会计算平方均值（μ}S[i,j]）的估计。最后，方差 σ²[i,j] 可以通过 μ^S[i,j] - (μ[i,j])² 来计算。再次强调，每个个体在扰动后只报告他们的一个值或值的平方，因为它们是相关的。

到目前为止，概率的计算是清晰且直接的。但你注意到当我们计算平均值和方差时，个体的类别标签并没有从数据聚合器那里隐藏吗？我们如何隐藏原始的类别标签？

为了克服这个问题并隐藏类别标签，我们可以采用以下方法：假设鲍勃正在报告一个与类别 C[j] 相关的特征值 F[i] = b[i]，其中 j ∈ {1,2, ..., k}。首先，他构建一个长度为 k 的向量，其中 k 是类别标签的数量。该向量初始化为零，除了对应于第 j 个类别标签的第 j 个元素，它被设置为特征值 b[i]。之后，向量的每个元素都像往常一样被扰动（即，通过添加拉普拉斯噪声）并贡献给数据聚合器。由于甚至在向量的零元素上也添加了噪声，数据聚合器将无法推断出实际的类别标签或实际值。

对于估计每个类别的实际平均值（以及平方值的平均值），数据聚合器只需要像往常一样计算扰动值的平均值，然后除以该类的概率。为了理解为什么我们需要这样做，假设一个类别 j 的概率为 P(C[j])。因此，对于特征 F[i]，只有 P(C[j]) 的个体在其输入向量的第 j 个元素中有实际值，而其余比例（1 - P(C[j])) 有零。因此，在围绕实际平均值的噪声相互抵消后，围绕零的噪声也相互抵消，我们将得到 P(C[j]) × μ[(i,j)] = 观测 (偏移) 平均值。之后，我们可以通过 P(C[j]) 来除以观测平均值以获得估计的平均值。同样的方法适用于平方值的平均值，因此也适用于计算方差。

5.3.4 评估不同 LDP 协议的性能

现在我们已经了解了理论，是时候讨论不同 LDP 协议的实现策略和实验评估结果了。这些实验基于从 UCI 机器学习仓库 [4] 获得的数据集。表 5.4 总结了实验中使用的数据集。

表 5.4 实验中使用的数据集摘要

数据集名称	实例数量	特征数量	类别标签数量
车辆评估	1,728	6	4
国际象棋	3,196	36	2
蘑菇	8,124	22	2
四子棋	67,557	42	3
澳大利亚信用批准	690	14	2
糖尿病	768	8	2

为了评估在 LDP 下朴素贝叶斯分类的准确性，我们使用 Python 和 pandas 以及 NumPy 库实现了前几节讨论的方法。我们实现了五种不同的 LDP 协议用于频率估计——直接编码（DE）、使用直方图编码的求和（SHE）、使用直方图编码的阈值（THE）、对称一元编码（SUE）和最优一元编码（OUE），并且在不同θ值下进行了 THE 的实验。通过这些实验，我们发现当θ = 0.25 时可以达到最佳准确性，因此我们将给出 SHE 在θ = 0.25 时的实验结果。总的来说，我们将比较这些不同实现的成果，以展示哪个算法最适合这些数据集。

使用离散特征评估 LDP 朴素贝叶斯

为了评估使用 LDP 朴素贝叶斯对具有离散特征的数据进行分类的准确性，我们使用了来自 UCI ML 存储库的四个不同数据集（Car evaluation、Chess、Mushroom 和 Connect-4）。最初，执行了没有 LDP 的朴素贝叶斯分类作为比较不同编码机制在 LDP 下准确性的基准。

让我们看看图 5.3 所示的实验结果，其中显示了直到 5 的ε值的变化。虚线显示了没有隐私的准确性。正如预期的那样，当训练集中的实例数量增加时，较小的ε值准确性更好。例如，在 Connect-4 数据集中，除了 SHE 以外的所有协议即使在非常小的ε值下也提供了超过 65%的准确性。由于没有隐私的准确性大约为 75%，因此所有这些协议在ε值小于 1 时的准确性是显著的。Mushroom 数据集的结果也类似。当ε = 0.5 时，除了 SHE 以外的所有协议提供了近 90%的分类准确性。

图 5.3 具有离散特征的 LDP 朴素贝叶斯分类准确性

在所有数据集中，你可以看到准确性最差的协议是 SHE。因为这个协议只是简单地对噪声值求和，其方差高于其他协议。此外，DE 在 Car Evaluation 和 Chess 数据集中对于小的ε值实现了最佳准确性，因为输入域较小。另一方面，DE 的方差与输入域的大小成正比。因此，当输入域较小时，其准确性更好。我们还可以看到，在所有实验中，SUE 和 OUE 提供了相似的准确性。当输入域较大时，它们的表现优于 DE。尽管 OUE 被提出以减少方差，但在这一组实验中，SUE 和 OUE 之间没有观察到显著的效用差异。

使用连续特征评估 LDP 朴素贝叶斯

现在，让我们讨论使用连续数据的 LDP Naive Bayes 的结果。在这种情况下，实验是在两个不同的数据集上进行的：澳大利亚信用批准和糖尿病。澳大利亚数据集有 14 个原始特征，而糖尿病数据集有 8 个特征。

最初，应用了离散化方法，然后实现了两种降维技术（PCA 和 DCA）以观察它们对准确率的影响。图 5.4 给出了两个数据集在不同 ϵ 值下的结果。我们还展示了两种 LDP 方案的结果，直接编码和优化一元编码，它们为不同领域大小提供了最佳准确率。对于澳大利亚数据集，输入域被划分为 d = 2 个桶，而对于糖尿病数据集，输入域被划分为 d = 4 个桶。

图 5.4 使用离散化方法对具有连续特征的数据集进行 LDP Naive Bayes 分类准确率

如您所见，对于澳大利亚数据集，当特征数量减少到 1 时，主成分分析（PCA）和判别成分分析（DCA）获得了最佳结果。另一方面，对于糖尿病数据集，当 PCA 将特征数量减少到 6，而 DCA 将特征数量减少到 1 时，达到了最佳准确率。如图 5.4 所示，DCA 提供了最佳的分类准确率，这显示了在离散化之前使用降维的优势。您还可以看到，DCA 的准确率优于 PCA，因为 DCA 主要是为分类设计的。

PCA 和 DCA 是什么？

主成分分析（PCA）和判别成分分析（DCA）是两种常用的降维方法，常用于降低大型数据集的维度。PCA 和 DCA 都通过将数据投影到低维超平面来工作。然而，它们之间的关键区别在于 PCA 假设与梯度之间存在线性关系，而 DCA 假设存在单峰关系。我们将在第九章中更详细地讨论不同的降维方法。

此外，我们还对相同的两个数据集应用了 LDP 高斯 Naive Bayes（LDP-GNB）。我们讨论的多维数据（在标题为“使用 LDP 处理多维数据”的子节中）的三个扰动方法都得到了实现。图 5.5 展示了在这两个数据集上执行 LDP-GNB 的结果。

图 5.5 使用连续特征的 LDP 高斯 Naive Bayes 分类准确率

如您所见，三种方法中的第一种（使用拉普拉斯机制）导致最低的效用，因为个体通过添加更多与维度数量成比例的噪声来报告所有特征。在每个图中，都显示了三条曲线，对应于使用原始数据（澳大利亚和糖尿病数据集分别有 14 个或 8 个特征）或在使用 LDP 噪声之前使用 PCA 或 DCA 投影数据。所有图表都显示了降低维度的积极影响。在两个数据集中，对于 PCA 和 DCA，降低的维度数都是 1。DCA 或 PCA 总是比原始数据表现更好，并且对于所有扰动方法。

最后，当您比较连续数据的离散化和高斯 Naive Bayes 的结果时，您会发现离散化提供了更好的准确性。特别是对于较小的 ϵ 值，离散化的优越性很明显。尽管无法比较随机响应和拉普拉斯机制产生的噪声量，但离散化可能由于输入域较小而引起更少的噪声。

摘要

• 有不同的高级 LDP 机制适用于一维和多维数据。

• 正如我们在 DP 的集中设置中所做的那样，我们也可以为 LDP 实现拉普拉斯机制。

• 虽然拉普拉斯机制是生成扰动噪声的一种方法，但 Duchi 机制也可以用来扰动 LDP 的多维连续数值数据。

• 断续机制可以用来处理 LDP 的多维连续数值数据，同时克服拉普拉斯和 Duchi 机制的不利之处。

• Naive Bayes 是一种简单而强大的机器学习分类器，它可以与 LDP 频率估计技术一起使用。

• LDP Naive Bayes 可以与离散和连续特征一起使用。

• 当涉及到具有连续特征的 LDP Naive Bayes 时，有两种主要方法，即离散 Naive Bayes 和高斯 Naive Bayes。

6 隐私保护合成数据生成

本章涵盖

• 合成数据生成

• 为匿名化生成合成数据

• 使用差分隐私机制生成隐私保护合成数据

• 为机器学习任务设计一个隐私保护合成数据生成方案

到目前为止，我们已经探讨了差分隐私（包括集中式、DP 和本地式、LDP 版本）的概念及其在开发隐私保护查询处理和机器学习（ML）算法中的应用。如您所见，DP 的理念是在查询结果中添加噪声（而不干扰其原始属性），以便结果可以确保个人的隐私同时满足应用的效用。

但有时数据用户可能需要原始数据以进行本地直接利用，可能用于开发新的查询和分析程序。隐私保护的数据共享方法可用于此类目的。本章将探讨合成数据生成——一种数据共享的可行解决方案，它生成合成且具有代表性的数据，可以在多个当事人之间安全地共享。合成数据生成的理念是人工生成具有与原始数据相似分布和属性的数据。由于它是人工生产的，我们不必担心隐私问题。

我们将从这个章节开始介绍合成数据生成的基本概念和原理。随后的章节将展示使用不同的数据匿名化技术或差分隐私（DP）实现合成数据生成方法的实例。在本章的末尾，我们将向您介绍一个案例研究，该研究实现了一种新颖的隐私保护合成数据生成方法，该方法使用数据匿名化和 DP 进行机器学习。

6.1 合成数据生成概述

从本质上讲，数据是一系列可以转化为计算机可以理解和处理的形式的事实。随着今天现代应用的发展，数据收集几乎无处不在，如商业分析、工程优化、社会科学分析、科学研究等。通常，不同的数据特征或模式可用于实现各种目标。例如，在医疗保健应用中，各种图像数据，如 X 光片、CT 扫描和皮肤镜检查图像，可以被机器学习应用用于诊断特定疾病或辅助治疗。

然而，在实践中，由于多种原因，包括隐私问题，获取真实（且敏感）数据非常具有挑战性，即使你能够收集数据，通常也不允许你与其他方分享。当涉及到机器学习应用时，大多数算法需要大量的训练数据才能达到最佳性能，但收集如此大量的真实数据并不总是可行的。因此，需要合成（但具有代表性）的数据，鉴于上述担忧，合成数据已成为越来越重要且受欢迎的话题。

6.1.1 什么是合成数据？为什么它很重要？

机器学习模型的表现很大程度上取决于用于训练模型的数据量和质量。当一个组织没有足够的数据进行训练时，具有相似研究兴趣的组织之间通常会进行数据共享。这使得研究可以扩展，但隐私问题仍然存在。数据通常包括可能导致个人隐私泄露的敏感个人信息。因此，在数据共享时启用隐私保护机制至关重要。为此，生成隐私保护合成数据是最佳替代方案之一——它是跨多个利益相关者共享敏感数据的灵活且可行的下一步解决方案。

合成数据是一种人工编制的数据，通常通过人工算法生成，而不是通过现实世界的直接测量技术收集。但它们仍然携带一些实际数据的临界特征（例如，统计属性、功能或结论）。分析合成数据可以产生与分析实际数据本身相似的结果。合成数据的另一个优点是，它可以针对现实中极难观察到的罕见测试场景的特定特征生成（即，难以获取实际数据的场景）。这使得工程师和研究人员能够生成不同的数据集来验证各种模型，评估机器学习算法，并在不同场景下测试新产品、流程和工具。

此外，合成数据帮助我们确保隐私保护。合成数据可以具有与原始数据相似的统计特性，而不泄露原始数据，这为保护隐私和机密性开辟了一条更安全的方式。例如，初级保健提供者（如医院）在患者同意的情况下收集和分享他们的患者信息用于研究目的。然而，大多数患者不会同意与其他方分享他们的私人信息。我们不是分享原始数据，而是可以根据原始数据集的特性生成人工或合成数据。然后我们可以与其他数据用户共享这些合成的数据。这样既保留了应用的效用，又保护了原始数据的隐私。

6.1.2 使用合成数据保护隐私的应用方面

合成数据不包含任何个人信息；它是一个与原始数据分布相似的人工产生的数据集。因此，工程、商业和科学研究应用可以从使用合成数据来保护隐私的目的中受益。

例如，让我们考虑一个在不同医疗实体之间（例如，医院和研究机构）共享临床和医疗数据的例子。假设两家医院，A 和 B，计划开展一项研究项目，以了解个人特定个人信息（年龄、BMI、血糖等）与患乳腺癌概率之间的关系。两家医院都可以从他们的患者那里收集有价值的数据，但由于患者-医院协议，两家医院不能相互分享他们的数据。此外，由于样本数量有限，一家医院的数据不足以支持此类研究。因此，两家医院必须合作进行研究，同时不泄露他们的患者的个人信息。

在这种情况下，我们可以使用合成数据生成技术来生成既合成又具有代表性的数据，这些数据可以安全地共享。通常，生成的合成数据具有与原始数据相同的格式、统计和分布（如图 6.1 所示），而不泄露任何个人信息。以与原始数据相同的形式共享合成数据集，为数据用户如何使用它提供了更多的灵活性，而无需担心隐私问题。

图 6.1 合成数据保留了原始数据的结构，但它们并不相同。

合成数据也可以在商业场景中使用。例如，假设一家公司想要进行商业分析以提高其营销支出。为了进行这项分析，公司的营销部门通常需要获得其客户的同意以使用他们的数据。然而，客户可能不会同意分享他们的数据，因为这些数据可能包含敏感信息，如交易、位置和购物信息。在这种情况下，使用从客户数据生成的合成数据将使公司能够在不需要客户同意的情况下进行准确的业务分析。由于合成数据是基于实际数据的统计特性生成的，因此它可以可靠地用于此类研究。

6.1.3 生成合成数据

在我们查看具体的生成技术之前，让我们回顾一下生成合成数据的一般过程，如图 6.2 所示。

图 6.2 生成合成数据的一般流程

在从原始数据集中提取任何统计特性之前，第一步是对原始数据集进行预处理，通过去除异常值和归一化特征值。异常值是远离其他观察点的数据点。它们可能来自实验中的可变性和测量误差，有时会向数据用户提供错误信息。在大多数情况下，异常值可能会误导合成数据生成器生成更多的异常值，从而使 ML 模型不准确。检测异常值的一种常见方法是使用基于密度的方法：观察在某个区域中特定点存在的概率是否远低于该区域的预期值。

下一步是特征归一化。每个数据集都有不同数量的特征，每个特征都有不同的值范围。特征归一化通常将所有特征缩放到相同的范围，这有助于我们提取统计特性，同时给予不同特征平等的考虑。在归一化数据集之后，我们可以构建分布提取模型，该模型保持原始数据的统计特性。

最后，隐私测试旨在确保生成的合成数据满足某些预定义的隐私保证（k-匿名性、DP 等）。如果生成的合成数据无法提供预定义的隐私保证，隐私测试将失败。我们可以反复生成合成数据集，直到其中一个通过隐私测试。

现在我们已经涵盖了基本概念、应用场景和一般合成数据生成过程，让我们来看看基于数据匿名化和 DP 的一些最流行的合成生成技术。我们将从数据匿名化方法开始。

6.2 通过数据匿名化确保隐私

前几章讨论了通过添加噪声和使用扰动技术来隐私化敏感信息的不同技术。正如我们在本章开头所讨论的，合成数据是人为产生的数据。因此，不同的数据匿名化技术也可以用来创建一个合成数据集。

在本节中，我们将讨论使用数据匿名化技术来共享私有和敏感信息而不泄露个人隐私的历史非 DP 方法。在第 6.3 节中，我们将讨论使用 DP 进行合成数据生成。

6.2.1 私有信息共享与隐私关注

在我们查看匿名化技术是如何工作的之前，让我们考虑这样一个场景：个人的医疗记录被公开发布用于研究目的。分享此类信息对研究有许多好处，包括帮助研究界确认已发表的结果，并促进他们进行更多定性深入的数据分析。因此，在发布数据之前对数据进行匿名化是常见的做法。

但我们能否任意匿名化一个数据集呢？1997 年，马萨诸塞州的集团保险委员会想要发布一个州雇员住院访问的数据集，该数据集将被用于研究目的[1]。当然，存在隐私考虑，所以他们移除了所有可以用来识别患者身份的列，例如姓名、电话号码、SSN 和地址。你认为这次数据发布进行得顺利吗？

不幸的是，它并没有。麻省理工学院的研究员 Latanya Sweeney [2] 发现，尽管主要标识符已被移除，但数据集中仍留下了一些人口统计信息，例如邮政编码、出生日期和性别。Sweeney 意识到，马萨诸塞州州长坚持认为个人隐私得到尊重的声明实际上是不正确的。她决定重新识别已发布（或匿名化）数据集中的哪些记录属于州长，因此她调查了马萨诸塞州的公共选民记录，这些记录具有完整的标识符，例如姓名、地址和人口统计数据，包括邮政编码和出生日期。她能够识别数据集中属于州长的处方和访问记录。

注意：在数据安全中，重新识别攻击是指有人试图将外部数据源与特定个人或敏感记录联系起来。

正如你所见，数据匿名化技术可以用来合成一个数据集，但我们需要确保数据集中的敏感值不再唯一。我们如何创建一个匿名化数据集，使得数据集中的所有敏感值都不再唯一？这就是所谓的k-匿名性，一种流行的数据匿名化方法。

6.2.2 利用 k-匿名性对抗重新识别攻击

K-匿名性是一个关键的安全概念，用于通过将其链接到外部数据集来减轻某人通过重新识别匿名化数据的风险 [3]。这个想法很简单。它使用称为 泛化 和 抑制 的技术来隐藏一组类似人员中的个人身份。在技术术语中，当敏感列的每个可能值组合至少出现在 k 个不同记录中时，数据集被认为是 k-匿名的，其中 k 代表该组中的记录数。如果特定数据集中的任何个人至少有 k-1 个其他个人具有相同的属性，则可以说该数据集是 k-匿名化的。

例如，假设我们有一个相同的团体保险委员会数据集，我们正在查看该数据集中的邮编，并将 k 设置为 20。如果我们查看该数据集中的任何个人，我们应该始终找到 19 个其他人与之共享相同的邮编。底线是，我们仅通过引用他们的邮编就无法具体识别个人。同样的概念可以进一步扩展到结合多个属性。例如，我们可以考虑邮编和年龄作为属性。在这种情况下，匿名化数据集应该始终有 19 个其他人与之共享相同的年龄和邮编，这使得重新识别比前一种情况更困难。

表 6.1 中的数据集是 2 匿名化的，其中每个值（在这种情况下，邮编和年龄）的组合至少出现 k = 2 次。

表 6.1 一个示例 2 匿名化数据集，其中邮编和年龄的每个组合至少出现两次

邮编	年龄
33617	24
33620	35
33620	35
33617	24
33620	35

如何制作合成数据集 k-匿名

有两种不同的技术可以用来使原始数据集 k-匿名：泛化和抑制。

在泛化中，主要思想是使一个值不那么精确，以便具有不同值的记录被泛化为具有相同值的记录。让我们考虑表 6.2 中显示的原始数据集和表 6.3 中显示的 2 匿名化版本。

表 6.2 原始数据集

邮编	年龄
33617	24
33620	41
23622	43
33617	29

表 6.3 表 6.2 中数据集的 2 匿名化版本

邮编	年龄
33617	20-29
33617	20-29
236**	40-49
236**	40-49

假设表 6.2 代表我们感兴趣的原始数据集，我们需要将其转换为它的 2 匿名化版本。在这种情况下，我们可以将数据集中的数值转换为数值范围，以便结果表验证 2 匿名性，如表 6.3 所示。

如您所见，即使在匿名化过程之后，结果值仍然相对接近数据集中的原始值。例如，年龄 24 变成了 20 到 29 的范围，但它仍然很接近原始值。

现在，让我们考虑表 6.4。在这里，前四条记录可以简单地转换为它们的 2-匿名版本。但最后一条记录是一个异常值。如果我们尝试将它与一对中的一对组合，结果将会有一个非常大的值范围。例如，年龄的范围将从 10 到 49 岁，而邮编将完全被删除。因此，最简单的解决方案是从数据集中删除异常值，并保留其余的记录。这个过程被称为抑制。

表 6.4 一个包含异常值的示例数据集。正如您所看到的，最后一行的 12 岁年龄是一个异常值。

邮编	年龄
33617	24
23620	41
23622	43
33617	29
19352	12

在高层次上，这是我们如何将k-匿名应用于数据集以生成匿名（或合成）数据集的方法。我们将在第七章中讨论更多详细示例和技术，以及实际操作练习。

正如您所看到的，通过泛化和抑制数据，k-匿名性使得隐私泄露变得困难。然而，它也有一些缺点，我们将在下面讨论。

6.2.3 超越 k-匿名化的匿名化

虽然k-匿名性使得重新识别记录变得更加困难，但它也有一些缺点。例如，假设数据集中的所有个体在考虑的属性上都有相同的值。在这种情况下，仅通过知道这些个体是数据集的一部分，就可能泄露这些信息。

让我们考虑表 6.5 中的数据集。正如您所看到的，它已经进行了 2-匿名化，但假设鲍勃住在 33620 邮编，并且知道他的邻居最近去做了医疗预约？鲍勃可能会推断出他的邻居患有心脏病。因此，尽管鲍勃不能区分哪条记录属于他的邻居（多亏了k-匿名），但他仍然可以推断出他的邻居患有哪种疾病。

表 6.5 即使是k-匿名化的数据集，也可能泄露一些信息。

邮编	年龄	疾病
33617	20-29	癌症
33617	20-29	传染病
33620	40-49	心脏病
33620	40-49	心脏病

通常，可以通过增加等价组内敏感值的多样性来解决此问题。这就是l-多样性，它是k-匿名的一个扩展，用于提供隐私保护。l-多样性的基本方法是确保每个组至少有l个不同的敏感值，这样就可以很难识别个人或敏感属性。可以通过增加记录的多样性来对相同的数据库进行l-多样性处理，如表 6.6 所示。

表 6.6 记录的多样性可以通过增加来保护那些k-匿名不起作用的情况。

邮编	年龄	疾病
33***	20-29	癌症
33***	20-29	传染病
33***	40-49	心脏病
33***	40-49	心脏病

如您所见，与表 6.5 相比，表 6.6 现在具有 2-多样性（l = 2），鲍勃无法区分他的邻居是否患有癌症、病毒感染或心脏病。然而，l-多样性在某些情况下可能仍然不起作用。如果鲍勃知道他的邻居 40 岁出头呢？现在他可能能够将搜索空间缩小到表 6.6 的最后两行，并且他会知道邻居患有心脏病。如果我们需要减轻这种情况，我们可以再次泛化年龄列，使其范围从 20 岁到 49 岁。然而，这将显著降低结果数据的有用性。我们将在第八章通过实际练习讨论如何在不同的场景中使用l-多样性。

效用与隐私（一种反向关系）之间的基本权衡始终是数据匿名化的一个关注点。为此，使用其他方法生成合成数据是解决该问题的可行下一步解决方案。本质上，我们将使用原始数据集来训练一个机器学习模型，然后使用该模型生成具有与底层真实数据相同统计特性的更真实但合成的数据。在下一节中，我们将探讨我们可以使用哪些技术来生成合成数据。

6.3 用于隐私保护合成数据生成的差分隐私（DP）

在上一节中，我们讨论了通过使用数据匿名化技术生成合成数据。在本节中，我们将探讨在合成数据生成中应用差分隐私（DP）。

让我们考虑以下数据共享场景。假设公司 A 收集了大量关于其客户（年龄、职业、婚姻状况等）的数据，并且他们想对这些数据进行商业分析以优化公司的支出和销售。然而，由于关键的隐私原因，公司 A 没有进行这种分析的能力。他们希望将这项任务外包给第三方运营商，公司 B。但是，由于关键的隐私原因，公司 A 不能与公司 B 共享原始数据。因此，公司 A 希望生成一个合成数据集，该数据集保留了原始数据集的统计特性，而不泄露任何私人信息。然后，他们可以将合成数据集与公司 B 共享，以进行进一步的分析。

在这种情况下，公司 A 有两个合成数据生成和共享选项。首先，他们可以生成原始数据集的合成数据表示，例如直方图、概率分布、均值/中位数或标准差。尽管这样的合成数据表示可以反映原始数据的一些属性，但它们与原始数据不具有相同的“形状”（即特征数量和样本数量）。如果数据分析过程需要特定的或更复杂且可定制的算法（如机器学习或深度学习算法），仅仅提供原始数据的合成数据表示无法满足这些数据需求。例如，大多数机器学习或深度学习算法都需要直接在数据集的特征向量上运行，而不是在数据集的统计数据（如均值或标准差）上运行。因此，第二种选项，即更通用和灵活的选项，是提供一个保持与原始数据集相同统计属性且具有相同形状的合成数据集。

在本节的剩余部分，我们将使用直方图作为示例数据表示，以展示如何生成满足差分隐私（DP）的合成数据表示。我们还将探讨如何使用 DP 合成数据表示来生成差异隐私合成数据。

6.3.1 DP 合成直方图表示生成

让我们继续我们之前的数据共享场景。假设我们的外包公司 B 想了解在特定年龄范围内的公司 A 客户数量。一个直接的方法就是向公司 B 提供一个计数查询函数，该函数可以直接查询公司 A 的原始数据。

让我们以美国人口普查数据集为例，并按以下列表加载它。

列表 6.1 加载美国人口普查数据集

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import sys
import io
import requests
import math

req = requests.get("https://archive.ics.uci.edu/ml/machine-learning-
➥ databases/adult/adult.data").content                               ❶
adult = pd.read_csv(io.StringIO(req.decode('utf-8')), header=None, 
➥ na_values='?', delimiter=r", ")
adult.dropna()
adult.head()

❶ 加载数据。

你将得到如图 6.3 所示的结果。

图 6.3 美国人口普查数据集快照

现在，让我们实现一个计数查询来计算特定年龄范围内的人数。在这个例子中，我们将寻找年龄在 44 到 55 岁之间的人数。

列表 6.2 实现计数查询

adult_age = adult[0].dropna()      ❶

def age_count_query(lo, hi):       ❷
    return sum(1 for age in adult_age if age >= lo and age < hi)

age_count_query(44, 55)

❶ 人群的年龄

❷ 计算特定年龄范围内的人数 [lo, hi)。

你会发现在这个数据集中，44 至 55 岁年龄范围内有 6,577 人。在这个时候，我们可以将 DP 扰动机制添加到计数查询的输出中，以满足公司 B 的需求。然而，这种实现只能满足公司 B 对公司 A 原始数据的一次性计数查询需求。在现实中，公司 B 不会只使用一次这个计数查询。正如我们在第二章中讨论的，增加同一数据集上的不同隐私查询次数意味着我们需要增加整体隐私预算，这意味着容忍更多来自原始数据集的隐私泄露，或者向查询输出添加更多噪声，这会导致精度下降。

我们如何改进这个解决方案以满足需求？答案是提供原始数据的不同隐私合成数据表示，而不是不同隐私查询函数。在这里，我们可以使用合成直方图来表示原始数据，并为计数查询提供足够的信息。首先，让我们使用之前定义的计数查询实现一个合成直方图生成器。

列表 6.3 合成直方图生成器

age_domain = list(range(0, 100))                                       ❶

age_histogram = [age_count_query(age, age + 1) for age in age_domain]  ❷

plt.bar(age_domain, age_histogram)
plt.ylabel('The number of people (Frequency)')
plt.xlabel('Ages')

❶ 年龄的域

❷ 使用年龄计数查询创建年龄直方图。

你将得到一个类似于图 6.4 的直方图。这里显示的是使用列表 6.2 中的年龄计数查询生成的直方图。正如你所见，它显示了每个年龄段在这个数据集中有多少人。

图 6.4 显示每个年龄段人数的直方图

让我们称这个为合成直方图或合成数据表示。记住，我们还没有生成任何合成数据——这是我们将用来生成合成数据的“表示”。

现在，让我们使用这个直方图来创建计数查询。

列表 6.4 使用合成直方图生成器实现计数查询

def synthetic_age_count_query(syn_age_hist_rep, lo, hi):         ❶
    return sum(syn_age_hist_rep[age] for age in range(lo, hi))

synthetic_age_count_query(age_histogram, 44, 55)

❶ 从年龄的合成直方图中生成合成计数查询结果。

从合成数据产生的输出将是 6,577。正如你所见，由合成直方图数据表示生成的结果与使用之前在原始数据上进行的计数查询生成的结果相同。这里的要点是，我们并不总是需要原始数据来查询或推断某些信息。如果我们能获得原始数据的一个合成数据表示，这足以让我们回答一些查询。

在列表 6.3 中，我们使用原始数据生成了直方图。现在，让我们使用拉普拉斯机制（敏感度和 epsilon 都等于 1.0）实现一个不同隐私合成直方图生成器。

列表 6.5 添加拉普拉斯机制

def laplace_mechanism(data, sensitivity, epsilon):                        ❶
    return data + np.random.laplace(loc=0, scale = sensitivity / epsilon)

sensitivity = 1.0                                                         ❷
epsilon = 1.0
dp_age_histogram = [laplace_mechanism(age_count_query(age, age + 1), 
➥ sensitivity, epsilon) for age in age_domain]

plt.bar(age_domain, dp_age_histogram)
plt.ylabel('The number of people (Frequency)')
plt.xlabel('Ages')

❶ DP 的拉普拉斯机制

❷ 生成一个差分隐私合成直方图。

结果如图 6.5 所示。让我们称这为差分隐私合成直方图数据表示。观察这个直方图和图 6.4 中的直方图的模式。你看到任何区别吗？这两个看起来非常相似，但这个并不是使用原始数据集生成的。相反，我们使用了拉普拉斯机制（DP）来生成数据。

图 6.5 一个差分隐私合成直方图

现在的问题是，“如果我们运行计数查询，这会给我们相同的结果吗？”让我们在相同的输入下，使用差分隐私合成直方图生成一个计数查询结果。

列表 6.6 差分隐私计数查询

synthetic_age_count_query(dp_age_histogram, 44, 55)   ❶

❶ 使用差分隐私合成直方图生成一个差分隐私计数查询结果。

你会得到类似 6,583.150,999,026,576 的输出。

注意：由于这是一个随机函数，你将得到不同的结果，但应该接近这个值。

如您所见，结果仍然与之前的真实结果非常相似。换句话说，差分隐私合成直方图数据表示可以在满足公司 B 的数据共享要求的同时，仍然保护公司 A 的隐私要求，因为我们使用的是合成数据而不是原始数据。

6.3.2 DP 合成表格数据生成

在上一节中，我们看到了如何使用差分隐私合成数据表示来启用隐私保护的数据共享。但是，如果公司 B 想要执行更复杂的数据分析方法，例如机器学习或深度学习算法，这些方法需要使用与原始数据集相同形状的数据集，那会怎样呢？在这种情况下，我们需要再次从合成数据表示中生成与原始数据相同形状的合成数据。

在我们的例子中，美国人口普查数据集包含表格数据。为了生成具有相同形状的合成表格数据，我们可以使用合成直方图作为表示原始数据潜在分布的概率分布。然后我们可以使用这个合成直方图来生成合成表格数据。

简而言之，给定一个直方图，我们可以将所有直方图区间的计数总和视为总数。对于每个直方图区间，我们可以使用其计数除以总数来表示样本落在该直方图区间的概率。一旦我们有了这些概率，我们就可以使用直方图及其区间的域轻松地采样合成数据集。

假设我们已经有了一个差分隐私合成直方图。然后我们需要预处理合成直方图，以确保所有计数都是非负的并且归一化。这意味着每个区间的计数应该是一个概率（它们应该加起来为 1.0）。以下列表显示了预处理和归一化操作。

列表 6.7 预处理和归一化操作

dp_age_histogram_preprocessed = np.clip(dp_age_histogram, 0, None)
dp_age_histogram_normalized = dp_age_histogram_preprocessed / 
➥ np.sum(dp_age_histogram_preprocessed)

plt.bar(age_domain, dp_age_histogram_normalized)
plt.ylabel('Frequency Rates (probabilities)')
plt.xlabel('Ages')

概率直方图可能看起来像图 6.6。

图 6.6 一个归一化的差分隐私合成直方图

如你所见，这个直方图的 y 轴现在已归一化，但它仍然与图 6.5 中输入的差分隐私合成直方图具有相同的形状。

现在让我们生成差分隐私合成表格数据。

列表 6.8 生成差分隐私合成表格数据

def syn_tabular_data_gen(cnt):
    return np.random.choice(age_domain, cnt, p = dp_age_histogram_normalized)

syn_tabular_data = pd.DataFrame(syn_tabular_data_gen(10), columns=['Age'])
syn_tabular_data

结果显示在图 6.7 中。记住，这是一个随机函数，所以你的结果可能会有所不同。

图 6.7 一组差分隐私合成表格数据的样本集

列表 6.8 中我们在做什么？我们使用列表 6.7 中生成的归一化合成直方图生成了十个不同的合成数据记录。这意味着我们使用归一化合成直方图的性质生成了全新的合成数据记录。现在我们有两个不同的数据集：原始数据集和合成生成数据集。

现在让我们使用直方图来比较合成数据和原始数据的统计特性，如图 6.9 和 6.10 所示。

列表 6.9 合成数据的直方图

syn_tabular_data = pd.DataFrame(syn_tabular_data_gen(len(adult_age)), 
➥ columns=['Age'])
plt.hist(syn_tabular_data['Age'], bins=age_domain)
plt.ylabel('The number of people (Frequency) - Synthetic')
plt.xlabel('Ages')

此代码生成如图 6.8 所示的合成数据的直方图。

图 6.8 使用合成表格数据生成产生的直方图

为了进行比较，让我们生成原始数据的直方图。

列表 6.10 原始数据的直方图

plt.bar(age_domain, age_histogram)
plt.ylabel('The number of people (Frequency) - True Value')
plt.xlabel('Ages')

结果可能看起来像图 6.9。

图 6.9 原始数据的直方图

如果你比较图 6.8 和 6.9 中的直方图形状，你会发现它们非常相似。换句话说，我们生成的合成数据具有与原始数据相同的统计特性。有趣，不是吗？

6.3.3 DP 合成多边际数据生成

上一节介绍了一种使用 DP 从合成直方图数据表示生成隐私保护的单列合成表格数据的方法。但大多数现实世界的数据集由多列表格数据组成。我们该如何解决这个问题？

一个简单的解决方案是使用我们之前描述的方法为多列表格数据的每一列生成合成数据，然后将所有合成的单列表格数据组合在一起。这个解决方案看起来很简单，但它并没有反映这些列之间的相关性。例如，在美国人口普查数据集中，年龄和婚姻状况直观上高度相关。在这种情况下我们该怎么办？

我们可以考虑同时考虑多个列。例如，我们可以计算有多少人是 18 岁且从未结婚，有多少人是 45 岁且离婚，有多少人是 90 岁且成为寡妇，等等。然后我们可以使用之前的方法计算每种情况的可能性，并从模拟的概率分布中采样合成数据。我们将这个结果称为合成多边缘数据。

让我们在包含年龄和婚姻状况的美国人口普查数据集上实现这个想法。

列表 6.11 2 路边缘表示

two_way_marginal_rep = adult.groupby([0, 5]).size().
➥ reset_index(name = 'count')
two_way_marginal_rep

原始数据集的 2 路边缘表示如图 6.10 所示。记住，列 0 是年龄，列 5 是婚姻状况。正如你在第二行（索引 1）中看到的那样，有 393 人从未结婚且年龄为 17 岁。

图 6.10 原始数据集的 2 路边缘表示快照

对于每种婚姻状况和年龄组合，我们都有 396 个这样的类别。一旦我们生成这样的 2 路边缘数据集，我们就可以使用拉普拉斯机制使其具有差分隐私。

列表 6.12 差分隐私的 2 路边缘表示

dp_two_way_marginal_rep = laplace_mechanism(two_way_marginal_rep["count"],
➥ 1, 1)
dp_two_way_marginal_rep

2 路边缘表示的结果如图 6.11 所示。正如你所看到的，我们已经为所有 396 个类别生成了一个差分隐私值。

图 6.11 差分隐私的 2 路边缘表示快照

现在，我们可以使用我们提出的方法来生成包含年龄和婚姻状况的合成多边缘数据。以下列表使用列表 6.12 中产生的 2 路边缘表示来生成合成数据集。

列表 6.13 生成合成多边缘数据

dp_two_way_marginal_rep_preprocessed = np.clip(dp_two_way_marginal_rep,
➥ 0, None)
dp_two_way_marginal_rep_normalized = dp_two_way_marginal_rep_preprocessed / 
➥ np.sum(dp_two_way_marginal_rep_preprocessed)
dp_two_way_marginal_rep_normalized

age_marital_pairs = [(a,b) for a,b,_ in 
➥ two_way_marginal_rep.values.tolist()]
list(zip(age_marital_pairs, dp_two_way_marginal_rep_normalized))

set_of_potential_samples = range(0, len(age_marital_pairs))

n = laplace_mechanism(len(adult), 1.0, 1.0)

generating_synthetic_data_samples = np.random.choice(
➥ set_of_potential_samples, int(max(n, 0)), 
➥ p=dp_two_way_marginal_rep_normalized)
synthetic_data_set = [age_marital_pairs[i] for i in 
➥ generating_synthetic_data_samples]

synthetic_data = pd.DataFrame(synthetic_data_set, 
➥ columns=['Age', 'Marital status'])
synthetic_data

生成的合成 2 路边缘数据集如图 6.12 所示。

图 6.12 合成产生的 2 路边缘数据集快照

让我们比较合成数据和原始数据的统计特性。首先，让我们比较年龄数据的直方图。

列表 6.14 使用合成多边缘数据生成的直方图

plt.hist(synthetic_data['Age'], bins=age_domain)
plt.ylabel('The number of people (Frequency) - Synthetic')
plt.xlabel('Ages')

合成数据的直方图如图 6.13 所示。

图 6.13 使用合成多边缘数据生成的直方图

为了比较结果，我们将使用以下代码（与列表 6.10 中的代码相同）来生成原始数据的直方图。

列表 6.15 原始数据的直方图

plt.bar(age_domain, age_histogram)
plt.ylabel('The number of people (Frequency) - True Value')
plt.xlabel('Ages')

原始数据的直方图如图 6.14 所示。通过简单地观察它们的形状和数据点的分布情况，我们可以快速得出结论，图 6.13 和图 6.14 中的两个直方图是相似的。

图 6.14 原始数据的直方图

我们已经研究了年龄的分布情况，但婚姻状况呢？让我们比较婚姻状况数据的分布。

列表 6.16 原始数据的统计

adult_marital_status = adult[5].dropna()
adult_marital_status.value_counts().sort_index()

结果如图 6.15 所示。

图 6.15 原始数据统计概要

下一个列表将总结原始数据集中的婚姻状况数据。

列表 6.17 合成数据的统计

syn_adult_marital_status = synthetic_data['Marital status'].dropna()
syn_adult_marital_status.value_counts().sort_index()

图 6.16 显示了合成数据的概要。如图所示，不同隐私的合成多边际数据的婚姻状况看起来与原始数据相似（但并不相同）。

图 6.16 合成产生的婚姻状况数据统计概要

再次，我们可以得出结论，我们不必使用原始数据，可以使用合成的数据来完成同样的任务，同时保护原始数据的隐私。

我们已经研究了生成满足 DP 的合成直方图数据表示，并且我们已经通过使用不同的私有合成直方图表示来生成隐私保护的合成单列表格数据和多边际数据。但是等等！我们如何处理包含两个或三个以上列和大量记录的大型数据集呢？我们将在下一部分找到答案。下一节将研究一个更复杂的案例研究，以展示我们如何应用数据匿名化和 DP 来为机器学习生成隐私保护的合成数据。

练习 1：自己试试

在列表 6.11 中，我们查看了一个包含年龄和婚姻状况的 2 向边际表示。正如讨论的那样，年龄和婚姻状况高度相关，我们想看看合成的数据是否也遵循类似的分布。现在尝试按照相同的步骤对教育和职业列进行操作，看看你是否能得到相似的结果。

提示：在原始数据集中，教育信息位于第 3 列，第 6 列是职业。首先按照以下方式更改列表 6.11 中的列：

adult.groupby([3, 6]).size().reset_index(name = 'count') 

然后按照所有步骤进行。

练习 2：自己试试

重复相同的过程，但对于 3 列数据的 3 向边际表示。例如，你可能考虑年龄、职业和婚姻状况作为 3 向表示。

6.4 通过特征级微聚合发布私有合成数据的案例研究

现在我们已经讨论了生成合成数据的不同方法，让我们通过一个案例研究来了解如何通过特征级微聚合方法设计私有合成数据发布机制。听起来太技术了吗？不用担心，我们将一步一步地介绍细节。

首先，回忆一下 DP（差分隐私）是一种机制，它为保护个人数据记录提供强大的隐私保障（正如我们在第二章所讨论的）。在本案例研究中，我们将讨论一种在 DP 保障下工作的隐私保护合成数据生成方法，该方法适用于多个机器学习任务。它是基于聚类数据的差分隐私生成模型来生成合成数据集。在本节的下半部分，我们将向您展示这种方法与一些现有方法相比的有效性，以及它如何与其他方法相比提高了效用。

在我们查看案例研究的细节之前，让我们首先回顾一些基础知识。通常，为机器学习设计一个强大的隐私保护合成数据生成方法会带来许多挑战。首先，隐私保护方法通常会向数据样本引入扰动，这会损害数据的效用。减轻扰动以达到一定程度的效用不是一项容易的任务。其次，机器学习可以表示为许多不同的任务，如分类、回归和聚类。一个有效的合成数据生成方法应该适用于所有这些不同的任务。第三，一些数据可能以非常复杂的分布形式出现。在这种情况下，很难基于整个数据分布形成一个准确的生成器。

在过去，人们已经提出了几种私有合成数据发布算法[4]，[5]。其中一种常见的方法是利用噪声直方图发布合成数据，但大多数都是为处理分类特征变量而设计的。另一方面，一些算法旨在在原始数据集上进行一些预处理后，在统计模型下生成合成数据。然而，它们通常只基于整个数据分布生成合成数据。

在这项研究中，我们将关注如何在保持与原始数据集相似的统计特征的同时生成合成数据，同时确保数据所有者没有隐私担忧。

既然你对我们要做什么有了基本的了解，让我们深入细节。

6.4.1 使用分层聚类和微聚合

我们方法论的一个关键部分，我们将在此基础上构建，是分层聚类。本质上，分层聚类是一种算法，它根据样本的邻近矩阵将输入样本聚类到不同的簇中。这个邻近矩阵表示每个簇之间的距离。在这种情况下，我们将使用聚合分层聚类 [6]，这是一种自下而上的方法，它首先将每个数据样本分配到它自己的组中，然后合并距离最小的簇对，直到只剩下一个簇为止。

如第 6.2 节所述，k-匿名性可以用来匿名化数据。在这里，我们将使用一种名为微聚合的数据匿名化算法来实现k-匿名性。我们这里提到的微聚合方法是一种简单的启发式方法，称为最大距离到平均记录（MDAV），由 Domingo-Ferrer 等人[7]提出。其想法是将样本分为簇，每个簇包含恰好k条记录（除了最后一个），簇中的记录在距离上应尽可能相似。此外，簇中的每条记录将被替换为该簇的代表记录以完成数据匿名化。

6.4.2 生成合成数据

在这个合成数据生成机制中，四个主要组件共同作用以生成满足 DP 的合成数据：

• 数据预处理—结合独立特征集和特征级微聚合来生成描述数据更通用的数据簇。

• 统计提取—提取每个数据簇的代表统计信息。

• DP 净化器—在提取的统计信息上添加差分隐私噪声。

• 数据生成器—通过扰动生成模型逐个生成合成数据样本。

这四个组件在图 6.17 中展示。

图 6.17 合成数据生成算法的不同组件

数据预处理的工作原理

在数据预处理中，我们使用微聚合作为全特征维度（覆盖所有我们感兴趣的特征的样本）样本的聚类方法。我们不会用代表记录替换记录，而是将使用差分隐私生成模型来建模每个簇。然而，这里有几个挑战。

在对 MDAV 生成的输出簇进行建模时，一些簇可能携带实际数据分布中可能不存在的相关性。这种虚假特征相关性在建模数据簇时可能施加不必要的约束，这可能导致合成数据呈现出不同的形状。另一方面，我们知道差分隐私（DP）通常会引入噪声方差。直观上，引入的 DP 噪声越少，效用越高。因此，减少 DP 机制噪声也有助于提高数据的效用。为了解决这些不利影响，我们不仅可以在样本级别采样数据，还可以在特征级别采样数据。

下面是如何进行特征级和样本级聚类的：

• 特征级聚类——每当我们在一个数值数据集 D⁽ⁿ×d^) 中时，我们可以使用层次聚类将这些 d 个数据特征划分为 m 个独立的特征集。在这里，可以将皮尔逊相关系数转换为距离的函数用于形成层次聚类中的邻近矩阵。相关性较高的特征应具有较低的距离，而较低的相关性对应较高的距离。这种方法将帮助我们确保同一集合中的特征之间相关性更高，与其他特征集的特征相关性更低。

• 样本级聚类——一旦我们获得了特征级聚类的输出，我们就在特征级别上分割数据，然后对每个数据段应用微聚合。其思想是将同质样本分配到同一聚类中，这将帮助我们保留更多来自原始数据的信息。与全局敏感性相比，每个样本聚类的敏感性也可能降低。这种降低将涉及 DP 机制中的较少噪声。换句话说，它在相同的隐私保证水平下增强了数据的效用。

生成合成数据背后的概念

微聚合过程输出包含至少 k 条记录的多个聚类。假设每个聚类形成一个多元高斯分布，则对每个聚类 c 计算均值 (μ) 和协方差矩阵 (Σ)。然后，隐私净化器在 μ 和 Σ 上添加噪声以确保模型满足差分隐私（DP）。最后，构建生成模型。生成合成数据的完整过程如图 6.18 所示。

图 6.18 合成数据生成器的工作原理。这里 μ 代表均值，Σ 是为每个聚类计算的协方差矩阵。

在图 6.18 中，原始的多变量高斯模型由均值 (μ) 和协方差矩阵 (Σ) 参数化。值得注意的是，隐私净化器输出两个参数，μDP 和 ΣDP，它们受到差分隐私的保护。因此，由 μDP 和 ΣDP 参数化的多变量高斯模型也受到差分隐私的保护。此外，根据差分隐私的后处理不变性，所有从差分隐私多元高斯模型导出的合成数据也受到差分隐私的保护。

方差、协方差和协方差矩阵

在统计学中，方差通常衡量单个随机变量的变化（例如，人口中一个人的身高），而协方差是衡量两个随机变量一起变化的量度。例如，我们可以考虑人口中一个人的身高和体重来计算协方差。

两个随机变量 x 和 y 的协方差公式如下

其中 n 是样本数量。协方差矩阵是一个由 C(i,j) = σ (x[i], x[j])给出的方阵，C ∈ ℝ⁽n^×n^)，其中 n 是随机变量的数量。协方差矩阵的对角线元素是方差，而其他元素是协方差。对于两个随机变量的情况，协方差矩阵可以按以下方式计算：

6.4.3 评估生成的合成数据的性能

为了评估所提出方法的性能，我们将其在 Java 中实现。是的，这次是 Java。完整的源代码、数据集和评估任务可在本书的 GitHub 仓库中找到：github.com/nogrady/PPML/blob/main/Ch6/PrivSyn_Demo.zip。

我们生成了不同的合成数据集，并在不同的聚类大小(k)和隐私预算(ε)下进行了实验。ε的设置从 0.1 到 1 不等，聚类大小为：k = 25, 50, 75, 100。对于每个合成数据集，我们考察了三个通用机器学习任务：分类、回归和聚类。为了完成这些任务，我们使用了两种不同的实验场景，结合了不同的合成和原始数据组合。

• 实验场景 1—使用原始数据进行训练，合成数据进行测试。

  机器学习模型在原始数据集上训练，并测试生成的合成数据集。对于每个实验数据集，30%的样本被用作种子数据集来生成合成数据集，而 70%被用作原始数据来训练模型。生成的合成数据用于测试。

• 实验场景 2—使用合成数据进行训练，原始数据进行测试。

  机器学习模型在合成数据集上训练，并在原始数据集上测试。对于每个实验数据集，80%的样本被用作种子数据集来生成合成数据集，而 20%被用作原始数据来测试模型。

实验中使用的数据集

对于这次性能评估，我们使用了来自 UCI 机器学习仓库[8]和 LIBSVM 数据仓库的三个数据集来检验不同算法的性能。数据集中的所有特征都被缩放到[-1,1]范围内：

• 糖尿病数据集—这个数据集包含了 768 个样本和 9 个特征的病人记录诊断测量，包括血压、BMI、胰岛素水平和年龄等信息。目标是识别病人是否患有糖尿病。

• 乳腺癌数据集—这个数据集是从乳腺癌诊断的临床病例中收集的。它有 699 个样本和 10 个特征。所有样本都被标记为良性或恶性。

• 澳大利亚数据集——这是来自 StatLog 项目的澳大利亚信用批准数据集。每个样本是一个信用卡申请，数据集包含 690 个样本和 14 个特征。样本通过申请是否被批准进行标记。

性能评估和结果

正如所讨论的，我们对三个主要的机器学习任务感兴趣，用于评估合成数据：分类、回归和聚类。

使用支持向量机（SVM）进行分类任务。在每个训练阶段，我们使用网格搜索和交叉验证来选择 SVM 模型的最佳参数组合。在选择最佳性能的 SVM 模型时，使用了 F1 分数。具有最高 F1 分数的模型用于测试分类精度。

对于回归任务，使用了线性回归作为回归器。回归的评价指标是均方误差（MSE）。

最后，使用了k-means 聚类作为聚类任务。正如你在前几章所学，聚类是一种无监督机器学习任务，它将相似的数据分组。与先前的分类和回归任务不同，聚类中原始数据集中的所有数据都被视为合成数据的种子。k-means 算法应用于原始和合成数据集，两者都产生了两个聚类，这些聚类在实验数据集中呈现二进制类别。在每个实验中，k-means 运行 50 次，每次使用不同的质心种子，并输出 50 次连续运行中的最佳情况。

三个机器学习任务的成果展示在图 6.19、6.20 和 6.21 中。你可以看到，当ε的范围从 0.1 到 0.4 时，每个k的性能都会迅速提高，但峰值性能并不总是来自固定的k值。例如，图 6.19（e）在k = 50 时有一个局部最优点，而图 6.21（a）和图 6.21（c）在k = 75 时有一个局部最优点。

图 6.19 任务 1（SVM）的两个不同实验场景的实验结果

图 6.20 任务 2（线性回归）的两个不同实验场景的实验结果

图 6.21 任务 3（k-means 聚类）的实验结果

从理论上讲，较小的 ε 值通常比较大的 ε 值引入更多的噪声到合成数据中，这增加了随机性。在回归的情况下（图 6.20），当隐私预算较小的时候，场景 2 中反映的随机性比场景 1 中的 MSE 要少得多。这是由于场景 1 中的测试数据具有差分隐私噪声，而场景 2 中的测试数据没有噪声。当 ε > 0.4 时，性能提升相对稳定，当 k = 100 时，在相同的隐私预算下，聚类方法总是优于其他 k 值。值得注意的是，当 k = 25 时，整体性能远低于其他 k 值。这是因为当我们在一个只包含少量数据样本的簇上形成多元高斯生成模型时，计算出的均值和协方差矩阵可能会存在偏差。该簇不能很好地反映数据分布。因此，k 应该是一个适中的值来形成多元高斯生成模型。更大的 k 值也可以使模型比更小的 k 值更快地收敛，如图 6.19（a）、6.19（d）、6.20（a）和 6.21（a）所示。

摘要

• 合成数据是从原始数据生成的人工数据，它保留了原始数据的统计特性并保护了原始数据的隐私信息。

• 合成数据生成过程涉及多个步骤，包括异常检测、归一化函数和构建模型。

• 隐私测试用于确保生成的合成数据满足某些预定义的隐私保证。

• K-匿名性是生成匿名化合成数据以减轻重新识别攻击的良好方法。

• 虽然 k-匿名性使得重新识别个体变得更加困难，但它也有一些缺点，这导致了其他匿名化机制，如 l-多样性。

• 数据集的合成表示可以捕捉原始数据集的统计特性，但大多数情况下，它不会与原始数据集具有相同的形状。

• 我们可以使用合成直方图来生成合成表格数据。

• 合成表示可以用来生成与原始数据集具有相同统计特性和形状的合成数据集。

• 我们可以通过将拉普拉斯机制应用于合成表示生成器来生成差分隐私合成数据，然后使用差分隐私合成表示生成器。

• 我们可以通过将微聚合技术应用于合成数据生成来生成满足 k-匿名性的差分隐私合成数据。

第三部分 构建隐私保障的机器学习应用

第三部分涵盖了构建隐私保障的机器学习应用所需的更高级的核心概念。第七章介绍了在数据挖掘应用中保留隐私的重要性，探讨了在数据挖掘中广泛使用的隐私保护机制，用于处理和发布数据。第八章讨论了数据挖掘中广泛使用的隐私模型及其威胁和漏洞。第九章专注于机器学习的压缩隐私，讨论了其设计和实现。最后，第十章将前几章的概念结合起来，设计了一个用于保护和共享研究数据的隐私增强平台。

7 隐私保护数据挖掘技术

本章涵盖

• 数据挖掘中隐私保护的重要性

• 处理和发布数据的隐私保护机制

• 探索数据挖掘的隐私增强技术

• 使用 Python 在数据挖掘中实现隐私技术

到目前为止，我们已经讨论了研究界和工业界合作的不同隐私增强技术。本章重点介绍这些隐私技术如何用于数据挖掘和管理操作。本质上，数据挖掘是发现数据中新关系和模式的过程，以实现进一步的有意义分析。这通常涉及机器学习、统计操作和数据管理系统。在本章中，我们将探讨如何将各种隐私增强技术与数据挖掘操作捆绑在一起，以实现隐私保护的数据挖掘。

首先，我们将探讨数据挖掘中隐私保护的重要性以及如何将个人信息泄露给外界。然后，我们将介绍可以用于确保数据挖掘操作隐私保证的不同方法，并附带一些示例。在本章的末尾，我们将讨论数据管理技术的最新发展，以及这些隐私机制如何被用于数据库系统以设计定制的隐私增强数据库管理系统。

7.1 数据挖掘和管理中隐私保护的重要性

今天的应用程序持续生成大量信息，我们都知道在这个深度学习时代隐私保护的重要性。同样重要的是在高效、安全的数据处理框架中处理、管理和存储收集到的信息。

让我们考虑一个基于云的电子商务应用的典型部署，其中用户的个人信息由数据库应用程序存储和处理（图 7.1）。

图 7.1 一个典型的电子商务 Web 应用的部署。所有用户数据，包括个人信息，都存储在数据库中，这些数据将被数据挖掘操作使用。

在电子商务应用中，用户通过网络浏览器连接，选择他们想要的产品或服务，并在网上进行支付。所有这些都在后端数据库中记录，包括客户的姓名、地址、性别、产品偏好和产品类型等私人信息。这些信息随后通过数据挖掘和机器学习操作进一步处理，以提供更好的客户体验。例如，可以将客户的产品偏好与其他客户的选择联系起来，以推荐额外的产品。同样，可以使用客户的地址提供基于位置的服务和建议。虽然这种方法为顾客带来了许多好处，如服务质量提升，但也伴随着许多隐私问题。

让我们以一个简单的例子来说明，一个客户经常在线购买衣服。在这种情况下，即使没有明确提到性别，数据挖掘算法也可能仅通过查看客户过去购买的衣服类型来推断客户的性别。这成为一个隐私问题，通常被称为推断攻击。我们将在下一章更详细地探讨这些攻击。

现在大多数科技巨头（如 Google、Amazon 和 Microsoft）提供机器学习即服务（MLaaS），中小型企业（SMEs）倾向于基于这些服务推出他们的产品。然而，这些服务容易受到各种内部和外部攻击，我们将在本章末尾讨论。因此，通过将两个或多个数据库或服务链接在一起，可以推断出更敏感或私人的信息。例如，一个能够访问电子商务网站上客户邮编和性别的攻击者可以将这些数据与公开可用的团体保险委员会（GIC）数据集[1]结合起来，他们可能能够提取个人的医疗记录。因此，在数据挖掘操作中，隐私保护至关重要。

为了这个目的，在本章和下一章中，我们将详细阐述数据挖掘和管理中隐私保护的重要性，它们的应用和技巧，以及在两个特定方面（如图 7.2 所示）的挑战：

• 数据处理和挖掘—可以在收集的信息通过各种数据挖掘和分析工具进行处理和分析时使用的工具和技术

• 数据管理—可以用于保存、存储和为不同数据处理应用提供服务的信息的方法和技术

图 7.2 在数据挖掘和管理方面，本质上有两个方面的隐私保护。

因此，我们将探讨如何通过修改或扰动输入数据来确保隐私保护，以及当数据发布给其他方时我们如何保护隐私。

7.2 数据处理和挖掘中的隐私保护

数据分析和挖掘工具旨在从收集的数据集中提取有意义的特征和模式，但直接在数据挖掘中使用数据可能会导致不希望的数据隐私侵犯。因此，已经开发出利用数据修改和噪声添加技术（有时称为数据扰动）的隐私保护方法，以保护敏感信息免受隐私泄露。

然而，修改数据可能会降低效用或甚至使其无法提取基本特征。这里的效用指的是数据挖掘任务；例如，在前面提到的电子商务应用中，向客户推荐产品的机制是效用，隐私保护方法可以用来保护这些数据。然而，任何数据转换都应该在隐私和预期应用效用之间保持平衡，以便仍然可以在转换后的数据上执行数据挖掘。

让我们简要地看看数据挖掘是什么以及隐私法规是如何出现的。

7.2.1 什么是数据挖掘以及它是如何被使用的？

数据挖掘是从收集的数据集或信息集中提取知识的过程。信息系统定期收集和存储有价值的信息，将信息存储在数据存储中的目的是提取诸如关系或模式等信息。为此，数据挖掘有助于从这些数据集中发现新的模式。因此，数据挖掘可以被认为是学习新模式或关系的过程。例如，在我们的电子商务示例中，数据挖掘算法可以用来确定一个购买了婴儿尿布的客户也购买婴儿湿巾的可能性有多大。基于这样的关系，服务提供商可以做出及时的决定。

通常，这些关系或模式可以用适用于集合中原始数据子集的数学模型来描述。实际上，已识别的模型可以以两种不同的方式使用。首先，模型可以用描述性的方式使用，其中集合中数据之间的关系可以被转换成人类可识别的描述。例如，一家公司的当前财务状况（是否盈利）可以根据存储在数据集中的历史财务数据来描述。这些被称为描述性模型，它们通常基于历史数据提供准确的信息。预测模型是第二种方式。它们的准确性可能不是非常精确，但可以根据历史数据预测未来。例如，像“如果公司投资这个新项目，五年后他们的利润率会增加吗？”这样的问题可以使用预测模型来回答。

图 7.3 数据挖掘中的关系和模式可以通过两种不同的方式实现。

如图 7.3 所示，数据挖掘可以产生描述性模型和预测性模型，我们可以根据底层应用的要求应用它们进行决策。例如，在电子商务应用中，预测模型可以用来预测产品的价格波动。

7.2.2 隐私法规要求的影响

传统上，数据安全和隐私要求由数据所有者（如组织自身）设定，以保护他们提供的产品和服务的竞争优势。然而，数据已成为数字经济中最有价值的资产，许多隐私法规已由政府实施，以防止敏感信息超出其预期用途的使用。不同的组织通常遵守隐私标准，如 HIPAA（1996 年健康保险可携带性和问责法案）、PCI-DSS（支付卡行业数据安全标准）、FERPA（家庭教育权利和隐私法案）以及欧盟的 GDPR（通用数据保护条例）。

例如，无论实践规模大小，几乎每个医疗服务提供者都会在涉及某些交易的情况下以电子方式传输健康信息，例如索赔、药物记录、福利资格查询、转诊授权请求等。然而，HIPAA 法规要求所有这些医疗服务提供者保护敏感患者健康信息，防止未经患者同意或知情的情况下泄露。

在下一节中，我们将详细探讨不同的隐私保护数据管理技术，并讨论它们在确保这些隐私要求方面的应用和缺陷。

7.3 通过修改输入保护隐私

现在你已经了解了基础知识，让我们深入了解细节。已建立的隐私保护数据管理（PPDM）技术可以根据隐私保证的实施方式分为几个不同的类别。在本章中，我们将讨论前两类；其他类别将在下一章中介绍。

第一类 PPDM 技术确保在数据收集阶段以及将其移动到数据存储之前数据的隐私性。这些技术通常在数据收集阶段结合不同的随机化技术，并为每条记录单独生成私有化值，因此原始值从未被存储。最常用的两种随机化技术是通过添加具有已知统计分布的噪声来修改数据，以及通过乘以具有已知统计分布的噪声来修改数据。

图 7.4 在数据输入修改中使用随机化技术

图 7.4 说明了这两种技术中的第一种。在数据收集阶段，添加一个公开已知的噪声分布以产生随机结果。然后，当涉及数据挖掘时，我们可以简单地根据样本估计噪声分布，并重建原始数据分布。然而，需要注意的是，尽管原始数据分布可能被重建，但原始值并未恢复。

7.3.1 应用和限制

现在我们已经了解了如何修改输入以保护隐私，让我们来看看这些随机化技术的优点和缺点。

最重要的是，这些方法可以在随机化后仍然保留原始数据分布的统计属性。这就是为什么它们被用于不同的隐私保护应用中，包括差分隐私（我们在第二章和第三章中讨论过）。

然而，由于原始数据已被扰动，只有数据分布可用（而非个体数据），这些方法需要特殊的数据挖掘算法，通过查看分布来提取必要的信息。因此，根据应用的不同，这种方法可能会对效用产生更大的影响。

分类和聚类等任务可以使用这些输入随机化技术，因为它们只需要访问数据分布。例如，考虑在基于特定特征或参数的疾病识别任务中，对医疗诊断数据集应用此类技术。在这种情况下，访问个体记录是不必要的，分类可以基于数据分布进行。

7.4 发布数据时的隐私保护

下一个类别的 PPDM 处理的是在将数据发布给第三方而不披露敏感信息所有权时的技术。在这种情况下，通过在将数据发布给外部各方之前对个体数据记录应用数据匿名化技术来实现数据隐私。

如前一章所述，在当前阶段，仅通过删除可以明确识别数据集中个体的属性是不够的。匿名化数据中的用户可能通过结合非敏感属性或记录与外部数据关联而被识别。这些属性被称为准标识符。

让我们考虑第六章中讨论的一个场景，即结合两个公开可用的数据集。在 US Census 数据集中结合不同的值，如邮政编码、性别和出生日期，与来自集团保险委员会（GIC）的匿名化数据集相当直接。通过这样做，有人可能能够提取特定个人的医疗记录。例如，如果鲍勃知道他的邻居爱丽丝的邮政编码、性别和出生日期，他可以使用这三个属性将这两个数据集结合起来，他可能能够确定 GIC 数据集中哪些医疗记录是爱丽丝的。这是一种称为链接或关联攻击的隐私威胁，其中特定数据集中的值与其他信息来源相链接，以创建更信息丰富和独特的条目。在发布数据时通常使用的 PPDM 技术通常包含一个或多个数据清洗操作以保护隐私。

注意：如果您不熟悉 GIC 数据集，它是一个显示美国州政府雇员每次医院访问的“匿名化”数据集。其目标是帮助研究人员，并且州政府花费时间移除了所有关键标识符，如姓名、地址和社会安全号码。

您可能已经注意到，在实际操作中使用了许多数据清洗操作，但大多数这些操作可以概括为以下几种类型之一：

• 泛化——这种操作将数据集中特定的值替换为一个更通用的属性。例如，一个人的薪水数值，如 56,000 美元，可以被替换为 50,000 美元至 100,000 美元的范围。在这种情况下，一旦值被清洗，我们就不知道确切的值，但我们知道它在 50,000 美元和 100,000 美元之间。

• 这种方法也可以应用于分类值。考虑之前提到的美国人口普查数据集，它包含就业详情。如图 7.5 所示，我们不是将人们分类到不同的职业中，而是简单地将他们分为“就业”或“失业”，而不暴露个人职业。

图 7.5 通过分组数据来实现泛化。

• 抑制——与泛化用更通用的表示替换原始记录不同，抑制的想法是从数据集中完全删除记录。考虑一个包含医院医疗记录的数据集。在这样的医疗数据库中，根据姓名（一个敏感属性）可以识别个人，因此我们可以在将数据集发布给第三方之前从数据集中删除姓名属性（见图 7.6）。

图 7.6 抑制通过删除原始记录来实现。

• 扰动法——另一种可能的数据净化操作是用具有相同统计属性且可以通过随机化技术生成的扰动数据替换个人记录。

• 一种可能的方法是使用我们在上一节中讨论的技术，如添加或乘法噪声添加，向原始值添加噪声。如图 7.7 的例子所示，原始数据库第一列的记录被基于随机噪声的完全不同的值所替换。

  

  图 7.7 扰动通过添加随机噪声来实现。

  另一种方法是使用第六章中讨论的合成数据生成技术。在这种情况下，使用原始数据构建一个统计模型，然后可以使用该模型生成合成数据，这些数据可以替换数据集中的原始记录。

  另一种可能的方法是使用数据交换技术来实现扰动。其思路是在数据集中交换多个敏感属性，以防止记录与个人关联。数据交换通常从随机选择一组目标记录开始，然后为每个记录找到一个具有相似特征的合适伙伴。一旦找到伙伴，就交换彼此的值。在实践中，数据交换相对耗时（因为它必须循环通过许多记录以找到合适的匹配），并且需要额外的努力来扰动数据。

• 解剖法——另一种可能的净化方法是把敏感属性和准标识符分别放入两个独立的数据库中。在这种情况下，原始值保持不变，但目的是使它们更难以相互关联并识别个人。考虑我们之前在这个列表中讨论过的医疗数据库。如图 7.8 所示，原始数据库可以被分为两个不同的数据库：敏感属性（例如，姓名、宗教）和准标识符（例如，性别、疾病）。

  

  图 7.8 使用解剖法

7.4.1 在 Python 中实现数据净化操作

在本节中，我们将使用 Python 实现这些不同的数据净化技术。对于这个例子，我们将使用 Barry Becker 最初从 1994 年美国人口普查数据库中提取的真实世界数据集[2]。该数据集包含 15 个不同的属性，我们首先将查看数据集的排列方式。然后，我们将应用不同的净化操作，如图 7.9 所示。

图 7.9 本节 Python 代码中使用的顺序和技术

首先，我们需要导入必要的库。如果你已经熟悉以下包，你可能已经安装了所有这些。

我们将使用 pip 命令安装这些库：

pip install sklearn-pandas

一切安装完毕后，将以下包导入到环境中：

import pandas as pd
import numpy as np
import scipy.stats
import matplotlib.pyplot as plt
from sklearn_pandas import DataFrameMapper
from sklearn.preprocessing import LabelEncoder

现在让我们加载数据集并看看它的样子。你可以直接从本书的代码仓库下载数据集（mng.bz/eJYw）。

df = pd.read_csv('./Data/all.data.csv')
df.shape
df.head()

使用 df.shape()命令，你可以获得数据框的维度（行数和列数）。正如你所看到的，这个数据集包含 48,842 条记录，分为 15 个不同的属性。你可以使用 df.head()命令列出数据集的前五行，如图 7.10 所示。

图 7.10 美国人口普查数据集的前五条记录

你可能已经注意到，有一些敏感属性，例如关系、种族、性别、国籍等等，需要匿名化。让我们首先对一些属性应用抑制，以便它们可以被删除：

df.drop(columns=["fnlwgt", "relationship"], inplace=True)

再次尝试 df.head()，看看有什么变化。

处理分类值

如果你仔细查看种族列，你会看到一些分类值，例如白人、黑人、亚洲-太平洋岛民、美洲印第安人-爱斯基摩人等等。因此，在隐私保护方面，我们需要对这些列进行泛化。为此，我们将使用 sklearn_pandas 中的 DataFrameMapper()，它允许我们将元组转换为编码值。在这个例子中，我们使用 LabelEncoder()：

encoders = [(["sex"], LabelEncoder()), (["race"], LabelEncoder())]
mapper = DataFrameMapper(encoders, df_out=True)
new_cols = mapper.fit_transform(df.copy())
df = pd.concat([df.drop(columns=["sex", "race"]), new_cols], axis="columns")

现在再次使用 df.head()检查结果。它将列出数据集的前五行，如图 7.11 所示。

图 7.11 编码值的结果数据集

我们将性别和种族列都进行了泛化，这样就没有人能知道某个人的性别和种族。

处理连续值

连续值，如年龄，仍然可能泄露一些关于个人的信息，正如我们之前讨论的那样。即使种族被编码（记住，种族是一个分类值），有人可能结合几条记录来获得更详细的结果。因此，让我们应用扰动技术来匿名化年龄和种族，如下面的列表所示。

列表 7.1 修改年龄和种族

categorical = ['race']
continuous = ['age']
unchanged = []

for col in list(df):
    if (col not in categorical) and (col not in continuous):
        unchanged.append(col)

best_distributions = []
for col in continuous:
    data = df[col]
    best_dist_name, best_dist_params = best_fit_distribution(data, 500)
    best_distributions.append((best_fit_name, best_fit_params))

对于连续变量年龄，我们使用了一个名为 best_fit_distribution()的函数，该函数遍历一系列连续函数，以找到具有最小误差的最佳拟合函数。一旦找到最佳拟合分布，我们就可以用它来近似年龄变量的新值。

对于分类变量种族，我们首先使用 value_counts()确定唯一值在分布中出现的频率，然后使用 np.random.choice()生成具有相同概率分布的随机值。

所有这些都可以封装在一个函数中，如下面的列表所示。

列表 7.2 对数值和分类值进行扰动

def perturb_data(df, unchanged_cols, categorical_cols, 
    ➥ continuous_cols, best_distributions, n, seed=0):
    np.random.seed(seed)
    data = {}

    for col in categorical_cols:
        counts = df[col].value_counts()
        data[col] = np.random.choice(list(counts.index),
        ➥ p=(counts/len(df)).values, size=n)

    for col, bd in zip(continuous_cols, best_distributions):
        dist = getattr(scipy.stats, bd[0])        
        data[col] = np.round(dist.rvs(size=n, *bd[1]))

    for col in unchanged_cols:
        data[col] = df[col]

    return pd.DataFrame(data, columns=unchanged_cols+categorical_cols+continuous_cols)    

gendf = perturb_data(df, unchanged, categorical, continuous,
➥ best_distributions, n=48842)

使用 gendf.head()命令的结果如图 7.12 所示。

图 7.12 扰动数值和分类值后的结果数据集

仔细观察最后两列。年龄和种族值已被替换为遵循与原始数据相同概率分布的随机生成数据。因此，现在可以将此数据集视为隐私保护的数据集。

我们现在已经讨论了在各种隐私保护应用中常用的数据净化操作。接下来，我们将探讨如何在实践中应用这些操作。我们已经在第 6.2.2 节中介绍了 k-匿名性的基础知识；现在，我们将扩展讨论。下一节将详细介绍 k-匿名性隐私模型，以及其在 Python 中的代码实现。

首先，让我们通过一个练习回顾本节中的净化操作。

练习 1

考虑一个数据挖掘应用与组织员工数据库相关联的场景。为了简洁起见，我们将考虑表 7.1 中的属性。

表 7.1 组织的员工数据库

Number	Name	Gender	Zip code	Salary (k)
1	John	Male	33617	78
2	Alex	Male	32113	90
3	Kishor	Male	33613	65
4	Emily	Female	33617	68
5	Ahmed	Male	33620	75

现在尝试回答以下问题，以使此数据集保持隐私：

• 哪些属性可以使用泛化操作进行净化？如何操作？

• 哪些属性可以使用抑制操作进行净化？如何操作？

• 哪些属性可以使用扰动操作进行净化？如何操作？

• 在此示例中，解剖是否有效？为什么？

7.4.2 k-anonymity

可以用于匿名化数据集的最常见且广泛采用的隐私模型之一是 k-匿名性。Latanya Sweeney 和 Pierangela Samarati 在 1990 年代末在其开创性工作“在披露信息时保护隐私” [3] 中首次提出了它。这是一个简单而强大的工具，强调为了使数据集中的记录不可区分，至少需要 k 个具有相同属性集（可用于唯一识别记录的准标识符）的个体记录。简单来说，如果一个数据集至少有 k 个具有相同敏感属性的相似记录，则该数据集被认为是 k-匿名的。我们将通过一个例子来探讨这一点，以更好地理解其工作原理。

k 是什么，以及如何应用它？

值 k 通常用于衡量隐私，当 k 值较高时，记录的匿名化变得更加困难。然而，当 k 值增加时，数据通常变得更加泛化，因此效用通常会降低。

许多不同的算法被提出以实现 k-匿名性，但其中绝大多数都应用了诸如抑制和泛化等净化操作以达到所需的隐私级别。图 7.13 展示了如何在数据集中定义敏感和非敏感属性，这些属性可以通过 k-匿名性在实践中进行净化。

图 7.13 定义敏感和非敏感属性的样本数据集

在这种情况下有几个重要且敏感的属性和准标识符。因此，当我们应用k-匿名性时，确保所有记录都足够匿名，使得数据用户难以去匿名化记录是至关重要的。

注意：属性的敏感性通常取决于应用程序的要求。在某些情况下非常敏感的属性在其他应用领域可能并不敏感。

让我们考虑图 7.14 中显示的数据集。正如你所见，姓名和宗教属性通过抑制进行了清理，而邮编和年龄则进行了泛化。如果你仔细观察，可能会意识到这是 2 匿名化（k = 2），意味着每个组至少有两条记录。让我们以表中的前两条记录为例。正如你所见，这些记录属于同一组，使得邮编、年龄和性别对两者都相同；唯一的区别是疾病。

图 7.14 使用泛化和抑制

现在让我们考虑一个场景，其中鲍勃知道他的朋友住在 32314 邮编，并且他 34 岁。仅通过查看数据集，鲍勃无法区分他的朋友是否有病毒感染或癌症。这就是k-匿名性的工作方式。原始信息被清理并难以重现，但结果仍可用于数据挖掘操作。在先前的例子中，k = 2，但当我们增加k时，重现原始记录就更加困难了。

K 匿名性并不总是有效

虽然k-匿名性是一种强大的技术，但它有一些直接和间接的缺点。让我们尝试了解这些缺陷，看看k-匿名性如何容易受到不同类型攻击的影响：

• 明智选择敏感属性的重要性—在k-匿名性中，敏感属性的选择必须谨慎进行。然而，所选属性不得泄露已匿名化属性的信息。例如，某些疾病可能在某些地区和年龄组中很普遍，因此有人可能通过参考地区或年龄组来识别疾病。为了避免这种情况，调整那些感兴趣属性的抑制和泛化级别是至关重要的。例如，与其将邮编改为 32，你可能会选择将其抑制到 3*，使原始值更难以猜测。

• 群体数据深度多样化的重要性——数据的多样性对k-匿名性有重大影响。从广义上讲，在k-匿名性方面，关于具有良好代表性的多样化数据存在两个重要问题。第一个问题是每个代表个体在组或等价类中只有一个记录。第二个问题出现在敏感属性的值对于组或等价类中的其他k-1 个记录都相同的情况下，这可能导致识别组中的任何个体。无论敏感属性是否相同，这些问题都可能使k-匿名性容易受到不同类型的攻击。

• 在低维度管理数据的重要性——当数据维度较高时，在实用范围内难以保持k-匿名性所需的数据隐私水平。例如，将多个数据记录串联起来有时可以唯一地识别个体，例如位置数据类型。另一方面，当数据记录分布稀疏时，必须添加大量噪声以将它们分组，以实现k-匿名性。

现在，让我们看看我们提到的攻击以及这些攻击是如何工作的。如图 7.15 所示，这些攻击要生效有一系列前提条件。例如，对于某些攻击，如同质性攻击，要生效，敏感属性的值必须与k-匿名化数据集中组内的其他记录相同。

图 7.15 解释k-匿名性可能存在的缺陷并导致不同攻击的流程图

让我们看看图 7.16 中描述的例子。假设 Alice 知道她的邻居 Bob 被送进了医院，他们两人都住在 33718 邮政编码的地区。此外，Bob 今年 36 岁。有了这些可用的信息，Alice 可以推断 Bob 可能患有癌症。这被称为同质性攻击，其中攻击者使用已有的信息来找到个体所属的记录组。

图 7.16 同质性攻击

或者，这可能导致背景知识攻击，其中攻击者使用外部背景信息来识别数据集中的个体（见图 7.17）。假设 Alice 有一个日本朋友 Sara，她 26 岁，目前住在 33613 邮政编码的地区。她还知道日本人的心脏病死亡率非常低。据此，她可以得出结论，她的朋友可能患有病毒感染。

图 7.17 背景知识攻击

如您所见，我们可以通过增加等价组中敏感值的多样性来防止由属性披露问题引起的攻击。

7.4.3 在 Python 中实现 k-匿名性

现在我们来实现代码中的 k-匿名性。为此，我们将使用 Python 中的 cn-protect [4] 包。（在出版时，CN-Protect 库已被 Snowflake 收购，库不再公开可访问。）你可以使用以下 pip 代码安装它：

pip install cn-protect

一旦准备就绪，你可以加载我们清理过的美国人口普查数据集以及以下列出的包。这个数据集版本可在代码仓库中下载（mng.bz/eJYw）。

列 7.3 导入数据集并应用 k-匿名性

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from cn.protect import Protect
sns.set(style="darkgrid")

df = pd.read_csv('./Data/all.data.csv')

df.shape
df.head()

结果将类似于图 7.18。

图 7.18 导入数据集的前几条记录

使用 Protect 类，我们首先定义什么是准标识符：

prot = Protect(df)
prot.itypes.age = 'quasi'
prot.itypes.sex = 'quasi'

你可以使用 prot .types 命令查看属性类型，如图 7.19 所示。

图 7.19 定义准标识符的数据集属性

现在是设置隐私参数的时候了。在这个例子中，我们使用 k-匿名性，所以让我们将 k 值设置为 5：

prot.privacy_model.k = 5

一旦设置好，你可以通过使用 prot.privacy_ model 命令来查看结果。结果应该类似于以下内容：

<KAnonymity: {'k': 5}>

你可以使用以下代码片段观察结果数据集（见图 7.20）：

prot_df = prot.protect()
prot_df

图 7.20 一个 5-匿名化的美国人口普查数据集

仔细观察结果中的年龄和性别属性。现在数据集已经实现了 5-匿名化。通过更改参数自己尝试一下。

练习 2

考虑一个数据挖掘应用场景，该场景涉及来自抵押贷款公司的以下贷款信息数据库。假设表 7.2 中显示的数据集具有许多属性（包括抵押贷款历史、贷款风险因素等）和记录，尽管表格只显示了其中的一些。此外，数据集已经实现了 2-匿名化（k = 2）。

表 7.2 简化的员工数据库

编号	姓名	年龄	区码	借款人种族	借款人收入
1	*	21-40	336**	黑人或非裔美国人	65k
2	*	31-40	34***	亚洲	80k
3	*	31-40	34***	白人	85k
4	*	21-40	336**	黑人或非裔美国人	130k

现在尝试回答以下问题，看看这个匿名化数据集是否仍然泄露了一些重要信息：

• 假设约翰知道他的邻居爱丽丝申请了抵押贷款，并且他们两人都住在 33617 区码？约翰可以推断出哪些信息？

• 如果爱丽丝是一位非裔美国女性，约翰还能了解哪些额外信息？

• 你如何保护这个数据集，使得约翰无法了解除爱丽丝的区码和种族之外的信息？

摘要

• 在数据挖掘和管理操作中采用隐私保护技术不是一种选择。如今，它对于今天的数据驱动应用来说，比以往任何时候都更加必要。

• 通过使用不同的噪声添加技术修改输入数据，可以在数据挖掘中实现隐私保护。

• 当发布数据以在数据挖掘应用中保护隐私时，可以使用不同的数据净化操作（泛化、抑制、扰动、解剖）。

• 数据净化操作可以根据应用需求以不同的方式实现。

• K-匿名性是一个广泛使用的隐私模型，可以在数据挖掘操作中实现。它允许我们在提供灵活性的同时应用各种净化操作。

• 虽然 k-匿名性是一种强大的技术，但它也有一些直接和间接的缺点。

• 在同质性攻击中，攻击者利用已有的信息来找到个体所属的记录组。

• 在背景知识攻击中，攻击者利用外部背景信息来识别数据集中的一名个体。

8 隐私保护的数据管理和操作

本章涵盖了

• 广泛使用的数据发布隐私模型

• 数据库系统中的隐私威胁和漏洞

• 在数据库管理系统中发现隐私保护策略

• 实现隐私保护数据库系统的数据库设计考虑因素

在上一章中，我们讨论了可以在数据挖掘操作中利用的不同隐私增强技术以及如何实现k-匿名性隐私模型。在本章中，我们将探讨研究社区提出的另一组旨在减轻k-匿名性模型缺陷的隐私模型。在本章的末尾，我们将讨论数据管理技术的最新发展，这些隐私机制如何在数据库系统中实施，以及设计隐私增强的数据库管理系统时需要考虑的因素。

8.1 数据处理和挖掘中的隐私保护快速回顾

您已经看到，数据分析和管理工具旨在从收集的数据集中提取有意义的特征和模式，并且直接在数据挖掘中使用原始数据可能会导致不希望的数据隐私侵犯。因此，我们使用不同的数据净化操作来最小化私人信息的披露。为此，第七章和本章的讨论涵盖了两个特定的方面，总结在图 8.1 中：

• 数据处理和挖掘——可以在收集的信息被数据挖掘和分析工具处理和分析时使用的工具和技术。

• 数据管理——可以用于存储、存储和为不同的数据处理应用提供服务所收集信息的方法和技术。

图 8.1 数据挖掘和管理中的隐私保护有两个主要方面。在本章中，我们将详细阐述这两个不同的方面。

到目前为止，我们已经讨论了不同的数据净化操作，它们在 Python 中的实现，以及在k-匿名性隐私模型中的应用。在下一节中，我们将继续讨论其他超越k-匿名性的流行隐私模型。

8.2 超越 k-匿名性的隐私保护

K-匿名性是一种非常强大且简单的技术，可以在许多不同场景中用于保护数据挖掘操作中的隐私。然而，正如我们在上一章所讨论的，k-匿名性并不适用于所有情况，如图 8.2 中的流程图所示。它容易受到不同的攻击，例如同质性和背景知识攻击（详情请参阅第 7.4.2 节）。让我们扩展我们对隐私保护的讨论，看看我们如何可以减轻这些缺陷。

图 8.2 解释k-匿名性可能存在的缺陷并导致不同攻击的流程图。如图所示，即使经过匿名化，如果一条记录可以用来识别个人，它可能会导致背景知识攻击或同质性攻击。

8.2.1 l-多样性

由于k-匿名性的局限性，Machanavajjhala 等人于 2007 年引入了一种称为l-多样性的新技术[1]（其中的“l”代表light）。它是k-匿名性的扩展，其中l-多样性表明每个组必须至少有l个不同的敏感记录。与k-匿名性模型类似，增加l值会增加同一组中敏感值的变异性，使其对可能的隐私泄露更加稳健。

让我们考虑我们在上一章讨论的相同医院数据集场景，并取图 8.3 中显示的k-匿名化示例。

图 8.3 k-匿名性（k=2）的示例

这些数据记录已经是 2-匿名（k = 2）。然而，如果攻击者知道 Alice 住在邮编 34317，他们可以轻松地将搜索范围缩小到最后两行。此外，即使攻击者无法区分哪个记录属于 Alice，他们也可以轻易地推断出 Alice 患有病毒感染。问题是该组中的所有患者都共享相同的准标识符；因此，会泄露私人信息。

l-多样性的基本方法是要确保每个组至少有l个不同的敏感值，这样就不容易识别任何个人。让我们将图 8.3 中的数据集变为 2-多样性（l = 2）。如图 8.4 所示，现在每个组至少有两个不同的敏感值。例如，第一和第四条记录属于同一个组，邮编为 3****，年龄为 21-40 岁，但他们有两种不同的疾病（季节性流感和病毒感染）。同样，第二和第三条记录属于同一个组，但有两种不同的疾病，因此无法区分哪个记录属于哪个患者。因此，攻击者很难知道哪个记录对应 Alice 以及疾病是什么，根据现有信息。

图 8.4 图 8.3 中示例的 2-多样性（l=2）版本

是否会泄露任何信息？

除了k-匿名性之外的隐私保证外，l-多样性也受到一些限制：

• 数据多样性仍然可能泄露一些敏感信息——即使有l-多样性数据，在某些情况下敏感信息仍可能泄露。让我们考虑与图 8.5 中的示例相同的医院数据集场景，该示例提供 2-多样性。

• 

  图 8.5 如何泄露l-多样性敏感信息

  让我们假设攻击者知道 Bob 住在 32317 邮政编码且 35 岁。攻击者可以缩小搜索范围，使得 Bob 要么患有黑色素瘤，要么患有基底细胞癌。考虑到这些信息，攻击者可以推断 Bob 患有可能是癌性的皮肤病。因此，仍然泄露了一些私人信息。

• 概率分布也可能泄露一些信息——在某些情况下，即使有l-多样性数据集，概率分布也可能泄露一些信息，使数据集容易受到攻击者的攻击。这种隐私泄露被称为偏斜攻击。

• 考虑图 8.6 所示的数据集。如图所示，它已经是一个 2-多样性数据集，但让我们考虑一个知道 Bob 住在 33617 邮政编码且 27 岁的攻击者。在这个时候，攻击者不知道 Bob 是否有病毒感染或心脏病，但根据数据分布，攻击者知道 Bob 患有心脏病的可能性更高。

  

  图 8.6 概率分布也可能泄露一些信息。

你可以看到，在数据集中拥有多样化的属性集是不够的。我们还需要在类别内平衡数据分布。

“类别内”是什么意思？

等价类是一组属于同一组的记录。例如，图 8.6 中第二组的九条记录都属于同一个邮政编码和年龄类别。同样，第一组的记录也具有相似的性质。这些不同的组可以被称为类别，我们使用类别内的数据分布来找出它们的统计特性。

8.2.2 t-接近度

从l-多样性方法的缺陷中吸取教训，Li 等人提出了另一个名为t-接近度的隐私模型[2]，以防止由于分布偏斜导致的属性泄露。t-接近度的理念是保持每个组（等价类）中敏感记录的分布与原始数据集中相应分布足够接近。换句话说，根据t-接近度原则，原始数据集中一个属性的分布与组内相同属性的分布之间的距离应该小于或等于t。

我们可以让X = (x[1], x[2], ..., x[n])表示原始数据集中敏感属性的值分布，而Y = (y[1], y[2], ..., y[n])表示所选组中相同属性的值。为了使这两个分布满足t-接近度，以下方程必须成立：

让我们考虑我们之前提到的医院数据挖掘场景，并使用图 8.7 中另一个 3-多样性数据集的例子。

图 8.7 一个 3-多样性数据集的例子，容易受到偏斜攻击

如你所见，数据集有三个不同的组，每个组有三个不同的记录。然而，它仍然容易受到我们在上一节中讨论的偏斜攻击的影响。假设攻击者已经知道他的朋友鲍勃的记录属于第一组。攻击者可以推断鲍勃可能有一些与胃相关的疾病，因为第一组中的所有疾病都与胃有关。因此，特定的多样性可能提供不同级别的隐私——我们需要考虑数据的整体分布。

让我们尝试将这个数据集转换为 t-接近度版本。正如我们在本节开头提到的，t-接近度依赖于概率分布之间的距离。有两种不同的方式来衡量两个概率分布之间的距离，但在实践中，t-接近度使用地球移动距离（也称为 Wasserstein 度量）、Kullback-Leibler 距离或变分距离等距离度量。

图 8.8 如何使用 t-接近度防止偏斜攻击

考虑如图 8.8 所示的相同数据集的匿名 t-接近度版本。由于攻击者无法清楚地判断鲍勃是否有与胃相关的疾病，因此偏斜攻击已被防止。

什么是地球移动距离？

地球移动距离（EMD）是评估两个数学分布之间相似性的技术。假设你有一个名为“空洞”的分布和另一个名为“地球元素”的分布。EMD 的想法是通过将地球元素移动到空洞中来填充空洞。EMD 通过将单位地球元素通过单位地面距离运输来衡量填充空洞所需的最小工作量。

假设 P = (p[1], p[2], ..., p[m]) 是地球元素的质量，而 Q = (q[1], q[2], ..., q[m]) 代表空洞。P 中元素 i 和 Q 中元素 j 之间的地面距离可以表示为 d[ij]。

流量 F = [f[ij]]（其中 f[ij] 是 p[i] 和 q[j] 之间的权重流量）可以定义为最小化总成本，[2]

受以下约束条件限制：

一旦解决了运输问题并找到了最优流量 F，EMD 被定义为总流量归一化的工作量，如下所示：

让我们通过一个例子来看看 EMD 是如何工作的。

为运输问题计算的可能流量排列之一

如您所见，P 和 Q 的权重之和为 1。然而，这只是可能的一种流。还可能有以下另一个优化流。

为运输问题计算的最优流

现在已经找到了最优流，EMD（P，Q）= 109.05。

这里最重要的点是，我们已经更改（泛化和抑制）了邮政编码和年龄属性，这使得我们可以交换记录 2 和 8，使得难以在每个组中识别疾病。

8.2.3 使用 Python 实现隐私模型

现在让我们尝试在 Python 中使用这些隐私模型。对于这个例子，我们将使用 Barry Becker 从 1994 年美国人口普查数据库中最初提取的成人数据集 [3]。该数据集包含 15 个不同的属性，我们将探讨如何使用 k- 匿名、l- 多样性和 t- 接近度对其进行隐私化。（此示例代码受 N. Prabhu 在 GitHub 上的实现 [4] 的启发）。

首先，我们需要导入必要的库。如果您已经熟悉以下包，您可能已经安装了所有内容。如果没有，请使用 pip 命令开始安装。

列表 8.1 准备数据集

pip install sklearn-pandas

import pandas as pd                                                   ❶
import matplotlib.pylab as pl
import matplotlib.patches as patches

from IPython.core.interactiveshell import InteractiveShell            ❷
InteractiveShell.ast_node_interactivity = "all"

names = ('age', 'workclass', 'fnlwgt', 'education', 'education-num',  ❸
         'marital-status', 'occupation', 'relationship', 
         'race', 'sex', 'capital-gain', 'capital-loss', 
         'hours-per-week', 'native-country', 'income',)

categorical = set(('workclass', 'education', 'marital-status', 
                   'occupation', 'relationship', 'sex',
                   'native-country', 'race', 'income',))

df = pd.read_csv("./Data/adult.all.txt", 
                 sep=", ", header=None, names=names, 
                 index_col=False, engine='python')

df.head()                                                             ❹
df.nunique()

❶ 一切安装完毕后，将以下包导入到环境中。

❷ 启用 shell 显示所有输出。

❸ 定义表头名称和分类属性。

❹ 打印表头。

该数据集包含 48,842 条记录，分为 15 个不同的属性，如图 8.9 所示。

图 8.9 美国人口普查数据集的前几条记录

让我们通过查看每一列来查找值范围，如下面的列表所示。

列表 8.2 寻找值范围

for name in categorical:                      ❶
    df[name] = df[name].astype('category')    

def get_spans(df, partition, scale=None):     ❷

    spans = {}
    for column in df.columns:
        if column in categorical:
            span = len(df[column][partition].unique())
        else:
            span = df[column][partition].max()-df[column][partition].min()
        if scale is not None:
            span = span/scale[column]
        spans[column] = span
        print("Column:", column, "Span:", span)
    return spans

full_spans = get_spans(df, df.index)

❶ 将这些属性分类。

❷ 获取值范围。

现在让我们对数据集进行分区。我们的示例是 k- 匿名化，k = 3，我们使用年龄和教育编号属性作为准标识符。

列表 8.3 数据集划分

def split(df, partition, column):                              ❶
    dfp = df[column][partition]
    if column in categorical:
        values = dfp.unique()
        lv = set(values[:len(values)//2])
        rv = set(values[len(values)//2:])
        return dfp.index[dfp.isin(lv)], dfp.index[dfp.isin(rv)]
    else:        
        median = dfp.median()
        dfl = dfp.index[dfp < median]
        dfr = dfp.index[dfp >= median]
        return (dfl, dfr)

def is_k_anonymous(df, partition, sensitive_column, k=3):      ❷
    if len(partition) < k:
        return False
    return True

def partition_dataset(df, feature_columns, sensitive_column, 
    ➥ scale, is_valid):                                       ❸
    finished_partitions = []
    partitions = [df.index]
    while partitions:
        partition = partitions.pop(0)
        spans = get_spans(df[feature_columns], partition, scale)
        for column, span in sorted(spans.items(), key=lambda x:-x[1]):
            lp, rp = split(df, partition, column)
            if not is_valid(df, lp, sensitive_column) or 
            ➥ not is_valid(df, rp, sensitive_column):
                continue
            partitions.extend((lp, rp))
            break
        else:
            finished_partitions.append(partition)
    return finished_partitions

feature_columns = ['age', 'education-num']
sensitive_column = 'income'
finished_partitions = partition_dataset(df, 
➥ feature_columns, sensitive_column, full_spans, 
➥ is_k_anonymous)

❶ 根据分类与否分割数据框。

❷ 检查是否为 k-匿名（k=3）。

❸ 分割数据集。

现在数据集已经划分，让我们根据分区构建匿名数据集，如下面的列表所示。

列表 8.4 构建匿名数据集

def agg_categorical_column(series):
    return [','.join(set(series))]

def agg_numerical_column(series):
    return [series.mean()]

def build_anonymized_dataset(df, partitions, 
    ➥ feature_columns, sensitive_column, max_partitions=None):    ❶
    aggregations = {}
    for column in feature_columns:
        if column in categorical:
            aggregations[column] = agg_categorical_column
        else:
            aggregations[column] = agg_numerical_column
    rows = []
    for i, partition in enumerate(partitions):
        if i % 100 == 1:
            print("Finished {} partitions...".format(i))
        if max_partitions is not None and i > max_partitions:
            break
        grouped_columns = df.loc[partition].agg(aggregations,
        ➥ squeeze=False)

        sensitive_counts = df.loc[partition].groupby(
        ➥ sensitive_column).agg({
        ➥ sensitive_column : 'count'})
        values = grouped_columns.iloc[0].to_dict()
        for sensitive_value, count in 
        ➥ sensitive_counts[sensitive_column].items():
            if count == 0:
                continue
            values.update({
                sensitive_column : sensitive_value,
                'count' : count,
            })
            rows.append(values.copy())
    return pd.DataFrame(rows)

dfn = build_anonymized_dataset(df, finished_partitions, 
➥ feature_columns, sensitive_column)

dfn.head()                                                        ❷

❶ 构建匿名数据集。

❷ 打印表头。

结果数据集将类似于图 8.10。

图 8.10 具有 k-匿名的匿名数据集

我们已经使用 k- 匿名对数据集进行了匿名化。现在让我们使用 l- 多样性对其进行匿名化。在下面的列表中，我们将使用 l = 2 的值。

列表 8.5 使用 l-多样性匿名化数据集

def diversity(df, partition, column):
    return len(df[column][partition].unique())

def is_l_diverse(df, partition, sensitive_column, l=2):            ❶
    return diversity(df, partition, sensitive_column) >= l

finished_l_diverse_partitions = partition_dataset(df, 
➥ feature_columns, sensitive_column, full_spans, 
➥ lambda *args: is_k_anonymous(*args) and is_l_diverse(*args))

column_x, column_y = feature_columns[:2]
dfl = build_anonymized_dataset(df, finished_l_diverse_partitions,
➥  feature_columns, sensitive_column)

print(dfl.sort_values([column_x, column_y, sensitive_column]))     ❷
dfl.head()

❶ 检查是否为 l-多样性（l=2）。

❷ 打印 l-多样化输出。

结果数据集如图 8.11 所示。

图 8.11 具有 l-多样性的匿名数据集

现在我们将使用t-closeness 对相同的数据集进行匿名化。不过，首先我们需要检查频率。

列表 8.6 检查频率

global_freqs = {}
total_count = float(len(df))
group_counts = df.groupby(sensitive_column)[sensitive_column].agg('count')
for value, count in group_counts.to_dict().items():
    p = count/total_count
    global_freqs[value] = p

print(global_freqs)     ❶

❶ 打印频率。

你可能会注意到，收入<=50k 的整体概率是 0.76，而收入>50k 的概率是 0.24。现在让我们根据这个概率使用t-closeness 对数据集进行匿名化。

列表 8.7 使用t-closeness 匿名化数据集

def t_closeness(df, partition, column, global_freqs):                      ❶
    total_count = float(len(partition))
    d_max = None
    group_counts = df.loc[partition].groupby(column)[column].agg('count')
    for value, count in group_counts.to_dict().items():
        p = count/total_count
        d = abs(p-global_freqs[value])
        if d_max is None or d > d_max:
            d_max = d
    return d_max

def is_t_close(df, partition, sensitive_column, global_freqs, p=0.2):      ❷
    if not sensitive_column in categorical:
        raise ValueError("this method only works for categorical values")
    return t_closeness(df, partition, sensitive_column, global_freqs) <= p

finished_t_close_partitions = partition_dataset(df, 
➥ feature_columns, sensitive_column, full_spans, 
➥ lambda *args: is_k_anonymous(*args) 
➥ and is_t_close(*args, global_freqs))

dft = build_anonymized_dataset(df, finished_t_close_partitions,
➥ feature_columns, sensitive_column)                                      ❸

#print the header
print(dft.sort_values([column_x, column_y, sensitive_column]))
dft.head()

❶ 计算t-closeness。

❷ 检查敏感列是否为分类列。

❸ 构建匿名化数据集。

结果数据集将类似于图 8.12。

图 8.12 基于t-closeness 的匿名化数据集

8.3 通过修改数据挖掘输出保护隐私

到目前为止，我们已经讨论了两种主要的隐私保护数据挖掘技术：第一种是在收集信息时，第二种是在发布数据时（见图 8.13）。现在我们正在探讨另一类重要的 PPDM，它与如何调节数据挖掘输出以保护数据隐私的技术相关。

图 8.13 不同 PPDM 技术的概览

通用思路是确保挖掘过程的结果（输出值）不会泄露任何敏感信息。问题是，有时在提交查询时，即使没有直接访问原始数据集，数据挖掘算法的输出也可能泄露敏感信息。

让我们考虑一个场景，即一个组织的员工数据库已经使用* k*-匿名性等技术进行了匿名化。不同的应用程序使用该数据集进行数据挖掘操作以做出预测性决策。

假设一个针对特定查询的数据挖掘算法返回所有收入超过$100,000 且年龄在 25-35 岁之间的员工的记录。由于数据集已经匿名化，我们不知道这些员工的名字，但根据数据挖掘输出，有人可能会推断这些员工可能有自己的车，考虑到他们的年龄和工资。这是一个简单的例子，但它可以强调保护数据挖掘输出以确保个人隐私的重要性。

现在我们将调查为保护数据挖掘算法输出泄露而开发的不同的隐私技术。

8.3.1 关联规则隐藏

关联规则数据挖掘是寻找数据模式和关联的一种流行的数据挖掘方法。通常，关联规则挖掘可以用来探索数据的特征（属性的维度），例如哪些特征相互关联，哪些特征同时出现。

例如，考虑一个场景，我们正在挖掘患者记录数据库。这个数据集可以用来找出已经患有疾病 A 的患者是否也可能会患有疾病 B。这被称为关联规则；如果疾病 A 发生，患者可能也会患有疾病 B。在另一个不同背景下，另一个经典例子是，收入超过$100,000 且年龄在 25-35 岁之间的人是否可能拥有房屋。这就是关联规则数据挖掘的工作方式。我们匹配两个或更多属性之间的关联以发现新的发现。

一旦建立了关联规则，可以使用两个重要参数来评估规则的有效性，这两个参数称为支持度和置信度。支持度指的是历史数据支持挖掘规则的程度，而置信度指的是你对建立的规则有多大的信心。

问题在于，这些规则中的一些可能明确地披露有关个人的私人信息。让我们考虑之前的例子，涉及收入和年龄。它可以揭示拥有房屋的个人年收入，这可能是应该保密的私人信息。

关联规则隐藏是一种技术，它允许在非敏感规则上进行数据挖掘操作，同时防止使用敏感规则。关联规则隐藏的一个典型方法是通过数据抑制操作删除与敏感规则相关的数据条目。例如，上述例子中的收入属性将被净化，并且不会包含在数据挖掘输出中。然而，这可能会隐藏大量的非敏感规则，从而降低数据挖掘操作的效用。因此，人们提出了不同的最优解决方案。

而不是完全抑制敏感属性，这些属性可以用其他（噪声）值来替换，以降低关联规则的支持度和置信度。例如，在不完全抑制收入属性的情况下，我们可以在生成结果时向其中添加一些噪声，以确保原始值永远不会暴露。正如我们在本书的第二章和第三章中讨论的那样，差分隐私是产生噪声结果的一种流行方法。

8.3.2 降低数据挖掘操作的精度

可能存在敌手可以误导数据挖掘操作以揭示其他个人敏感信息的情况。通常，这些敌手用户会通过恶意输入来欺骗或误导系统。例如，考虑一个场景，敌手向疾病诊断机器学习服务提供某人的医疗记录，以检查该人是否患有癌症。这被称为成员推理攻击，在数据挖掘操作中这是一个威胁性的情况。

在成员推理攻击中，攻击者试图推断出用于训练具有黑盒访问权限的机器学习模型的个人原始记录。例如，假设攻击者使用爱丽丝的个人信息公开信息来确定记录是否在原始数据集（训练集）中。为了实现这一点，攻击者通常会使用一个辅助的机器学习模型，该模型使用主模型的预测结果构建。

如图 8.14 所示，给定一个机器学习模型、一个输入样本和攻击者的领域知识，成员推理攻击试图确定该样本是否是用于构建机器学习模型的原始训练数据集的成员。这种攻击利用了在训练阶段由模型预测产生的输出数据与训练集未包含的数据之间的差异。通常，这些攻击模型是使用从真实数据的噪声版本或其他方法（如我们在第 1.3 节中讨论的模型反演攻击）生成的阴影（攻击）模型进行训练的。

图 8.14 成员推理攻击的工作原理

为了防止此类攻击同时支持数据挖掘操作，通常使用精度降低方法（将精度降低到某个水平）。然而，每当精度降低时，数据挖掘操作的结果就会变得不那么准确。因此，想法是确保尽管攻击者可以推断出更多信息，但攻击者不能得出精确的结论。

8.3.3 统计数据库中的推理控制

为了保护隐私而规范数据挖掘输出的另一个重要方面是采用推理控制机制。当数据库中的数据记录频繁更新时，为每次数据挖掘操作生成一个单独的清洗数据集是具有挑战性的。因此，组织有时会提供对原始数据集的有限访问权限，允许进行统计查询，如聚合。

让我们回到我们在第七章中讨论的电子商务示例。通常，此类应用的底层数据库更新非常频繁。这使得维护数据集的清洁当前版本具有挑战性。在实践中，我们通常允许数据挖掘操作在原始未清洗数据上执行一组有限的统计查询（如 COUNT、MAX、SUM 等）。然而，某些查询可能仍然会泄露敏感信息，因此通常实施不同的推理控制机制。

正如你在图 8.15 中可以看到的，不允许在员工详细信息数据库中进行诸如“亚历克斯的年龄是多少？”这样的查询，但可以回答诸如“最高工资是多少？”这样的查询。这里的担忧是，有人可能会假设首席执行官是公司中薪酬最高的员工，因此他们的薪水是 85,000 美元。我们如何减轻这种担忧？

图 8.15 如何对聚合查询进行推理控制的示例

最直接答案是，我们不必返回确切的值；相反，我们可以返回一个范围作为答案。例如，我们可以返回 $50,000-100,000 而不是 $85,000 作为答案。还有一些其他的方法。我们将在 8.4.4 节中讨论在统计数据库上实现推理控制的常见方法。

8.4 数据管理系统中的隐私保护

到目前为止，我们已经讨论了不同的方法来增强隐私，特别是在数据挖掘操作中。但如果数据在源头泄漏怎么办？让我们看看如何在数据库级别处理隐私。

让我们回到我们的电子商务应用示例。通常，一个连接到电子商务应用（如亚马逊）的数据库在几分钟内可以处理数千笔交易或记录。显然，数据库需要管理这些信息。除了管理高量的交易外，该应用还需要提供额外的功能，如产品推荐，这涉及到数据挖掘。因此，除了简单的存储功能外，现代数据库系统还需要提供强大的数据挖掘能力。

随着组织对数据库系统的使用增加，尤其是大数据，这些系统管理的信息的安全性变得更加重要。机密性、完整性和可用性被认为是数据安全和隐私的基础，但在现代数据库系统中实现这些属性仍然是一个重大问题。数据库基础设施从本地到分布式云架构的迁移也增加了安全和隐私泄露的风险，而且大多数组织不会将关键任务数据存储在云端，因为当数据存储在本地时，对安全性的信心更高。因此，数据库系统的新挑战是利用它们为大数据应用提供的最先进性能优势，同时不牺牲安全性。本节将讨论在设计数据库管理系统时需要考虑的因素，以便满足现代数据隐私需求。

8.4.1 数据库安全和隐私：威胁和漏洞

在我们探讨如何在数据库系统中集成增强隐私的技术之前，让我们快速回顾一些保护数据的一般技术。

行业目前采用的数据保护方案

让我们看看数据库系统中提供安全性的现有解决方案。今天大多数可用的关系数据库系统都配备了加密机制来保护静态和传输中的数据。其中一些加密技术是针对特定数据库系统的，而另一些则由许多供应商应用。

透明数据加密（TDE）是许多供应商采用的一种技术，用于保护静态数据。Oracle 数据库和 Microsoft SQL Server 是两种流行的关系型数据库系统，它们使用 TDE 作为其主要的数据加密机制。它们通过在硬盘和备份媒体上加密数据库，在文件级别实施保护。然而，许多 NoSQL 解决方案，如 Riak、Redis、Memcached 和 CouchDB，被设计成在安全和可信的环境中工作，因此它们不提供加密机制。尽管如此，Cassandra 和 HBase 等 NoSQL 数据存储现在在其企业版本中包含 TDE，以提供静态数据的加密。

虽然静态数据保护是在数据库引擎中实现的，但同样重要的是确保数据在交换时或数据库服务器与客户端应用程序或其他同一集群内的节点之间的通信过程中得到保护。传统上，大多数数据库系统都采用了防火墙策略、操作系统配置或组织级别的虚拟专用网络（VPN）来确保节点间通信的安全性，因为它们通常是在本地可信环境中部署的。然而，数据存储现在越来越分布式，它们的部署架构已经从本地转变为云基础设施，因此需要特殊的机制来确保传输中的数据保护。包括 NoSQL 和 NewSQL 在内的大多数数据库系统现在通过使用传输层安全性（TLS）支持传输中的数据加密。

什么是 TLS？

传输层安全性（TLS）是一种广泛采用的加密安全协议，它促进了两个或更多通信计算机应用程序之间的隐私和数据安全。在当今世界，TLS 的主要用例是加密 Web 应用程序和服务器之间的通信，例如浏览器加载网站。除此之外，TLS 还用于许多其他应用程序，以加密通信，如电子邮件、消息和 IP 语音（VoIP）。

隐私保证非常具有挑战性！

即使有了所有这些安全机制，在实际部署中确保数据隐私仍然具有挑战性。你可能已经注意到，大多数最新的数据库引擎并没有提供任何类型的集成机制来保护数据免受安全或隐私攻击[5]。管理敏感信息的数据库系统中的大规模妥协已经影响了针对现有数据库系统中可用的典型安全和隐私机制之外的信息安全新技术的积极研究。

由于现代大数据应用的需求，也提出了各种协议，用于将数据安全地外包给第三方数据库服务器，使用强加密原语，如全同态加密、无感知 RAM、顺序保持加密等[6]。然而，一些最近的研究已经证明了成功的攻击，尤其是在加密数据库上，并发现这些系统仍然容易受到攻击[7]、[8]、[9]。因此，如果你计划部署新的数据驱动型应用，了解数据库系统中的性能和隐私权衡是至关重要的，包括不同的攻击策略。

8.4.2 现代数据库系统泄露私人信息的可能性有多大？

既然你已经对现有的安全机制有了背景了解，让我们详细看看数据库系统是如何泄露私人信息的。

数据库系统中最严重的威胁通常是主动攻击者，他们完全控制数据库服务器并执行任意恶意数据库操作。例如，数据库和系统管理员或云服务提供商通常可以无限制地访问生产数据库。他们可以执行恶意操作并从数据库中推断敏感信息。这种攻击很难防御。

除了这些主动攻击者之外，还可能有被动攻击者，他们不会干扰数据库的功能，而是被动地观察所有操作。我们通常将它们归类为“诚实但好奇”。他们通常会观察和分析数据用户发出的查询，并查看查询如何访问数据。

大多数这些威胁模型都是理论上的抽象。然而，还有许多其他类型的数据泄露，例如通过数据库日志文件、虚拟机（VM）快照泄露、应用程序核心转储等。下一节将讨论针对数据库系统的各种可能的攻击[5]。

8.4.3 对数据库系统的攻击

我们可以将对数据库系统的攻击分为两大类：

• 对数据机密性的攻击——对于大多数违反数据机密性的攻击，攻击者是“诚实但好奇”的人——他们有一些访问数据库服务器或嗅探服务器端通信的手段。然而，对于查询劫持攻击，例如注入攻击，攻击者可能在客户端，当数据库客户端或协议包装器处理 Web 请求时，将恶意代码注入远程 Web 访问请求（通过 API）。

• 对数据隐私的攻击——对于大多数针对隐私泄露的攻击，攻击者可能是合法的数据用户，他们可以无限制地访问数据库，例如数据分析师。

在高层次上，机密性控制防止对机构手中已有的信息的未经授权使用。相比之下，隐私保护个人控制机构收集、维护和与他人共享的信息的权利。

在本章的结尾，我们将探讨为满足用户隐私需求而量身定制的隐私保护数据库系统的设计考虑因素。为了实现这一点，研究这些攻击向量的影响是至关重要的。

图 8.16 展示了典型的数据库服务器部署并总结了可能的数据库攻击。正如您所看到的，数据泄露的可能性有很多，甚至在数据库级别处理之前：在客户端驱动程序或包装器中，在通信通道中，或者在服务器端的操作系统级别。让我们详细看看这些。

图 8.16 一个典型的数据库服务器部署。攻击可能导致数据泄露发生在客户端、网络接口本身，甚至在服务器端组件上。

针对数据机密性的攻击

数据库攻击的第一类是基于攻击者突破数据机密性的能力。让我们看看这些攻击如何在日常应用中部署：

• 注入攻击—SQL 注入是一种常见的攻击，通过在基于 SQL 的查询语句中插入恶意代码，该应用程序将其传递给数据库客户端（在客户端机器上）。大多数数据库在系统级诊断表中收集和存储性能统计信息，这些信息可用于数据库调整和解决诊断问题。有时，这些表会保留当前执行查询的时间戳列表（例如，MySQL 中的信息模式和性能模式数据库）。有了当前执行查询的列表，攻击者可以轻松地获取其他用户执行的查询列表。这在 NoSQL 数据库中也是可能的，一些研究表明攻击者可以通过注入恶意代码绕过身份验证机制非法提取数据。

• 重建（泄露滥用）攻击—这是一种攻击策略，其中攻击者利用一些泄露来恢复查询信息。这种攻击可以基于查询访问模式和通信量。

  基本上，使用查询访问模式进行的重建攻击涉及服务器学习特定查询返回的哪些记录。相比之下，使用通信量进行的重建攻击涉及服务器学习查询返回了多少记录。此外，这些攻击即使在加密数据库（EDBs）中也是可能的。正如你在本节开头所学的，加密数据库是安全数据库系统，其中数据以加密形式（而非明文）存储，这样查询仍然可以进行。大多数 EDBs 依赖于某种类型的属性保持加密（PPE）机制（例如，确定性或顺序保持加密），这使得它们能够执行各种数据库操作。然而，由于底层加密算法的弱点，这些解决方案仍然会泄露一些信息。

• 具体攻击——另一种可能的攻击场景是持久存储（磁盘盗窃）。大多数符合 ACID 规范的数据库使用磁盘日志文件来简化最近事务的回滚操作。通过使用标准的取证技术，这些日志文件可以用来重建数据库上发出的过去查询事务。此外，SQL 查询的时间可能携带敏感信息，这些信息可以从支持复制事务的日志文件中提取。这些攻击可以通过使用静态数据加密机制来缓解。

• 快照泄露——现代数据库系统越来越多地部署在虚拟机上，因此它们面临着一种称为虚拟机镜像泄露攻击的威胁。在这种情况下，攻击者获取虚拟机的快照镜像，从而揭示整个持久或易失性内存的特定时间点状态。此外，通过访问缓存内存中的单个页面，攻击者可以泄露有关过去执行查询的信息。

• 全面系统破坏——全面系统破坏是一种攻击策略，涉及根数据库系统并获取对数据库和操作系统状态的完全访问权限。这可能是一种持续的被动或主动攻击；被动攻击更为常见。

针对数据隐私的攻击

我们已经讨论了一些针对数据机密性的攻击。然而，我们今天面临的一个主要担忧是将不同类型的数据集链接在一起，以揭示个人的独特指纹或敏感信息（也称为再识别）。通常，这些都是内部攻击，并且可以分为两个子类：

• 关联攻击——在关联攻击中，数据集中的值与其他信息源相关联，以创建独特且信息丰富的条目。考虑医院数据库和药店数据库的场景。如果一个公开的数据库列出了带有药物处方的用户信息，而另一个列出了带有访问药店的用户信息，将它们联系起来可以提供有关哪些患者从哪些药店购买药物的信息。因此，最终的关联数据集可能包含关于每个用户更多的信息。

• 识别攻击——虽然关联攻击试图任意地将两个数据集联系起来，但识别攻击试图通过链接数据库中的条目来获取有关特定个人的更多信息。这可以被认为是数据隐私攻击中最具威胁性的一种，因为它对个人隐私的影响更大。例如，如果雇主在药店客户数据库中搜索其员工的记录，这可能会透露一些关于其员工医疗治疗和疾病的信息。

数据匿名化或数据脱敏技术可以在缓解这些攻击中发挥重要作用。虽然数据集的链接仍然可行，但识别结果数据集中的个人却很困难。下一节将讨论隐私增强技术在数据库系统（尤其是在统计数据库）中的应用，以克服先前的威胁和漏洞。

8.4.4 统计数据库系统中的隐私保护技术

您现在对攻击向量有了基本的了解。现在是时候看看如何在数据库系统中应用隐私保护了。

通常，统计数据库（SDB）系统允许用户检索数据库中呈现的实体子集的汇总统计信息（例如，计数、平均值、样本均值等）。例如，在一个公司数据库中查找员工的平均工资是一个在数据库内作为 SQL 查询执行的汇总统计查询。今天的大多数数据驱动型应用都使用数据分析（通常称为在线分析处理，或 OLAP）进行决策。然而，正如我们已经看到的，当前的数据安全方法在提供通用访问（对于内部用户）时，尤其是对于数据库系统中的 OLAP 查询，无法保证个人的隐私。常见的机制，如访问控制策略，可以限制对特定数据库的访问，但一旦内部分析师获得了数据访问权限，这些策略就无法控制数据的使用方式。过去许多内部攻击所揭示的情况表明，允许无限制地访问数据是隐私泄露的一个重要原因 [10]，[11]，[12]。在统计数据库上提供安全性已经成为一个公众关注的问题。

研究社区已经提出了几种防止统计数据库妥协的技术。这些技术主要可以分为两大类：噪声添加和数据或查询限制：

• 噪声添加技术—在统计数据库中，最常用的隐私保护方法是向输出查询结果添加噪声。在此方法中，数据库中的所有数据都可用于使用，但只返回近似值。噪声添加技术的重点是通过对敏感数据添加一定程度的噪声来掩盖其实际值。这通常以受控的方式进行，以平衡隐私和信息损失之间的竞争需求。根据噪声添加的方式，这些技术可以进一步分类：

  • 数据扰动方法—在此方法中，数据库的原始内容被替换为扰动数据库，在该数据库中执行统计查询，如图 8.17 所示。

  

  图 8.17 数据扰动方法

  • 输出扰动方法—使用输出扰动方法（如图 8.18 所示），查询在原始数据上评估。然而，在将结果发布给查询方之前，数据库会向单个结果添加噪声（通过数据库），以确保原始值永远不会被披露。这可以通过使用我们在本章开头讨论的数据匿名化噪声添加技术来实现。然而，值得注意的是，查询的最终准确性取决于我们添加多少噪声。显然，当噪声较高时，隐私性更好，但它可能会影响最终结果的准确性。

  

  图 8.18 输出扰动方法

• 查询（或数据）限制技术—查询或数据限制技术将数据净化操作应用于查询结果（见图 8.19）。这些技术可以进一步细分为三种不同的方法：

  • 全局记录方法将属性转换到另一个域以确保隐私。例如，而不是返回某人的年龄为 26 岁，它将年龄转换为范围值，并以类似 20-30 岁的范围返回。

  • 抑制方法的应用是用原始数据集中未出现过的值替换属性的值。这与第 7.4 节中讨论的抑制技术类似，但不是完全删除记录，而是用另一个值替换它。为了找到一个替换值，我们首先需要确定一个在我们所查看的属性中不可用的值。例如，假设我们有一个定义为 Age = [20, 23, 35,..., 42, 26]的属性，并且假设列表中不包含值 33。因此，33 可以作为替换值的候选。

  • 使用查询限制技术，用户的查询要么得到精确回答，要么被拒绝。决定哪些查询应该得到正确回答的决策基于不同的参数，例如查询集大小、查询集重叠等。

  

  图 8.19 查询限制方法

既然我们已经讨论了可以在数据库系统上实施的不同隐私增强技术及其局限性，那么让我们看看我们如何定制这些隐私技术。不同的应用程序有不同的隐私需求，因此，在数据库系统中拥有可定制的隐私组件集，允许用户根据他们的需求配置隐私，这一点很重要。下一节将讨论如何设计隐私保护数据库系统，强调主要架构需求。

8.4.5 设计可定制隐私保护数据库系统时需要考虑的因素

许多现代数据库系统由于各种原因没有上述隐私增强技术。今天的大多数数据库架构都是考虑到高可用性和性能而设计的，但并未考虑隐私。因此，这些系统很难覆盖数据隐私，除了在架构设计层面的认证、授权和访问控制等安全原语之外。隐私伴随着额外的成本。在数据库系统中实施隐私技术总是涉及数据隐私和性能之间的权衡。

已经研究了专门针对支持隐私策略和标准的数据库管理系统；万维网联盟（W3C）的隐私偏好平台（P3P）项目就是这样一项研究。然而，领先的数据库提供商中没有任何一家能够提供实用的隐私保障数据库系统，这需要隐私增强技术和隐私保护数据挖掘的联合方法。在本节中，我们将简要讨论设计隐私保护数据库系统所需的稳固数据库架构变更和需求。

在高层次上，一旦收集数据，信息系统的隐私承诺必须得到执行。因此，设计这样一个系统需要利用广泛的安全策略和其他净化技术。让我们简要地看看它们。

维护丰富的隐私相关元数据

类似于 P3P 这样的机制通常要求数据用户指定他们检索数据的预期用途，以确保隐私保证。因此，为了便于访问此类元数据，保护隐私的数据库管理系统应实施机制以存储与数据相关的隐私特定元数据。例如，数据库中的一组数据属性可以具有相关的元数据，指定其预期用途，例如数据是否用于内部，是否可以与其他属性结合，等等。此外，这些元数据应与数据关联，以一系列可能的粒度进行，具有足够的灵活性，且不会降低数据存储的整体性能。

支持属性级别的访问控制机制

一个保护隐私的数据库系统应该支持数据属性级别的访问控制。大多数数据库系统（无论是关系型、NoSQL 还是 NewSQL）都配备了基于角色的访问控制（RBAC）机制，其中每个用户配置文件被分配预定义的角色，例如管理员、最终用户或特殊用户。例如，管理员可能拥有删除记录的权限，而最终用户可能只能添加或查看记录。同样，所有被分配 HR 角色的用户可能被授予访问薪酬信息的权限，而其他人则没有。然而，RBAC 不提供用于隐私执行的应用依赖用户配置文件。这些策略通常为每个数据表（或集合）定义，但不是基于属性。因此，在保护隐私的数据库管理系统中，有必要有机制来扩展对基于属性或基于目的的访问控制机制的支撑。

什么是基于属性的访问控制？

与 RBAC 不同，基于属性的访问控制（ABAC）具有大量称为“属性”的可能控制变量，这使得访问控制比 RBAC 更细粒度。这些属性可以采取不同的形式，例如用户属性（user_name、user_id、role 等）、资源属性（resource_owner、creation_date、privacy_level 等）或环境属性（access_date_time、data_location、risk_level 等）。这些不同的属性允许 ABAC 提供更细粒度的访问控制级别。

例如，假设我们有一个 RBAC，其中所有 HR 角色的用户都可以访问数据库中的员工和薪酬信息。使用 ABAC 可以进一步过滤，使得只有特定的分支或办公室可以访问薪酬信息，而其他人则受到限制。

基于角色和基于属性的访问控制之间的区别

实施对数据的细粒度访问控制

除了 ABAC 机制之外，对数据的细粒度访问控制至关重要。

在传统的数据库系统中，通过数据库视图实现细粒度的访问控制。视图 是一个虚拟表，不存储数据，但可以像表一样查询。视图通常将数据库中的几个表或集合组合起来，然后授予一组用户查询这些数据的权限。然而，视图仅限于受控的属性组。用户不能在此级别修改数据，但数据可以用于挖掘任务。

为了实现隐私增强的数据库管理系统解决方案，这些 视图 机制应该扩展到每个被保护的元组或元组集的水平，并且应该基于每个用户实现。例如，人力资源经理可以访问 HR 视图中的所有属性，而其他人力资源用户可能只能访问视图中有限的一组属性。实现这一点的最直接方法是为每个用户或用户组创建新的或额外的视图，但这会消耗资源。因此，数据库系统本身必须具备提供这种细粒度访问控制数据的机制。

视图是什么？它是如何工作的？

视图是存储在表上的聚合结果的输出，数据库用户可以像查询持久化集合对象（如表）一样查询它。让我们通过一个快速示例来创建 MongoDB 中的视图，通过连接两个表（在 MongoDB 中称为集合）。

在这个例子中，viewName 是我们要创建的视图的名称，而 table1 和 table2 是我们要连接的表。对于 $lookup，连接的条件是 table2.col1=table1.col1，而在 $project 中的参数 0 强调了 table1 的 col3 和 col4 以及 table2 的 col1 和 col3 应该从最终视图中移除。

Db.createView("viewName", "table1",
   [{$lookup: {from: "table2", localField: "col1", 
foreignField: "col1", as: "t2"}},
   {$project: {"col3": 0, "col4": 0, "t2.col1": 0, "t2.col3": 0}])

在 MongoDB 中生成视图

我们如何连接图中显示的所有三个表？你可以自己尝试一下。

维护隐私保护的信息流

另一个重要的考虑因素是在数据库系统中保持隐私保护的数据流。在大多数分布式数据库系统中，数据会在不同的域之间流动，因此，与数据相关的所有隐私策略也应该随着数据一起流动，无论是在组织内部还是在组织之间。如果敏感数据是在特定的隐私承诺下收集的，那么在数据传递给不同方时，这些限制也应该得到执行。例如，一个组织的分布式数据库系统可能位于全球范围内，收集全球范围内的个人数据。每当数据从一个区域收集并通过另一个区域时，应该保证相同的隐私执行集合。

防止内部攻击

合法的高权限用户滥用权限是数据库系统中最具威胁的攻击之一。虽然防止这种攻击具有挑战性，但有一些方法可以减轻此类攻击。

最简单的方法是采用按用户分层的加密机制，这样每个用户都有自己的加密。其他用户仍然可以访问数据，但由于加密密钥不同，他们无法从中获取任何有价值的信息。然而，这给数据库系统的实用性带来了更多问题。

另一个可能的选择是使用用户访问配置文件技术。一旦用户在数据库系统中定义，他们的配置文件就可以通过机器学习技术进行监控，以检测与常规活动不同的行为。如果有人访问未经授权的内容，可以被检测到。

我们现在已经讨论了可以在实际部署中使用的数据保护方案，以及各种攻击如何针对数据机密性和隐私。在第十章中，我们将使用这些概念来解释如何设计一个实用的隐私保护数据管理解决方案。但首先，在第九章中，我们将探讨机器学习的压缩隐私，这是一种扰动数据的替代方法。

摘要

• 有时，k-匿名性隐私模型并不是保护数据挖掘应用隐私的最佳解决方案。

• 通过在属性组中创建l个不同的敏感记录，可以使用l-多样性来减轻k-匿名性对同质性和背景知识攻击的敏感性。

• t-接近性的理念是确保每个组（等价类）中敏感记录的分布足够接近原始数据集中的相应分布。这防止了由于分布偏斜导致的属性泄露。

• 数据挖掘算法的输出可以被修改以保护某些数据挖掘应用的隐私。

• 数据库系统中存在许多不同的安全和隐私威胁和漏洞，针对机密性和数据的隐私。

• 我们可以将对数据库系统的攻击分为两大类：对数据机密性的攻击和对数据隐私的攻击。

• 统计数据库系统中的隐私保护技术可以用来减轻当今数据库系统中的大多数隐私威胁。

• 大多数现代数据库系统并不是从数据隐私的角度设计的；它们通常关注数据库的性能。

9 压缩隐私在机器学习中的应用

本章涵盖

• 理解压缩隐私

• 为机器学习应用引入压缩隐私

• 从理论到实践的压缩隐私实现

• 用于隐私保护机器学习的压缩隐私解决方案

在前面的章节中，我们探讨了差分隐私、局部差分隐私、隐私保护合成数据生成、隐私保护数据挖掘以及在设计隐私保护机器学习解决方案时的应用。如您所回忆的，在差分隐私中，一个可信的数据管理员从个人那里收集数据，并通过向个人数据的聚合中添加精确计算的噪声来产生差分隐私的结果。在局部差分隐私中，个人在将数据发送到数据聚合器之前通过扰动来隐私化自己的数据，从而消除了需要一个可信的数据管理员从个人那里收集数据的需要。在数据挖掘中，我们探讨了在收集信息和发布数据时可以使用的各种隐私保护技术和操作。我们还讨论了调节数据挖掘输出的策略。隐私保护合成数据生成提供了私有数据共享的可行解决方案，其中可以生成合成且具有代表性的数据，然后安全且安全地共享给多个当事人。

如您所见，我们讨论的大多数技术都是基于差分隐私（DP）的定义，它不对对手的能力做出任何假设，因此提供了极其强大的隐私保证。然而，为了实现这种强大的隐私保证，基于 DP 的机制通常会在私有数据上添加过多的噪声，导致某种程度的不可避免的有效性下降。这阻止了 DP 方法应用于许多现实世界应用，尤其是使用机器学习（ML）或深度学习的实际应用。这促使我们探索其他基于扰动的隐私保护方法。压缩隐私（CP）是我们可以探讨的一种替代方法。在本章中，我们将探讨压缩隐私的概念、机制和应用。

9.1 引入压缩隐私

压缩隐私（CP）是一种通过压缩和降维（DR）技术将数据投影到低维超平面上来扰动数据的方法。为了更好地理解压缩隐私的概念和优势，让我们将其与我们在第二章中讨论的差分隐私（DP）理念进行比较。

根据 DP 的定义，如果一个随机算法M满足对于所有S属于M的输出集Range(M)以及所有只相差一个项目的数据集D和D'，都有 Pr[M(D) ∈ S] ≤ e^ε ∙ Pr[M(D') ∈ S]，则称该算法是输入数据的ε-DP 算法。其中，Range(M)是算法M的输出集。换句话说，DP 背后的思想是，如果对数据库进行任意单个更改或替换的影响足够小，查询结果就不能用来推断任何单个个体的信息，因此它提供了隐私保护。正如你所看到的，DP 保证了从数据集查询结果的分布，无论数据集中的单个项目是否更改，都应该是不可区分的（模e^ε因子）。DP 的定义没有对对手做出任何先前的假设。例如，对手可能拥有无界的辅助信息和无限的计算资源，但 DP 机制仍然可以在这种 DP 定义下提供隐私保证。

这显示了 DP 的积极一面——它通过严格的理论分析提供了强大的隐私保证。然而，DP 的定义和机制并没有对效用做出任何假设。因此，DP 机制通常不能在效用方面提供良好的性能。这在将 DP 方法应用于需要复杂计算的实际应用（如数据挖掘和机器学习）时尤其如此。这就是为什么我们还需要探索其他考虑效用同时放松理论隐私保证的隐私增强技术。CP 就是这样一种可以用于实际应用的替代方案。

与 DP 不同，CP 方法允许查询根据已知的效用和隐私任务进行定制。具体来说，对于具有两个标签的样本数据集，即效用标签和隐私标签，CP 允许数据所有者以最大化效用标签学习准确性的方式将数据投影到低维空间，同时降低隐私标签学习的准确性。我们将在详细讨论时讨论这些标签。值得注意的是，尽管 CP 不能消除所有数据隐私风险，但在隐私任务已知的情况下，它提供了一些对数据滥用的控制。此外，CP 保证原始数据永远不会被完全恢复，这主要是由于降维。

现在我们来深入探讨 CP 是如何工作的。图 9.1 展示了 CP 的威胁模型。对手是所有拥有对公共数据集（例如，背景和辅助信息）完全访问权限的数据用户。

图 9.1 压缩隐私的威胁模型。真正的挑战在于平衡效用和隐私之间的权衡。

在这个场景中，让我们假设隐私任务是二分类{+,-}问题（实用任务与隐私任务独立），X[+]和X[-]是两个公开数据集。假设X[S]是数据所有者的私有数据，其中s ∈{+,-}是其原始类别（隐私任务），而t ∈ {+,-}是在应用 CP 扰动后的预期类别（隐私任务）。数据所有者可以使用 CP 机制发布z（X[S]的扰动版本）。然而，也可能存在一个对手，使用他们的方法z' = A(z, X[+], X[-])来推断原始（隐私任务）类别s。因此，我们想要实现的目标是最小化概率差异，|Pr (z' = +|z) - P r (z' = -|z)|，这样对手就不能学习到任何有价值的信息。

在图 9.1 中，Alice（数据所有者）有一些私有数据，她希望为了一个实用任务发布这些数据。假设这个实用任务是允许数据用户使用这些数据执行机器学习分类。由于它包含个人信息，Alice 可以使用 CP 对数据进行扰动。每当 Bob（数据用户）想要使用这个压缩数据时，他需要恢复信息，这可以通过使用在类似领域公开可用的数据集的统计特性（我们称之为实用任务特征空间）来实现。问题是，其他人，比如 Eve（一个对手），也可能使用压缩数据并尝试使用另一个公开可用的数据集来恢复它，这可能导致隐私泄露。因此，CP 的真正挑战在于平衡这种实用/隐私权衡。我们可以压缩数据以执行实用任务，但仍然需要让其他人难以恢复数据以识别个人信息。

以下章节将向您介绍几个有用的组件，这些组件使 CP 能够用于隐私保护的数据共享或机器学习应用。

9.2 压缩隐私机制

CP（差分隐私）的一个重要组成部分是监督降维技术，它依赖于数据标签。主成分分析（PCA）是一种广泛使用的方法，旨在将数据投影到具有最高方差的主成分上，从而在降低数据维度的同时保留数据中的大部分信息。我们曾在 3.4.1 节中简要讨论过这一点，但让我们快速回顾一下。

9.2.1 主成分分析（PCA）

让我们先了解一下主成分是什么。主成分 是通过数据集中初始变量的线性组合构造的新变量。这些组合是以一种方式创建的，使得新变量之间不相关，并且初始变量中的大部分信息都压缩到了第一个成分中（这就是为什么我们称之为 压缩）。因此，例如，当 10 维数据给出 10 个主成分时，PCA 尝试将尽可能多的信息放入第一个成分，剩余的最大信息放入第二个成分，依此类推。当你以这种方式组织主成分信息时，你可以在不丢失太多关键信息的情况下降低维度。

让我们考虑一个包含 N 个训练样本的 x[1], x[2], ..., x[N]，其中每个样本有 M 个特征（x[i] ∈ ℝ^M）的数据集。PCA 执行一种称为 中心调整散布矩阵的谱分解 的操作，使得

其中 μ 是均值向量，Λ = diag(λ[1], λ[2], ..., λ[M]) 是一个对角矩阵，其对角线上的特征值按单调递减的顺序排列（即 λ[1] ≥ λ[2] ≥ ⋯ ≥ λ[M])。

在这里，矩阵 U = [u[1],u[2], ..., u[M]] 是一个 M × M 的单位矩阵，其中 u[j] 表示之前提到的散布矩阵的第 j 个特征向量。对于 PCA，我们保留与 m 个最高特征值相对应的 m 个主成分以获得投影矩阵 U[m]。一旦找到投影矩阵，就可以找到以下降低维度的特征向量：

如您所见，参数 m 决定了在降维后信号功率保留的程度。

特征值分解

在线性代数中，特征值分解（EVD）是将矩阵分解为标准形式的过程，其中矩阵用其特征值和特征向量表示。基本上，它旨在找到满足方程 Au = λu 的矩阵 A 的特征值（称为 λ）和特征向量（称为 u）。

通常，特征值分解（EVD）可以以多种方式执行。一些方法，如 QR 算法，一次找到所有特征向量和特征值。然而，PCA 减少了维度，因此不需要所有特征向量。因此，我们可以依赖仅找到特征值和特征向量子集的方法，以避免与找到不必要的特征向量相关的额外计算。

为了达到这个目的，最著名的特征值分解算法之一是幂迭代法。这种方法找到主导特征值（最大的值）及其相关的特征向量。之后可以使用矩阵消去法来消除已找到的主导特征值的影响，同时保持剩余特征值不变。我们可以通过反复应用幂迭代法和矩阵消去法来找到所需的特征向量数量。

9.2.2 其他降维方法

现在你已经了解了主成分分析（PCA）的工作原理，通过将数据投影到主成分上，让我们看看一些可以用于不同机器学习分类任务的其他方法。因为相同的数据库可以在不同的分类问题中使用，所以让我们定义一个分类问题为 c，它与相应的训练样本 x[i] 相关的唯一标签集相关。不失一般性，该数据库可以用于单个效用目标 U 和单个隐私目标 P。

例如，假设一个机器学习算法使用人脸图像数据集进行训练。效用目标是识别人脸，而隐私目标是识别个人。在这种情况下，每个训练样本 x[i] 有两个标签 ∈ {1, 2, ..., L^u} 和 ∈ {1, 2, ..., L^p}。*L*u 和 L^p 分别是效用目标和隐私目标的类别数量。

基于费舍尔线性判别分析 [1]，[2]，给定一个分类问题，其训练样本的类内散布矩阵包含大部分 噪声信息，而其训练样本的类间散布矩阵包含大部分 信号信息。我们可以按以下方式定义效用目标的类内散布矩阵和类间散布矩阵，

其中 是属于类别 l 的所有训练样本的均值向量，而 N^u[l] 是属于类别 l 的效用目标训练样本的数量。

同样地，对于隐私目标，类内散布矩阵和类间散布矩阵被定义为

假设我们让 W 是一个 K × M 投影矩阵，其中 K < M。给定一个测试样本 x，∙ W 是其在子空间中的投影。我们将要探讨的框架结合了两种基于特征值分解的降维（DR）技术的优点：DCA（效用驱动投影）[3] 和 MDR（隐私强调投影）[4]。让我们快速了解一下这些：

• 判别成分分析（DCA）——DCA 涉及搜索投影矩阵 W ∈ R^(M×K),

  

  其中 det(.) 是行列式算子，ρI 是为了数值稳定性而添加的小正则化项，。

  该问题的最优解可以从矩阵 pencil 的前 K 个主广义特征向量 中导出。

• 多类判别比（MDR）——MDR 考虑了效用目标和隐私目标，定义为

  

  其中 ρI 是为了数值稳定性而添加的小正则化项。MDR 的最优解可以从矩阵 pencil 的前 K 个主广义特征向量 中导出。

在这些基本原理和数学公式的基础上，让我们看看如何在 Python 中实现 CP 技术。

9.3 使用压缩隐私进行机器学习应用

到目前为止，我们已经讨论了不同 CP 机制的理论背景。让我们将这些技术应用于实际的实时人脸识别应用中。由于其在从简单的在线图像搜索到监控等各个领域的广泛应用，人脸识别一直是机器学习（ML）和信号处理领域的一个研究热点。

在当前的隐私要求下，一个现实世界的人脸识别应用必须确保数据本身不会出现任何隐私泄露。让我们研究几种不同的 CP 方法，看看我们如何确保人脸识别应用的效用和重建图像的隐私。在提交给人脸识别应用之前，我们需要压缩人脸图像，以便应用仍然能够识别人脸。然而，其他人不应该仅通过观察就能区分图像，或者能够重建原始图像。在我们的实验中，我们将使用三个不同的面部数据集。这些动手实验的源代码可以在本书的 GitHub 仓库中下载：github.com/nogrady/PPML/tree/main/Ch9。

• 耶鲁人脸数据库——耶鲁人脸数据库包含 15 个个体的 165 张灰度图像，并可以从 cvc.cs.yale.edu/cvc/projects/yalefaces/yalefaces.xhtml 公开获取。

• 奥利维蒂人脸数据集—这个数据集包含 1992 年 4 月至 1994 年 4 月在 AT&T 实验室剑桥拍摄的 40 位不同人物的 400 张灰度人脸图像。数据集可以从 scikit-learn.org/0.19/datasets/olivetti_faces.xhtml 下载。

• 眼镜数据集—我们通过选择性地从耶鲁和奥利维蒂数据集中选择戴眼镜的受试者来推导出这个数据集。在这种情况下，数据集包含 300 张图像。其中一半的图像是戴眼镜的人，另一半是不戴眼镜的人。

对于耶鲁和奥利维蒂数据集，从人脸图像中识别个人的任务将是我们的应用（我们的目标应用），而图像的重构将是我们的隐私目标。一个用例场景是一个“实体”想要使用用户提供的用于训练的敏感人脸图像构建人脸识别算法。但在这种场景中，人们通常不愿意分享他们的面部图像，除非它们被改变到没有人能识别图像中的人。

为了简单起见，我们可以假设想要构建人脸识别分类器的实体是一个服务运营商，但这个运营商可能是恶意的，并试图从从用户那里接收到的训练数据中重建原始图像。

对于眼镜数据集，我们有两种不同的类别（戴眼镜和不戴眼镜）。我们应用的价值将在于识别某人是否佩戴了一副眼镜；隐私目标将是图像的重构。

9.3.1 实现压缩隐私

现在让我们开始工作！我们将使用耶鲁数据集，看看我们如何在人脸识别应用中使用 CP 技术。首先，你需要加载一些模块和数据集。请注意，discriminant_analysis.py 是我们为 PCA 和 DCA 方法开发的模块。更多信息请参考源代码。

注意：你可以直接使用耶鲁数据集的清洁版本，它可在代码仓库中找到：github.com/nogrady/PPML/tree/main/Ch9。

列表 9.1 加载模块和数据集

import sys
sys.path.append('..');
import numpy as np
from discriminant_analysis import DCA, PCA
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
from matplotlib.pyplot import *

data_dir = './CompPrivacy/DataSet/Yale_Faces/';    ❶
X = np.loadtxt(data_dir+'Xyale.txt');
y = np.loadtxt(data_dir+'Yyale.txt');

❶ 加载数据集。

你可以运行以下命令来查看数据集的外观：

print('Shape of the dataset: %s' %(X.shape,))

如您从输出中看到的，数据集包含 165 张图像，每张图像为 64 x 64（这就是为什么我们得到 4,096）。

Shape of the dataset: (165, 4096)

现在让我们回顾数据集中的几幅图像。由于数据集包含 165 张不同的图像，你可以运行以下列表中的代码来随机选择四幅不同的图像。我们使用 randrange 函数随机选择图像。为了在输出中显示图像，我们使用 displayImage 例程和四列的 subplot。

列表 9.2 从数据集中加载一些图像

def displayImage(vImage,height,width):             ❶
    mImage = np.reshape(vImage, (height,width)).T
    imshow(mImage, cmap='gray')
    axis('off')

for i in range(4):                                 ❷
    subplot(1,4,i+1)
    displayImage(X[randrange(165)], height, width)

show()

❶ 定义一个显示图像的函数。

❷ 从数据集中随机选择四幅不同的图像。

输出将类似于图 9.2，尽管你将得到不同的随机人脸图像。

图 9.2 来自耶鲁数据集的一组样本图像

现在你已经知道了我们正在处理的数据类型，让我们用这个数据集实现不同的 CP 技术。我们特别关注在这个数据集上实现主成分分析（PCA）和判别成分分析（DCA）。我们已经开发和封装了 PCA 和 DCA 的核心功能到 discriminant_analysis.py 类中，所以你可以简单地调用它并初始化方法。

注意：Discriminant_analysis.py 是我们开发的一个类文件，用于涵盖 PCA 和 DCA 方法。你可以参考该文件的源代码以获取更多信息：github.com/nogrady/PPML/blob/main/Ch9/discriminant_analysis.py。

DCA 对象使用两个参数初始化：rho 和 rho_p。你将记得我们在第 9.2.2 节中讨论了这些参数（ρ和更新的ρ）。我们使用的代码将首先定义和初始化这些值，以及一组我们将需要用于投影图像数据以查看结果的维度。

我们将首先设置 rho = 10 和 rho_p = -0.05，但在此章的后面部分，你将了解到这些参数的重要属性以及不同值如何影响隐私。现在我们只关注算法的训练和测试部分。

设置 ntests = 10 意味着我们将进行相同的实验 10 次以平均最终结果。你可以将此值设置为任何数字，但越高越好。dims 数组定义了我们将使用的维度数。正如你所见，我们将从少数维度开始，例如 2，然后移动到更多维度，例如 4096。再次提醒，你可以尝试为这个值设置自己的值。

rho = 10; 
rho_p = -0.05;
ntests = 10;
dims = [2,5,8,10,14,39,1000,2000,3000,4096];

mydca = DCA(rho,rho_p);
mypca = PCA();

一旦定义了这些值，mypca 和 mydca 对象将在数据集分为训练集和测试集之后，使用以下代码进行训练。Xtr 是训练数据矩阵（训练集），而 ytr 是训练标签向量。fit 命令从数据中学习一些量，特别是主成分和解释方差。

Xtr, Xte, ytr, yte = train_test_split(X,y,test_size=0.1,stratify=y);
mypca.fit(Xtr);
mydca.fit(Xtr,ytr);

此后，可以按以下方式获得数据的投影：

Dtr_pca = mypca.transform(Xtr);
Dte_pca = mypca.transform(Xte);
Dtr_dca = mydca.transform(Xtr);
Dte_dca = mydca.transform(Xte);   
print('Principal and discriminant components were extracted.')

对于我们感兴趣的每个维度（2, 5, 8, 10, 14, 39, 1000 等），可以找到投影矩阵 D，然后可以将图像数据重构为 Xrec：

D = np.r_[Dtr_pca[:,:dims[j]],Dte_pca[:,:dims[j]]];   ❶
Xrec = np.dot(D,mypca.components[:dims[j],:]);

D = np.r_[Dtr_dca[:,:dims[j]],Dte_dca[:,:dims[j]]];   ❷
Xrec = mydca.inverse_transform(D,dim=dims[j]);

❶ 使用 PCA 技术重构数据。

❷ 使用 DCA 技术重构数据。

当我们将所有这些放在一起时，完整的代码如下所示。

列表 9.3 重构图像和计算准确性的完整代码

import sys
sys.path.append('..');
import numpy as np
from random import randrange
from discriminant_analysis import DCA, PCA
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
from matplotlib.pyplot import *

def displayImage(vImage,height,width):
    mImage = np.reshape(vImage, (height,width)).T
    imshow(mImage, cmap='gray')
    axis('off')

height = 64
width = 64

data_dir = './CompPrivacy/DataSet/Yale_Faces/';
X = np.loadtxt(data_dir+'Xyale.txt');
y = np.loadtxt(data_dir+'Yyale.txt');

print('Shape of the dataset: %s' %(X.shape,))

for i in range(4):    
    subplot(1,4,i+1)
    displayImage(X[randrange(165)], height, width)
show()

rho = 10; 
rho_p = -0.05;
ntests = 10;
dims = [2,5,8,10,14,39,1000,2000,3000,4096];

mydca = DCA(rho,rho_p);
mypca = PCA();

svm_tuned_params = [{'kernel': ['linear'], 'C': 
➥ [0.1,1,10,100,1000]},{'kernel':
    ['rbf'], 'gamma': [0.00001, 0.0001, 0.001, 0.01], 'C': 
    ➥ [0.1,1,10,100,1000]}];

utilAcc_pca = np.zeros((ntests,len(dims)));
utilAcc_dca = np.zeros((ntests,len(dims)));
reconErr_pca = np.zeros((ntests,len(dims)));
reconErr_dca = np.zeros((ntests,len(dims)));

clf = GridSearchCV(SVC(max_iter=1e5),svm_tuned_params,cv=3);

for i in range(ntests):
    print('Experiment %d:' %(i+1));
    Xtr, Xte, ytr, yte = train_test_split(X,y,test_size=0.1,stratify=y);
    mypca.fit(Xtr);
    mydca.fit(Xtr,ytr);

    Dtr_pca = mypca.transform(Xtr);                                     ❶
    Dte_pca = mypca.transform(Xte);
    Dtr_dca = mydca.transform(Xtr);
    Dte_dca = mydca.transform(Xte);   
    print('Principal and discriminant components were extracted.')

    subplot(2,5,1)
    title('Original',{'fontsize':8})
    displayImage(Xtr[i],height,width)

    subplot(2,5,6)
    title('Original',{'fontsize':8})
    displayImage(Xtr[i],height,width)    

    for j in range(len(dims)):
        clf.fit(Dtr_pca[:,:dims[j]],ytr);                               ❷
        utilAcc_pca[i,j] = clf.score(Dte_pca[:,:dims[j]],yte);
        print('Utility accuracy of %d-dimensional PCA: %f' 
              %(dims[j],utilAcc_pca[i,j]));

        D = np.r_[Dtr_pca[:,:dims[j]],Dte_pca[:,:dims[j]]];             ❸
        Xrec = np.dot(D,mypca.components[:dims[j],:]);
        reconErr_pca[i,j] = sum(np.linalg.norm(X-Xrec,2,axis=1))/len(X);
        eigV_pca = np.reshape(Xrec,(len(X),64,64))
        print('Average reconstruction error of %d-dimensional PCA: %f' 
              %(dims[j],reconErr_pca[i,j]));

        clf.fit(Dtr_dca[:,:dims[j]],ytr);                               ❹
        utilAcc_dca[i,j] = clf.score(Dte_dca[:,:dims[j]],yte);
        print('Utility accuracy of %d-dimensional DCA: %f' 
              %(dims[j],utilAcc_dca[i,j]));

        D = np.r_[Dtr_dca[:,:dims[j]],Dte_dca[:,:dims[j]]];             ❺
        Xrec = mydca.inverse_transform(D,dim=dims[j]);
        reconErr_dca[i,j] = sum(np.linalg.norm(X-Xrec,2,axis=1))/len(X);
        eigV_dca = np.reshape(Xrec,(len(X),64,64))
        print('Average reconstruction error of %d-dimensional DCA: %f' 
              %(dims[j],reconErr_dca[i,j]));    

        subplot(2,5,j+2)                                                ❻
        title('DCA dim: ' + str(dims[j]),{'fontsize':8})
        displayImage(eigV_dca[i],height,width) 

        subplot(2,5,j+7)
        title('PCA dim: ' + str(dims[j]),{'fontsize':8})
        displayImage(eigV_pca[i],height,width)        

    show()

np.savetxt('utilAcc_pca.out', utilAcc_pca, delimiter=',')               ❼
np.savetxt('utilAcc_dca.out', utilAcc_dca, delimiter=',')
np.savetxt('reconErr_pca.out', reconErr_pca, delimiter=',')
np.savetxt('reconErr_dca.out', reconErr_dca, delimiter=',')

❶ 预计算所有组件。

❷ 测试 PCA 的准确性。

❸ 测试 PCA 的重构误差。

❹ 测试 DCA 的准确性。

❺ 测试 DCA 的重构误差。

❻ 显示重构的图像。

❼ 将每个周期的准确性和重建误差保存为文本文件。

如列表 9.3 所示，我们正在运行 PCA 和 DCA 重建 10 次（记住我们设置了 ntests = 10），并且对于每种情况，它都会随机分割数据集进行训练和测试。最后，我们计算每个维度的 PCA 和 DCA 的准确性和重建误差。这将使我们能够评估压缩图像重建的准确性。

当你运行代码时，结果可能看起来像以下这样。完整的输出太长，无法在此处包含——我们只包含了输出前几行和循环中前两次运行的重构图像。

Experiment 1:
Principal and discriminant components were extracted.
Utility accuracy of 5-dimensional PCA: 0.588235
Average reconstruction error of 5-dimensional PCA: 3987.932630
Utility accuracy of 5-dimensional DCA: 0.882353
Average reconstruction error of 5-dimensional DCA: 7157.040696
Utility accuracy of 14-dimensional PCA: 0.823529
Average reconstruction error of 14-dimensional PCA: 4048.247986
Utility accuracy of 14-dimensional DCA: 0.941176
Average reconstruction error of 14-dimensional DCA: 7164.268844
Utility accuracy of 50-dimensional PCA: 0.941176
Average reconstruction error of 50-dimensional PCA: 4142.000701
Utility accuracy of 50-dimensional DCA: 0.941176
Average reconstruction error of 50-dimensional DCA: 6710.181110
Utility accuracy of 160-dimensional PCA: 0.941176
Average reconstruction error of 160-dimensional PCA: 4190.105696
Utility accuracy of 160-dimensional DCA: 0.941176
Average reconstruction error of 160-dimensional DCA: 4189.337999
...
...

Experiment 2:
Principal and discriminant components were extracted.
...
...

如果你仔细查看输出中的重现图像，与原始图像相比，你会看到当降低维度时，很难识别这个人。例如，如果你比较原始图像和维度为 5（无论是 PCA 还是 DCA）的版本，从压缩图像中识别这个人相当困难。另一方面，当 dims = 160 时，你可以看到重建图像正在变得更好。这意味着我们通过减少维度来保护敏感数据的隐私。正如你所看到的，在这种情况下，DCA 对于 5 到 50 的维度比 PCA 表现得更好，使其接近原始图像，但仍难以识别。

9.3.2 效用任务的准确性

你现在知道，当维度减少时，隐私性会提高。但效用任务的准确性如何呢？如果我们无法为效用任务获得相当高的准确性，那么在这种情况下使用 CP 技术就没有意义了。

为了检查效用任务的准确性如何随着维度的减少而变化，我们可以简单地增加 ntests 变量的值到最大值（因为数据集中有 165 条记录，所以最大值是 165），并对每个维度的效用准确性结果进行平均。

图 9.3 总结了准确性结果。如果你仔细查看 DCA 的结果，你会注意到，当维度变为 14 时，其准确性在大约 91%左右饱和。现在看看维度为 14 的 DCA 的脸部图像。你会注意到，很难识别这个人，但图表显示，效用任务（在这种情况下是面部识别应用）的准确性仍然很高。这就是 CP 如何工作，确保隐私和效用之间的平衡。

图 9.3 不同维度设置下重建图像准确性的比较

既然我们已经研究了效用函数的准确性，让我们看看其他人重建压缩图像有多困难。这可以通过重构误差来衡量。为了确定这一点，我们需要遍历整个数据集，而不仅仅是几条记录。因此，我们将稍微修改一下代码，如下所示。

列表 9.4 计算平均重构误差

import sys
sys.path.append('..');
import numpy as np
from discriminant_analysis import DCA, PCA

rho = 10; 
rho_p = -0.05;

dims = [2,5,8,10,14,39,1000,2000,3000,4096];

data_dir = './CompPrivacy/DataSet/Yale_Faces/';
X = np.loadtxt(data_dir+'Xyale.txt');
y = np.loadtxt(data_dir+'Yyale.txt');

reconErr_pca = np.zeros((len(dims)));
reconErr_dca = np.zeros((len(dims)));

mydca = DCA(rho,rho_p);
mypca = PCA();
mypca.fit(X);
mydca.fit(X,y);

D_pca = mypca.transform(X);                                            ❶
D_dca = mydca.transform(X); 
print('Principal and discriminant components were extracted.')

for j in range(len(dims)):
    Xrec = np.dot(D_pca[:,:dims[j]],mypca.components[:dims[j],:]);     ❷
    reconErr_pca[j] = sum(np.linalg.norm(X-Xrec,2,axis=1))/len(X);
    print('Average reconstruction error of %d-dimensional PCA: %f' 
              %(dims[j],reconErr_pca[j]));

    Xrec = mydca.inverse_transform(D_dca[:,:dims[j]],dim=dims[j]);     ❸
    reconErr_dca[j] = sum(np.linalg.norm(X-Xrec,2,axis=1))/len(X);
    print('Average reconstruction error of %d-dimensional DCA: %f' 
              %(dims[j],reconErr_dca[j]));

np.savetxt('reconErr_pca.out', reconErr_pca, delimiter=',')            ❹
np.savetxt('reconErr_dca.out', reconErr_dca, delimiter=',')

❶ 预计算所有组件。

❷ 测试 PCA 的重构误差。

❸ 测试 DCA 的重构误差。

❹ 将结果保存到文本文件中。

图 9.4 显示了列表 9.4 的结果与不同维度对比。如图所示，当维度较低时，其他人很难准确重建图像。例如，在维度 14 的 DCA 数据点具有很高的重构误差值，这使得其他人很难重建图像。然而，正如你之前看到的，它仍然为面部识别任务提供了良好的准确性。这就是使用 CP 技术应用于机器学习应用的整体思路。

图 9.4 比较不同维度设置的平均重构误差

9.3.3 DCA 中 ρ' 对隐私和效用的影响

我们已经实验了如何通过降维来确定隐私。当维度数量较低时，损失的信息更多，从而提供更好的隐私。但在 DCA 中，我们还有一个参数 ρ。到目前为止，我们只改变了维度的数量，并将 ρ 保持为 rho_p = -0.05。现在我们将通过保持维度数量不变来观察这个参数在确定隐私水平方面的重要性。

以下列表几乎与列表 9.3 相同，只是现在我们将改变 rho_p 参数为不同的值：[-0.05, -0.01, -0.001, 0.0, 0.001, 0.01, 0.05]。我们将维度固定在 160（你也可以尝试不同的值）。

列表 9.5 在 DCA 中改变 ρ 并确定其对隐私的影响

import sys
sys.path.append('..');
import numpy as np
from discriminant_analysis import DCA
from matplotlib.pyplot import *
from random import randrange

def displayImage(vImage,height,width):
    mImage = np.reshape(vImage, (height,width)).T
    imshow(mImage, cmap='gray')
    axis('off')

height = 64
width = 64

rho = 10; 
rho_p = [-0.05,-0.01,-0.001,0.0,0.001,0.01,0.05]
selected_dim = 160
image_id = randrange(165)

data_dir = './CompPrivacy/DataSet/Yale_Faces/';
X = np.loadtxt(data_dir+'Xyale.txt');
y = np.loadtxt(data_dir+'Yyale.txt');

subplot(2,4,1)
title('Original',{'fontsize':8})
displayImage(X[image_id],height,width)

for j in range(len(rho_p)):    
    mydca = DCA(rho,rho_p[j]);   
    mydca.fit(X,y);
    D_dca = mydca.transform(X); 
    print('Discriminant components were extracted for rho_p: '+str(rho_p[j]))

    Xrec = mydca.inverse_transform(D_dca[:,:selected_dim],dim=selected_dim);
    eigV_dca = np.reshape(Xrec,(len(X),64,64))

    subplot(2,4,j+2)
    title('rho_p: ' + str(rho_p[j]),{'fontsize':8})
    displayImage(eigV_dca[image_id],height,width)

show()

结果显示在图 9.5 中。左上角的图像是原始图像，其余图像是用不同的 rho_p 值生成的。如图所示，当 rho_p 值从 -0.05 变化到 0.05 时，生成的图像发生了显著变化，难以识别。因此，我们可以推断出 ρ 也是在 DCA 使用时确定隐私水平的一个重要参数。如图所示，ρ 的正值比负值提供了更高的隐私水平。

图 9.5 在耶鲁数据集上固定维度为 160 时 ρ 对隐私的影响

我们现在已经探讨了将 CP 技术集成到机器学习应用中的可能性。您已经看到，在最小数量的维度下，可以获得最大的面部识别准确率，同时重建图像的隐私性仍然得到保护。在下一节中，我们将通过一个关于水平分区数据隐私保护案例研究来进一步扩展讨论。

首先，这里有一些练习您可以探索，以了解ρ对提高准确性的影响，并尝试不同的数据集。

练习 1

您现在知道ρ的正值有助于提高隐私。那么，面部识别任务的准确性呢？ρ的正值是否也有助于提高准确性？更改列表 9.3 中的代码，观察每个不同的ρ值的有效性和平均重建误差。（提示：您可以通过添加另一个循环来实现，该循环遍历不同的 rho_p 值。）

解决方案：在面部识别任务的准确性方面，ρ的值没有显著影响。尝试绘制ρ与准确性的关系图，您将清楚地看到这一点。

练习 2

我们迄今为止探索的所有实验都是基于耶鲁数据集的。切换到奥利维蒂数据集，重新运行所有实验，看看观察到的模式和现象是否相似。（提示：这相当直接。您只需更改数据集名称和位置。）

解决方案：此解决方案在本书的源代码库中提供。

练习 3

现在将数据集更改为眼镜数据集。在这种情况下，请记住，应用程序的效用是确定一个人是否戴眼镜。隐私目标是图像的重建。更改代码，看看 PCA 和 DCA 在这里如何帮助。

解决方案：解决方案在本书的源代码库中提供。

9.4 案例研究：水平分区数据上的隐私保护 PCA 和 DCA

如您所知，机器学习（ML）可以分为两类不同的任务或类别：监督任务，如回归和分类，以及无监督任务，如聚类。在实践中，这些技术被广泛应用于许多不同的应用中，例如身份和访问管理、检测欺诈信用卡交易、构建临床决策支持系统等。这些应用在机器学习的训练和测试阶段通常会使用个人数据，例如医疗记录、财务数据等。

虽然有许多不同的方法，但降维（DR）是机器学习中的一个重要工具，可以用来克服不同类型的问题：

• 当特征维度远超过训练样本数量时的过拟合

• 由于搜索不优导致的性能下降

• 由于特征空间中的高维性导致的高计算成本和功耗

我们在本章中已经讨论了几种 DR 方法：PCA 和 DCA。

如您所回忆的那样，主成分分析（PCA）旨在将数据投影到具有最高方差的主成分上，从而在降低数据维度的同时保留大部分信息。如图 9.6（a）所示，大部分变异性都沿着第一个主成分（表示为 PC-1）发生。因此，将所有点投影到这个新轴上可以在不牺牲太多数据变异性的情况下降低维度。

与 PCA 相比，DCA 是为监督学习应用设计的。DCA 的目标不是可恢复性（如 PCA 用于减少重建误差），而是提高学习分类器的判别能力，以便它们可以有效地区分不同的类别。图 9.6（b）显示了一个监督学习问题的例子，其中 PCA 会选择 PC-1 作为数据投影的主成分，因为 PC-1 是最大变异性方向。相比之下，DCA 会选择 PC-2，因为它提供了最高的判别能力。

图 9.6 主成分分析（PCA）如何工作

传统上，PCA 和 DCA 是通过在集中位置收集数据来执行的，但在许多应用中（如连续认证[5]），数据分布在多个数据所有者之间。在这种情况下，协作学习是在由不同数据所有者持有的样本组成的联合数据集上进行的，其中每个样本包含相同的属性（特征）。这种数据被称为水平分割，因为数据以类似特征的行（列）表示，并且每个数据所有者在联合数据矩阵中持有不同的一组行。

在这种情况下，假设一个中心实体（数据用户）想要以隐私保护的方式使用分布在多个数据所有者之间的数据来计算 PCA（或 DCA）投影矩阵。然后，数据所有者可以使用投影矩阵来降低其数据的维度。这种降低维度的数据可以随后用作输入到特定的隐私保护机器学习算法中，这些算法执行分类或回归。

在本节的研究案例中，我们将探讨数据用户在计算 PCA 和 DCA 投影矩阵时不会损害数据所有者隐私的问题。在早期关于 PCA 的分布式机器学习研究中，根本未考虑隐私问题。后来，为 PCA 提出了不同的隐私保护方法[6]，但在实施时，它们要求所有数据所有者在协议执行期间保持在线，这并不太实用。在本案例研究中，我们将通过提出并实现一种使用 PCA 和 DCA 的隐私保护方法来解决这个问题。

与早期方法相比，我们即将探讨的协议不会泄露任何中间结果（例如散布矩阵），并且不需要数据所有者相互交互或提交他们的个人加密份额后保持在线。这种新的方法可以作为在应用其他隐私保护机器学习算法进行分类或回归之前，隐私保护数据预处理阶段的利用。因此，它确保在将机器学习算法应用于私有数据时既保护隐私又保持效用。

9.4.1 在水平分区数据上实现隐私保护

在我们深入了解细节之前，让我们快速浏览一下在这个案例研究中我们将关注的要点。为了便于分布式隐私保护主成分分析（或 DCA），需要以分布式方式计算散布矩阵。我们将使用加法同态加密来计算散布矩阵。

除了数据所有者（持有数据）和数据用户（旨在计算投影矩阵）之外，我们还将假设存在一个第三方实体，即加密服务提供商（CSP），它不会与数据用户串通。当数据所有者发送数据时，他们需要计算他们的个人份额，使用 CSP 的公钥进行同态加密，最后将这些份额发送给数据用户，数据用户将汇总这些份额。之后，CSP 可以构建一个执行从汇总份额中计算的散布矩阵的混淆电路（参见侧边栏中对混淆电路的讨论）。数据用户和 CSP 都无法以明文形式看到汇总份额，因此此解决方案中的数据交换协议不会泄露任何中间值，例如用户份额或散布矩阵。此外，这种方法不会给数据所有者带来与其他数据所有者互动的负担，并且不需要他们在发送加密份额后保持在线，这使得这些协议变得实用。

什么是混淆电路？

混淆电路（由安德鲁·姚提出）是一种加密计算的方法，使得它揭示了计算的输出，但不会揭示关于输入或任何中间状态或值的任何信息。其想法是使两个不信任的当事人能够安全地通信，并在他们的私有输入上执行计算，而不需要可信的第三方。

让我们通过一个简单的例子来探讨这个问题。假设爱丽丝有一个私有输入 x，鲍勃有一个私有输入 y。他们同意某个计算函数 f（称为电路），并且双方都想学习 f(x, y)，但不希望对方了解任何更多内容，例如中间值或对方的输入。他们将这样做：

• 双方需要就如何表达 f 达成一致。然后爱丽丝将电路 f 转换为其混淆版本，并将该混淆版本及其输入 x̂ 的混淆版本一起发送给鲍勃。

• Bob 想要创建其输入ŷ的混乱版本，而不让 Alice 知道原始值y是什么。为此，他们使用了无意识传输（OT）技术。无意识传输是一种两方协议，发送者和接收者之间通过发送者向接收者传输一些信息，但发送者对接收者实际获得的信息保持无意识。

• 现在 Bob 已经拥有了混乱的电路以及该电路的混乱输入 x̂和ŷ，他可以评估混乱电路并学习f(x, y)，并将其向 Alice 揭示。因此，该协议揭示的不会超过f(x, y)。

9.4.2 回顾降维方法

在本章的后面部分，我们将使用我们之前讨论的降维（DR）技术以及其他增强隐私的技术，以实现 PCA 和 DCA 的隐私保护。让我们快速回顾一下我们讨论过的 DR 方法。

PCA 是一种常用于降低大型数据集维度的 DR 方法。其想法是将大量变量转换成较小的集合，同时仍然包含大部分大集合中的信息。在数据集中减少变量的数量自然会以精度为代价。然而，DR 技术以牺牲一点精度为代价，换取方法的简单性。由于较小的数据集更容易探索和可视化，并且因为它们使机器学习算法分析数据变得更容易更快，这些 DR 技术在其中发挥着至关重要的作用。

虽然 PCA 是一种无监督的 DR 技术（它不利用数据标签），但 DCA 是一种监督的 DR 方法。DCA 选择一个可以有效地区分不同类别的投影超平面。从高层次来看，这两种技术之间的关键区别在于 PCA 假设梯度之间存在线性关系，而 DCA 假设存在单峰关系。

除了 PCA 和 DCA 之外，许多其他 DR 技术依赖于本章开头讨论的两个不同步骤：计算散布矩阵和计算特征值。一般来说，这些 DR 方法可以根据所需的散布矩阵和需要解决的特征值问题来区分。例如，线性判别分析（LDA）是一种类似于 DCA 的方法（两者都是基于效用）。我们不会在这里深入细节，但主要区别在于 LDA 利用类内散布矩阵来求解特征值，而 DCA 使用类间散布矩阵。

虽然 DCA 和 LDA 是以效用驱动的 DR 技术，但另一类 DR 方法集中在效用-隐私优化问题上，如多类判别比（MDR）[4]。我们在本章开头探讨了 MDR 的细节。在高层上，MDR 旨在最大化效用分类问题（预期任务）的分离性，同时最小化隐私敏感分类问题（敏感任务）的分离性。它假设每个数据样本有两个标签：一个效用标签（用于数据的预期目的）和一个隐私标签（用于指定敏感信息的类型）。因此，我们可以获得两个类间散布矩阵：一个基于效用标签，另一个使用隐私标签计算。

9.4.3 使用加法同态加密

为了便于加密服务提供商（CSP）的功能，加法同态加密将成为我们协议中的基本构建块。在第 3.4.1 节中，我们讨论了同态加密。正如你所知，存在多种语义安全的加法同态加密方案。我们将探讨 Paillier 密码系统[7]如何作为此类加密方案的一个示例。假设函数E[pk][∙]是一个由公钥pk索引的加密操作，并且假设D[sk][∙]是一个由私钥sk索引的解密操作。加法同态加密可以表示为E[pk][a + b] = E[pk][a] ⊗ E[pk][b]，其中⊗是加密域中的模乘运算符。此外，通过E[pk][a]^b = E[pk][a ∙ b]可以实现标量乘法。如果你对 Paillier 密码系统的更多细节感兴趣，可以参考原始论文。你需要理解同态加密方案的基本功能，因为我们将在下一节中使用它。

这种加密方案仅接受整数作为明文，但在大多数用例中，当你实现机器学习（ML）应用时，你会处理实数值。在处理 ML 时，典型的方法是将数据（特征值）离散化以获得整数值。

9.4.4 提出方法概述

在这项研究中，我们将考虑跨多个数据所有者的水平分区数据的情况。系统架构如图 9.7 所示。假设有N个数据所有者，其中每个数据所有者n持有一组特征向量Xi^i ∈ ℝ^(k×M)，其中M是特征数（维度）且i = 1, ..., k。在这里，k是特征向量的总数。因此，每个数据所有者n将有一个数据矩阵，使得X^n ∈ ℝ^(k×M)。此外，在监督学习中，每个样本x都有一个标签y，表示它属于某一类。

图 9.7 系统架构及其工作原理

在这个系统中，数据用户希望利用数据并从数据中计算 PCA（或 DCA）投影矩阵，这些数据在多个数据所有者之间水平划分。有许多实际应用属于这种数据共享模型。例如，在持续认证（CA）应用中，CA 服务器需要使用机器学习算法（包括 PCA 等 DR 技术）为注册用户群体构建认证配置文件。因此，CA 服务器（数据用户）需要使用分布（水平）在所有注册用户（数据所有者）之间的数据进行 PCA（或 DCA）投影矩阵的计算。

我们将在稍后详细了解每个步骤的细节，但让我们假设有两个数据所有者，Alice 和 Bob，他们希望为了协作机器学习任务共享他们的私有数据。在这种情况下，机器学习任务将是数据用户。从隐私的角度来看，最重要的关注点是任何计算方，如数据用户或 CSP，都不应了解 Alice 或 Bob 的任何输入数据或任何中间值的明文格式。这就是为什么我们需要首先加密数据的原因。但是，当数据被加密时，机器学习算法如何学习任何东西呢？这就是同态性质发挥作用的地方，它允许你在加密数据的情况下仍然执行某些计算，如加法或减法。

传统上，主成分分析（PCA）和分解浓度分析（DCA）仅用于联合数据集（由多个数据所有者贡献的数据）的集中位置，但计算投影矩阵 U 需要数据所有者透露他们的数据。在本案例研究中，我们将修改投影矩阵的计算方法，使其分布式且保护隐私。为了便于这种隐私保护计算，我们将利用第三方（加密服务提供商），该第三方将与数据用户进行相对简短的单一回合信息交换，以计算投影矩阵。然后，数据所有者可以使用投影矩阵来降低他们数据的维度。这种降低维度的数据可以后来用作输入，供某些执行分类或回归的隐私保护机器学习（ML）算法使用。

在设计安全架构时，识别可能对我们正在开发的解决方案造成潜在危害或脆弱性的威胁非常重要。因此，让我们快速回顾一下我们可能面临的威胁类型，以便我们可以在我们的解决方案中减轻它们。我们协议的主要隐私要求是使数据所有者能够保护其数据的隐私。我们将考虑对手为计算方：数据用户和加密服务提供商（CSP）。这些方中的任何一方都不应能够访问任何数据所有者的输入数据或任何中间值（例如数据所有者份额或散布矩阵）的明文格式。数据用户应仅了解 PCA 或 DCA 投影矩阵的输出和特征值。

CSP 的主要角色是促进散布矩阵的隐私保护计算。为此，假设 CSP 是一个独立的第三方，不与数据用户勾结。例如，数据用户和 CSP 可能是不同的公司，它们不会勾结，至少为了维护它们的声誉和客户群。此外，我们假设所有参与者都是诚实但好奇的（这是半诚实对抗模型）。这意味着所有方都将正确遵循协议规范，但他们可能会好奇并试图使用协议记录来提取新信息。因此，数据用户和 CSP 都被视为半诚实、非勾结，但其他方面不受信任的服务器。我们还将讨论可以解释数据用户与数据所有者子集勾结以获取有关单个数据所有者的私人信息的扩展。

假设数据所有者、数据用户和 CSP 之间的所有通信都是通过使用 SSL/TLS、数字证书和签名等已知方法在安全通道上进行的。

9.4.5 隐私保护计算的工作原理

现在我们已经涵盖了所有必要的背景信息，让我们继续进行散布矩阵和 PCA 或 DCA 投影矩阵的隐私保护计算。我们假设有N个数据所有者愿意与某个数据用户合作来计算散布矩阵。

隐私保护 PCA

PCA 的第一步是以分布式方式计算散布矩阵的总和。假设总散布矩阵是，并且它可以以迭代方式计算。我们有N个数据所有者，每个数据所有者n携带一组训练样本，我们将这些样本表示为P^n。每个数据所有者计算一组值，我们将这些值称为本地份额，如下面的方程所示：

散布矩阵的总和可以通过将每个参与方的部分贡献相加得到，如下所示，

其中

重要的是，数据所有者不应该以明文形式将他们的本地份额发送给数据用户，因为这些份额包含了他们数据的统计摘要。本地份额可以使用加法同态加密方案（如 Paillier 密码系统）进行加密，其中 CSP 提供公钥。

在接收到这些加密份额后，数据使用者可以将它们聚合起来计算加密的中间值（即 R、V 和 Q），在盲化这些值后发送给 CSP 进行解密。然后，数据使用者可以使用这些聚合值通过使用混淆电路和无意识传输来计算散点矩阵和 PCA 投影矩阵。在这里，“盲化”指的是向加密值添加随机数，以防止 CSP 在聚合形式中了解任何关于数据的信息。（这些值使用一次性密码的等效物进行盲化。）

让我们一步一步地看看这个协议是如何工作的，以确保在保持 PCA 的同时保护隐私：

1. 设置用户—在设置过程中，CSP 根据数据所有者和数据使用者的请求，向数据所有者和数据使用者发送 Paillier 密码系统的公钥 pk。这一步也可能包括数据所有者向 CSP 的官方注册。

2. 计算本地份额—每个数据所有者 n 将使用我们之前讨论的方程计算其自己的份额 DS^n = {R^n, V^n, Q^n}。在将所有值离散化以获得整数值后，数据所有者将使用 CSP 的公钥加密 R^n、*V*n 和 Q^n，以获得 E[pk][DS^n] = {E[pk][R^n], E[pk][V^n], E[pk][Q^n]}。最后，每个数据所有者将 E[pk][DS^n] 发送给数据使用者。

3. 聚合本地份额—数据使用者从每个数据所有者那里接收 E[pk][DS^n] = {E[pk][R^n], E[pk][V^n], E[pk][Q^n]}，并继续计算 R、V 和 Q 的加密。更具体地说，数据使用者能够从加密的数据所有者份额中计算出 E[pk][R]，E[pk][V]，和 E[pk][Q]，如下所示：

   

   

   

   数据使用者将这些聚合值添加一些随机整数以掩盖它们，从而获得盲化的聚合份额 E[pk][R']，E[pk][V']，和 E[pk][Q']，这些可以发送给 CSP 进行解密。

4. 使用混淆电路进行特征值分解（EVD）：

   1. 一旦从数据使用者那里收到盲化的聚合份额，CSP 将使用其私钥解密它们，E[pk][R']，E[pk][V']，和 E[pk][Q']。由于 CSP 不知道数据使用者添加的随机值，因此 CSP 无法了解原始的聚合值。

   2. CSP 将构建一个混淆电路，对从聚合份额计算出的散点矩阵执行特征值分解（EVD）。这个混淆电路的输入是 CSP 解密后的盲化聚合份额的混淆版本以及由数据使用者生成并持有的盲化值。

   3. 由于 CSP 构建了混淆电路，它可以自己获得其输入的混淆版本。然而，数据用户需要通过不可知传输与 CSP 交互，以获得其输入的混淆版本：盲化值。使用不可知传输，我们可以保证 CSP 不会学习到数据用户持有的盲化值。

   4. CSP 构建的混淆电路接收两个混淆输入，并从份额 R', V', 和 Q' 中减去数据用户在之前步骤中添加的盲化值，从而计算出散布矩阵。CSP 随后通过在散布矩阵上执行特征分解来获得 PCA 投影矩阵。

   5. 数据用户将接收到的混淆电路作为其评估器。这个混淆电路已经包含了 CSP 的混淆输入（解密和盲化的聚合份额），并且数据用户通过不可知传输获得了盲化值的混淆版本。

   6. 最后，数据用户执行混淆电路，并获取投影矩阵和特征值作为输出。

这就是隐私保护 PCA 如何在实际应用中实现和计算的方法。我们将在本章后面讨论这种方法的有效性。现在让我们看看隐私保护 DCA 是如何工作的。

隐私保护 dca

正如我们在第 9.2 节中讨论的那样，DCA 计算需要计算总散布矩阵 和信号矩阵 S[B]。此外，一些其他的 DCA 公式还使用称为 噪声 矩阵 S[W]。我们首先简要概述 S[B] 和 S[W] 的分布式计算，然后我们将继续介绍协议实现细节。

S[B] 和 S[W] 的计算可能因数据所有者是否拥有属于单个类别的数据而不同。例如，考虑一个垃圾邮件检测应用，其中每个数据所有者都有垃圾邮件和非垃圾邮件。这种情况代表两个类别（垃圾邮件和非垃圾邮件），它是多类别数据所有者（MCDO）的一个例子。另一方面，有时每个数据所有者代表一个类别，如在连续认证系统中。在这种情况下，所有他们的数据都会有相同的标签。这是一个单类别数据所有者（SCDO）的例子。

我们将首先回顾计算散布矩阵 S[B] 和 S[W] 的方程，然后我们将介绍执行隐私保护 DCA 计算的协议。假设每个样本 X[i] 有一个标签 y[i]，表示它属于 K 个类别 C[1]，C[2]，...，C[k] 中的一个。我们将用 μ 表示类别 C[k] 中训练样本的均值向量，用 M[k] 表示类别 C[k] 中的样本数量。有了这些，噪声矩阵 S[W] 可以按以下方式计算，

其中矩阵 O[k] 代表与类别 k 相关的份额。由于每个数据所有者 n 映射到单个类别 k（在 SCDO 情况下），我们可以写出 O[k] = O^n 并有 。

对于多类别数据所有者（MCDO）的情况，每个数据所有者 n 将持有属于不同类别的数据。我们将 P^n[k] 表示为数据所有者 n 持有的属于类别 k 的训练样本集合。对于每个类别 k，数据所有者可以在本地计算

此外，M^n[k] 可以计算为 M^n[k] = |P^n[k]|，数据所有者也会像 PCA 一样计算 R^n，因为它不受特定类别的限制。现在，S[W] 可以根据数据所有者的部分贡献安排如下，

其中

现在，让我们看看我们如何计算信号矩阵 S[B]。单类别（SCDO）和多类别（MCDO）的计算方式相同。此外，信号矩阵可以直接从前面方程中描述的聚合数据（V[k]，M[k]，V，M）计算如下：

与散点矩阵不同，噪声矩阵和信号矩阵在计算中都使用类别平均值。这将需要数据所有者向数据使用者发送每个类别的份额。如果一个数据所有者只发送与数据所有者拥有的类别相关的份额，这将泄露哪些类别属于哪个数据所有者的知识。因此，建议所有数据所有者发送代表所有类别的份额，当一个数据所有者不拥有某些类别的数据时，他们可以将该类份额设置为全零。

让我们一步一步地看看隐私保护 DCA 协议是如何工作的：

1. 设置用户—这一步与我们为 PCA 所做的工作非常相似。CSP 根据数据所有者和数据使用者的请求，向他们发送 Paillier 密码系统的公钥 pk。

2. 计算局部份额—每个数据所有者 n 从其数据中计算 R^n，对于每个标记为 k 的类别，数据所有者计算 V^n[k] 和 M^n[k]。如前所述，如果一个数据所有者没有与类别 k 相关的样本，他们仍然会生成 V^n[k] 和 M^n[k]，但将它们设置为零。在离散化和获得整数值后，数据所有者将使用 CSP 的公钥加密 R^n 以获得 E[pk][R^{n]，并且还会加密基于类别的份额（V}n[k] 和 M^n[k]），为每个类别 k 获得如下：{k，E[pk][V^{n[k]]，*E*[pk][M}n[k]]}。最后，数据所有者将发送他们自己的加密份额 DS n 到数据使用者。

3. 聚合本地份额——从每个数据所有者那里，数据用户接收 DS^n，其中包含 E[pk][R^n]，并且对于每个类别 k，它还包括 {k, E[pk][V^n[k]], E[pk][M^n[k]]}。数据用户随后继续重建 R 的加密、V[k] 的值和 M[k] 的值，如下所示：

   

   对于每个类别 k ∈ 1, ..., K，数据用户计算

   

   

   此后，数据用户将这些聚合值添加一些随机整数以掩盖它们，从而获得盲化份额 E[pk][R'] 以及 E[pk] 和 E[pk] 的值。然后，这些盲值被发送到 CSP。

4. 执行广义特征值分解（GEVD）：

   1. CSP 将使用其私钥解密从数据用户那里接收到的盲化份额 E[pk][R'] 以及 E[pk][V’[k]] 和 E[pk][M’[k]] 的值。在不了解数据用户添加的随机值的情况下，CSP 无法学习到聚合值。

   2. 然后，CSP 将构建一个混淆电路，对从聚合份额计算出的信号和总散布矩阵执行 GEVD。这个混淆电路的输入是 CSP 解密后的盲化聚合份额的混淆版本以及数据用户生成并持有的盲值。

   3. 正如我们在 PCA 案例中讨论的那样，由于 CSP 构建了混淆电路，它可以自己获得其输入的混淆版本。然而，数据用户需要通过盲传输与 CSP 交互，以获得其输入的混淆版本：盲值。这种盲传输保证 CSP 不会学习到数据用户持有的盲值。

   4. CSP 构建的混淆电路接受两个混淆输入，并从聚合份额中移除盲值，并使用份额 V'[k] 和 M'[k] 来计算 V 和 M。然后，它计算总散布矩阵 ，以及信号矩阵 S[B]，最后，它执行广义特征值分解来计算 DCA 投影矩阵。

   5. 数据用户将接收到混淆电路作为其评估器。我们知道这个混淆电路已经包含了 CSP 的混淆输入（解密并盲化的聚合份额），因此他们通过盲传输获得盲值的混淆版本。

   6. 最后，数据用户执行混淆电路，并获得投影矩阵和特征值作为输出。

这就是如何在您的应用程序和用例中实现隐私保护 DCA。

什么是广义特征值分解（GEVD）？

给定矩阵 A 和 B，GEVD 的目标是找到满足方程 Au = λBu 的特征值（称为 λ）和特征向量（称为 u）。

您可能会考虑将这个问题简化为常规的 EVD，通过计算 B 的逆并尝试解 B^((-1))Au = λu。然而，B^((-1))A 并不总是保证是一个对称矩阵。散布矩阵的一个重要特性是它们是对称的。对称矩阵的特征值总是实数，这使得我们可以有一个更简单的幂方法实现，该方法不涉及复数。

您现在已经了解了如何使用加密份额转换数据以及如何执行特征值分解以在具有隐私性的 ML 任务中与 PCA 和 DCA 一起工作的方程。在下一节中，我们将评估这些不同方法的效率和准确性。

9.4.6 评估隐私保护 PCA 和 DCA 的效率和准确性

到目前为止，在本章中，我们已经讨论了理论背景以及在不同现实世界的 ML 应用中实现 CP（尤其是 PCA 和 DCA）的不同方法。在这里，我们将评估本案例研究前几节（尤其是 9.4.4 节）中讨论的实现方法的效率和准确性。正如我们已经讨论过的，当我们将隐私整合到我们的 ML 任务中时，保持隐私和效用之间的平衡是很重要的。因此，我们将评估这一点，看看所提出的方案对于实际的 ML 应用有多有效。

在本案例研究中，我们用于实验的数据集来自 UCI 机器学习仓库[8]。虽然 PCA 和 DCA 适用于任何类型的 ML 算法，但我们选择了分类，因为可用的分类数据集数量（255 个）远远超过了聚类或回归（每个大约 55 个）。此外，由于所提出的协议的效率取决于数据维度（特征的数量），我们选择了具有不同特征数量的数据集：8-50 个。表 9.1 和 9.2 总结了每个数据集的特征和类别数量。SVM 被用作这些评估的分类任务，并且所有情况下数据所有者的数量都设置为 10。

分析效率

表 9.1 和 9.2 显示了使用 Paillier 密钥长度为 1,024 位在不同数据集上执行隐私保护 PCA 和 DCA 的计时数据。您可以尝试使用不同的密钥长度来查看它将如何影响性能——您会发现当密钥长度更长时，性能会受到不利影响。

对于数据所有者，平均时间成本指的是数据所有者计算各个份额并对其进行加密所花费的总时间。对于数据使用者，平均时间成本代表从每个数据所有者收集每个份额并添加到当前这些份额总和（在加密域中）所需的时间。

表格还显示了 CSP 解密从数据用户接收到的盲化聚合值所需的时间。最后，它们显示了使用混淆电路运行特征值分解以计算 PCA 或 DCA 投影矩阵所需的时间。括号中的值指的是使用混淆电路生成的主成分数量。当然，减少这个数量将减少给定数据集的计算时间。正如我们将在下一节讨论的，即使是 SensIT Vehicle（声学）数据集的 15 个主成分也足以达到足够的准确性。

最后，你会注意到增加数据的维度将增加协议所有阶段的计算时间，尤其是特征值分解。

表 9.1 分布式 PCA 的效率

数据集	特征	类别	数据所有者平均时间成本（秒）	数据用户平均时间成本（毫秒）	CSP 解密时间（秒）	使用混淆电路进行特征值分解
糖尿病	8	2	0.63	10	0.67	13.8 sec (8)
乳腺癌	10	2	0.93	11	1.0	20.7 sec (8)
澳大利亚	14	2	1.7	12	1.8	37.4 sec (8)
德国	24	2	5.0	17	5.0	3.28 min (15)
电离层	34	2	9.8	24	9.9	6.44 min (15)
SensIT Vehicle（声学）	50	3	22.5	40	22.7	13.8 min (15)

表 9.2 分布式 DCA 的效率

数据集	特征	类别	数据所有者平均时间成本（秒）	数据用户平均时间成本（毫秒）	CSP 解密时间（秒）	使用混淆电路进行特征值分解
糖尿病	8	2	0.7	12	0.8	4.0 sec (1)
乳腺癌	10	2	1.2	13	1.3	5.8 sec (1)
澳大利亚	14	2	2.1	15	2.2	12.1 sec (1)
德国	24	2	5.6	22	5.8	46.6 sec (1)
电离层	34	2	11.2	29	11.6	1.9 min (1)
SensIT Vehicle（声学）	50	3	26.2	48	26.9	6.7 min (2)

分析 ml 任务的准确性

图 9.8 和表 9.3 总结了执行实验以测试在隐私保护协议使用后分类任务准确性的结果，与使用 Python 库 NumPy 获得的结果进行了比较。

图 9.8 隐私保护 PCA 准确性

我们在这里使用加权 F1 分数来测试分类器的准确性。F1 分数可以被视为精确度和召回率分数的加权平均值；当 F1 分数为 1 时，分类器处于最佳状态，而当分数为 0 时，处于最差状态。F1 分数是 ML 应用中用于比较两个分类器性能的主要指标之一。有关 F1 分数如何工作的更多信息，请参阅第 3.4.3 节。

作为提醒，以下是计算 F1 分数的方法：

DCA 的结果显示在表 9.3 中，每个值只有一个，因为 DCA 将数据投影到K - 1 个维度（其中K是类别标签的数量），而 PCA 将数据投影到可变数量的维度。正如您所看到的，这些协议是正确的，并且它们的结果与使用 NumPy 获得的结果相同。需要注意的是，加权 F1 分数的轻微波动主要是由于 SVM 参数选择造成的。然而，两种方法的准确性几乎相同。

表 9.3 隐私保护 DCA 准确性

数据集	F1 分数 %(使用所提出的方法)	F1 分数 %(使用 NumPy 库)
糖尿病	76.5	76.4
乳腺癌	96.9	96.8
澳大利亚	86.1	85.5
德国	72.7	73.8
电离层	84.3	83.4
SensIT Vehicle (Acoustic)	67.8	68.4

在本案例研究中，我们讨论了如何在水平划分的数据上实现机器学习（尤其是 PCA 和 DCA）的隐私保护协议，这些数据分布在多个数据所有者之间。从结果来看，这种方法是高效的，它既保持了数据用户的效用，又保护了数据所有者数据的隐私。

摘要

• 基于 DP 的隐私保护技术的主要问题是，它们通常会给私有数据添加过多的噪声，导致不可避免地降低效用。

• 压缩隐私是一种替代方法（与 DP 相比），可以在许多实际应用中用于隐私保护，而不会在效用任务中造成重大损失。

• 压缩隐私本质上通过压缩和 DR 技术将数据投影到低维超平面，从而扰动数据，使得数据可以在不影响隐私的情况下被恢复。

• 不同的压缩隐私机制适用于不同的应用，但对于机器学习和数据挖掘任务，PCA、DCA 和 MDR 是一些流行的方法。

• 压缩隐私技术，如 PCA 和 DCA，也可以在分布式环境中使用，以实现机器学习的隐私保护协议。

10 整合所有要素：设计一个隐私增强平台（DataHub）

本章涵盖

• 针对协作工作的隐私增强平台要求

• 研究协作工作空间的不同组件

• 现实世界应用中的隐私和安全要求

• 在研究数据保护和共享平台上整合隐私和安全技术

在前面的章节中，我们探讨了服务于不同目的的隐私增强技术。例如，在第二章和第三章中，我们探讨了差分隐私（DP），它涉及向数据查询结果添加噪声，以确保个人的隐私，同时不影响数据的原始属性。在第四章和第五章中，我们研究了局部差分隐私（LDP），它是一种局部设置，利用本地部署的数据聚合器。本质上，LDP 消除了我们在原始 DP 技术中使用的可信数据管理员。然后，在第六章中，我们讨论了合成数据生成技术，这些技术可以替代上述隐私技术。在第七章和第八章中，我们探讨了在数据库应用中存储数据并在不同的数据挖掘任务中发布数据时保护数据隐私的问题。最后，在第九章中，我们向您介绍了不同的压缩隐私（CP）策略，这些策略将数据投影到低维空间。我们还讨论了使用 CP 方法的好处，特别是对于机器学习（ML）算法。

现在我们已经到达这本书的最后一章。在这里，我们将向您展示如何将隐私增强技术和方法应用于实现一个现实世界的应用，一个研究数据保护和共享平台——我们将称之为DataHub。在本章中，我们将探讨这个假设系统的功能和特性。我们的目标是向您展示一个实际应用的设计过程，其中隐私和安全增强技术发挥着至关重要的作用。

10.1 研究数据保护和共享平台的重要性

在许多应用场景中，需要将隐私增强技术应用于现实世界的应用，以保护个人的隐私。例如，正如我们在前面的章节中讨论的那样，从电子商务或银行应用中收集的私人数据，如年龄、性别、邮编、支付模式等，需要得到保护，以便其他方无法追踪回原始用户。

类似地，在医疗保健应用中，你必须确保所有必要的隐私保护。患者记录和药物详情不得泄露，即使在研究目的下，也必须在患者同意的情况下。在这种情况下，当利用这种私有信息进行诸如研究之类的目的时，最佳方法是应用某种隐私增强机制并扰动原始数据。但哪种机制最有效？我们能否在所有不同的用例中使用任何机制？本章将通过将不同的机制组合到一个协作任务中来回答这些问题。

让我们考虑一个场景，其中不同的医疗机构独立地寻找特定疾病（如皮肤癌）的治愈方法。每个机构都与其患者紧密合作，以开发高级研究项目。假设他们正在使用机器学习算法，根据皮肤镜图像对皮肤癌进行分类，以帮助研究过程。然而，如果他们不是各自独立工作，而是协作以提高机器学习模型的准确性，那会怎样。不同的机构可以贡献不同类型的数据，这提供了更多样化的数据集，从而提高了准确性。

然而，正如你所知，专门为研究目的收集的人类受试者数据必须得到安全维护，通常由于隐私问题不能与其他方共享。这就是隐私增强技术发挥作用的地方。由于这是一个协作努力，我们必须选择最合适的技术来确保数据隐私保证。

本章将探讨我们如何允许不同的利益相关者进行协作（在这种情况下，各种医疗机构）。我们将设计一个端到端平台，使用一系列增强安全和隐私的技术来保护和共享研究数据。我们的想法是展示如何将我们在前几章中讨论的技术应用于现实世界场景。我们的用例将是 DataHub——研究数据保护和共享平台。

10.1.1 DataHub 平台背后的动机

来自不同机构、组织或国家的研究人员共同合作，以实现一个共同的科学目标。他们通常从各种来源收集大量数据，并对其进行分析，以回答具体的研究问题。例如，假设一个癌症研究所正在进行预防和治疗间皮瘤的研究，这是一种在美国人群中很少见的癌症类型。由于这是一种罕见的癌症类型，该研究所提供的间皮瘤患者数据非常有限。因此，该研究所的研究人员需要从其他癌症研究所获取更多患者数据，但其他研究所可能不愿意分享患者数据，因为隐私政策。在协作研究中，从多个数据所有者聚合私有数据是一个重大问题。

让我们考虑另一个场景。假设一位研究人员正在调查个人的政治态度。研究人员可能进行传统的面对面调查或使用在线调查工具，但在任何情况下，研究人员都会获得包含个人隐私信息的原始数据。这种原始数据容易受到滥用，正如我们在第一章中简要讨论的 Facebook-Cambridge Analytica 数据丑闻所示——剑桥分析公司收集的数据被用来试图影响选民的观点。因此，对允许数据共享和聚合同时保护安全和隐私的系统需求日益增加。

本章的 DataHub 是一个假设的系统，它将实现这些目标。在这样的系统中，我们需要提供数据存储的安全性、消除数据滥用，并维护研究过程的完整性。由于人类是许多研究领域（如医学、生物学、心理学、人类学和社会学）的研究对象，因此，对于使用包含个人信息的数据的研究人员来说，保护个人隐私是一个基本要求。我们将设计的 DataHub 平台将通过为分析来自多个数据所有者的聚合数据提供隐私保护机制来解决这个问题。此外，这个平台将包含进行隐私保护调查的工具，这些工具从个人收集扰动数据，并保证隐私。本质上，我们可以通过这些隐私保证来提高调查参与度并消除隐私泄露。

10.1.2 DataHub 的重要特性

对于这个应用，将会有许多不同的利益相关者——数据所有者、数据使用者、算法提供商等等——因此，需要通过数据或技术贡献和共享来促进平台用户之间的协作，并指定由数据所有者设定的隐私访问控制。

让我们来看看这种应用所需的关键特性：

• 确保数据保护。收集的数据需要通过安全和隐私增强技术进行保护。通过数据存储和检索过程中的数据加密/解密和完整性检查可以确保安全性。完整性验证可以保证数据不会被无意或恶意地更改。通过使用我们在前几章讨论的隐私保护技术，包括合成数据生成和隐私保护机器学习，可以扰动数据或分析结果来确保隐私。

• 允许应用程序扩展。一旦部署，系统应利用云计算和数据库系统中新兴的分布式数据处理技术的进步，随着数据和应用程序需求的增长来扩展计算。安全性和隐私技术应通过在虚拟机（VMs）上部署的数据保护作为服务来实现。随着数据和用户数量的增加，可以动态部署更多虚拟机资源。

• 启用利益相关者的协作和参与。平台应通过至少四个角色促进协作：数据所有者、数据提供者、数据用户和算法提供者。除了研究数据外，还可以收集和共享跨机构的数据分析和保护算法。可以通过不同的基于角色的访问控制机制启用对数据和算法的访问。

即使在数据保护和共享的背景下，也有许多不同的应用用例。我们已经提到了两个：一个用于跨多个协作机构的数据聚合的应用程序，以及一个在线调查工具，用于促进数据收集过程。可能还有许多其他用例，涉及存储、分析、收集和共享研究数据。

如果你想知道是否有任何类似这种的既定解决方案，答案是肯定的。例如，BIOVIA ScienceCloud (www.sciencecloud.com) 是一个基于云的基础设施，它能够提供研究协作的解决方案。HUBzero (hubzero.org) 是另一个开源软件平台，用于托管分析工具、发布数据、共享资源、协作和建立社区。开放科学数据云（OSDC；www.opensciencedatacloud.org）是另一个促进存储、共享和分析千兆和太字节规模科学数据集的云平台。然而，现有的解决方案中没有任何一个允许隐私保护查询或分析来自多个来源的保护数据，这正是我们所寻找的。此外，它们中没有一个提供进行隐私保护调查的工具，这是从个人收集信息的基本方式，尤其是在社会科学领域。这种缺乏隐私保护技术意味着当前的平台不足以支持研究协作。我们将通过提供一个安全、共享的工作空间来填补这一空白，在这个工作空间中，多个组织和科学研究社区可以共同在云基础系统上工作，这个系统在一个屋檐下满足科学社区的所有需求，并确保隐私安全。

10.2 理解研究协作工作空间

我们现在将详细阐述研究协作工作空间的设计。DataHub 将促进平台上的四个不同用户群体：数据所有者、数据提供者、数据用户和算法提供者，如图 10.1 所示。这些不同的用户可以通过基于角色的访问控制机制进行配置。平台用户也可能在系统中拥有多个角色。例如，数据所有者可能希望利用其他数据所有者的数据。在这种情况下，数据所有者可以作为数据用户运行隐私保护算法。

图 10.1 DataHub 系统中不同用户角色的概述

如图 10.1 所示，数据所有者的目标是允许研究人员使用他们的数据集，同时保护这些数据集的安全性和隐私。实现数据集安全性和隐私的一种方法是将可扩展的基于云的 SEC-NoSQL 安全 NoSQL 数据库解决方案[1]集成到架构中。

每当数据所有者将他们的数据提交给 DataHub 时，这些数据将安全地存储在数据库中。为了实现这一点，一个解决方案是数据所有者加密这些信息并将其放入数据库中。然而，每当我们需要查询该数据集中的一个数据元组时，数据所有者必须解密整个数据库，这在多方应用中既不实用也不高效。为了解决这个问题，研究界提出了一个 SQL 感知加密概念[2]。其想法是数据将以一种方式加密，使得查询加密数据成为可能，而无需解密整个数据库。这可以通过不同属性保持加密的层次来实现。SEC-NoSQL 框架将通过数据加密机制和数据存储和检索期间的数据完整性验证来提供数据安全。完整性验证防止数据被任何一方无意或恶意地更改。我们将在第 10.3.1 节中探讨细节，但作为一个快速的高级概述，数据安全操作可以在两种信任模型中实现，以保护数据所有者的数据免受 DataHub 其他部分的影响：

• 一个半信任的第三方称为加密服务提供商（CSP），将为加密提供公钥。

• 算法将在数据所有者和 DataHub 之间执行，而不需要加密服务提供商的帮助。

在这个平台上，数据所有者将通过访问控制机制定义不同的保护策略来控制他们的数据如何被使用以及谁可以访问或使用它。

在安全架构设计中，什么是信任模型？

通常，信任是安全架构的一个特征，它可以被看作是使人们对某事将以可预测的方式发生或不会发生产生信心。例如，根据 ITU-T X.509 标准，信任被定义为以下内容：“当第一个实体假定第二个实体将完全按照第一个实体期望的方式行事时，可以说第一个实体‘信任’第二个实体。”

信任模型提供了一个提供安全机制的框架。信任建模是安全架构师执行的过程，用于定义一个补充的威胁配置文件。该练习的结果将整合有关特定 IT 架构的威胁、漏洞和风险的信息。

DataHub 还将有一个用于通过隐私保护调查收集数据的组件（见图 10.1）。正如我们在第四章中讨论的，局部差分隐私（LDP）允许数据用户在保护每个个人（数据所有者）隐私的同时，通过使用随机响应机制（见第 4.1.2 节）聚合有关人群的信息。

此外，数据用户可以通过在 DataHub 中运行隐私保护算法来利用数据所有者拥有的数据。这些算法可以是隐私保护机器学习、查询处理、合成数据生成等。一般来说，如果获得访问权限，数据用户将只会了解算法的结果。算法的结果将保证差分隐私，这是我们讨论的第二章和第三章中常用的量化个人隐私的标准。

最后，数据集可以通过算法提供商添加新的算法（图 10.1）来扩展。这促进了不同机构之间的合作。

10.2.1 架构设计

作为科学社区的扩展系统，DataHub 将是一个在公共云上管理所有数据和算法的平台。如图 10.1 所示，DataHub 的主要功能将在受保护的数据集上运行隐私保护算法。NoSQL 数据库将被用于数据存储，因为它们为大数据提供了更好的性能和高度的可扩展性，特别是对于增加的工作负载。详细的部署架构如图 10.2 所示。

图 10.2 DataHub 的系统部署架构

让我们快速浏览一下图 10.2 中显示的组件。如图所示，DataHub 可以建立在不同的商业可用、开源工具和技术之上。数据所有者和数据使用者通过公共互联网连接到 DataHub 平台，就像访问任何网页一样。访问网关将在登录过程中执行访问策略，以识别分配给每个用户的权限。如果访问被允许，负载均衡器将适当地分配负载，并根据请求类型将请求转发到相关的 DataHub 服务应用程序。我们将在本章后面讨论不同的服务提供。DataHub 执行的每个功能都作为服务应用程序（资源即服务）提供。例如，机器学习作为机器学习即服务提供。最后，为了便于某些服务的安全交付，集成了加密服务提供商。

注意：图 10.2 标识了一些最受欢迎的开源软件产品，以给您一个关于它们功能的想法。这只是为了参考。您可以使用您首选的软件产品。

在部署方面，我们可以为 DataHub 选择半诚实信任模型。在半诚实信任模型中，系统中的每个参与者都假定正确遵循协议，但他们可能会对交换的数据感到好奇，并可能通过分析协议执行期间接收到的值来尝试获取更多信息。数据所有者不能完全信任基于云的服务提供商，因此 DataHub 在运行算法时不会要求数据所有者提供原始数据。

我们可以为半诚实信任模型的两种变体开发隐私保护算法。第一种信任模型需要一个半信任的第三方，即加密服务提供商（CSP），它将提供用于加密的公钥。这个模型在通信成本方面更有效率。第二种信任模型不需要 CSP，但在执行过程中，算法需要数据所有者和 DataHub 之间有更多的通信。在这两种模型中，都可以分析来自多个数据所有者的汇总数据，促进协作研究。

现在让我们详细地看看这些信任模型。

10.2.2 混合不同的信任模型

如前所述，我们在我们的设计架构中使用了两种不同的半诚实信任模型。

基于 CSP 的信任模型

在这个模型中，想法是使用一个半信任的第三方，即加密服务提供商（CSP）[3]，来开发更有效的算法。CSP 首先生成一个密钥对，并提供公钥供数据所有者用于加密。由于数据所有者不希望与 DataHub 共享他们的原始数据，因此他们加密他们的数据，并与 DataHub 共享加密后的数据。

要在加密数据上执行计算，我们可以使用同态加密等加密方案（我们在第 9.4 节讨论了类似的协议）。当 DataHub 为算法在多个加密数据集上执行计算时，它需要在将结果与数据用户共享之前与 CSP 互动以解密结果。这种方法是实用的，因为它不需要数据所有者在算法执行期间在线。然而，它涉及一些假设，例如 CSP 和 DataHub 之间没有勾结。

图 10.3 展示了在 DataHub 中使用 CSP 执行算法的方式。每个数据所有者首先使用 CSP 的公钥加密他们的数据并将其发送到 DataHub 平台。每当数据用户想要访问数据，例如在该数据上运行机器学习任务时，DataHub 将在加密数据上运行任务并获得结果。然后，这些结果将被盲化并发送给 CSP 进行解密。由于数据被盲化，CSP 无法推断数据。一旦收到解密后的数据，DataHub 将移除盲化并将数据发送回数据用户以完成请求。

图 10.3 在 DataHub 中针对基于 CSP 的信任模型的隐私保护算法的执行

非 CSP 基于信任模型

此模型不需要 CSP 执行算法。当算法正在执行时，DataHub 直接与数据所有者互动。对此模型有几种解决方案。例如，可以在 DataHub 和数据所有者之间开发安全多方协议，或者每个数据所有者可以使用自己的密钥进行加密和解密。

我们可以使用分布式差分隐私（在第三章中讨论）作为此模型的另一种可能解决方案。当有数据用户请求在多个数据集上运行算法时，DataHub 可以将这些请求分配给这些数据集的所有者。使用 DataHub 插件，每个数据集所有者可以在本地计算其份额并对其计算出的份额应用差分隐私。当 DataHub 从数据所有者收集所有差分隐私份额时，可以使用私有份额计算数据用户请求的结果。

图 10.4 阐述了该分布式差分隐私算法的执行过程。与基于 CSP 的模型相比，这种方法要求数据所有者在算法执行期间在线，这需要 DataHub 和数据所有者之间有更多的通信。

图 10.4 在 DataHub 中针对非 CSP 基于信任模型的隐私保护算法（分布式 DP 方法）的执行

10.2.3 配置访问控制机制

身份和访问管理是任何信息系统安全的重要组成部分。通常，访问控制机制是一个框架，有助于管理应用程序的身份和访问管理。在这个系统中使用适当的访问控制机制非常重要，既要保护系统资产（数据和隐私保护算法）免受未经授权的外部方的侵害，又要管理不同资产如何被内部用户访问（数据所有者、数据提供者、数据用户或算法提供者）。

访问控制策略通常可以用对象、主体和操作来描述。对象代表系统中需要保护的具体资产，例如数据所有者的数据和算法。主体指的是特定的系统用户。操作描述了系统用户（主体）在系统资产（对象）上执行的具体动作，例如创建、读取、更新和删除。一个访问控制策略定义了主体如何对某个对象进行操作。

今天的应用程序中采用了四种主要的访问控制类型：

• 基于任意访问控制（DAC**）—在 DAC 模型中，资源所有者指定哪些主体可以访问特定的资源。例如，在 Windows、macOS 或 Ubuntu 等操作系统上，当你创建一个文件夹时，你可以轻松地添加、删除或修改你想给予其他用户的权限（如完全控制、只读等）。这种模型被称为任意，因为访问控制基于资源所有者的决定。

• 强制访问控制（MAC**）—在 MAC 模型中，用户不能确定谁可以访问他们的资源。相反，系统的安全策略将决定谁可以访问资源。这通常用于信息机密性至关重要的环境，例如军事机构。

• 基于角色的访问控制（RBAC**）—在 RBAC 模型中，不是为每个主体授予对不同对象的访问权限，而是授予对角色的访问权限。与角色关联的主体将获得对这些对象的相应访问权限。

• 基于属性的访问控制（ABAC**）—ABAC 模型是 RBAC 的高级实现，其中访问基于系统中对象的属性。这些属性可以是用户、网络、网络上的设备等几乎任何特征。

DataHub 是一个基于角色的协作数据共享平台（如你在图 10.1 中看到的），它涉及大量用户（主体）访问数据（对象）。对每个主体对众多不同对象的访问进行单独管理是不切实际的。因此，我们将在我们的平台上设计和实现一个基于角色的访问控制（RBAC）机制。

现在，让我们看看 RBAC 如何帮助我们实现 DataHub 中的访问控制策略。如图 10.5 所示，存在一组对象（例如，数据集 D[1]，算法 A[1]），一组主体（例如，用户 U[1]，U[2] 和 U[3]），以及一组操作（例如，查询处理，执行机器学习算法）。对于每个对象，我们根据不同的角色定义不同的访问控制策略（例如，R[1]，R[2]）。每个角色都由某些属性和规则来描述。属性定义了与相应角色关联的主体，规则定义了相应的策略。例如，在图 10.5 中，U[1] 和 U[2] 与 D[1] 内定义的 R[1] 相关联，该规则还定义了“允许查询处理访问”。在这种情况下，U[1] 和 U[2] 被允许在 D[1] 上执行查询处理。同样，U[3] 被允许在数据集 D[1] 上执行机器学习算法 A[1]。

图 10.5 角色基于访问控制（RBAC）的工作原理

在这个设计中，相应的用户（例如，数据所有者或数据提供者）可以将访问控制策略（例如）与他们的数据一起提交给 DataHub。这样，数据所有者和数据提供者可以完全控制他们提交的数据。他们还有权控制和监控访问他们数据的算法。当新的数据用户被添加到 DataHub 时，他们可以请求访问特定数据集的权限。请求数据集的数据所有者可以决定是否将该用户添加到与该数据集关联的角色之一。这就是图 10.2 中访问网关得以实现的方式。

既然你对 DataHub 的架构有了基本的了解，让我们看看隐私技术是如何协同工作来保护这个平台的。

10.3 将隐私和安全技术集成到 DataHub 中

正如我们在本章前面提到的，我们的目标是向你展示如何在现实场景中结合不同的隐私增强技术。在本节中，我们将探讨这些不同技术集成的技术方面。首先，我们将介绍数据存储选项，然后我们将讨论机器学习机制。

10.3.1 使用基于云的安全 NoSQL 数据库进行数据存储

在第七章和第八章中，我们讨论了隐私增强技术如何在数据挖掘任务和数据库应用中使用。作为一个快速回顾，无论我们使用的数据模型是什么（无论是关系型还是非关系型），安全性在任何数据存储中都是一个主要关注点。但大多数现代数据库系统（尤其是 NoSQL 数据库系统）更关注性能和可扩展性，而不是安全性。

基于不同方法的安全感知数据库系统已经研究了许多年[2]，[4]。在云环境中确保敏感数据安全的一种方法是在客户端加密数据。CryptDB [2] 是为关系数据库开发的一个这样的系统。它利用中间件应用程序重写客户端发出的原始查询，因此这些查询在数据库级别上执行在加密数据上。基于这种方法，我们探索了可能性并实现了一个名为 SEC-NoSQL [1]的框架，如图 10.6 所示。它确保了 NoSQL 数据库的安全性和隐私，同时保持了大数据分析中的数据库性能。

图 10.6 SEC-NoSQL 的架构

SEC-NoSQL 框架背后的主要思想是实现一个实用且安全感知的 NoSQL 数据库解决方案，该方案在云上运行，并保证了一定的性能和可扩展性。在这个设计中，客户端仅与代理服务器通信，就像它们直接将数据存储到数据库或从数据库检索数据时一样。首先，数据所有者向代理发出创建数据库模式的请求。代理通过匿名化列名来转换模式，并在数据库中执行该模式。当代理收到数据写入请求时，它将通过加密机制，并使用 HMAC-SHA256 算法生成该记录的哈希值（HMAC）。此值将被存储在代理维护的哈希表中。在读取请求的情况下，代理从数据库中检索加密记录，生成哈希值，并将哈希表中的对应条目进行比较以确保数据完整性。如果完整性检查通过，则记录将被解密，并将相应的结果发送回客户端。

为了方便对加密记录进行查询，我们需要实现允许我们在加密数据上执行基本读写操作的加密技术。不同的加密算法提供不同的安全保证。更安全的加密算法可以确保对强大对手不可区分，并且某些方案允许在加密数据上执行不同的操作。

通过遵循 CryptDB 建议的方法，我们实现了一套不同的加密算法，以方便对加密数据进行一系列不同的 SQL 查询。基于不同的加密操作，如随机加密、确定性加密、顺序保持加密和同态加密，SEC-NoSQL 可以在不影响数据库性能水平的情况下，对加密数据进行操作和处理。

在对 SEC-NoSQL 的工作原理有了基本理解之后，让我们快速看一下查询操作的一个简单示例。假设我们正在使用 MongoDB 作为我们的后端数据库，并且需要在数据库的 table_emp 表中插入员工的 ID 和姓名。在 MongoDB 中，我们可以通过执行以下类似的内容来实现：

db.table_emp.insertOne({col_id: 1, col_name: 'xyz'})

然而，当这个查询被 SEC-NoSQL 的中间件应用程序接收时，它将被翻译成以下类似的内容：

db.table_one.insertOne({col_one: DET(1), col_two: RND('xyz')})

如您所见，所有的表和列名都将被匿名化，数据将被加密（这里，DET 表示确定性加密）。这就是简单的 INSERT 操作是如何工作的。类似的方案可以用来实现 READ、UPDATE 和 DELETE 操作。

10.3.2 基于本地差分隐私的隐私保护数据收集

我们在第四章和第五章中讨论了本地差分隐私（LDP）的基本原理和应用。LDP 的一个潜在用例是用于在线调查。研究人员使用调查用于各种目的，例如分析行为或评估思想和观点。

由于隐私原因，从个人收集调查信息用于研究目的具有挑战性。个人可能不会足够信任数据收集者来分享敏感信息。尽管个人可以匿名参与调查，但仍然有可能通过提供的信息[5]识别出这个人。LDP 是解决这个问题的方法之一。您可能还记得，LDP 是在数据收集者不受信任时确保个人隐私的一种方式。LDP 的目标是确保当个人提供一个值时，很难识别出原始值是什么。

那么，我们如何在 DataHub 平台上使用 LDP 呢？在我们回答这个问题之前，让我们快速回顾一下 LDP 的基础知识。LDP 协议由三个主要步骤组成。首先，每个用户使用编码方案对他们的值（或数据）进行编码。然后，每个用户扰动他们的编码值并将它们发送给数据收集者。最后，数据收集者汇总所有报告的值并估计隐私保护统计信息。图 10.7，您在第四章中已经看到，展示了这个 LDP 过程。

图 10.7 本地差分隐私是如何工作的

我们将为 DataHub 平台设计一个在线调查工具，如图 10.8 所示，通过实现从个人（数据提供者）收集数据并估计关于人群的统计信息现有的 LDP 方法。由于每个值在发送到 DataHub 之前都会被扰动，因此数据提供者不必担心他们的隐私。

图 10.8 DataHub 的隐私保护调查机制

大多数现有的 LDP 实现方案都假设单个ϵ值由数据收集者确定并由个人使用。然而，个人可能有不同的隐私偏好。在我们的方法中，我们计划允许数据提供者为提交给 DataHub 的每条信息选择一个隐私级别。例如，一个人可能愿意与数据收集者分享他们的年龄，而另一个人可能更愿意隐藏它。研究人员可以通过在 LDP 下保证每个个人的隐私来收集个人用于不同目的的数据。当个人通过 DataHub 与研究人员共享信息时，他们将控制他们隐私的级别。

同样的架构不仅可以用于诸如频率估计等基本问题，还可以用于其他分析，如分类和回归。正如第 5.3 节所讨论的，我们可以使用扰动数据来训练一个朴素贝叶斯分类器，然后可以用于不同的任务。

10.3.3 隐私保护机器学习

机器学习高度依赖于底层数据，当数据来自多个方时，数据隐私成为一个关键问题。例如，数据可能分布在几个方之间，他们可能希望在不透露他们的数据的情况下运行 ML 任务。或者数据所有者可能希望在他们的数据上运行 ML 任务，并与其他方共享学习到的模型。在这种情况下，模型不应透露任何关于训练数据的任何信息。

有不同的方法来解决这个问题，这些方法可以大致分为两类：基于密码学的方法和基于扰动的的方法。

密码学方法

在基于密码学的隐私保护机器学习（PPML）解决方案中，同态加密、混淆电路和秘密共享技术是广泛使用的机制，用于保护隐私。

在第 9.4 节的研究案例中，我们讨论了一个混合系统，该系统利用加法同态加密和混淆电路在不泄露底层数据信息的情况下执行主成分分析（PCA）。如图 10.9 所示，数据所有者计算并加密汇总统计数据，然后将它们发送给数据用户。数据用户随后将数据所有者的所有加密份额汇总起来，向结果添加一个随机盲化值，并将它们传递给 CSP。CSP 使用其私钥解密盲化数据，构建混淆电路，并将它们转回数据用户。最后，数据用户执行混淆电路以获得输出。

图 10.9 基于密码学的隐私保护机器学习协议

在 DataHub 的情况下，我们可以稍微修改这个协议。例如，由于加密数据集将存储在 NoSQL 数据库中，DataHub 可以使用同态属性计算每个数据所有者的本地份额并遵循该协议。在具有 CSP 的信任模型中，DataHub 不需要与数据所有者交互，并且可以在 CSP 的帮助下解密结果。

基于扰动的方案

我们在第二章和第三章中讨论了差分隐私 (DP) 的使用。作为一个快速回顾，DP 的目的是在发布数据库中的聚合信息的同时保护个人的隐私，通过向算法的输出添加随机性来防止成员推理攻击。我们将使用基于扰动的方案结合 DP。

已经开发了几种不同的隐私保护机器学习算法来满足差分隐私 (DP)。在这些算法中，研究社区已经调查了使用不同方法的不同隐私 PCA。一些方法通过添加对称高斯噪声矩阵来估计数据的协方差矩阵，而另一些方法则使用 Wishart 分布来近似协方差矩阵。这两种方法都假设数据已经被收集。在第 3.4 节中，我们探索了一种高度高效和可扩展的差分隐私分布式 PCA 协议 (DPDPCA) 用于水平分区数据。我们将在 DataHub 中使用该协议。

如图 10.10 所示，每个数据所有者加密其数据份额并发送给代理，代理位于数据用户和数据所有者之间的半信任方。代理聚合从每个数据所有者接收到的加密数据份额。为了防止通过 PCA 进行推理，代理向聚合结果添加一个噪声矩阵，使得散点矩阵的近似满足 (ε, δ)-差分隐私。聚合结果被发送给数据用户，数据用户解密结果，构建散点矩阵的近似，然后继续进行 PCA。

图 10.10 基于扰动的隐私保护机器学习协议

10.3.4 隐私保护查询处理

现在让我们看看如何利用 DataHub 来简化查询处理。正如我们在第 10.2.2 节中讨论的那样，DataHub 平台将支持两种信任模型：基于 CSP 的信任模型和非基于 CSP 的信任模型，其中 CSP 是一个半诚实的第三方。因此，我们将为这两种信任模型开发处理一个或多个受保护数据集查询的算法。这种查询处理功能可以通过两种不同的方法启用。第一种方法通过 SEC-NoSQL 框架实现查询处理，而另一种方法则实现差分隐私查询处理。每种方法都有其优点和缺点，因此让我们详细回顾这些方法的技术细节。

我们当前的 SEC-NoSQL 框架支持主要的 CRUD 操作（创建、读取、更新和删除）。通过使用其他加密方案，如同态加密和有序保持加密，我们可以扩展此框架以支持不同类型的统计查询，如 SUM、AVERAGE 和 ORDER BY。在基于 CSP 的信任模型中，数据所有者将使用 CSP 的公钥进行同态加密，并将加密后的数据提交给 DataHub，DataHub 可以在 CSP 的帮助下处理聚合查询。在非 CSP 基于信任模型下使用 SEC-NoSQL 框架处理查询也是可能的。每个数据所有者可以使用他们自己的公钥并将加密后的数据发送到 DataHub。然而，当数据用户想要处理查询时，DataHub 需要与数据所有者进行交互以进行解密。这将降低查询处理的实用性，因为数据所有者需要在查询处理期间在线，并且需要更多的 DataHub 与每个数据所有者之间的通信。

在分布式设置中，对于差分隐私查询处理方法不需要 CSP。为了满足数值查询的差分隐私，我们只需向查询结果添加所需的噪声级别。然而，当数据分布在几个当事人之间时，决定每个当事人应添加多少噪声并非易事。我们在 3.4.2 节中讨论了这个问题。作为一个解决方案，Goryczka 等人[6]为安全求和聚合问题引入了一个分布式差分隐私设置。在分布式拉普拉斯扰动算法（DLPA）中，每个数据所有者生成一个从高斯、伽马或拉普拉斯分布中采样的部分噪声，聚合器中累积的噪声将遵循拉普拉斯分布，这满足 DP。在实践中，使用拉普拉斯分布进行部分噪声对于具有隐私的分布式数据聚合来说更有效率，并且添加的冗余噪声更少。因此，DataHub 将在分布式模型中使用 DLPA 来实现差分隐私。

10.3.5 在 DataHub 平台中使用合成数据生成

在第六章中，我们讨论了合成数据生成的不同用例以及为什么合成数据如此重要。隐私保护查询处理和机器学习算法很重要，但有时研究人员想要执行新的查询和分析程序。当没有预定义的操作算法时，我们必须从数据所有者那里请求原始数据，以便我们可以在本地使用它。这就是隐私保护数据共享方法，如k-匿名性、l-多样性、t-接近性和数据扰动发挥作用的地方。我们在第七章和第八章中讨论了这些隐私保护数据共享和数据挖掘技术。然而，数据共享的另一个有希望的解决方案是生成既合成又具有代表性的数据，这些数据可以安全地共享。以与原始数据相同格式的合成数据集进行共享，使我们能够在数据用户如何使用数据方面拥有更多的灵活性，无需担心数据隐私。让我们看看如何在 DataHub 平台上利用合成数据生成机制。

DataHub 将包括一个私有的合成数据生成算法作为服务，如图 10.11 所示。此算法将结合属性级微聚合[7]和差分隐私多元高斯生成模型（MGGM）来生成满足差分隐私的合成数据集。正如第六章中讨论的那样，为了实现合成数据的 DP 所需的噪声小于其他算法。数据用户将能够在合成数据集上执行聚合查询，或者他们可以使用 DataHub 中的合成数据与机器学习算法一起使用。

为了更好地捕捉实际数据的统计特征，我们可以将属性划分为独立的属性子集。同一子集中的属性将相互关联，并且与不同属性子集中的属性不相关。对于每个属性子集，我们可以分配一个包含微聚合和差分隐私 MGGM 的合成数据生成器。您可以参考第 6.4 节了解更多关于实现和技术细节的信息。

我们提出的解决方案将非常适合我们之前讨论的信任模型（带有 CSP 和不带有 CSP）。在基于 CSP 的信任模型中，DataHub 在 CSP 的帮助下生成合成数据。在非 CSP 基于的信任模型中，数据所有者生成合成数据并将其发布到 DataHub。图 10.11 显示了在 DataHub 中生成和使用合成数据（非 CSP 基于的信任模型）所涉及的步骤。

图 10.11 DataHub 的没有 CSP 的合成数据生成机制

这就结束了我们对 DataHub 平台不同功能的讨论。我们通过在实际场景中部署这些技术，探讨了实现和产业化本书中讨论的隐私增强技术的可能方法。DataHub 只是其中一个应用场景。你可以在你的应用领域中运用相同的概念、技术和方法。每章的相关源代码都可在本书的 GitHub 仓库中找到，因此你可以应用我们讨论的任何概念。实施它们，实验它们，并充分利用它们。祝你好运！

摘要

• 在整本书中，我们讨论了各种可以服务于整体隐私保护的隐私增强技术。

• 这些不同的概念各有其优点、缺点和用例。当你想要实现隐私时，重要的是要看到更广阔的图景，并明智地选择适当的技术。

• 我们用于研究数据保护和共享的隐私增强平台（DataHub）是一个现实世界的应用场景，展示了我们如何将不同的隐私增强技术对准共同目标。

• 有两种主要的信任模型——基于 CSP 和非基于 CSP 的——我们可以将其集成到 DataHub 的架构设计中。

• 在设计应用程序时，数据隐私和安全至关重要，尤其是在分布式、协作环境中。

• 我们可以在基于云的、安全的 NoSQL 数据库中，将数据存储在 DataHub 平台上。

• DataHub 可以通过两种不同的设置促进隐私保护的数据收集：使用基于密码学和扰动的方法。

• DataHub 还提供在两种信任模型（带有 CSP 和不带有 CSP）中的合成数据生成。

附录 A. 差分隐私的更多细节

正如我们在第二章中讨论的，差分隐私（DP）是最受欢迎和最有影响力的隐私保护方案之一。它基于使数据集足够健壮的概念，以至于数据集中的任何单个替换都不会泄露私人数据。这通常是通过计算数据集中组内的模式来实现的，我们称之为 复杂统计，同时保留数据集中个人的信息。差分隐私的美丽之处在于其数学可证明性和可量化性。在接下来的章节中，我们将介绍数学基础和差分隐私的正式定义。如果你对这些数学基础不感兴趣，你现在可以跳过这部分，并在需要时再回来。

A.1 差分隐私的正式定义

在我们介绍差分隐私的正式定义之前，让我们看看一些最初由 Dwork 和 Roth [1]定义的基本术语：

• 概率单纯形—令 B 表示一个离散集合。B 的概率单纯形，记为 Δ(B)，定义为 Δ(B) = {x ∈ ℝ^(|B|) : x[i] ≥ 0 for all i and Σ^(|B|)[i=1] x[i] = 1}。你可以将概率单纯形视为给定概率分布的空间。

• 随机算法—一个具有域 A 和离散范围 B 的随机算法 M 与映射 M : A→Δ(B) 相关联。给定一个输入 a ∈ A，算法 M 以概率 (M(a))[b] 输出 M(a) = b，对于每个 b ∈ B。概率空间是算法 M 的硬币翻转。我们已经在第 2.2.1 节中讨论了算法中的随机化是如何发生的。

• 数据库—数据库 x 是形成宇宙 X 的记录集合。

  例如，让全集 X 定义数据库中的唯一元素集合。那么一个数据库可以通过数据库内元素的直方图来表示，x ∈ ℕ^(|X|)，其中每个条目 x[i] 代表数据库 x 中类型 i ∈ X 的元素数量。

• 数据库之间的距离—数据库 x 的 l[1] 范数表示为 ‖x‖[1]，定义为 ‖x‖[1] = Σ^(|x|)[i=1] |xi|。因此，两个数据库 x 和 y 之间的 l[1] 距离是 ‖x - y‖[1]。

• 邻近数据库—两个数据库 x 和 y 被定义为邻近数据库，如果它们只在一行上有所不同。例如，对于数据库对 x，y ∈ N^(|X|)，如果 ‖x - y‖[1] ≤ 1，我们则认为 x 和 y 是邻近数据库。

现在我们准备介绍差分隐私的正式和最一般的定义。它为随机算法提供了在邻近数据库上表现相似的数学保证。

• (ϵ, δ)-差分隐私—一个随机算法 M 是 (ϵ, δ)-DP，如果对于每一对邻近数据库 x，y 和对于所有 S ⊆ Range(M )，我们有

  Pr[M(x) ∈ S] ≤ e^ε ⋅ Pr[M(y) ∈ S] + δ

  其中 Pr[⋅] 表示事件的概率，Range(M) 表示随机算法 M 所有可能输出的集合。当 ϵ 和 δ 越小，Pr[M(x) ∈ S] 和 Pr[M(y) ∈ S] 越接近，隐私保护就越强。当 δ = 0 时，算法 M 满足 ϵ-DP，这比 (ϵ, δ)-DP（δ > 0）提供了更强的隐私保证。通常人们将 ϵ 称为 DP 定义中的 隐私预算。ϵ 的值越高，意味着拥有更多的隐私预算，因此可以容忍更多的隐私泄露。ϵ 的值越低，意味着需要或提供的隐私保护越强。隐私参数 δ 代表定义中的“失败概率”。以 1 - δ 的概率，我们将获得与纯 DP（即 ϵ-DP，其中 δ = 0）相同的保证。以 δ > 0 的概率，我们则没有任何保证。换句话说，

  • 以 1 - δ 的概率，我们有 Pr[M(x) ∈ S] ≤ e^ϵ⋅Pr[M(y) ∈ S]。

  • 以 δ 的概率，我们根本没有任何保证。

A.2 其他差分隐私机制

第二章讨论了三种最流行的差分隐私机制：二元、拉普拉斯和对数。为了回顾，二元机制中的随机化来自二元响应（抛硬币），这有助于我们扰动结果。拉普拉斯机制通过向目标查询或函数添加来自拉普拉斯分布的随机噪声来实现 DP。对数机制帮助我们应对那些效用是选择最佳响应但直接向查询函数的输出添加噪声会完全破坏效用的场景。在本节中，我们将讨论一些其他的 DP 机制。

A.2.1 几何机制

拉普拉斯机制（在第 2.2.2 节中讨论）向查询函数的输出添加实值噪声。它最适合输出实值的查询函数，因为直接将噪声添加到输出中不会使结果变得无意义。对于输出整数的查询函数，你仍然可以添加拉普拉斯噪声，但之后需要应用离散化机制。然而，这可能会降低结果的效用。

正是几何机制在这里发挥作用 [2]。它被设计用来向只有整数输出值的查询函数添加拉普拉斯噪声的离散对应物（从几何分布中抽取）。以下是几何分布和几何机制的定义：

• 几何分布—给定一个大于 1 的实数 α，几何分布表示为 Geom(α) 是一个对称分布，它取整数值，其概率质量函数在 k 处为 ((α – 1) /(α + 1)) ⋅ α^(-|k|)

  几何分布具有与拉普拉斯分布相似的性质。从 Geom(α) 中抽取的随机变量的方差为 σ² = 2α/(1 - α)²。

• 几何机制—给定一个数值查询函数 f: ℕ^(|X|) → ℤ^k，数据库 x ∈ ℕ^(|X|) ，以及隐私预算 ϵ，几何机制定义为

  

  其中 Y[1] 是从 Geom(ϵ/Δf) 中抽取的独立同分布随机变量，Δf 是查询函数 f 的 l[1]-敏感性。

定理 A.1 几何机制满足 (ϵ, 0)-DP。

几何机制可以应用于第 2.2.2 节中涉及拉普拉斯机制的示例，提供略微更好的效用。

A.2.2 高斯机制

高斯机制 [1] 是拉普拉斯机制的另一种替代方案。它不是添加拉普拉斯噪声，而是添加高斯噪声，并提供略微放宽的隐私保证。

高斯机制将其噪声缩放到 l[2] 敏感性（与拉普拉斯机制相比，它缩放到 l[1] 敏感性），如下定义：

• l[2]-敏感性—给定一个数值查询函数 f: ℕ^(|X|) → ℝ^k，对于所有数据库对，x, y ∈ ℕ^(|X|)，其 l[2]-敏感性是 。

我们可以根据高斯分布和 l[2]-敏感性定义高斯机制如下：

• 高斯机制—给定一个数值查询函数 f: ℕ^(|X|) → ℝ^k，数据库，x ∈ ℕ^(|X|) ，以及隐私预算 ϵ 和 δ，高斯机制定义为

  

  其中 Y[i] 是从高斯分布 τ = Δf √(2ln (1.25/ δ)) / ε 中抽取的独立同分布随机变量，Δf 是查询函数 f 的 l[2]-敏感性。

定理 a.2 高斯机制满足 (ϵ, δ)-DP。

与其他随机噪声相比，添加高斯噪声有两个优点：

• 高斯噪声与其他许多噪声源相同（例如，通信通道中的白噪声）。

• 高斯随机变量的和导致一个新的高斯随机变量。

这些优点使得分析并纠正应用高斯机制的保护隐私机器学习算法变得更加容易。

A.2.3 梯度机制

梯度机制 [3] 是拉普拉斯机制的一种特殊情况。它通过调整拉普拉斯机制（其概率密度函数是连续的）和几何机制（其概率密度函数是离散的）之间的权衡来优化经典拉普拉斯机制的错误界限。

在梯度机制中，我们通常定义一个损失函数 L(⋅) : ℝ → ℝ，这是一个关于加性噪声的函数，其中给定加性噪声 n，损失变为 L(n)。令 t ∈ ℝ 表示查询函数 f ( ) 的输出，P[t] 表示生成加性噪声的随机变量的概率分布。那么，损失函数的期望将是

梯度机制旨在最小化所有可能的查询输出 t ∈ ℝ 中的最坏情况成本：

关于如何构建和解决此类优化问题的更多信息，请参阅 Geng 和 Viswanath 的原论文[3]。

梯度机制可以通过三个参数指定：ϵ、Δf 和 γ^*，它由 ϵ 和损失函数 L( ) 确定。图 A.1 展示了拉普拉斯和梯度机制的概率密度函数。

图 A.1 拉普拉斯和梯度机制的概率密度函数

A.2.4 向量机制

向量机制旨在扰动向量值函数，例如许多机器学习算法的凸目标函数（线性回归、岭回归、支持向量机等）。

向量机制将其噪声缩放到以下定义的向量值函数的 l[2] 敏感性：

• 向量值函数的 l[2]-sensitivity——给定一个向量值查询函数 f，其 l[2] 敏感性定义为当输入变化时函数值在 l[2] 范数中的最大变化：

  

一旦定义了向量值函数的 l[2] 敏感性（尽管在现实场景中，如机器学习算法中，构建此类敏感性是非平凡的），我们就可以使用从任何其他机制（如 Lap(Δf/ϵ)，其中Δf是向量值函数 f 的 l[2] 敏感性）抽取的独立同分布随机变量来定义向量机制。

A.2.5 维斯哈特机制

维斯哈特机制[4]旨在在二次矩矩阵（如协方差矩阵）上实现差分隐私。基本思想是将从维斯哈特分布生成的维斯哈特噪声矩阵添加到二次矩矩阵中。由于维斯哈特矩阵始终是正半定的，并且可以被认为是某些随机高斯向量的散布矩阵，因此它是生成具有其意义和有用性的差分隐私协方差矩阵的自然噪声源（因为协方差矩阵始终是正半定的，也是散布矩阵）。图 A.2 展示了在协方差矩阵上应用维斯哈特机制的伪代码，其中 Wd(⋅,⋅) 是维斯哈特分布。

图 A.2 应用维斯哈特机制的伪代码

A.3 差分隐私的组成属性的形式定义

差分隐私的一个重要且有用的属性是其组成定理。差分隐私的严谨数学设计使得分析和控制多个差分隐私计算中的累积隐私损失成为可能。有两个主要组成属性，我们已在第 2.3.3 节中详细讨论了它们。在本节中，我们将探讨这些属性数学定义。

A.3.1 序列组成的差分隐私的形式定义

DP 的序列组合属性确认了从数据的多次查询中累积的隐私泄露总是高于单次查询的泄露（图 A.3）。例如，如果第一次查询的 DP 分析使用隐私预算 ϵ[1] = 0.1，第二次查询的隐私预算为 ϵ[2] = 0.2，这两个分析可以视为一个具有可能大于 ϵ[1] 或 ϵ[2] 但最多为 ϵ[3] = ϵ[1] + ϵ[2] = 0.3 的隐私损失参数的单次分析。

图 A.3 序列组合

我们从一个简单的案例开始，其中有两个独立的差分隐私算法，一个(ϵ[1], 0)-DP 算法 M[1] 和一个(ϵ[2], 0)-DP 算法 M[2]。如果依次应用 M[1] 和 M[2]（其中 M[1] 的输出成为 M[2] 的输入），那么它遵循以下的双序列组合定理。

定理 a.3 双序列组合：令 M[1] : ℕ^(|X|) → R[1] 表示一个(ϵ[1], 0)-DP 的随机算法，令 M[2] : ℕ^(|X|) → R[2] 表示一个(ϵ[2], 0)-DP 的随机算法。这两个算法的序列组合，表示为 M[1,2] : ℕ^(|X|) → R[1] × R[2]，通过映射 M[1,2] (x) = (M1, M2)，满足(ϵ[1] + ϵ[2], 0)-DP。

在看到双序列组合定理之后，将其扩展到适用于多个独立 DP 算法级联的多序列组合定理应该不难，如下所示。

定理 a.4 多序列组合 1.0：令 M[i] : ℕ^(|X|) → R[i] 表示一个(ϵ[i], 0)-DP 的随机算法。k 个 DP 算法的序列组合，M[i]，其中 i = 1, 2, ... , k，表示为 M[(k)] : ℕ^(|X|) → Π^k[i=1]R[i]，通过映射 M[k] = (M1, M2, ..., Mk) 满足 (Σ^k[i=1] ε[i], 0)。

如果 δ ≠ 0 会怎样？序列组合会是什么样子？看看以下定理。

定理 a.5 多序列组合 2.0：令 M[i] : ℕ^(|X|) → R[i] 表示一个(ϵ[i], δ[i])-DP 的随机算法。k 个 DP 算法的序列组合，M[i]，其中 i = 1, 2, ... , k，表示为 M[(k)] : ℕ^(|X|) → Π^k[i=1]R[i]，通过映射 M[k] = (M1, M2, ..., Mk) 满足 Σ^k[i=1] ε[i], Σ^k[i=1] δ[i])-DP。

A.3.2 并行组合 DP 的形式定义

现在让我们转向 DP 的并行组合。总结来说，如果算法 F1 满足 ϵ[1]-DP，F2 满足 ϵ[2]-DP，其中 (x[1], x[2]) 是整个数据集 x 的非重叠划分（图 A.4），F1 和 F2 的并行组合满足 max(ϵ[1], ϵ[2])-DP。

图 A.4 并行组合

假设单个数据库 x 已经被分割成 k 个不相交的子集，x[i]。在这里，“不相交”确保了任何两个子集，x[i] 和 x[j]，彼此独立。在这种情况下，可能有 k 个独立的差分隐私算法，但它们都满足相同的 (ϵ, 0)-DP，并且每个算法 M[i] 专门负责一个子集 x[i]。以下并行组合定理将允许我们组合这 k 个差分隐私算法。

定理 a.6 并行组合 1.0：令 M[i] : ℕ^(|X|) → R[i] 表示一个随机算法，它是 (ϵ, 0)-DP，其中 i = 1, 2, ... , k。k 个差分隐私算法的并行组合，M[i]，i = 1, 2, ... , k，表示为 M[(k)] : ℕ^(|X|) → Π^k[i=1]R[i]，通过映射 M[k] = (M1, M2, ..., Mk)，其中 x[i]，i = 1, 2, ... , k 代表数据库 x 的 k 个不相交子集，满足 (ϵ, 0)-DP。

如果所有差分隐私算法都使用差分隐私预算，从而在并行组合场景中满足不同级别的差分隐私，那会怎样？以下定理提供了这种情况的解决方案。

定理 a.7 并行组合 2.0：令 M[i] : ℕ^(|X|) → R[i] 表示一个随机算法，它是 (ϵ[i], 0)-DP，其中 i = 1, 2, ... , k。k 个差分隐私算法的并行组合，M[i]，i = 1, 2, ... , k，表示为 M[(k)] : ℕ^(|X|) → Π^k[i=1]R[i]，通过映射 M[][k][] = (M1, M2, ..., Mk)，其中 x[i]，i = 1, 2, ... , k 代表数据库 x 的 k 个不相交子集，满足 (max ϵ[i], 0)-DP。

参考文献

第一章

[1] J. Feng 和 A.K. Jain, “指纹重建：从细节到相位,” IEEE 传输模式分析与机器智能, 第 33 卷, 第 2 期, 第 209-223 页, 2011, doi: 10.1109/TPAMI.2010.77.

[2] M. Al-Rubaie 和 J.M. Chang, “针对基于移动的云中连续认证系统的重建攻击,” IEEE 信息取证与安全传输, 第 11 卷, 第 12 期, 第 2648-2663 页, 2016, doi: 10.1109/TIFS.2016.2594132.

[3] S. Garfinkel, J.M. Abowd 和 C. Martindale, “理解公共数据上的数据库重建攻击,” ACM 通讯, 第 62 卷, 第 3 期, 第 46-53 页, 2019 年 3 月, doi: 10.1145/3287287.

[4] M. Fredrikson, S. Jha 和 T. Ristenpart, “利用置信信息的基本对策的模型反演攻击,” ACM 计算机通信安全会议论文集, 2015 年 10 月, 第 1322-1333 页, 2015, doi: 10.1145/2810103.2813677.

[5] R. Shokri, M. Stronati, C. Song 和 V. Shmatikov, “针对机器学习模型的成员身份推断攻击,” IEEE 安全与隐私研讨会论文集, 第 3-18 页, 2017, doi: 10.1109/SP.2017.41.

[6] A. Narayanan 和 V. Shmatikov, “大型稀疏数据集的鲁棒去匿名化,” IEEE 安全与隐私研讨会论文集, 第 111-125 页, 2008, doi: 10.1109/SP.2008.33.

[7] M. Barbaro 和 T. Zeller, “AOL 搜索者 No. 4417749 的面孔被揭露,” 纽约时报, 2006 年 8 月 9 日, 第 1-3 页, 2006, [在线]. 可用: papers3://publication/uuid/33AEE899-4F9D-4C05-AFC7-70B2FF16069D.

[8] A. Narayanan 和 V. Shmatikov, “如何破解 Netflix 奖数据集的匿名性,” 2006, [在线]. 可用: arxiv.org/abs/cs/0610105.

[9] B. Cyphers 和 K. Veeramachaneni, “AnonML: 在对等网络上的本地隐私机器学习,” 2017 国际数据科学和高级分析会议论文集, 第 549-560 页, doi: 10.1109/DSAA.2017.80.

[10] M. Hardt, K. Ligett 和 F. McSherry, “一个简单且实用的差分隐私数据发布算法,” Nips, 第 1-9 页, 2012, [在线]. 可用: papers.nips.cc/paper/4548-a-simple-and-practical-algorithm-for-differentially-private-data-release.pdf.

[11] V. Bindschaedler, R. Shokri 和 C.A. Gunter, “隐私保护数据合成的合理否认,” VLDB 奖励论文, 第 10 卷, 第 5 期, 第 481-492 页, 2017 年 1 月, doi: 10.14778/3055540.3055542.

[12] J. Soria-Comas 和 J. Domingo-Ferrer, “基于微聚合和记录扰动的差分隐私数据集,” 计算机科学笔记, LNAI, 第 10571 卷, 第 119-131 页, 2017, doi: 10.1007/978-3-319-67422-3_11.

[13] K. Liu, H. Kargupta 和 J. Ryan, “基于随机投影的乘性数据扰动以保护隐私的分布式数据挖掘,” IEEE 知识与数据工程传输, 第 18 卷, 第 1 期, 第 92-106 页, 2006, doi: 10.1109/TKDE.2006.14.

[14] X. Jiang, Z. Ji, and S. Wang, “Differential-Private Data Publishing Through Component Analysis,” Bone, vol. 23, no. 1, pp. 1-7, 2014, doi: 10.1038/jid.2014.371.

[15] S.Y. Kung, “Compressive Privacy : From Information/Estimation Theory to Machine Learning,” IEEE Signal Process. Mag., vol. 34, no. 1, pp. 94-112, January 2017, doi: 10.1109/MSP.2016.2616720.

Chapter 2

[1] X. Shen, B. Tan, and C. Zhai, “Privacy protection in personalized search,” ACM SIGIR Forum, vol. 41, no. 1, pp. 4-17, 2007, doi: 10.1145/1273221.1273222.

[2] A. Narayanan and V. Shmatikov, “Robust De-anonymization of Large Sparse Datasets,” Proc. - IEEE Symp. Secur. Priv., pp. 111-125, 2008, doi: 10.1109/SP.2008.33.

[3] C. Dwork, “Differential Privacy,” in International Colloquium on Automata, Languages, and Programming, 2006, LNTCS, vol. 4052, pp. 1-12, 2006, doi:10.1007/11787006_1.

[4] C. Dwork, A. Roth, et al., “The Algorithmic Foundations of Differential Privacy,” Found. Trends Theor. Comput. Sci., vol. 9, no. 3-4, pp. 211-407, 2014, doi: 10.1561/0400000042.

[5] S.L. Warner, “Randomized Response: A Survey Technique for Eliminating Evasive Answer Bias,” J. Am. Stat. Assoc., vol. 60, no. 309, pp. 63-69, 1965.

[6] C. Dwork, F. McSherry, K. Nissim, and A. Smith, “Calibrating Noise to Sensitivity in Private Data Analysis,” in Theory of Cryptography Conference, 2006, vol. 3875, pp. 265-284, 2006, doi: doi.org/10.1007/11681878_14.

[7] F. McSherry and K. Talwar, “Mechanism Design Via Differential Privacy,” in 48th Annual IEEE Symposium on Foundations of Computer Science (FOCS’07), 2007, pp. 94-103, doi: 10.1109/FOCS.2007.66.

Chapter 3

[1] C. Dwork, A. Roth, et al., “The Algorithmic Foundations of Differential Privacy,” Found. Trends Theor. Comput. Sci., vol. 9, no. 3-4, pp. 211-407, 2014, doi: 10.1561/0400000042.

[2] M. Hardt and E. Price, “The Noisy Power Method: A Meta Algorithm with Applications,” Adv. Neural Inf. Process. Syst., vol. 27, pp. 2861-2869, 2014, doi: 10.48550/arXiv.1311.2495.

[3] M. Abadi et al., “Deep learning with differential privacy,” in Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pp. 308-318, 2016, doi: 10.48550/arXiv.1607.00133.

[4] J. Vaidya, B. Shafiq, A. Basu, and Y. Hong, “Differentially Private Naive Bayes Classification,” in 2013 IEEE/WIC/ACM International Joint Conferences on Web Intelligence (WI) and Intelligent Agent Technologies (IAT), vol. 1, pp. 571-576, 2013, doi: 10.1109/WI-IAT.2013.80.

[5] K. Chaudhuri, C. Monteleoni, and A.D. Sarwate, “Differentially Private Empirical Risk Minimization,” J. Mach. Learn. Res., vol. 12, no. 3, 2011, 10.48550/arXiv.0912.007

[6] O. Sheffet, “Private Approximations of the 2nd-moment Matrix Using Existing Techniques in Linear Regression,” arXiv Prepr. arXiv1507.00056, 2015.

[7] S. Lloyd, “PCM 中的最小二乘量化,” IEEE 信息系统汇刊, 第 28 卷，第 2 期，第 129-137 页，1982 年，doi: 10.1109/TIT.1982.1056489.

[8] D. Su, J. Cao, N. Li, E. Bertino 和 H. Jin, “差分隐私 K-means 聚类,” 在 2016 年第六届 ACM 数据和应用安全与隐私会议论文集, 第 26-37 页，doi: 10.1145/2857705.2857708.

[9] S. Wang 和 J.M. Chang, “在水平划分数据上的差分隐私主成分分析,” 在 2018 年 IEEE 可靠和安全的计算会议 (DSC), 2018 年，第 1-8 页，doi: 10.1109/DESEC.2018.8625131.

[10] H. Imtiaz, R. Silva, B. Baker, S.M. Plis, A.D. Sarwate 和 V. Calhoun, “使用独立成分分析对分布式数据进行隐私保护源分离,” 在 2016 年信息科学和系统年度会议 (CISS), 2016 年，第 123-127 页，doi: 10.1109/CISS.2016.7460488.

[11] H. Imtiaz 和 A.D. Sarwate, “对称矩阵扰动用于差分隐私主成分分析,” 在 2016 年 IEEE 国际声学、语音和信号处理会议 (ICASSP), 2016 年，第 2339-2343 页，doi: 10.1109/ICASSP.2016.7472095.

第四章

[1] Ú. Erlingsson, V. Pihur 和 A. Korolova, “RAPPOR：随机可聚合的隐私保护有序响应,” ACM 计算机通信安全会议论文集, 第 1054-1067 页，2014 年，doi: 10.1145/2660267.2660348.

[2] J.C. Duchi, M.I. Jordan 和 M.J. Wainwright, “局部隐私和统计最小-最大速率,” IEEE 计算机科学基金会年度研讨会论文集 (FOCS), 第 429-438 页，2013 年，doi: 10.1109/FOCS.2013.53.

[3] T. Wang, J. Blocki 和 N. Li, “频率估计的局部差分隐私协议,” USENIX 安全性，2017.

[4] E. Yilmaz, M. Al-Rubaie 和 J. Morris Chang, “局部差分隐私下的朴素贝叶斯分类,” IEEE 第 7 届国际数据科学和先进分析会议 (DSAA 2020), 第 709-718 页，2020 年，doi: 10.1109/DSAA49011.2020.00081.

第五章

[1] N. Wang 等人， “使用局部差分隐私收集和分析多维数据,” 2019 年 IEEE 第 35 届国际数据工程会议 (ICDE), 2019 年，第 638-649 页，doi: 10.1109/ICDE.2019.00063.

[2] J.C. Duchi, M.I. Jordan, 和 M.J. Wainwright, “局部隐私估计的最小-最大最优程序,” 美国统计学会会刊, 第 113 卷，第 521 期，第 182-201 页，2018 年，doi: 10.1080/01621459.2017.1389735.

[3] E. Yilmaz, M. Al-Rubaie 和 J.M. Chang, “局部差分隐私朴素贝叶斯分类,” arXiv, 第 1-14 页，2019 年，10.48550/arXiv.1905.01039.

[4] D. Dheeru 和 E.K. Taniskidou, “UCI 机器学习仓库,” 2017 年，archive.ics.uci.edu/ml (访问日期：2021 年 1 月 18 日).

第六章

[1] D.C. Barth-Jones, “威廉·韦尔德州长医疗信息的‘重新识别’：对健康数据识别风险和隐私保护，过去和现在的批判性再审视,” SSRN 电子期刊, 第 1-19 页，2012 年，doi: 10.2139/ssrn.2076397.

[2] L. Sweeny, “k-ANONYMITY：保护隐私的模型 1,” 国际不确定性、模糊性和基于知识的系统杂志, 第 10 卷，第 5 期，第 557-570 页，2002 年，doi: 10.1142/S0218488502001648.

[3] P. Samarati 和 L. Sweeney, “在披露信息时保护隐私：K 匿名及其通过抑制的执行,” 国际商业智能杂志, 第 001 卷，第 002 期，第 28-31 页，1998 年，doi: 10.20894/ijbi.105.001.002.001.

[4] D. Su, J. Cao, N. Li, 和 M. Lyu, “PrivPfC：用于分类的差分隐私数据发布,” VLDB 杂志, 第 27 卷，第 2 期，第 201-223 页，2018 年，doi: 10.1007/s00778-017-0492-3.

[5] K. Taneja, “DiffGen: 自动回归单元测试生成,” 在 IEEE/ACM 国际自动化软件工程会议, 2008 年, 第 407-410 页，doi: 10.1109/ASE.2008.60.

[6] S.C. Johnson, “分层聚类方案,” 心理测量学杂志, 第 32 卷，第 3 期，第 241-254 页，1967 年，doi: 10.1007/BF02289588.

[7] J. Domingo-Ferrer, “微聚合,” L. Liu 和 M.T. Özsu (编者), 数据库系统百科全书, Springer, 波士顿，MA，2009 年，doi:10.1007/978-0-387-39940-9_1496.

[8] D. Dheeru 和 E.K. Taniskidou, “UCI 机器学习仓库，” 2017 年，archive.ics.uci.edu/ml (访问日期：2021 年 1 月 18 日).

第七章

[1] 马萨诸塞州州政府， “团体保险委员会，” 1997 年，www.mass.gov/orgs/group-insurance-commission (访问日期：2020 年 1 月 5 日).

[2] R. Kohavi 和 B. Becker, “Adult 数据集，” 1996 年，archive.ics.uci.edu/ml/datasets/Adult (访问日期：2020 年 4 月 26 日).

[3] P. Samarati 和 L. Sweeney, “在披露信息时保护隐私：K 匿名及其通过抑制的执行,” 国际商业智能杂志, 第 1 卷，第 2 期，第 28-31 页，1998 年，doi: 10.20894/IJCOA.101.001.001.004.

[4] CryptoNumerics, “CN-Protect for Data Science，” 2019 年.

第八章

[1] A. Machanavajjhala, D. Kifer, J. Gehrke, 和 M. Venkatasubramanian, “L 多样性：超越 k 匿名性的隐私,” ACM 知识发现与数据传输杂志, 第 1 卷，第 1 期，2007 年，doi: 10.1145/1217299.1217302.

[2] L. Ninghui, L. Tiancheng, 和 S. Venkatasubramanian, “t-Closeness：超越 k 匿名性和ℓ多样性的隐私,” 国际数据工程会议论文集, 第 3 期，第 106-115 页，2007 年，doi: 10.1109/ICDE.2007.367856.

[3] R. Kohavi 和 B. Becker, “Adult 数据集，” 1996 年. archive.ics.uci.edu/ml/datasets/Adult (访问日期：2020 年 4 月 26 日).

[4] N. Prabhu, “网络安全中的匿名化方法，” 2018. github.com/Nuclearstar/K-Anonymity (访问日期：2020 年 5 月 12 日).

[5] G.D. Samaraweera 和 M.J. Chang, “大数据时代数据库系统的安全和隐私影响：综述,” IEEE 知识数据工程传输杂志, 第 33 卷，第 1 期，第 239-258 页，2021 年 1 月，doi: 10.1109/tkde.2019.2929794.

[6] B. Fuller 等人, “基于密码学保护的数据库搜索综述,” IEEE 安全隐私研讨会论文集, 第 172-191 页, 2017, doi: 10.1109/SP.2017.10.

[7] G. Kellaris, G. Kollios, K. Nissim, and A. O’Neill, “通用攻击对安全外包数据库的影响,” 2016 ACM SIGSAC 计算机通信安全会议论文集 - CCS’16, 第 1329-1340 页, 2016, doi: 10.1145/2976749.2978386.

[8] P. Grubbs, T. Ristenpart, 和 V. Shmatikov, “为什么你的加密数据库并不安全，” 第 16 届操作系统热点话题研讨会论文集 - HotOS’17, 第 162-168 页, 2017, doi: 10.1145/3102980.3103007.

[9] M.S. Lacharite, B. Minaud, 和 K.G. Paterson, “使用范围查询泄露改进加密数据的重建攻击,” IEEE 安全隐私研讨会论文集, 第 297-314 页, 2018, doi: 10.1109/SP.2018.00002.

[10] M. Hosenball, “瑞士间谍机构警告美国和英国关于大量数据泄露，” 路透社, 2012 年 12 月 4 日. www.reuters.com/article/us-usa-switzerland-datatheft/swiss-spy-agency-warns-u-s-britain-about-huge-data-leak-idUSBRE8B30ID20121204 (访问日期：2019 年 1 月 15 日).

[11] C. Terhune, “近 5,000 名患者受加州大学欧文分校医疗数据泄露事件影响,” 洛杉矶时报, 2015 年 6 月 18 日. www.latimes.com/business/la-fi-uc-irvine-data-breach-20150618-story.xhtml (访问日期：2019 年 1 月 15 日).

[12] J. Vijayan, “摩根士丹利数据泄露事件提醒内部风险,” 安全情报, 2015 年 1 月 8 日. securityintelligence.com/news/morgan-stanley-breach-reminder-insider-risks/ (访问日期：2019 年 1 月 15 日).

第九章

[1] F. Douglas, L. Pat, 和 R. Fisher, “概念聚类方法及其与数值分类学的关系,” 人类遗传学年度, 第 7 卷，第 2 期，第 179-188 页, 1985.

[2] B. Scholkopft 和 K. Mullert, “核 Fisher 判别分析,” 神经网络与信号处理 IX, 第 41-48 页, 1999.

[3] S.Y. Kung, “用于大数据隐私保护和可视化的判别成分分析,” 多媒体工具与应用, 第 76 卷，第 3 期，第 3999-4034 页, 2017, doi: 10.1007/s11042-015-2959-9.

[4] K. Diamantaras 和 S.Y. Kung, “通过核子空间投影和广义特征值分解进行数据隐私保护,” IEEE 国际机器学习与信号处理研讨会论文集 MLSP, 2016, doi: 10.1109/MLSP.2016.7738831.

[5] J. Šeděnka, S. Govindarajan, P. Gasti, 和 K.S. Balagani, “在智能手机上对生物识别认证进行安全外包和性能评估,” IEEE 信息取证与安全传输, 第 10 卷，第 2 期，第 384-396 页, 2015, doi: 10.1109/TIFS.2014.2375571.

[6] M.A. Pathak 和 B. Raj, “在私有数据上计算主特征向量的高效协议,” 数据隐私传输, 第 4 卷，第 3 期，第 129-146 页, 2011.

[7] P. Paillier, “基于复合度剩余类的大数密钥密码系统，” 密码技术理论与应用国际会议，第 223-238 页，Springer，柏林，海德堡，1999 年。

[8] D. Dheeru 和 E.K. Taniskidou, “UCI 机器学习仓库，” 2017 年。archive.ics.uci.edu/ml（访问日期：2021 年 1 月 18 日）。

第十章

[1] G.D. Samaraweera 和 J.M. Chang, “SEC-NoSQL：面向 NoSQL 数据库的高性能安全即服务实现，” arXiv，2019 年，[在线]。可获得：arxiv.org/abs/2107.01640。

[2] R. Popa 和 C. Redfield, “在加密数据库上处理查询的 CryptDB，” ACM 通讯，第 55 卷，第 9 期，第 103 页，2012 年，doi: 10.1145/2330667.2330691。

[3] V. Nikolaenko, U. Weinsberg, S. Ioannidis, M. Joye, D. Boneh 和 N. Taft, “在数亿条记录上实现隐私保护的岭回归，” IEEE 安全与隐私研讨会论文，第 334-348 页，2013 年，doi: 10.1109/SP.2013.30。

[4] E. Pattuk, M. Kantarcioglu, V. Khadilkar, H. Ulusoy 和 S. Mehrotra, “BigSecret：用于键值存储的安全数据管理框架，” IEEE 国际云计算会议 CLOUD，第 147-154 页，2013 年，doi: 10.1109/CLOUD.2013.37。

[5] A. Narayanan 和 V. Shmatikov, “大型稀疏数据集的鲁棒去匿名化，” IEEE 安全与隐私研讨会论文，第 111-125 页，2008 年，doi: 10.1109/SP.2008.33。

[6] S. Goryczka, L. Xiong 和 V. Sunderam, “具有差分隐私的多方安全聚合：比较研究，” ACM 国际会议论文集系列，第 155-163 页，2013 年，doi: 10.1145/2457317.2457343。

[7] J. Domingo-Ferrer 和 V. Torra, “通过微聚合实现序数、连续和异构 K-匿名，” 数据挖掘与知识发现，第 11 卷，第 2 期，第 195-212 页，2005 年，doi: 10.1007/s10618-005-0007-5。

附录

[1] C. Dwork 和 A. Roth, “差分隐私的算法基础，” 理论计算机科学基础与趋势，第 9 卷，第 3-4 期，第 211-407 页，2014 年，doi: 10.1561/0400000042。

[2] A. Ghosh, T. Roughgarden, and M. Sundararajan, “普遍效用最大化的隐私机制，” SIAM 计算杂志，第 41 卷，第 6 期，第 1673-1693 页，2012 年。

[3] Q. Geng 和 P. Viswanath, “差分隐私中的最优机制，” 2014 年 IEEE 国际信息理论研讨会，2014 年，第 2371-2375 页，doi: 10.1109/ISIT.2014.6875258。

[4] H. Imtiaz 和 A.D. Sarwate, “对称矩阵扰动用于差分隐私主成分分析，” 2016 年 IEEE 国际声学、语音和信号处理会议，2016 年，第 2339-2343 页，doi: 10.1109/ICASSP.2016.7472095。