A/B 测试是一种随机测试，将两个不同的东西（即 A 和 B）进行假设比较。A/B 测试可以用来测试某一个变量两个不同版本的差异，一般是让 A 和 B 只有该变量不同，再测试目标对于 A 和 B 的反应差异，再判断 A 和 B 的方式何者较佳 ¹。A/B 测试的前身为双盲测试 ²，在双盲测试中人员会被随机分为两组，受试验的对象及研究人员并不知道哪些对象属于对照组，哪些属于实验组，通过一段时间的实验后对比两组人员的结果是否有明显差异。在各种科学研究领域中，从医学、食品、心理到社会科学及法证都有使用双盲方法进行实验。

一个简单的 A/B 测试流程如下：

1. 对目标人群进行随机划分，以进行有效的独立随机实验。
2. 对不同分组应用不同的策略。
3. 在确保实验有效的前提下，对不同分组的结果进行分析，以确定不同策略的优劣。

A/B 测试的主要目的是帮助我们更加科学的判断不同策略的优劣性，避免拍脑门的决策，不给杠精们互相 BATTLE 的机会。同时我们也需要认识到 A/B 测试只是一个工具，它能够帮助我们对产品和策略进行不断优化，但对产品和策略的创新更多还是需要洞察力。它可以让我们在已达到的山上越来越高，却不能用它来发现一座新的山脉。一句话：A/B 测试不是万能的，但离开 A/B 测试是万万不能的。

A/B 测试的科学性

流量分配

进行 A/B 测试的第一个问题就是如何划分用户，如果采用上面简单五五开的方式我们一次只能做一个实验，当我们需要同时做多个实验时就无法满足了。如果对用户分成多个桶，当桶的数量过多时，每个桶中的用户数量就会过少，从而会导致实验的置信度下降。

为了保证可以使用相同的流量开展不同的实验，同时各个实验之间不能相关干扰，我们需要采用正交实验。正交实验的思想如下：

每个独立实验为一层，层与层之间的流量是正交的，流量经过一层实验后会再次被随机打散。

有些情况下实验并不是独立的，例如同时对按钮和背景的颜色进行实验，按钮和背景颜色之间并不是独立的（即有些按钮和背景颜色搭配从设计角度是不可行的，没有必要进行实验），这种情况下我们需要采用互斥实验。互斥实验的思想如下：

实验在同一层进行流量拆分，不同组之间的流量是没有重叠的。

在 A/B 测试中，当多个实验内容相互影响应选择互斥方法分配流量，当多个实验内容不会相互影响应选择正交方法分配流量。更加精细的流量分类和控制可以参考 Google 的论文 Overlapping Experiment Infrastructure: More, Better, Faster Experimentation ³。

评价指标选择

在设计实验之前我们需要明确实验的目标，根据目标才能确定合理的评价指标。更多情况下我们应该从业务的视角出发选择合适的评价指标，我们以风险策略模型实验为例，我们可以从技术和业务角度选择不同的评价指标：

1. 技术角度：准确率和召回率
2. 业务角度：客诉率和追损金额

单纯从技术角度出发我们会忽视很多现实问题，例如两个策略的准确率和召回率差不多，但识别的结果人群不一样，这些人造成的损失也可能不一样。因此能够帮助我们追回更多损失同时有更小的客诉率才是更优的策略。

在进行实验时结果指标至关重要，但有时我们也应该关注一些过程指标。以页面优化实验为例，可能的过程指标和结果指标有：

1. 过程指标：页面平均停留时间，页面跳出率等
2. 结果指标：商品加购率，商品转化率等

策略和模型最终都是要为业务服务的，因此我们应常关注业务指标，一些常用的业务指标有：点击率（CTR）、转化率（CVR）、千次展示收入（RPM）等。

有效性检验

当实验完成得到结果后，我们还需要判断实验结果是否有效，这部分主要依靠统计学中的假设检验进行分析。针对两个实验在确定合理的统计量后，需要构建如下两个假设：

• 原假设 $H_0$：两个实验的统计量无差异
• 备选假设 $H_1$：两个实验的统计量有差异

对于假设检验只可能有两种结果：一个是接受原假设，一个是拒绝原假设。在进行假设检验过程中，容易犯两类错误：

第一类错误（弃真）即原假设为真时拒绝原假设，犯第一类错误的概率为 $\alpha$，即显著水平。第二类错误（取伪）即原假设为假时未拒绝原假设，犯第二类错误的概率为 $\beta$。

在进行有效性检验时我们有多个指标可以参考：

1. P 值。P 值就是当原假设为真时，比所得到的样本观察结果更极端的结果出现的概率。如果 P 值很小，说明原假设情况的发生的概率很小，而如果出现了，根据小概率原理，我们就有理由拒绝原假设，P 值越小，我们拒绝原假设的理由越充分。
2. 置信区间。置信区间就是分别以统计量的置信上限和置信下限为上下界构成的区间。置信水平是指包含总体平均值的概率是多大，例如：95% 的置信水平表示，如果有 100 个样本，可以构造出 100 个这样的区间，有 95% 的可能性包含总体平均值。在 A/B 测试时，如果置信区间上下限的值同为正或负，则认为存在有显著差异的可能性；如果同时有正值和负值，则认为不存在有显著差异的可能性。
3. 统计功效。一般情况下我们希望拒绝原假设，得到新的结论，即在进行 A/B 测试时希望实验组的效果优于对照组。也就是我们希望不要出现在应该拒绝原假设时却没有拒绝的情况，即犯第二类错误。统计功效就是我们没有犯第二类错误的概率 $1 - \beta$，在进行 A/B 测试时表示当两个策略之间存在显著差异时，实验能正确做出存在差异判断的概率。

综上，我们可以认为当 A/B 测试实验数据在 95% 的置信水平区间内，P 值小于0.05，功效大于 80% 的情况下，实验结果是可信赖的。

A/A 测试

在做 A/B 测试的时候，有时尽管我们发现 A/B 两组有明显差异，但我们依旧无法确认这种差异是由于实验条件不同还是 A/B 两组用户本身的差异带来的。尽管 A/B 两组用户是随机抽样，但两组用户在空跑期（即实验条件一致）也会出现显著差异。因此为了避免这个问题，我们会选择进行 A/A 测试，即在正式开启实验之前，先进行一段时间的空跑，对 A/B 两组用户采用同样的实验条件，一段时间后，再看两组之间的差异。如果差异显著，数据弃之不用，重新选组。如果差异不显著，记录两组之间的均值差，然后在实验期结束时，用实验期的组间差异减去空跑期的组间差异得到最终实验结果。

A/A 测试也会存在一些局限，在实际情况中，组间差异是一定存在。因此在这个前提下，可以用统计方式来衡量差异大小，在计算实验效果的时候，把差异考虑在内即可。差异产生的主要原因就是“随机性”，我们同样可以利用置信度和置信区间来描述 A/A 实验的波动。在进行实验时直接进行 A/B 测试，不需要考虑 A/A 测试，在分析结果时，需要考虑 A/B 测试实验之间的差异要大于 A/A 测试实验之间的差异。

三十岁了，不小了，一些事情再不做就不知道会拖到什么时候了。自从之前看到朋友发的一段摩旅的视频，就一直念念不忘，有机会一定要来一次，虽然不一定如视频中那般潇洒。最后证明确实不一样，尽管谈不上是一场修行，但遇到的人事物都是独特且难以忘记的。

有了出发的勇气，但拖延症还是很严重，各种准备和规划直到出发前一晚才简单搞定，当然这也给后面的遇到的问题埋下了伏笔。本来规划了 5 天的行程，最后一天赶到大同见朋友一面再返回北京，但一场冷雨让我在第 4 天直接折返北京。

第一天

折腾了好久，费劲扒拉才把后座包绑好。出门还没上高速，碰见一个骑复古车的哥们，问了我去哪里，我说自己去内蒙古，一句注意安全，一句感谢。出发前才掉了一格油，就没有去加，距离丰宁还 20 多公里，油表灯就闪了，好在还是坚持到了丰宁，成功续满了油。路上断断续续发现成队的、独行的骑士，还有一个书包和后座包都贴了实习标志的哥们，应该都是追逐自由的人吧。

到丰宁前中途停下检查了后座包，发现有一侧绑的不合理，卡口会被后轮摩到，都快要磨断了，幸好检查了下，改造一番绑好继续上路。从丰宁出发没多久，隐约闻道一股烧焦的味道，没当回事儿，以为是路上其他汽车的尾气。中间休息的时候又检查了一下后座包，才发现从丰宁出发时有一侧绑的有点松，后座包倒向了排气那边。奈何我帅气的双排气在上面，就把包烫了一个大洞，一并倒霉的还有带了但一次还没来得及穿过的冬款骑行服和骑行裤。不过好在底下放的是衣服，如果我把相机、电脑、无人机、充电宝放在那边低下…..都不敢想会有什么事儿。这就是没有提前做好功课如何绑后座包的后果，当然闻道异味没有第一时间检查也很不好。

包和衣服被烫了之后，心情一下就不好了，虽然一再自我安慰，但还是缓了很久才勉强不伤心了。由于中途发生了不少事情，整体耽误了一个小时左右，赶到塞罕坝这边酒店的时候已经是六点半了，天已经完全黑下来了，后面一个多小时的路程真的是又累又冷。万幸的是我把我夏季骑行服里面的内胆加上了，不然估计到酒店就冻成狗了。

第二天

早起退房碰见一对儿摩旅的，男生骑了一辆 ADV，小姐姐骑了一辆 Ninja 400。一清早晴空万里，阳光明媚，昨日的不开心一下子全都消散了。虽然秋天已经来了好一阵儿了，不过路两旁的风景还是很漂亮的。

骑进乌兰布统，越往后走人越少，路上碰见了好多次牛马拦路。从乌兰布统去到多伦的路上风景很好，选择下道骑行是明智的，一路上草原、小河、树林，遇到太多美景。

赶着中午骑到了多伦湖，简单吃过饭后就开始了环湖之旅，一路上走走停停。到了一处小高峰，把摩托骑了上去，太适合给我的小摩托来一张照片了。刚拍上就碰到了俩大哥，帮我和我的小摩托来了本次摩旅的第一张合照，聊了会儿道谢之后就开始往回返。

回到环湖起点时间还早，简单搜了下发现往北一点儿就是「滦河」源，小时候家乡人口中的滦河（唐山话：láng hé）原来是从这里流下去的。往滦河源的路不是很好走，骑到一半发现一条土路，骑过去是一个小平台，望向四周很美。后面跟过来好多越野车，也纷纷下来拍照，发现我骑了摩托过来就一个个站在旁边拍起了照片。我过去车上拿我的相机，说道慢慢拍不着急，小姐姐问我可不可以坐上去，我说没问题。后来我也拜托他们帮我和我的小摩托拍了第二张合照，我也成了几个阿姨的摄影师。

快乐是什么？一路上美丽的风景，一路上美丽的人，还有多少能带给他人快乐的我和我的小摩托。果然不敢路的一天是轻松的，从滦河源下来之后就早早赶到多伦的酒店休息了。

第三天

早起的阳光不错，虽然空气有些凉，但是太阳照着还是暖洋洋的，耳机里恰巧响起了赵照的「在冬天和奶奶一起晒太阳」，有些惬意。走着走着云多了起来，中午赶到了太仆寺旗，吃上一口热乎的麻辣烫。

中午微信群里有哥们说北京下大雨了，我心底还在暗暗窃喜这几天出行的天气都还不错，然而这 Flag 还是立早了……下午在去往张北的路上碰见了一波从北京来的摩旅队伍，什么车都有，有 ADV，有踏板，可见是真友谊，ADV 还能带着小踏板一起愉快的玩耍。前半程的风景很不错，路两旁的树叶开始泛黄飘落，一条直路望不见头。

天气渐渐阴沉了下来，肉眼可见前方有积雨云，但还是朝着前方骑了下去。突然天空飘起了小雨，但很快又没了，停在一个加油站打开雷达云图，发现云应该已经从要走的路上飘过去了，简单休息了一下又继续往前走。

路上淅淅沥沥的飘落几滴雨，但路面已经湿透了，之前应该是下了一阵。走着走着发现大腿有点凉，想着应该是雨水溅落到裤子上了。找了个地方停下一看，我去，车子、衣服、后座包已经被黒黑的泥水沾满，躲过了雨水，躲不过泥巴……水越溅越多，身体也越来越冷，万幸还是撑到了张北。找了个肯德基，点了一大杯热拿铁，喝完天已经放晴，看看时间不早了，再不走估计到乌兰察布得很晚了，简单把车擦了下就又启程了。

前半程的国道一路都是风景，但从张北到乌兰察布的后半程除了大车和尘土啥都没有。天彻底放晴，一股暖意上来，还好老天没太折磨我，停下来特意给我脏了吧唧但不离不弃的小摩托照了张像，纪念有史以来最脏的一次。

上了高速就快多了，大概 6 点半多赶到了酒店，卸下行囊第一件事就是去找了个洗车店把我的小摩托好好冲一冲，拿过老板的水枪就开始了自助洗车，洗完之后，我漂亮的小摩托又回来了！

第四天

一早起来天气有些阴冷，不过早有预期，昨天看天气，相比其他地方至少没有下雨。先走了国道去火山，路不太好，一路上身体到不是很冷，冷的是手，夏季的手套还真实漏风，走走停停，冷的受不了就带着手套放在发动机上「烤烤火」。

快到火山了发现一条岔路，还有警察叔叔在摆一个大牌子，「火山旅游路线」，问了后果断选择了指向的新路，新路好走的不要不要的。来到六号火山，人还不少，阴天更是给这里增添了一份外星感。摩托的好处是能骑上平台，转到北面发现人比较少，借来的大疆终于能派上用场了，虽然最后感觉拍的并不好。

往下走看到有几辆越野车爬上了小山丘，心里想来都来了，不在土路上骑一遭怎么对得起我这「越野版」的小狮子。

转完火山发现时间不是很晚，导航了下发现应该能在 7 点前赶回北京，想了想北京这几天都有雨，应该怎么都躲不过，一番权衡之下打算今天直接回北京。上了高速很快就到了集宁服务区，已经快 2 点了，正好吃午饭，这时天也下上了小雨。吃完之后再次权衡，还是决定继续往北京走，如果下大了不行就找最近的口下。一路上，雨不算大也不算小，这就让人很纠结，每到一个服务区就停下来看看云图，最终还是在晚上 10 点前回到了北京。陪了我五年的手机最终在进入地库前因为进水太多失灵然后宕机了，万幸坚持到了回家。

这段雨中经历感觉能回忆一辈子，不是因为勇敢，也不是因为幸运。敢这么走下来，还是评估了环境没有那么恶劣，对自己的驾驶技术也有一定把握，当然最重要的是量力，人永远不要同自然和生命开玩笑。所以每一个服务区都停下来，要么吃点东西，要么喝点热水，休整好后继续往前走。如果说知道 10 点才能到北京，让我再选择一次的话，我想我会选择在中途歇上一晚，虽然第二天也躲不开雨，但能骑得更从容些。

之后

真的要感谢我靠谱的小摩托，一直不离不弃，也要感谢这一路上遇到的陌生人的祝福和帮助。服务区遇到的摩托情侣，问我衣服是不是穿得太少，我没好意思说烫坏了，就只说带少了。餐厅拼桌吃饭的一家，男主人在深圳上班，自己不玩摩托，但工作的地方挨着交管局，见到太多扣查的摩托（深圳全市禁摩），分别时一个握手，一句平安。高速路上，三车道，我在最右侧，中间车道的一辆大车超我时特意变到左侧，掀起的水花完全没溅到我，这一定是个可爱的司机大叔吧。

旅行的意义在哪里？形形色色的人，真实且普通，慢下来，你能看到自己的更多面，也能看到陌生人的一面，或好或坏，无所谓，世界不就是这样吗。

为什么构建设计语言？

统一

通过设计语言可以在整个平台中统一颜色、字体、组件、动效等各种规范，避免由于设计师的个人特点导致产品风格不一致。

体验

优秀的设计语言符合大众审美，可以提高产品的可用性和易用性。设计语言可以使用户能够与具备一致性的应用进行交互，让用户在使用过程中获得愉悦，提升用户体验。

效率

优秀的设计语言使得设计和开发团队能够快速、经济、高效地进行开发、重构和迭代产品。通过不断更新和完善的文档库，可以改善团队之间的协作，提高生产力。

品牌

设计语言的构建可以传达一个统一的公司品牌形象。设计语言让产品具有自己的身份，使其在市场上的众多产品中更容易被识别出来，加深用户对品牌的印象。

设计语言构建

在此我们借助语言学的角度来讨论数字化产品的构建 ²。在语言应用中，我们通常会涉及语法、语素、语句、语义、语境、语气、语素和响度等维度，通过不同的组合达成应景的表达和适时的沟通。

语法

设计语言中的语法即设计价值观和设计原则，这是构建设计语言系统的起点，用于传达品牌主张或设计理念，它将指引业务设计执行的方向。

制定设计原则时，首先研究用户特性，聚焦产品核心价值，然后通过脑暴等形式选择有特点的维度，结合用户体验与品牌属性将其视觉化，最后用简要的语言归纳出来。

Ant Design 设计价值观 ³

	自然 数字世界的光速迭代使得产品日益复杂，而人类意识和注意力资源有限。面对这种设计矛盾，追求「自然」交互将是 Ant Design 持之以恒的方向。
	确定性 界面是用户与系统交互的媒介，是手段而非目的。在追求「自然」交互基础上，通过 Ant Design 创造的产品界面应是高确定性、低合作熵的状态。
	意义感 一个产品或功能被设计者创造出来不只是用户的需要，而更多是承载用户的某个工作使命。产品设计应充分站在工作视角，促成用户使命的达成；同时，在「自然」、「确定」之上，兼顾用户的人性需求，为工作过程创造富有意义感的人机交互。
	生长性 企业级产品功能的增长与用户系统角色的演变相生相伴。设计者应为自己创造的产品负责，提升功能、价值的可发现性。用发展的眼光做设计，充分考虑人、机两端的共同生长。

Ant Design 设计原则 ⁴

亲密性

如果信息之间关联性越高，它们之间的距离就应该越接近，也越像一个视觉单元；反之，则它们的距离就应该越远，也越像多个视觉单元。亲密性的根本目的是实现组织性，让用户对页面结构和信息层次一目了然。

对齐

正如「格式塔学派」中的连续律（Law of Continuity）所描述的，在知觉过程中人们往往倾向于使知觉对象的直线继续成为直线，使曲线继续成为曲线。在界面设计中，将元素进行对齐，既符合用户的认知特性，也能引导视觉流向，让用户更流畅地接收信息。

对比

对比是增加视觉效果最有效方法之一，同时也能在不同元素之间建立一种有组织的层次结构，让用户快速识别关键信息。

重复

相同的元素在整个界面中不断重复，不仅可以有效降低用户的学习成本，也可以帮助用户识别出这些元素之间的关联性。

直截了当

正如 Alan Cooper 所言：「需要在哪里输出，就要允许在哪里输入」。这就是直接操作的原理。eg：不要为了编辑内容而打开另一个页面，应该直接在上下文中实现编辑。

足不出户

能在这个页面解决的问题，就不要去其它页面解决，因为任何页面刷新和跳转都会引起变化盲视（Change Blindness），导致用户心流（Flow）被打断。频繁的页面刷新和跳转，就像在看戏时，演员说完一行台词就安排一次谢幕一样。

简化交互

根据费茨法则（Fitts’s Law）所描述的，如果用户鼠标移动距离越少、对象相对目标越大，那么用户越容易操作。通过运用上下文工具（即：放在内容中的操作工具），使内容和操作融合，从而简化交互。

提供邀请

很多富交互模式（eg：「拖放」、「行内编辑」、「上下文工具」）都有一个共同问题，就是缺少易发现性。所以「提供邀请」是成功完成人机交互的关键所在。

邀请就是引导用户进入下一个交互层次的提醒和暗示，通常包括意符（eg：实时的提示信息）和可供性，以表明在下一个界面可以做什么。当可供性中可感知的部分（Perceived Affordance）表现为意符时，人机交互的过程往往更加自然、顺畅。

巧用过渡

人脑灰质（Gray Matter）会对动态的事物（eg：移动、形变、色变等）保持敏感。在界面中，适当的加入一些过渡效果，能让界面保持生动，同时也能增强用户和界面的沟通。

即时反应

「提供邀请」的强大体现在 交互之前 给出反馈，解决易发现性问题；「巧用过渡」的有用体现在它能够在 交互期间 为用户提供视觉反馈；「即时反应」的重要性体现在 交互之后 立即给出反馈。

就像「牛顿第三定律」所描述作用力和反作用一样，用户进行了操作或者内部数据发生了变化，系统就应该立即有一个对应的反馈，同时输入量级越大、重要性越高，那么反馈量级越大、重要性越高。

虽然反馈太多（准确的说，错误的反馈太多）是一个问题，但是反馈太少甚至没有反馈的系统，则让人感觉迟钝和笨拙，用户体验更差。

Alibaba Fusion 设计价值观 ⁵

化繁为简的交互模式

面对互联网产品高迭代节奏和复杂的中后台场景，将复杂的业务组件抽象为用户标准认知层的交互方式，这套组件库来自于阿里巴巴上百个中后台场景的抽象结果，试图建立中后台 web 设计标准。

驾驭技术

你用的所有设计资料，小到 sketch 样式工具中的颜色、字体、字号、投影、边框、尺寸；再到组件，大到一套完整的中后台产品系统，均能找到其对应的代码，完整的释放整个团队的前端生产力。

追求新鲜，潮流

设计风格每年都会更新换代，由于 Alibaba Fusion 设计系统中的颜色、字体、字号、投影等样式均可通过线上配置修改，这也决定了它可以快速（甚至 15 分钟内）完成整套设计系统的样式迭代。

聚变/裂变

通过在 Alibaba Fusion 设计系统原则下，变换样式、多维度定制组件交互形式，可瞬间获取属于自己业务属性的设计系统；我们期待有无数业务线能够通过 Alibaba Fusion 的设计系统原则聚变出符合各类业务场景的 Fusion 生态系统。

效率

Alibaba Fusion Design 希望构建一套提升设计与开发之间 UI 构建效率的工作方式，让 UED 的工作能够尽可能多的投入在 UE（User Experience）的用户调研、用户体验、商业思考，而在 D（Design）的过程中更多的投入与创意而非日复一日的重复绘图。

腾讯 Q 语言理念 ⁶

	统一体验 QQ 作为一个社交平台，会容纳多样性的功能与体验，为了降低用户在不同场景功能下的学习成本，并提升易用性，统一体验是提升平台易用性的关键基础。同时有助于提升各角色间的协作效率。
	基因体现 当今同质化的社交应用越来越多，QQ 作为横跨多时期多平台的社交应用，一方面需紧贴时代趋势，在众多应用中脱颖而出，另一方面有足够的历史底蕴，应强化自身基因特征，提升整体品牌认知。
	社交向善 社交应用会融入琳琅满目的娱乐化规则与玩法，但吸引年轻人的不应只是单纯娱乐消费，需要考虑社交娱乐的本质初心，QQ 更倡导用户在一个积极健康，安全贴心，触动情感的环境进行社交，并最终导人向善。
	高效娱乐 伴随信息传播便利性提升，用户需要更高浓度的信息和更快的娱乐方式。用户时间愈加宝贵，偏向消费耗时较短的短视频、信息流等内容，希望更快找到喜欢的内容，以及更高浓度的内容。
	兴趣细分 互联网使用场景更细分，兴趣爱好更加细分深入。各种兴趣圈、游戏圈、粉丝圈等年轻用户基于互联网衍生出来的圈子，需要有更细分深入的功能场景去承载。线上和线下联动是细分圈子持续活跃的关键。
	社交压力 互联网信息传播的扩散效应，以及社会的复杂性给用户带来更多社交压力，原创越来越少。可以通过丰富的形象建立和维护体系增强用户的社交动力，引导产生更多原创内容和互动。

腾讯 Q 语言原则 ⁷

	活力灵动 对年轻人有吸引力，传递积极乐观情感，有怦然心动的感觉。
	亲和自然 体验过程犹如与朋友打交道，亲和自然，懂我所想。
	自我有范 用户能无压力表达自我，满足不同人群个性诉求。

语素

视觉基础是构成设计语言的最小单位，就像语素是语言中最小的音义结合体。在原子设计理论中，它属于最小粒度的元素，通常包括：色彩、布局、字体、图标等。

色彩

无论 UI 还是平面，颜色是视觉传达的最核心也是最基本的语言，不同的主色，会给人不同的视觉感受，同样的主色不同的配色，视觉感受也会不同。通常一款产品的色彩体系包含：品牌色、功能色、中立色三个部分：

品牌色：代表品牌形象及 VI 识别的色彩，品牌色的数量可以一个也可以多个，用于主按钮、主 icon 等需要突出品牌特征的地方。

功能色：代表明确的信息以及状态，如成功、出错、失败、提醒等。功能色的选取需要遵守用户对色彩的基本认知，如绿色代表成功，红色代表警示或失败。

中立色：灰或饱和度低的颜色，用于界面设计中的字体、背景、边框、分割线等，中立色通常是按照透明度的方式实现。

布局

空间布局是体系化视觉设计的起点，和传统的平面设计的不同之处在于，UI 界面的布局空间要基于「动态、体系化」的角度出发展开。在中后台视觉体系中定义布局系统，可以从 5 个方面出发：统一的画板尺寸、适配方案、网格单位、栅格、常用模度。

统一画板：为了尽可能减少沟通与理解的成本，有必要在组织内部统一设计板的尺寸。

适配：在设计过程中还需要建立适配的概念，根据具体情况判断系统是否需要进行适配，以及哪些区块需要考虑动态布局。

左右布局的适配方案：常被用于左右布局的设计方案中，常见的做法是将左边的导航栏固定，对右边的工作区域进行动态缩放。

上下布局的适配方案：常被用于上下布局的设计方案中，做法是对两边留白区域进行最小值的定义，当留白区域到达限定值之后再对中间的主内容区域进行动态缩放。

网格单位：通过网格体系可以实现视觉体系的秩序。网格的基数为 8，不仅符合偶数的思路同时能够匹配多数主流的显示设备。通过建立网格的思考方式，还能帮助设计者快速实现布局空间的设计决策同时也能简化设计到开发的沟通损耗。

栅格：以上下布局的结构为例，对内容区域进行 24 栅格的划分设置，如下图所示。页面中栅格的 Gutter 设定了定值，即浏览器在一定范围扩大或缩小，栅格的 Column 宽度会随之扩大或缩小，但 Gutter 的宽度值固定不变。

模度：模度是为了帮助不同设计能力的设计者们在界面布局上的一致性和韵律感，统一设计到开发的布局语言，减少还原损耗。

字体

字体是界面设计中最基本的构成之一。通过定义字体在设计上的使用规则，从而在阅读的舒适性上达到平衡。确定字体主要从下面四个方面出发：字体家族、主字体、字阶与行高、字重。

字体家族：优秀的字体系统首先是要选择合适的字体家族。提供一套利于屏显的备用字体库，来维护在不同平台以及浏览器的显示下，字体始终保持良好的易读性和可读性，体现了友好、稳定和专业的特性。在中后台系统中，数字经常需要进行纵向对比展示，将数字的字体 font-variant-numeric 设置为 tabular-nums，使其为等宽字体。

主字体：基于电脑显示器阅读距离（50 cm）以及最佳阅读角度（0.3），将自私设置为 14，以保证在多数常用显示器上的用户阅读效率最佳。

字阶与行高：字阶和行高决定着一套字体系统的动态与秩序之美。字阶是指一系列有规律的不同尺寸的字体。行高可以理解为一个包裹在字体外面的无形的盒子。

字重：字重的选择同样基于秩序、稳定、克制的原则。多数情况下，只出现 regular 以及 medium 的两种字体重量，分别对应代码中的 400 和 500。在英文字体加粗的情况下会采用 semibold 的字体重量，对应代码中的 600。

图标

图标是 UI 设计中必不可少的组成。通常我们理解图标设计的含义，是将某个概念转换成清晰易读的图形，从而降低用户的理解成本，提升界面的美观度。在我们的企业级应用设计范围中，图标在界面设计的诸多元素中往往只占了很小的比重，在调用时也会被缩到比设计稿小很多倍的尺寸，加上在图形素材极度丰富并且便于获取的今天，在产品设计体系中实现一套美观、一致、易用、便于延展的图标体系往往会被不小心忽略掉。

语句

组件就像由若干个语素组成的语句，比如一个基础按钮，通常就是由颜色、字体、边距等元素组成。而我们平时所说的组件库，其实就是一部词典，其中包含了设计系统中所需的基础组件与用法，在界面设计中也具有较高的通用性。

语义

符号是语言的载体，但符号本身没有意义，只有被赋予含义的符号才能够被使用，这时候语言就转化为信息，而语言的含义就是语义。在视觉传达设计中也一样，使用的图标或图形，需具备正确的语义属性。如果商场导视设计中非要使用「裙子」图标来代表「男厕」入口，如此混淆语义挑战公众认知，那就等着被投诉吧。

语境

语境包含 3 个维度：一是流程意义上的上下文，二是产品属性中的语境，三是用户当下所处的环境。

当设计需要对上下文进行特别处理时，有可能对话的层级次序是受限于屏幕稀缺性，通常可采用 z-depth 叠加（Material Design 属性）、步骤条、元素关联转场动效等方式。举个常见的例子，当用户发起一个删除数据的请求时，界面会弹出一个二次确认的模态会话，用户点击确认之后才会执行删除操作。

针对用户当下所处的环境来适配界面语境，常见通过界面换肤的手法来实现，比如微信读书等阅读应用为用户提供白天模式或黑夜模式的选择。用户所处的外部环境因素可以很大程度上决定界面语言的应用，就好像在菜市场买东西要靠吼，在图书馆借书仅需要用肢体语言便能达成。

语气

交互界面通常需要使用说明或提示文案来指导用户完成操作，大多数情况下都是使用第二人称，就像在与用户对话，从以用户为中心的角度上讲，建议保持谦逊、友善的语气，尽可能避免使用晦涩的专业术语，谨慎使用带有强烈情感属性的感叹号，或过于口语化的语言。另外，语气的拿捏也将直接影响到与用户的距离感，以及当下的应景度。

语速

语速在这里指的是界面的信息密度，在不同的场合对语速的控制能够提升接受者的体验，视觉设计也同样需要注意把握间距与留白，网格系统在这里可以起到「节拍器」的作用，借助节拍器可以让设计更具节奏感。而交互意义上的语速，更多体现在操作路径的长度，以及动效的速率。

下图分别展示了 QQ 音乐和富途牛牛两种不同场景的「语速」：

响度

其实就好像我们说话可以通过音量大小来控制信息的可感知程度，希望接受者听清楚的就说大声一点。汤姆奥斯本（Tom Osborne）的视觉响度指南（Visual Loudness Guide）是一个如何系统地处理按钮和链接的例子，它们不是单独列出，而是作为一个套件呈现，并且根据每个元素的视觉冲击力会相应的拥有一个「响度」值。我们在构建设计语言系统时，也同样需要设置梯级「响度」的按钮、字重等组件来满足不同场景的表达需求。

设计语言列表

影响 SQL 执行性能的主要因素可以总结为如下几项：

1. 计算资源量（CPU，内存，网络等）
2. 计算数据量（输入和输出的记录数）
3. 计算复杂度（业务逻辑复杂程度和对应的 SQL 实现和执行）

计算资源量是一个前置制约因素，理论上更多的资源能够带来更快的计算效果。计算数据量也可以认为是一个前置制约因素，理论上更大的数据量会导致计算速度降低，但对于复杂的计算逻辑，通过合理的 SQL 可以更好的控制计算过程中的数据量，从而提升 SQL 性能。计算复杂度是影响 SQL 性能的关键因素，复杂的业务逻辑必然比简单的业务逻辑处理时间要长，相同业务逻辑的不同 SQL 实现也会影响运行效率，这就要求我们对业务逻辑进行全面的理解，对实现 SQL 进行合理优化，从而提升计算速度。

执行引擎

SQL 是用于一种用于数据定义和数据操纵的特定目的的编程语言 ¹。SQL 虽然有 ISO 标准 ²，但大部分 SQL 代码在不同的数据库系统中并不具有完全的跨平台性。不同的执行引擎也会对 SQL 的语法有相应的改动和扩展，同时对于 SQL 的执行也会进行不同的适配和优化。因此，脱离执行引擎的 SQL 性能优化是不可取的。

Hive

Apache Hive 是一个建立在 Hadoop 架构之上的数据仓库。可以将结构化的数据文件映射为一张数据库表，并提供简单的 SQL 查询功能，可以将 SQL 语句转换为 MapReduce 任务进行运行。因此 MapReduce 是 Hive SQL 运行的核心和根基。

我们以 Word Count 为例简单介绍一下 MapReduce 的原理和过程，Word Count 的 MapReduce 处理过程如下图所示：

1. Input：程序的输入数据。
2. Splitting：讲输入数据分割为若干部分。
3. Mapping：针对 Splitting 分割的每个部分，对应有一个 Map 程序处理。本例中将分割后的文本统计成 <K,V> 格式，其中 K 为单词，V 为该单词在这个 Map 中出现的次数。
4. Shuffling：对 Mapping 的相关输出结果进行合并。本例中将具有相同 K 的统计结果合并到一起。
5. Reducing：对 Shuffling 合并的结果进行汇总。本例中讲相同 K 的 V 值进行加和操作并返回单个统计结果。
6. Merged：对 Reducing 的结果进行融合形成最终输出。

Spark

Apache Spark 是一个用于大规模数据处理的统一分析引擎，Spark SQL 则作为 Apache Spark 用于处理结构化数据的模块。

Spark 中常见的概念有：

1. RDD：Resilient Distributed Dataset，弹性分布式数据集，是分布式内存中一个抽象概念，提供了一种高度受限的共享内存模型。
2. DAG：Directed Acyclic Graph，有向无环图，反应了 RDD 之间的依赖关系。
3. Driver Program：控制程序，负责为 Application 创建 DAG，通常用 SparkContext 代表 Driver Program。
4. Cluster Manager：集群管理器，负责分配计算资源。
5. Worker Node：工作节点，负责具体计算。
6. Executor：运行在 Worker Node 上的一个进程，负责运行 Task，并为 Application 存储数据。
7. Application：Spark 应用程序，包含多个 Executor。
8. Task：任务，运行在 Executor 上的工作单元，是 Executor 中的一个线程。
9. Stage：一组并行的 Task，Spark 一般会根据 Shuffle 类算子（例如：reduceByKey 或 join 等）划分 Stage。
10. Job：一组 Stage 的集合，一个 Job 包含多个 RDD 及作用于 RDD 上的操作。

相关概念构成了 Spark 的整体架构，如下图所示：

在 Spark 中，一个任务的执行过程大致分为 4 个阶段，如下图所示：

1. 定义 RDD 的 Transformations 和 Actions 算子 ³，并根据这些算子形成 DAG。
2. 根据形成的 DAG，DAGScheduler 将其划分为多个 Stage，每个 Stage 包含多个 Task。
3. DAGScheduler 将 TaskSet 交由 TaskScheduler 运行，并将执行完毕后的结果返回给 DAGScheduler。
4. TaskScheduler 将任务分发到每一个 Worker 去执行，并将执行完毕后的结果返回给 TaskScheduler。

Spark 相比于 Hadoop 的主要改进有如下几点：

1. Hadoop 的 MapReduce 的中间结果都会持久化到磁盘上，而 Spark 则采用基于内存的计算（内存不足时也可选持久化到磁盘上），从而减少 Shuffle 数据，进而提升计算速度。
2. Spark 采用的 DAG 相比于 Hadoop 的 MapReduce 具有更好的容错性和可恢复性，由于 Spark 预先计算出了整个任务的 DAG，相比于 MapReduce 中各个操作之间是独立的，这更有助于进行全局优化。

Presto

Presto 是一种用于大数据的高性能分布式 SQL 查询引擎。Presto 与 Hive 执行任务过程的差异如下图所示：

Presto 的优点主要有如下几点：

1. 基于内存计算，减少了磁盘 IO，从而计算速度更快。
2. 能够连接多个数据源，跨数据源连表查询。

虽然 Presto 能够处理 PB 级数据，但并不代表 Presto 会把 PB 级别数据都放在内存中计算。而是根据场景，例如 COUNT 和 AVG 等聚合操作，是边读数据边计算，再清理内存，再读取数据计算，这种情况消耗的内存并不高。但是连表查询，可能产生大量的临时数据，从而速度会变慢。

性能调优

本节关于 SQL 性能调优的建议主要针对 Hive，Spark 和 Presto 这类大数据 OLAP 执行引擎设计，其他执行引擎不一定完全适用。

下文性能调优中均以如下两张表为例进行说明：

CREATE TABLE IF NOT EXISTS sku_order
(
  order_id STRING '订单 ID',
  sku_id STRING '商品 ID',
  sale_quantity BIGINT '销售数量' 
)
COMMENT '商品订单表'
PARTITIONED BY
(
  dt STRING COMMENT '日期分区'
)
;

CREATE TABLE IF NOT EXISTS sku_info
(
  sku_id STRING '商品 ID',
  sku_name STRING '商品名称',
  category_id STRING '品类 ID',
  category_name STRING '品类名称'
)
COMMENT '商品信息表'

减少数据量

• 限定查询分区。对于包含分区的数据表（例如：日期分区），通过合理限定分区来减少数据量，避免全表扫描。
• 限定查询字段。避免使用 SELECT *，仅选择需要的字段。SELECT * 会通过查询元数据获取字段信息，同时查询所有字段会造成更大的网络开销。
• 在关联前过滤数据。应在进行数据表关联之前按照业务逻辑进行数据过滤，从而提升执行效率。

数据倾斜

在 Shuffle 阶段，需要将各节点上相同的 Key 拉取到某个节点（Task）上处理，如果某个 Key 对应的数据量特别大则会产生数据倾斜。结果就是该 Task 运行的时间要远远大于其他 Task 的运行时间，从而造成作业整体运行缓慢，数据量过大甚至可能导致某个 Task 出现 OOM。

在 SQL 中主要有如下几种情况会产生数据倾斜：

• JOIN 导致的数据倾斜：两表关联，关联字段的无效值（例如：NULL）或有效值过多，可能会导致数据倾斜。
• GROUP BY 导致的数据倾斜：当 GROUP BY 的字段（或字段组合）中，Key 分布不均，可能会导致数据倾斜。
• DISTINCT 导致的数据倾斜：当 DISTINCT 的字段（或字段组合）中，Key 分布不均，可能会导致数据倾斜。

对于不同的数据倾斜情况，解决方案如下：

• 对于 JOIN 中的无效值进行过滤。

  SELECT
    category_name,
    SUM(sale_quantity) AS sale_quantity
  FROM
    (
      SELECT
        sku_id,
        sale_quantity
      FROM
        sku_order
      WHERE
        dt = '20210523'
        AND sku_id IS NOT NULL
    ) AS sku_order_filtered
  LEFT JOIN
    sku_info
  ON
    sku_order_filtered.sku_id = sku_info.sku_id
  GROUP BY
    category_name
  ;
  

• 对于 JOIN 开启 Map Join 或 Broadcast Join 策略，将小表广播到每个 Executor 上来避免产生 Shuffle，从而使得 JOIN 能够快速完成。

set spark.sql.autoBroadcastJoinThreshold=10485760;

• 对于 JOIN 中存在数据倾斜的 KEY 进行打散处理。

  SELECT
    category_name,
    SUM(sale_quantity) AS sale_quantity
  FROM
    (
      SELECT
        IF(sku_id IN (0000, 9999), CONCAT(sku_id, '_', CEIL(RAND() * 10)), sku_id) AS sku_id,
        sale_quantity
      FROM
        sku_order
      WHERE
        dt = '20210523'
    ) AS sku_order_modified
  LEFT JOIN
    (
      SELECT
        sku_id,
        category_name,
      FROM
        sku_info
      WHERE
        sku_id NOT IN (0000, 9999)
      UNION ALL
      SELECT
        CONCAT(sku_id, '_', suffix) AS sku_id,
        category_name
      FROM
        (
          SELECT
            sku_id,
            SPLIT('1,2,3,4,5,6,7,8,9,10', ',') AS suffix_list,
            category_name
          FROM
            sku_info
          WHERE
            sku_id IN (0000, 9999)
        ) sku_info_tmp LATERAL VIEW EXPLODE(suffix_list) sku_info_suffix AS suffix
    ) sku_info_all
  ON
    sku_order_modified.sku_id = sku_info_all.sku_id
  GROUP BY
    category_name
  ;
  

• 对于 GROUP BY 导致的数据倾斜采用两步聚合。

  SELECT
    IF(sku_is_null = 1, NULL, sku_id) AS sku_id,
    SUM(sale_quantity) AS sale_quantity
  FROM
    (
      SELECT
        sku_id,
        sku_is_null,
        SUM(sale_quantity) AS sale_quantity
      FROM
      (
        SELECT
          IF(sku_id IS NULL, CONCAT(sku_id, CEIL(RAND() * 10)), sku_id) AS sku_id,
          IF(sku_id IS NULL, 1, 0) AS sku_is_null,
          sale_quantity
        FROM
          sku_order
        WHERE
          dt = '20210523'
      ) sku_order_modified
      GROUP BY
        sku_id,
        sku_is_null
    ) sku_order_group
  GROUP BY
    IF(sku_is_null = 1, NULL, sku_id)
  ;
  

• 对于 DISTINCT 导致的数据倾斜，可以改写为 GROUP BY 实现，从而通过多个 Task 计算避免数据倾斜。

  /* COUNT DISTINCT */
  SELECT
    COUNT(DISTINCT sku_id) AS cnt
  FROM
    sku_order
  WHERE
    dt = '20210523'
  ;
  
  /* GROUP BY */
  SELECT
    COUNT(1) AS cnt
  FROM
    (
      SELECT
        sku_id
      FROM
        sku_order
      WHERE
        dt = '20210523'
      GROUP BY
        sku_id
    ) AS sku_stats
  ;
  

其他建议

• 使用 Common Table Expressions (CTEs) 而非子查询。WITH 语句产生的结果类似临时表，可以重复使用，从而避免相同逻辑业务重复计算。

• 使用 LEFT SEMI JOIN 而非 IN 和子查询。Hive 在 0.13 后的版本中才在 IN 和 NOT IN 中支持子查询。

  /* BAD */
  SELECT
    order_id,
    sku_id,
    sale_quantity
  FROM
    sku_order
  WHERE
    sku_id IN (SELECT sku_id FROM sku_info)
  ;
  
  /* GOOD */
  SELECT
    order_id,
    sku_id,
    sale_quantity
  FROM
    sku_order
  LEFT SEMI JOIN
    sku_info
  ON
    sku_order.sku_id = sku_info.sku_id
  ;
  

参数调优

除了 SQL 本身逻辑的优化外，执行引擎的相关参数设置也会影响 SQL 的执行性能。本小节以 Spark 引擎为例，总结相关参数的设置及其影响。

动态分区

/* 以下 Hive 参数对 Spark 同样有效 */

/* 是否启用动态分区功能 */
set hive.exec.dynamic.partition=true;

/* strict 表示至少需要指定一个分区，nonstrict 表示可以全部动态指定分区 */
set hive.exec.dynamic.partition.mode=nonstrict;

/* 动态生成分区的最大数量 */
set hive.exec.max.dynamic.partitions=1000;

资源申请

/* 每个 Executor 中的核数 */
set spark.executor.cores=2;

/* Executor 的内存总量。YARN 中 Container 的内存限制为 spark.executor.memory + spark.yarn.executor.memoryOverhead <= 16G。 */
set spark.executor.memory=4G;

/* Executor 的堆外内存大小，由 YARN 控制，单位为 MB。YARN 中 Container 的内存限制为 spark.executor.memory + spark.yarn.executor.memoryOverhead <= 16G。 */
set spark.yarn.executor.memoryOverhead=1024;

/* Driver 的内存总量，主要用于存放任务执行过程中 Shuffle 元数据，以及任务中 Collect 的数据，Broadcast 的小表也会先存放在 Driver 中。YARN 中 Container 的内存限制为 spark.executor.memory + spark.yarn.executor.memoryOverhead <= 16G。 */
set spark.driver.memory=8G;

/* Driver 的堆外内存，由 YARN 控制，单位为 MB。YARN 中 Container 的内存限制为 spark.executor.memory + spark.yarn.executor.memoryOverhead <= 16G。 */
set spark.yarn.driver.memoryOverhead=1024;

/* storage memory + execution memory 占总内存（java heap-reserved memory）的比例。executor jvm 中内存分为 storage、execution 和 other 内存。storage 存放缓存 RDD 数据，execution 存放 Shuffle 过程的中间数据，other 存放用户定义的数据结构或 Spark 内部元数据。如果用户自定义数据结构较少，可以将该参数比例适当上调。 */
set spark.memory.fraction=0.7;

动态分配

开启动态分配，Spark 可以根据当前作业负载动态申请和释放资源：

set spark.dynamicAllocation.enabled=true;

同时需要设置同一时刻可以申请的最小和最大 Executor 数量：

set spark.dynamicAllocation.minExecutors=10;
set spark.dynamicAllocation.maxExecutors=100;

小文件合并

/* 小文件合并阈值，如果生成的文件平均大小低于阈值会额外启动一轮 Stage 进行小文件的合并，默认不合并小文件。 */
set spark.sql.mergeSmallFileSize=67108864;

/* 	设置额外的合并 Job 时的 Map 端输入大小 */
set spark.sql.targetBytesInPartitionWhenMerge=67108864;

/* 设置 Map 端输入的合并文件大小 */
set spark.hadoopRDD.targetBytesInPartition=67108864;

在决定一个目录是否需要合并小文件时，会统计目录下的平均大小，然后和 spark.sql.mergeSmallFileSize 比较。在合并文件时，一个 Map Task 读取的数据量取决于下面三者的较大值：spark.sql.mergeSmallFileSize，spark.sql.targetBytesInPartitionWhenMerge，spark.hadoopRDD.targetBytesInPartition。

Shuffle 相关

当大表 JOIN 小表时，如果小表足够小，可以将小表广播到所有 Executor 中，在 Map 阶段完成 JOIN。如果该值设置太大，容易导致 Executor 出现 OOM。

/* 10 * 1024 * 1024, 10MB */
set spark.sql.autoBroadcastJoinThreshold=10485760;

设置 Reduce 阶段的分区数：

set spark.sql.shuffle.partitions=1000;

设置过大可能导致很多 Reducer 同时向一个 Mapper 拉取数据，导致 Mapper 由于请求压力过大而挂掉或响应缓慢，从而 fetch failed。

一些其他 Shuffle 相关的配置如下：

/* 同一时刻一个 Reducer 可以同时拉取的数据量大小 */
set spark.reducer.maxSizeInFlight=25165824;

/* 同一时刻一个 Reducer 可以同时产生的请求数 */
set spark.reducer.maxReqsInFlight=10;

/* 同一时刻一个 Reducer 向同一个上游 Executor 拉取的最多 Block 数 */
set spark.reducer.maxBlocksInFlightPerAddress=1;

/* Shufle 请求的 Block 超过该阈值就会强制落盘，防止一大堆并发请求将内存占满 */
set spark.reducer.maxReqSizeShuffleToMem=536870911;

/* Shuffle 中连接超时时间，超过该时间会 fetch failed */
set spark.shuffle.io.connectionTimeout=120;

/* Shuffle 中拉取数据的最大重试次数 */
set spark.shuffle.io.maxRetries=3;

/* Shuffle 重试的等待间隔 */
set spark.shuffle.io.retryWait=5;

ORC 相关

ORC 文件的格式如下图所示：

其中，Postscript 为文件描述信息，包括 File Footer 和元数据长度、文件版本、压缩格式等；File Footer 是文件的元数据信息，包括数据量、每列的统计信息等；文件中的数据为 Stripe，每个 Stripe 包括索引数据、行数据和 Stripe Footer。更多有关 ORC 文件格式的信息请参见 ORC Specification v1 。

在读取 ORC 压缩表时，可以控制生成 Split 的策略，包括：

• BI：以文件为力度进行 Split 划分
• ETL：将文件进行切分，多个 Stripe 组成一个 Split
• HYBRID：当文件的平均大小大于 Hadoop 最大 Split 值时使用 ETL 策略，否则使用 BI 策略

对于一些较大的 ORC 表，可能其 Footer 较大，ETL 策略可能会导致从 HDFS 拉取大量的数据来切分 Split，甚至会导致 Driver 端 OOM，因此这类表的读取建议采用 BI 策略。对于一些较小，尤其是有数据倾斜的表（即大量 Stripe 存储于少数文件中），建议使用 ETL 策略。

一些其他 ORC 相关的配置如下：

/* ORC 谓词下推，默认是关闭 */
set spark.sql.orc.filterPushdown=true;

/* 	开启后，在 Split 划分时会使用 Footer 信息 */
set spark.sql.orc.splits.include.file.footer=true;

/* 设置每个 Stripe 可以缓存的大小 */
set spark.sql.orc.cache.stripe.details.size=10000;

/* 当为 true 时，Spark SQL 的谓语将被下推到 Hive Metastore 中，更早的消除不匹配的分区。 */
set spark.sql.hive.metastorePartitionPruning=true;

/* 读 ORC 表时，设置小文件合并的阈值，低于该值的 Split 会合并在一个 Task 中执行 */
set spark.hadoop.mapreduce.input.fileinputformat.split.minsize=67108864;

/* 读 ORC 表时，设置一个 Split 的最大阈值，大于该值的 Split 会切分成多个 Split。 */
set spark.hadoop.mapreduce.input.fileinputformat.split.maxsize=268435456;

/* 文件提交到HDFS上的算法：1. version=1 是按照文件提交。2. version=2 是批量按照目录进行提交，可以极大节约文件提交到 HDFS 的时间，减轻 NameNode 压力。 */
set spark.hadoop.mapreduce.fileoutputcommitter.algorithm.version=2;

自适应执行

/* 开启动态执行 */
set spark.sql.adaptive.enabled=true;

当自适应执行开启后，调整 spark.sql.adaptive.shuffle.targetPostShuffleInputSize，当 Mapper 端两个 Partition 的数据合并后小于该值时，Spark 会将两个 Partition 合并到一个 Reducer 进行处理。

set spark.sql.adaptive.shuffle.targetPostShuffleInputSize=67108864;

当自适应执行开启后，有时会导致过多分区被合并，为了防止分区过少影响性能，可以设置如下参数：

set spark.sql.adaptive.minNumPostShufflePartitions=10;

一些其他自适应执行相关的配置如下：

/* 开启动态调整 Join */
set spark.sql.adaptive.join.enabled=true;

/* 设置 SortMergeJoin 转 BroadcastJoin 的阈值，如果不设置该参数，该阈值和 spark.sql.autoBroadcastJoinThreshold 值相等。 */
set spark.sql.adaptiveBroadcastJoinThreshold=33554432;

/* 是否允许为了优化 Join 而增加 Shuffle，默认是 false */
set spark.sql.adaptive.allowAddititionalShuffle=false;

/* 开启自动处理 Join 时的数据倾斜 */
set spark.sql.adaptive.skewedJoin.enabled=true;

/* 控制处理一个倾斜 Partition 的 Task 个数上限，默认值是 5 */
set spark.sql.adaptive.skewedPartitionMaxSplits=100;

/* 设置一个 Partition 被视为倾斜 Partition 的行数下限，行数低于该值的 Partition 不会被当做倾斜 Partition 处理。 */
set spark.sql.adaptive.skewedPartitionRowCountThreshold=10000000;

/* 设置一个 Partition 被视为倾斜 Partition 的大小下限，大小小于该值的 Partition 不会被当做倾斜 Partition 处理。 */
set spark.sql.adaptive.skewedPartitionSizeThreshold=536870912;

/* 设置倾斜因子，当一个 Partition 满足以下两个条件之一，就会被视为倾斜 Partition：1. 大小大于 spark.sql.adaptive.skewedPartitionSizeThreshold 的同时大于各 Partition 大小中位数与该因子的乘积。2. 行数大于 spark.sql.adaptive.skewedRowCountThreshold 的同时大于各 Partition 行数中位数与该因子的乘积。*/
set spark.sql.adaptive.skewedPartitionFactor=10;

推测执行

/* Spark 推测执行开关，默认是 true */
set spark.speculation=true;

/* 开启推测执行后，每隔该值时间会检测是否有需要推测执行的 Task */
set spark.speculation.interval=1000ms;

/* 当成功 Task 占总 Task 的比例超过 spark.speculation.quantile，统计成功 Task 运行时间中位数乘以 spark.speculation.multiplier 得到推测执行阈值，当在运行的任务超过这个阈值就会启动推测执行。当资源充足时，可以适当减小这两个值。 */
set spark.speculation.quantile=0.99;
set spark.speculation.multiplier=3;

衡量代码质量的唯一有效标准：WTF/min – Robert C. Martin

Google 针对大多数编程语言（例如：C/C++，Java，JavaScript，Python，R 等）都整理了相关的代码风格，但对于 SQL 这种用于数据库查询特殊目的的编程语言并没有整理对应的风格。同其他编程语言代码风格一样，没有哪种风格是最好的，只要在项目中采用统一合理的风格即可。

本文参考的 SQL 样式指南有如下几种：

1. https://www.sqlstyle.guide/zh/
2. https://about.gitlab.com/handbook/business-technology/data-team/platform/sql-style-guide/
3. https://docs.telemetry.mozilla.org/concepts/sql_style.html
4. https://github.com/mattm/sql-style-guide

本文给出的 SQL 样式指南基于上述几种进行整理和修改。

一般原则

• 使用一致的、描述性名称。
• 使用空格（2 个或 4 个，项目中保持一致），避免使用 TAB 缩进。
• 在 SQL 中加入必要的注释，块注释使用 /* */，行注释使用 --，并在末尾换行。
• 使用单引号 ' 作为被引号包裹的标识符。
• 运算符前后添加空格，逗号 , 后添加空格，避免行尾有空格。
• 每行代码不超过 80 个字符。

命名惯例

• 避免名称和保留字一样。
• 关键词、函数名称采用大写，字段名、表名采用小蛇式（lower snake case）命名。
• 名称要以字母开头，不能以下划线结尾，名称中仅可以使用字母、数字和下划线。
• 不要在名字中出现连续下划线 __，这样很难辨认。
• 尽量避免使用缩写词。使用时一定确定这个缩写简明易懂。
• 字段名总是使用单数。

对齐和换行

• 避免川流式对齐代码。

  /* Good */
  SELECT id
  FROM table_name
  WHERE column = "test"
  ;
  

  /* Bad */
  SELECT id
    FROM talbe_name
   WHERE column = "test"
  ;
  

• 多个元素组合无法呈现在一行中时，应将第一个元素另起一行。

  /* Good */
  SELECT
    CASE postcode
      WHEN 'BN1' THEN 'Brighton'
      WHEN 'EH1' THEN 'Edinburgh'
    END AS city
  FROM table_name
  ;
  

  /* Bad */
  SELECT
    CASE postcode WHEN 'BN1' THEN 'Brighton'
                  WHEN 'EH1' THEN 'Edinburgh'
    END AS city
  FROM table_name
  ;
  

• 由括号构成的多行，结尾括号应单独一行。

  /* Good */
  SELECT id
  FROM table_name
  WHERE postcode IN (
    'looooooooooooooooooooooooong_BN1',
    'loooooooooooooooooooooooooog_EH1'
  )
  

  /* Bad */
  SELECT id
  FROM table_name
  WHERE postcode IN ('looooooooong_BN1',
                     'looooooooong_EH1')
  

• 多行采用右侧逗号和左侧关键字连接。

  /* Good */
  SELECT
    id,
    name
  FROM
    talbe_name
  WHERE
    id > 1
    AND name LIKE "%Tom%"
  ;
  

  /* Bad */
  SELECT
    id
    , name
  FROM
    table_name
  WHERE
    id > 1 AND
    name LIKE "%Tom%"
  ;
  

• 根关键词建议单独一行，多个参数单独一行。

  /* Good */
  SELECT
    id,
    name
  FROM
    table_name
  WHERE
    id > 1
    AND name LIKE "%Tom%"
  LIMIT
    10
  ;
  

  /* Acceptable */
  SELECT
    id,
    name
  FROM table_name
  WHERE
    id > 1
    AND name LIKE "%Tom%"
  LIMIT 10
  ;
  

  /* Bad */
  SELECT id, name
  FROM table_name
  WHERE
    id > 1
    AND name LIKE "%Tom%"
  LIMIT 10
  ;
  

明确指定

• 使用 AS 明确指定别名，而非隐式。

  /* Good */
  SELECT
    table_name_1.id AS user_id,
    table_name_2.name AS user_name
  FROM
    looooooooong_table_name_1 AS table_name_1
  LEFT JOIN
    looooooooong_table_name_2 AS table_name_2
  ON
    table_name_1.id = table_name_2.id
  ;
  

  /* Bad */
  SELECT
    table_name_1.id user_id,
    table_name_2.name user_name
  FROM
    looooooooong_table_name_1 table_name_1
  LEFT JOIN
    looooooooong_table_name_2 table_name_2
  ON
    table_name_1.id = table_name_2.id
  ;
  

• 避免使用隐式关联。

  /* Good */
  SELECT
    table_name_1.id,
    table_name_2.name
  FROM
    table_name_1
  INNER JOIN
    table_name_2
  ON
    table_name_1.id = table_name_2.id
  ;
  

  /* Bad */
  SELECT
    table_name_1.id,
    table_name_2.name
  FROM
    table_name_1,
    table_name_2
  ON
    table_name_1.id = table_name_2.id
  ;
  

• 明确关联类型。

  /* Good */
  SELECT
    table_name_1.id,
    table_name_2.name
  FROM
    table_name_1
  INNER JOIN
    table_name_2
  ON
    table_name_1.id = table_name_2.id
  ;
  

  /* Bad */
  SELECT
    table_name_1.id,
    table_name_2.name
  FROM
    table_name_1
  JOIN
    table_name_2
  ON
    table_name_1.id = table_name_2.id
  ;
  

• 明确指定分组列。

  /* Good */
  SELECT
    submission_date,
    normalized_channel IN ('nightly', 'aurora', 'beta') AS is_prerelease,
    COUNT(*) AS count
  FROM
    telemetry.clients_daily
  WHERE
    submission_date > '2019-07-01'
  GROUP BY
    submission_date,
    is_prerelease
  ;
  

  /* Bad */
  SELECT
    submission_date,
    normalized_channel IN ('nightly', 'aurora', 'beta') AS is_prerelease,
    COUNT(*) AS count
  FROM
    telemetry.clients_daily
  WHERE
    submission_date > '2019-07-01'
  GROUP BY
    1, 2
  ;
  

子查询

• 尽量使用 Common Table Expressions (CTEs) 而非子查询。

  /* Good */
  WITH sample AS (
    SELECT
      client_id,
      submission_date
    FROM
      main_summary
    WHERE
      sample_id = '42'
  )
  
  SELECT *
  FROM sample
  LIMIT 10
  

  /* Bad */
  SELECT *
  FROM (
    SELECT
      client_id,
      submission_date
    FROM
      main_summary
    WHERE
      sample_id = '42'
  )
  LIMIT 10
  

• 尽量在 CTEs 中处理查询而非主语句中。

  /* Good */
  WITH backings_per_category AS (
    SELECT
      ...
  ), backers AS (
    SELECT
      backings_per_category.backer_id,
      COUNT(backings_per_category.id) AS projects_backed_per_category
    INNER JOIN ksr.users AS users ON users.id = backings_per_category.backer_id
    GROUP BY backings_per_category.backer_id
  ), backers_and_creators AS (
    ...
  )
  SELECT * FROM backers_and_creators;
  

  /* Bad */
  WITH backings_per_category AS (
    SELECT
      ...
  ), backers AS (
    SELECT
      backer_id,
      COUNT(backings_per_category.id) AS projects_backed_per_category
  ), backers_and_creators AS (
    ...
  )
  SELECT *
  FROM backers_and_creators
  INNER JOIN backers
  ON backers_and_creators
  ON backers.backer_id = backers_and_creators.backer_id
  

其他

• 尽量使用 != 而不是 <> 表示不等于。
• 尽量使用 BETWEEN 而不是多个 AND 语句。
• 尽量使用 IN() 而不是多个 OR 语句。
• 尽量避免使用 SELECT *。
• 尽量避免使用无意义的别名，例如：a, b, c。

理论篇请参见：进程，线程和协程 (Process, Thread and Coroutine) - 理论篇

本文将介绍进程，线程和协程在 Python 中的实现，代码详见这里，部分参考自「Python 并发编程」 ¹:。

进程和线程

在 Python 中可以使用 multiprocessing.Process 和 threading.Thread 来实现进程和线程。我们采用CPU 密集型、磁盘 IO 密集型、网络 IO 密集型和模拟 IO 密集型任务类型来测试单线程，多线程和多进程之间的性能差异。

import requests

# CPU 密集型
def cpu_bound_task(x=1, y=1):
    c = 0

    while c < 1500000:
        c += 1
        x += x
        y += y

# 磁盘 IO 密集型
def disk_io_bound_task():
    with open('tmp.log', 'w') as f:
        for idx in range(5000000):
            f.write('{}\n'.format(idx))

# 网络 IO 密集型
def web_io_bound_task():
    try:
        requests.get('https://www.baidu.com')
    except Exception as e:
        pass

# 模拟 IO 密集型
def simulation_io_bound_task():
    time.sleep(2)

为了方便统计运行时间，定义如下一个运行时间装饰器：

import time

def timer(task_mode):
    def wrapper(func):
        def decorator(*args, **kwargs):
            task_type = kwargs.setdefault('task_type', None)
            start_time = time.time()
            func(*args, **kwargs)
            end_time = time.time()
            print('耗时（{} - {}）: {}'.format(
                task_mode, task_type, end_time - start_time))
        return decorator
    return wrapper

单线程，多线程和多进程的测试代码如下：

from threading import Thread
from multiprocessing import Process

@timer('单线程')
def single_thread(func, task_type='', n=10):
    for idx in range(n):
        func()


@timer('多线程')
def multi_threads(func, task_type='', n=10):
    threads = {}

    for idx in range(n):
        t = Thread(target=func)
        threads[idx] = t
        t.start()

    for thread in threads.values():
        thread.join()


@timer('多进程')
def multi_processes(func, task_type='', n=10):
    processes = {}

    for idx in range(n):
        p = Process(target=func)
        processes[idx] = p
        p.start()

    for process in processes.values():
        process.join()

运行测试

# 单线程
single_thread(cpu_bound_task, task_type='CPU 密集型任务')
single_thread(disk_io_bound_task, task_type='磁盘 IO 密集型任务')
single_thread(web_io_bound_task, task_type='网络 IO 密集型任务')
single_thread(simulation_io_bound_task, task_type='模拟 IO 密集型任务')

# 多线程
multi_threads(cpu_bound_task, task_type='CPU 密集型任务')
multi_threads(disk_io_bound_task, task_type='磁盘 IO 密集型任务')
multi_threads(web_io_bound_task, task_type='网络 IO 密集型任务')
multi_threads(simulation_io_bound_task, task_type='模拟 IO 密集型任务'

# 多进程
multi_processes(cpu_bound_task, task_type='CPU 密集型任务')
multi_processes(disk_io_bound_task, task_type='磁盘 IO 密集型任务')
multi_processes(web_io_bound_task, task_type='网络 IO 密集型任务')
multi_processes(simulation_io_bound_task, task_type='模拟 IO 密集型任务')

可以得到类似如下的结果：

从测试结果来看，不难得出如下结论：

1. 多线程和多进程相比单线程速度整体上有很大提升。
2. 对于 CPU 密集型任务，由于 GIL 加锁和释放问题，多线程相比单线程更慢。
3. 多线程更适合在 IO 密集场景下使用，例如：爬虫等。
4. 多进程更适合在 CPU 密集场景下使用，例如：大数据处理，机器学习等。

创建线程有两种方式：

利用函数创建线程

Python 中的 threading.Thread() 接受两个参数：线程函数，用于指定线程执行的函数；线程函数参数，以元组的形式传入执行函数所需的参数。

import time
from threading import Thread

# 自定义函数
def func(name='Python'):
    for idx in range(2):
        print('Hello, {}'.format(name))
        time.sleep(1)

# 创建线程
thread_1 = Thread(target=func)
thread_2 = Thread(target=func, args=('Leo', ))

# 启动线程
thread_1.start()
thread_2.start()

可以得到如下输出：

Hello, Python
Hello, Leo
Hello, Python
Hello, Leo

利用类创建线程

利用类创建线程需要自定义一个类并继承 threading.Thread 这个父类，同时重写 run 方法。最后通过实例化该类，并运行 start() 方法执行该线程。

# 自定义类
class MyThread(Thread):
    def __init__(self, name='Python'):
        super(MyThread, self).__init__()
        self.name = name

    def run(self):
        for idx in range(2):
            print('Hello, {}'.format(self.name))
            time.sleep(1)

# 创建线程
thread_1 = MyThread()
thread_2 = MyThread('Leo')

# 启动线程
thread_1.start()
thread_2.start()

可以得到同上面一样的输出：

Hello, Python
Hello, Leo
Hello, Python
Hello, Leo

线程的一些常用方法和属性如下所示：

# 创建线程
t = Thread(target=func)

# 启动线程
t.start()

# 阻塞线程
t.join()

# 判断线程是否处于执行状态
# True: 执行中，False: 其他
t.is_alive()

# 这是线程是否随主线程退出而退出
# 默认为 False
t.daemon = True

# 设置线程名称
t.name = 'My Thread'

锁

在一段代码中加锁表示同一时间有且仅有一个线程可以执行这段代码。在 Python 中锁分为两种：互斥锁和可重入锁。利用 threading.Lock() 可以获取全局唯一的锁对象，使用 acquire() 和 release() 方法可以获取和释放锁，注意两个需成对出现，否则可能造成死锁。

互斥锁

例如定义两个函数，并在两个线程中执行，这两个函数共用一个变量 C：

import time
import random

from threading import Thread

# 共用变量
C = 0

def job1(n=10):
    global C

    for idx in range(n):
        C += 1
        print('Job1: {}'.format(C))

def job2(n=10):
    global C

    for idx in range(n):
        C += 10
        print('Job2: {}'.format(C))

t1 = Thread(target=job1)
t2 = Thread(target=job2)

t1.start()
t2.start()

运行结果如下：

Job1: 1
Job2: 11
Job2: 21
Job1: 22
Job1: 23
Job2: 33
Job2: 43
Job1: 44
Job2: 54
Job1: 55
Job2: 65
Job1: 66
Job2: 76
Job2: 86
Job1: 87
Job1: 88
Job2: 98
Job1: 99
Job2: 109
Job1: 110

两个线程共用一个全局变量，两个线程根据自己执行的快慢对变量 C 进行修改。在增加锁后：

import time
import random

from threading import Lock

# 全局唯一锁
LOCK = Lock()

# 共用变量
C = 0

def job1_with_lock(n=10):
    global C, LOCK

    LOCK.acquire()

    for idx in range(n):
        C += 1
        print('Job1: {}'.format(C))
        time.sleep(random.random())

    LOCK.release()


def job2_with_lock(n=10):
    global C, LOCK

    LOCK.acquire()

    for idx in range(n):
        C += 10
        print('Job2: {}'.format(C))
        time.sleep(random.random())

    LOCK.release()

t1 = Thread(target=job1_with_lock)
t2 = Thread(target=job2_with_lock)

t1.start()
t2.start()

运行结果如下：

Job1: 1
Job1: 2
Job1: 3
Job1: 4
Job1: 5
Job1: 6
Job1: 7
Job1: 8
Job1: 9
Job1: 10
Job2: 20
Job2: 30
Job2: 40
Job2: 50
Job2: 60
Job2: 70
Job2: 80
Job2: 90
Job2: 100
Job2: 110

此时，由于 job1_with_lock 先拿到了锁，所以当执行时 job2_with_lock 无法获取到锁，就无法对 C 进行修改。只有当 job1_with_lock 执行完毕释放锁后，job2_with_lock 才能执行对 C 的修改操作。为了避免忘记释放锁，可以使用 with 上下文管理器来加锁。

可重入锁

在同一个线程中，我们可能会多次请求同一个资源，这称为嵌套锁。如果使用常规的方式：

from threading import Lock

def lock_with_lock(n=10):
    c = 0
    lock = Lock()

    with lock:
        for idx in range(n):
            c += 1
            with lock:
                print(c)

t = Thread(target=lock_with_lock)
t.start()

则无法正常运行，因为第二次获取锁时，锁已经被同一线程获取，从而无法运行后续代码。由于后续代码无法运行则无法释放锁，从而上述的嵌套锁会造成死锁。

为了解决这个问题，threading 模块提供了可重入锁 RLock：

from threading import RLock

def rlock_with_lock(n=10):
    c = 0
    lock = RLock()

    with lock:
        for idx in range(n):
            c += 1
            with lock:
                print(c)
  
t = Thread(target=rlock_with_lock)
t.start()

运行结果如下：

1
2
3
4
5
6
7
8
9
10

全局解释器锁

全局解释器锁（Global Interpreter Lock，GIL），是计算机程序设计语言解释器用于同步线程的一种机制，它使得任何时刻仅有一个线程在执行。

任何 Python 线程执行前，必须先获得 GIL 锁，然后，每执行 100 条字节码，解释器就自动释放 GIL 锁，让别的线程有机会执行。这个 GIL 全局锁实际上把所有线程的执行代码都给上了锁，所以，多线程在 Python 中只能交替执行，即使 100 个线程跑在 100 核 CPU 上，也只能用到 1 个核。

通信

Python 中实现线程中通信有如下 3 中方法：

Event 事件

threading.Event 可以创建一个事件变量，多个线程等待这个事件的发生，在事件发生后，所有线程继续运行。threading.Event 包含如下三个函数：

event = threading.Event()

# 重置 event，使得所有该 event 事件都处于待命状态
event.clear()

# 等待接收 event 的指令，决定是否阻塞程序执行
event.wait()

# 发送 event 指令，使所有设置该 event 事件的线程执行
event.set()

例如：

import time

from threading import Thread, Event

class EventThread(Thread):
    def __init__(self, name, event):
        super(EventThread, self).__init__()

        self.name = name
        self.event = event

    def run(self):
        print('线程 {} 启动于 {}'.format(self.name, time.ctime(time.time())))
        self.event.wait()
        print('线程 {} 结束于 {}'.format(self.name, time.ctime(time.time())))

threads = {}
event = Event()

for tid in range(3):
    threads[tid] = EventThread(str(tid), event)

event.clear()

for thread in threads.values():
    thread.start()

print('等待 3 秒钟 ...')
time.sleep(3)

print('唤醒所有线程 ...')
event.set() 

运行结果如下：

线程 0 启动于 Thu Apr  1 23:12:32 2021
线程 1 启动于 Thu Apr  1 23:12:32 2021
线程 2 启动于 Thu Apr  1 23:12:32 2021
等待 3 秒钟 ...
唤醒所有线程 ...
线程 0 结束于 Thu Apr  1 23:12:35 2021
线程 1 结束于 Thu Apr  1 23:12:35 2021
线程 2 结束于 Thu Apr  1 23:12:35 2021

可见线程启动后并未执行完成，而是卡在了 event.wait() 处，直到通过 event.set() 发送指令后，所有线程才继续向下执行。

Condition

threading.Condition 与 threading.Event 类似，包含如下 4 个函数：

cond = threading.Condition()

# 类似 lock.acquire()
cond.acquire()

# 类似 lock.release()
cond.release()

# 等待指定触发，同时会释放对锁的获取,直到被 notify 才重新占有琐。
cond.wait()

# 发送指定，触发执行
cond.notify()

以一个捉迷藏的游戏为例：

import time

from threading import Thread, Condition

class Seeker(Thread):
    def __init__(self, condition, name):
        super(Seeker, self).__init__()

        self.condition = condition
        self.name = name

    def run(self):
        time.sleep(1) # 确保先运行 Hider 中的方法

        self.condition.acquire()

        print('{}: 我把眼睛蒙好了'.format(self.name))
        self.condition.notify()
        self.condition.wait()
        print('{}: 我找到你了'.format(self.name))
        self.condition.notify()

        self.condition.release()
        print('{}: 我赢了'.format(self.name))


class Hider(Thread):
    def __init__(self, condition, name):
        super(Hider, self).__init__()

        self.condition = condition
        self.name = name

    def run(self):
        self.condition.acquire()

        self.condition.wait()
        print('{}: 我藏好了'.format(self.name))
        self.condition.notify()
        self.condition.wait()
        self.condition.release()
        print('{}: 被你找到了'.format(self.name))

condition = Condition()

seeker = Seeker(condition, 'Seeker')
hider = Hider(condition, 'Hider')

seeker.start()
hider.start()

运行结果如下：

Seeker: 我把眼睛蒙好了
Hider: 我藏好了
Seeker: 我找到你了
Seeker: 我赢了
Hider: 被你找到了

可见通过 cond.wait() 和 cond.notify() 进行阻塞和通知可以实现双方动作交替进行。

Queue 队列

从一个线程向另一个线程发送数据最安全的方式是使用 queue 库中的队列。创建一个被多个线程共享的队列对象，通过 put() 和 get() 方法向队列发送和获取元素。队列的常用方法如下：

from queue import Queue

# maxsize=0 表示不限大小
# maxsize>0 且消息数达到限制时，put() 方法会阻塞
q = Queue(maxsize=0)

# 默认阻塞程序，等待队列消息，可设置超时时间
q.get(block=True, timeout=None)

# 发送消息，默认会阻塞程序至队列中有空闲位置放入数据
q.put(item, block=True, timeout=None)

# 等待所有的消息都被消费完
q.join()

# 通知队列任务处理已经完成，当所有任务都处理完成时，join() 阻塞将会解除
q.task_done()

# 查询当前队列的消息个数
q.qsize()

# 队列消息是否都被消费完，返回 True/False
q.empty()

# 检测队列里消息是否已满
q.full()

以老师点名为例：

import time

from queue import Queue
from threading import Thread

class Student(object):
    def __init__(self, name):
        super(Student, self).__init__()

        self.name = name

    def speak(self):
        print('{}: 到'.format(self.name))


class Teacher(object):
    def __init__(self, queue):
        super(Teacher, self).__init__()

        self.queue = queue

    def call(self, student_name):
        if student_name == 'exit':
            print('老师: 点名结束，开始上课')
        else:
            print('老师: {}'.format(student_name))

        self.queue.put(student_name)


class CallManager(Thread):
    def __init__(self, queue):
        super(CallManager, self).__init__()

        self.students = {}
        self.queue = queue

    def put(self, student):
        self.students.setdefault(student.name, student)

    def run(self):
        while True:
            student_name = self.queue.get()

            if student_name == 'exit':
                break
            elif student_name in self.students:
                self.students[student_name].speak()
            else:
                print('学生: 老师，没有 {} 这个人'.format(student_name))

queue = Queue()

teacher = Teacher(queue=queue)
s1 = Student(name='张三')
s2 = Student(name='李四')

cm = CallManager(queue)
cm.put(s1)
cm.put(s2)

cm.start()

print('开始点名')
teacher.call('张三')
time.sleep(1)
teacher.call('李四')
time.sleep(1)
teacher.call('王五')
time.sleep(1)
teacher.call('exit')

运行结果如下：

开始点名
老师: 张三
张三: 到
老师: 李四
李四: 到
老师: 王五
学生: 老师，没有 王五 这个人
老师: 点名结束，开始上课

除了先进先出队列 queue.Queue 外，还有后进先出队列 queue.LifoQueue 和优先级队列 queue.PriorityQueue。

进程池和线程池

池是一组资源的集合，这组资源在服务器启动之初就被完全创建好并初始化，这称为静态资源分配。当服务器进入正式运行阶段，即开始处理客户请求的时候，如果它需要相关的资源，就可以直接从池中获取，无需动态分配。很显然，直接从池中取得所需资源比动态分配资源的速度要快得多，因为分配系统资源的系统调用都是很耗时的。

池的概念主要目的是为了重用：让线程或进程在生命周期内可以多次使用。它减少了创建创建线程和进程的开销，以空间换时间来提高了程序性能。重用不是必须的规则，但它是程序员在应用中使用池的主要原因。

Python 中利用 concurrent.futures 库中的 ThreadPoolExecutor 和 ProcessPoolExecutor 创建线程池和进程池。示例如下：

import time
import threading

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed


def print_func(n=3):
    for idx in range(n):
        print('运行 {}-{}'.format(threading.get_ident(), idx))
        time.sleep(1)


def return_func(n=3):
    res = []

    for idx in range(n):
        res.append('{}-{}'.format(threading.get_ident(), idx))
        time.sleep(1)

    return res


def test_thread_pool_print(n=3, m=12):
    with ThreadPoolExecutor(max_workers=n) as executor:
        for _ in range(m):
            executor.submit(print_func)


def test_process_pool_print(n=3, m=12):
    with ProcessPoolExecutor(max_workers=n) as executor:
        for _ in range(m):
            executor.submit(print_func)


def test_thread_pool_return(n=3, m=12):
    with ThreadPoolExecutor(max_workers=n) as executor:
        futures = [executor.submit(return_func) for _ in range(m)]

        for future in as_completed(futures):
            print(future.result())


def test_process_pool_return(n=3, m=12):
    with ProcessPoolExecutor(max_workers=n) as executor:
        futures = [executor.submit(return_func) for _ in range(m)]

        for future in as_completed(futures):
            print(future.result())


line_sep = '-' * 60

print(line_sep)
print('测试线程池')
print(line_sep)
test_thread_pool_print()
print(line_sep)

print(line_sep)
print('测试进程池')
print(line_sep)
test_process_pool_print()
print(line_sep)

print(line_sep)
print('测试线程池')
print(line_sep)
test_thread_pool_return()
print(line_sep)

print(line_sep)
print('测试进程池')
print(line_sep)
test_process_pool_return()
print(line_sep)

运行结果如下：

------------------------------------------------------------
测试线程池
------------------------------------------------------------
运行 123145462505472-0
运行 123145479294976-0
运行 123145496084480-0
运行 123145496084480-1
运行 123145462505472-1
运行 123145479294976-1
运行 123145496084480-2
运行 123145462505472-2
运行 123145479294976-2
运行 123145462505472-0
运行 123145479294976-0
运行 123145496084480-0
运行 123145479294976-1
运行 123145462505472-1
运行 123145496084480-1
运行 123145479294976-2
运行 123145462505472-2
运行 123145496084480-2
------------------------------------------------------------
------------------------------------------------------------
测试进程池
------------------------------------------------------------
运行 4545199616-0
运行 4545199616-1
运行 4545199616-2
运行 4545199616-0
运行 4545199616-1
运行 4545199616-2
运行 4663131648-0
运行 4663131648-1
运行 4663131648-2
运行 4663131648-0
运行 4663131648-1
运行 4663131648-2
运行 4633173504-0
运行 4633173504-1
运行 4633173504-2
运行 4633173504-0
运行 4633173504-1
运行 4633173504-2
------------------------------------------------------------
------------------------------------------------------------
测试线程池
------------------------------------------------------------
['123145496084480-0', '123145496084480-1', '123145496084480-2']
['123145479294976-0', '123145479294976-1', '123145479294976-2']
['123145462505472-0', '123145462505472-1', '123145462505472-2']
['123145479294976-0', '123145479294976-1', '123145479294976-2']
['123145496084480-0', '123145496084480-1', '123145496084480-2']
['123145462505472-0', '123145462505472-1', '123145462505472-2']
------------------------------------------------------------
------------------------------------------------------------
测试进程池
------------------------------------------------------------
['4791307776-0', '4791307776-1', '4791307776-2']
['4588228096-0', '4588228096-1', '4588228096-2']
['4654599680-0', '4654599680-1', '4654599680-2']
['4791307776-0', '4791307776-1', '4791307776-2']
['4588228096-0', '4588228096-1', '4588228096-2']
['4654599680-0', '4654599680-1', '4654599680-2']
------------------------------------------------------------

其中，submit() 方法用于提交要执行的任务到线程池或进程池中，并返回该任务的 Future 对象。Future 对象的 done() 方法用于判断任务是否执行完毕，通过 result(timeout=None) 方法获取返回结果。利用 concurrent.futures.as_completed() 方法可以返回一个包含指定 Future 实例的迭代器，这些实例在完成时生成 Future 对象。

生成器和迭代器

容器是一种把多个元素组织在一起的数据结构，容器中的元素可以逐个迭代获取，可以用 in 或 not in 判断元素是否包含在容器中。常见的容器对象有：

list, deque, ...
set, frozensets, ...
dict, defaultdict, OrderedDict, Counter, ...
tuple, namedtuple, ...
str

可迭代对象

很多容器都是可迭代对象，此外还有更多的对象同样也可以是可迭代对象，比如处于打开状态的 file 和 socket 等。凡是可以返回一个迭代器的对象都可称之为可迭代对象，例如：

from collections import deque
from collections.abc import Iterable

print(isinstance('Leo Van', Iterable))
print(isinstance([1, 2, 3], Iterable))
print(isinstance({'k1': 'v1', 'k2': 'v2'}, Iterable))
print(isinstance(deque('abc'), Iterable))

运行结果如下：

True
True
True
True

迭代器

迭代器是一个带有状态的对象，通过 next() 方法可以返回容器中的下一个值。任何实现 __iter__() 和 __next__() 方法的对象都是迭代器。其中，__iter__() 方法返回迭代器本身，__next__() 方法返回容器中的下一个值，如果容器中没有更多元素了，则抛出 StopIteration 异常。例如：

class MyList(object):
    def __init__(self, end):
        super(MyList, self).__init__()

        self.end = end

    def __iter__(self):
        return MyListIterator(self.end)

    def __repr__(self):
        return '[{}]'.format(', '.join([str(ele) for ele in self]))


class MyListIterator(object):
    def __init__(self, end):
        super(MyListIterator, self).__init__()

        self.data = end
        self.start = 0

    def __iter__(self):
        return self

    def __next__(self):
        while self.start < self.data:
            self.start += 1
            return self.start - 1

        raise StopIteration

my_list = MyList(3)

print('MyList: {}'.format(my_list))
print(isinstance(my_list, Iterable))
print(isinstance(my_list, Iterator))

for ele in my_list:
    print(ele)

my_list_iterator = MyListIterator(3)

print('MyListIterator: {}'.format(my_list_iterator))
print(isinstance(my_list_iterator, Iterable))
print(isinstance(my_list_iterator, Iterator))

my_iterator = iter(my_list)

print('MyIterator: {}'.format(my_iterator))
print(isinstance(my_iterator, Iterable))
print(isinstance(my_iterator, Iterator))

while True:
    try:
        print(next(my_iterator))
    except StopIteration as e:
        return

运行结果如下：

MyList: [0, 1, 2]
True
False
0
1
2
MyListIterator: <__main__.MyListIterator object at 0x7fc9602b2100>
True
True
0
1
2
MyIterator: <__main__.MyListIterator object at 0x7fc9602b2fa0>
True
True
0
1
2
Stop

生成器

生成器非常类似于返回数组的函数，都是具有参数、可被调用、产生一系列的值。但是生成器并不是构造出数组包含所有的值并一次性返回，而是每次产生一个值，因此生成器看起来像函数，但行为像迭代器。

Python 中创建生成器有两种方法：使用类似列表方式或 yield 关键字：

from collections.abc import Generator
from inspect import getgeneratorstate

a_list = [x for x in range(10)]
print(a_list)
print(isinstance(a_list, Generator))

a_generator = (x for x in range(10))
print(a_generator)
print(isinstance(a_generator, Generator))

def my_yield(n):
    now = 0

    while now < n:
        yield now
        now += 1

    raise StopIteration

gen = my_yield(4)
print(gen)
print(isinstance(gen, Generator))

运行结果如下：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
False
<generator object <genexpr> at 0x7fdf84a8a430>
True
<generator object my_yield at 0x7fdf86a03f20>
True

由于生成器并不是一次生成所有元素，而是每次执行后返回一个值，通过 next() 和 generator.send(None) 两个方法可以激活生成器，例如：

def my_yield(n):
    now = 0

    while now < n:
        yield now
        now += 1

    raise StopIteration

gen = my_yield(4)
print(gen.send(None))
print(next(gen))
print(gen.send(None))
print(next(gen))

运行结果如下：

0
1
2
3

生成器在其生命周期中共有 4 种状态：

• GEN_CREATED：已创建
• GEN_RUNNING：正在执行（只在多线程应用中能看到该状态）
• GEN_SUSPENDED：暂停中
• GEN_CLOSED：已关闭

例如：

from collections.abc import Generator
from inspect import getgeneratorstate

def my_yield(n):
    now = 0

    while now < n:
        yield now
        now += 1

    raise StopIteration

gen = my_yield(4)
print(gen)
print(getgeneratorstate(gen))

print(gen.send(None))
print(next(gen))
print(getgeneratorstate(gen))

print(gen.send(None))
print(next(gen))
print(getgeneratorstate(gen))

gen.close()
print(getgeneratorstate(gen))

运行结果如下：

GEN_CREATED
0
1
GEN_SUSPENDED
2
3
GEN_SUSPENDED
GEN_CLOSED

生成器在不满足生成元素的条件时，会抛出 StopIteration 异常，通过类似列表形式构建的生成器会自动实现该异常，自定的生成器则需要手动实现该异常。

协程

yield

协程通过 yield 暂停生成器，可以将程序的执行流程交给其他子程序，从而实现不同子程序之间的交替执行。例如：

def jump_range(n):
    idx = 0

    while idx < n:
        jump = yield idx
        print('[idx: {}, jump: {}]'.format(idx, jump))

        if jump is None:
            jump = 1

        idx += jump

itr = jump_range(6)
print(next(itr))
print(itr.send(2))
print(next(itr))
print(itr.send(-1))
print(next(itr))
print(next(itr))

运行结果如下：

0
[idx: 0, jump: 2]
2
[idx: 2, jump: None]
3
[idx: 3, jump: -1]
2
[idx: 2, jump: None]
3
[idx: 3, jump: None]
4

yield idx 将 idx 返回给外部调用程序，jump = yield 可以接受外部程序通过 send() 发送的信息，并将其赋值给 jump。

yield from 是 Python 3.3 之后出现的新语法，后面是可迭代对象，可以是普通的可迭代对象，也可以是迭代器，甚至是生成器。yield 和 yield from 的对比如下：

a_str = 'Leo'
a_list = [1, 2, 3]
a_dict = {'name': 'Leo', 'gender': 'Male'}
a_gen = (idx for idx in range(4, 8))

def gen(*args, **kwargs):
    for item in args:
        for ele in item:
            yield ele

new_gen = gen(a_str, a_list, a_dict, a_gen)
print(list(new_gen))

a_gen = (idx for idx in range(4, 8))

def gen_from(*args, **kwargs):
    for item in args:
        yield from item

new_gen = gen_from(a_str, a_list, a_dict, a_gen)
print(list(new_gen))

运行结果如下：

['L', 'e', 'o', 1, 2, 3, 'name', 'gender', 4, 5, 6, 7]
['L', 'e', 'o', 1, 2, 3, 'name', 'gender', 4, 5, 6, 7]

在实现生成器的嵌套时，使用 yield from 可以比使用 yield 避免各种意想不到的异常。使用 yield from 时，需要关注如下几个概念：

• 调用方：调用委托生成器的代码
• 委托生成器：包含 yield from 表达式的生成器函数
• 子生成器：yield from 后面的生成器函数

如下是一个计算平均数的例子：

# 子生成器
def average_gen():
    total = 0
    count = 0
    average = 0

    while True:
        num = yield average

        if num is None:
            break

        count += 1
        total += num
        average = total / count

    return total, count, average

# 委托生成器
def proxy_gen():
    while True:
        total, count, average = yield from average_gen()
        print('计算完毕，共输入 {} 个数值，总和 {}，平均值 {}'.format(
            count, total, average))

# 调用方
calc_average = proxy_gen()
next(calc_average)
print(calc_average.send(10))
print(calc_average.send(20))
print(calc_average.send(30))
calc_average.send(None)

运行结果如下：

10.0
15.0
20.0
计算完毕，共输入 3 个数值，总和 60，平均值 20.0

委托生成器的作用是在调用方和子生成器之间建立一个双向通道，调用方通过 send() 将消息发送给子生成器，子生成器 yield 的值则返回给调用方。yield from 背后为整个过程做了很多操作，例如：捕获 StopIteration 异常等。

asyncio

asyncio 是 Python 3.4 引入的标准库，直接内置了对异步 IO 的支持。只要在一个函数前面加上 async 关键字就可以将一个函数变为一个协程。例如：

from collections.abc import Coroutine

async def async_func(name):
    print('Hello, ', name)

coroutine = async_func('World')
print(isinstance(coroutine, Coroutine))

运行结果如下：

True

利用 asyncio.coroutine 装饰器可以将一个生成器当作协程使用，但其本质仍旧是一个生成器。例如：

import asyncio

from collections.abc import Generator, Coroutine

@asyncio.coroutine
def coroutine_func(name):
    print('Hello,', name)
    yield from asyncio.sleep(1)
    print('Bye,', name)


coroutine = coroutine_func('World')
print(isinstance(coroutine, Generator))
print(isinstance(coroutine, Coroutine))

运行结果如下：

True
False

asyncio 中包含如下几个重要概念：

• event_loop 事件循环：程序开启一个无限的循环，协程将注册到事件循环上，当满足事件发生时，调用相应的协程函数。
• coroutine 协程：一个使用 async 定义的协程函数，它的调用不会立即执行，而是会返回一个协程对象。协程对象需要注册到事件循环上，由事件循环控制调用。
• future 对象：代表将来执行或没有执行的对象。它和 task 对象没有本质上的区别。
• task 对象：一个协程对象是一个原生可以挂起的函数，任务是对协程的进一步封装，其中包含任务的各种状态。Task 对象是 Future 的子类，它将 coroutine 和 Future 联系在一起，将 coroutine 封装成为一个 Future 对象。
• async / await 关键字：async 定义一个协程，await 用于挂起阻塞的异步调用接口。

协程完整的工作流程如下：

import asyncio

async def hello(name):
    print('Hello,', name)
    
# 定义协程
coroutine = hello('World')

# 定义事件循环
loop = asyncio.get_event_loop()

# 创建任务
task = loop.create_task(coroutine)

# 将任务交由时间循环并执行
loop.run_until_complete(task)

运行结果如下：

Hello, World

await 用于挂起阻塞的异步调用接口，其作用在一定程度上类似于 yield。yield from 后面可接可迭代对象，也可接 future 对象或协程对象；await 后面必须接 future 对象或协程对象。

import asyncio
from asyncio.futures import Future

async def hello(name):
    await asyncio.sleep(2)
    print('Hello, ', name)

coroutine = hello("World")

# 将协程转为 task 对象
task = asyncio.ensure_future(coroutine)

print(isinstance(task, Future))

运行结果如下：

True

异步 IO 的实现原理就是在 IO 高的地方挂起，等 IO 结束后再继续执行。绝大部分情况下，后续代码的执行是需要依赖 IO 的返回值的，这就需要使用回调。

回调的实现有两种，一种是在同步编程中直接获取返回结果：

import asyncio
import time

async def _sleep(x):
    time.sleep(x)
    return '暂停了 {} 秒'.format(x)

coroutine = _sleep(2)
loop = asyncio.get_event_loop()
task = asyncio.ensure_future(coroutine)

loop.run_until_complete(task)
print('返回结果：{}'.format(task.result()))

运行结果如下：

返回结果：暂停了 2 秒

另一种是通过添加回调函数来实现：

import asyncio
import time

async def _sleep(x):
    time.sleep(x)
    return '暂停了 {} 秒'.format(x)

def callback(future):
    print('回调返回结果：{}'.format(future.result()))

coroutine = _sleep(2)
loop = asyncio.get_event_loop()
task = asyncio.ensure_future(coroutine)

task.add_done_callback(callback)
loop.run_until_complete(task)

运行结果如下：

回调返回结果：暂停了 2 秒

asyncio 实现并发需要多个协程来完成，每当有任务阻塞时需要 await，然后让其他协程继续工作。

import asyncio

async def do_some_work(x):
    print('等待中 ...')
    await asyncio.sleep(x)
    print('{} 秒后结束'.format(x))
    return x

# 协程对象
coroutine1 = do_some_work(1)
coroutine2 = do_some_work(2)
coroutine3 = do_some_work(4)

# 任务列表
tasks = [
    asyncio.ensure_future(coroutine1),
    asyncio.ensure_future(coroutine2),
    asyncio.ensure_future(coroutine3)
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

for task in tasks:
    print('任务结果：{}'.format(task.result()))

运行结果如下：

等待中 ...
等待中 ...
等待中 ...
1 秒后结束
2 秒后结束
4 秒后结束
任务结果：1
任务结果：2
任务结果：4

协程之间可以进行嵌套，即在一个协程中 await 另一个协程：

import asyncio

async def do_some_work(x):
    print('等待中 ...')
    await asyncio.sleep(x)
    print('{} 秒后结束'.format(x))
    return x

async def out_do_some_work():
    coroutine1 = do_some_work(1)
    coroutine2 = do_some_work(2)
    coroutine3 = do_some_work(4)

    tasks = [
        asyncio.ensure_future(coroutine1),
        asyncio.ensure_future(coroutine2),
        asyncio.ensure_future(coroutine3)
    ]

    dones, pendings = await asyncio.wait(tasks)

    for task in dones:
        print('任务结果：{}'.format(task.result()))

loop = asyncio.get_event_loop()
loop.run_until_complete(out_do_some_work())

如果使用 asyncio.gather() 来获取结果，则需要对获取结果部分做如下修改：

results = await asyncio.gather(*tasks)
for result in results:
    print('任务结果：{}'.format(result))

asyncio.wait() 返回 dones 和 pendings，分别表示已完成和未完成的任务；asyncio.gather() 则会把结果直接返回。

运行结果如下：

等待中 ...
等待中 ...
等待中 ...
1 秒后结束
2 秒后结束
4 秒后结束
任务结果：1
任务结果：4
任务结果：2

协程（准确的说是 Future 或 Task 对象）包含如下状态：

• Pending：已创建，未执行
• Running：执行中
• Done：执行完毕
• Cancelled：被取消

测试代码如下：

coroutine = _sleep(10)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)

print('Pending')

try:
    t = Thread(target=loop.run_until_complete, args=(task, ))
    t.start()
    print('Running')
    t.join()
except KeyboardInterrupt as e:
    task.cancel()
    print('Cancel')
finally:
    print('Done')

执行顺利的话，运行结果如下：

Pending
Running
Done

如果在启动后按下 Ctrl + C 则会触发 task.cancel()，运行结果如下：

Pending
Running
Cancelled
Done

asyncio.wait() 可以通过参数控制何时返回：

import random
import asyncio

async def random_sleep():
    await asyncio.sleep(random.uniform(0.5, 6))

loop = asyncio.get_event_loop()
tasks = [random_sleep() for _ in range(1, 10)]

dones, pendings = loop.run_until_complete(asyncio.wait(
    tasks, return_when=asyncio.FIRST_COMPLETED))
print('第一次完成的任务数：{}'.format(len(dones)))

dones, pendings = loop.run_until_complete(asyncio.wait(
    pendings, timeout=2))
print('第二次完成的任务数: {}'.format(len(dones)))

dones, pendings = loop.run_until_complete(asyncio.wait(pendings))
print('第三次完成的任务数：{}'.format(len(dones)))

运行结果如下：

第一次完成的任务数：1
第二次完成的任务数: 4
第三次完成的任务数：4

Python 实现篇请参见：进程，线程和协程 (Process, Thread and Coroutine) - 实现篇

进程，线程和协程

**进程（Process）**是计算机中已运行的程序 ¹。**线程（Thread）**是操作系统能够进行运算调度的最小单位。大部分情况下，线程被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务 ²。

进程和线程之间的主要区别在于：

1. 线程共享创建其进程的地址空间，进程使用自己的地址。
2. 线程可以直接访问进程的数据，进程使用其父进程数据的副本。
3. 线程可以同其进程中其他线程直接通信，进程必须使用**进程间通讯（inter-process communicate, IPC）**与同级进程通信。
4. 线程开销较小，进程开销较大。
5. 线程的创建较为容易，进程需要复制其父进程。
6. 线程可以控制相同进程的其他线程，进程只能控制其子进程。
7. 对于主线程的修改（例如：取消、优先级修改等）可能会影响进程中的其他线程，对于父进程的修改不会影响其子进程。

单线程进程和多线程进程之间的对比如下图所示：

一个关于进程和线程的形象类比如下 ³：

1. 计算机的核心是 CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。
2. 假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个 CPU 一次只能运行一个任务。
3. 进程就好比工厂的车间，它代表 CPU 所能处理的单个任务。任一时刻，CPU 总是运行一个进程，其他进程处于非运行状态。
4. 一个车间里，可以有很多工人。他们协同完成一个任务。
5. 线程就好比车间里的工人。一个进程可以包括多个线程。
6. 车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享内存。
7. 可是，每间房间的大小不同，有些房间最多只能容纳一个人，比如厕所。里面有人的时候，其他人就不能进去了。这代表一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。
8. 一个防止他人进入的简单方法，就是门口加一把锁。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫“互斥锁”（Mutual Exclusion，Mutex），防止多个线程同时读写某一块内存区域。
9. 还有些房间，可以同时容纳 $n$ 个人，比如厨房。也就是说，如果人数大于 $n$，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。
10. 这时的解决方法，就是在门口挂 $n$ 把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做“信号量”（Semaphore），用来保证多个线程不会互相冲突。不难看出，Mutex 是 Semaphore 的一种特殊情况（$n = 1$ 时）。也就是说，完全可以用后者替代前者。但是，因为 Mutex 较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。
11. 操作系统的设计，因此可以归结为三点：(1). 以多进程形式，允许多个任务同时运行；(2). 以多线程形式，允许单个任务分成不同的部分运行；(3). 提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。

协程（Coroutine）是计算机程序的一类组件，推广了协作式多任务的子例程，允许执行被挂起与被恢复。相对子例程而言，协程更为一般和灵活，但在实践中使用没有子例程那样广泛。协程更适合于用来实现彼此熟悉的程序组件，如协作式多任务、异常处理、事件循环、迭代器、无限列表和管道。

子例程（Subroutine），是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

协程和子例程的执行过程对比如下：

• 子例程可以调用其他子例程，调用者等待被调用者结束后继续执行，故而子例程的生命期遵循后进先出，即最后一个被调用的子例程最先结束返回。协程的生命期完全由对它们的使用需要来决定。
• 子例程的起始处是惟一的入口点，每当子例程被调用时，执行都从被调用子例程的起始处开始。协程可以有多个入口点，协程的起始处是第一个入口点，每个 yield 返回出口点都是再次被调用执行时的入口点。
• 子例程只在结束时一次性的返回全部结果值。协程可以在 yield 时不调用其他协程，而是每次返回一部分的结果值，这种协程常称为生成器或迭代器。

协程类似于线程，但是协程是协作式多任务的，而线程是抢占式多任务的。这意味着协程提供并发性而非并行性。协程超过线程的好处是它们可以用于硬性实时的语境（在协程之间的切换不需要涉及任何系统调用或任何阻塞调用），这里不需要用来守卫临界区段的同步原语比如互斥锁、信号量等，并且不需要来自操作系统的支持。

通信

进程间通信

管道

管道（Pipeline）是一系列将标准输入输出链接起来的进程，其中每一个进程的输出被直接作为下一个进程的输入。 例如：

ls -l | less

ls 用于在 Unix 下列出目录内容，less 是一个有搜索功能的交互式的文本分页器。这个管道使得用户可以在列出的目录内容比屏幕长时目录上下翻页。

命名管道

命名管道是计算机进程间的一种先进先出通信机制。是类 Unix 系统传统管道的扩展。传统管道属于匿名管道，其生存期不超过创建管道的进程的生存期。但命名管道的生存期可以与操作系统运行期一样长。

信号

信号（Signals）是 Unix、类 Unix 以及其他 POSIX 兼容的操作系统中进程间通讯的一种有限制的方式。它是一种异步的通知机制，用来提醒进程一个事件已经发生。当一个信号发送给一个进程，操作系统中断了进程正常的控制流程，此时，任何非原子操作都将被中断。如果进程定义了信号的处理函数，那么它将被执行，否则就执行默认的处理函数。

例如，在一个运行的程序的控制终端键入特定的组合键可以向它发送某些信号：Ctrl + C 发送 INT 信号（SIGINT），这会导致进程终止；Ctrl + Z 发送 TSTP 信号（SIGTSTP），这会导致进程挂起。

消息队列

消息队列提供了异步的通信协议，每一个贮列中的纪录包含详细说明的资料，包含发生的时间，输入设备的种类，以及特定的输入参数，也就是说：消息的发送者和接收者不需要同时与消息队列交互。消息会保存在队列中，直到接收者取回它。

消息队列本身是异步的，它允许接收者在消息发送很长时间后再取回消息。和信号相比，消息队列能够传递更多的信息。与管道相比，消息队列提供了有格式的数据，这可以减少开发人员的工作量。

信号量

信号量（Semaphore）又称为信号标，是一个同步对象，用于保持在 0 至指定最大值之间的一个计数值。当线程完成一次对该 Semaphore 对象的等待（wait）时，该计数值减一；当线程完成一次对 Semaphore 对象的释放（release）时，计数值加一。当计数值为 0，则线程等待该 Semaphore 对象不再能成功直至该 Semaphore 对象变成 signaled 状态。Semaphore 对象的计数值大于 0，为 signaled 状态；计数值等于 0，为 nonsignaled 状态.

共享内存

共享内存指可被多个进程存取的内存，一个进程是一段程序的单个运行实例。在这种情况下，共享内存被用作进程间的通讯。

伯克利套接字

伯克利套接字（Internet Berkeley Sockets），又称为 BSD 套接字是一种应用程序接口，主要用于实现进程间通讯，在计算机网络通讯方面被广泛使用。

线程间通信

锁机制

• 互斥锁：互斥锁（Mutual Exclusion，Mutex）是一种用于多线程编程中，防止两条线程同时对同一公共资源（比如全局变量）进行读写的机制。
• 条件锁：读写锁是计算机程序的并发控制的一种同步机制，用于解决读写问题。读操作可并发重入，写操作是互斥的。
• 条件变量：条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待“条件变量的条件成立”而挂起；另一个线程使“条件成立”（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。
• 自旋锁：自旋锁是用于多线程同步的一种锁，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。

信号

同上文。

信号量

同上文。

卷积神经网络（CNN）在图像领域取得了很大的成功，但同时也存在一定的缺陷。卷积层中的卷积核对输入图像利用卷积运算提取其中的特征。卷积核以一个较小的尺寸并以一定的步长在图像上移动得到特征图。步长越大，特征图的尺寸就越小，过大的步长会丢失部分图像中的特征。池化层作用于产生的特征图上，使得 CNN 可以在不同形式的图像中识别出相同的物体，为 CNN 引入了空间不变性。

CNN 最大的缺陷就是忽略了不同特征之间的相对位置，从而无法从图像中识别出姿势、纹理和变化。CNN 中的池化操作使得模型具有空间不变性，因此模型就不具备等变性。以下图为例，CNN 会把第一幅和第二幅识别为人脸，而将第三幅方向翻转的图识别为不是人脸。池化操作造成了部分信息的丢失，因此需要更多的训练数据来补偿这些损失。

等变和不变

对于一个函数 $f$ 和一个变换 $g$，如果有：

$$ f \left(g \left(x\right)\right) = g \left(f \left(x\right)\right) $$

则称 $f$ 对变换 $g$ 有等变性。

例如，变换 $g$ 为将图像向左平移若干像素，函数 $f$ 表示检测一个人脸的位置。则 $f \left(g \left(x\right)\right)$ 表示先将图片左移，我们将在原图的左侧检测到人脸；$g \left(f \left(x\right)\right)$ 表示先检测人脸位置，然后将人脸位置左移。这两者的输出结果是一样的，与我们施加变换的顺序无关。CNN 中的卷积操作使得它对平移操作具有等变性。

对于一个函数 $f$ 和一个变换 $g: g \left(x\right) = x'$，如果有：

$$ f \left(x\right) = f \left(x'\right) = f \left(g \left(x\right)\right) $$

则称 $f$ 对变换 $g$ 有不变性。

例如，变换 $g$ 为旋转或平移，函数 $f$ 表示检测图中是否有黑色，那么这些变换不会对函数结果有任何影响，可以说函数对该变换具有不变性。CNN 中的池化操作对平移操作具有近似不变性。

逆图形

计算机图形学根据几何数据的内部层次结构来构造可视图像，该表示的结构将对象的相对位置考虑在内。软件采用层次的表示方式将其渲染为屏幕上的图像。人类大脑的工作原理则与渲染过程相反，我们称其为逆图形。大脑中对象的表示并不依赖于视角。

例如下图，人眼可以很容易的分辨出是自由女神像，只是角度不同，但 CNN 却很难做到，因为它不理解 3D 空间的内在。

胶囊网络

胶囊

在引入“胶囊”这个概念的第一篇文献 Transforming Auto-encoders ¹ 中，Hinton 等人对胶囊概念理解如下：

人工神经网络不应当追求“神经元”活动中的视角不变性（使用单一的标量输出来总结一个局部池中的重复特征检测器的活动），而应当使用局部的“胶囊”，这些胶囊对其输入执行一些相当复杂的内部计算，然后将这些计算的结果封装成一个包含信息丰富的输出的小向量。每个胶囊学习辨识一个有限的观察条件和变形范围内隐式定义的视觉实体，并输出实体在有限范围内存在的概率及一组“实例参数”，实例参数可能包括相对这个视觉实体的隐式定义的典型版本的精确的位姿、照明条件和变形信息。当胶囊工作正常时，视觉实体存在的概率具有局部不变性——当实体在胶囊覆盖的有限范围内的外观流形上移动时，概率不会改变。实例参数却是“等变的”——随着观察条件的变化，实体在外观流形上移动时，实例参数也会相应地变化，因为实例参数表示实体在外观流形上的内在坐标。

人造神经元输出单个标量。对于 CNN 卷积层中的每个卷积核，对整个输入图复制同一个内核的权重输出一个二维矩阵。矩阵中每个数字是该卷积核对输入图像一部分的卷积，这个二维矩阵看作是重复特征检测器的输出。所有卷积核的二维矩阵堆叠在一起得到卷积层的输出。CNN 利用最大池化实现不变性，但最大池化丢失了有价值的信息，也没有编码特征之间的相对空间关系。

胶囊将特征检测的概率作为其输出向量的长度进行编码，检测出的特征的状态被编码为该向量指向的方向。当检测出的特征在图像中移动或其状态发生变化时，概率仍然保持不变（向量的长度没有改变），但它的方向改变了。

下表总结了胶囊和神经元的不同：

		Capsule	Traditional Neuron
Input from low-level capsule/neuron		$\text{vector}\left(\mathbf{u}_i\right)$	$\text{scalar}\left(x_i\right)$
Operration	Affine Transform	$\widehat{\mathbf{u}}_{j \mid i}=\mathbf{W}_{i j} \mathbf{u}_{i}$	-
	Weighting	$\mathbf{s}_{j}=\sum_{i} c_{i j} \widehat{\mathbf{u}}_{j \mid i}$	$a_{j}=\sum_{i} w_{i} x_{i}+b$
	Sum
	Nonlinear Activation	$\mathbf{v}_{j}=\dfrac{\left\|\mathbf{s}_{j}\right\|^{2}}{1+\left\|\mathbf{s}_{j}\right\|^{2}} \dfrac{\mathbf{s}_{j}}{\left\|\mathbf{s}_{j}\right\|}$	$h_{j}=f\left(a_{j}\right)$
Output		$\text{vector}\left(\mathbf{v}_j\right)$	$\text{scalar}\left(h_j\right)$

人造神经元包含如下 3 个计算步骤：

1. 输入标量的加权
2. 加权标量的求和
3. 求和标量到输出标量的非线性变换

胶囊可以理解为上述 3 个步骤的向量版，同时增加了对输入的仿射变换：

1. 输入向量的矩阵乘法：胶囊接受的输入向量编码了低层胶囊检测出的相应对象的概率，向量的方向编码了检测出的对象的一些内部状态。接着将这些向量乘以相应的权重矩阵 $\mathbf{W}$，$\mathbf{W}$ 编码了低层特征（例如：眼睛、嘴巴和鼻子）和高层特征（例如：面部）之间的空间关系和其他重要关系。
2. 向量的标量加权：这个步骤同人造神经元对应的步骤类似，但神经元的权重是通过反向传播学习的，而胶囊则使用动态路由。
3. 加权向量的求和：这个步骤同人造神经元对应的步骤类似。
4. 求和向量到输出向量的非线性变换：胶囊神经网络的非线性激活函数接受一个向量，然后在不改变方向的前提下，将其长度压缩到 1 以下。

动态路由

胶囊网络使用动态路由算法进行训练，算法过程如下 ²：

\begin{algorithm}
\caption{Routing 算法}
\begin{algorithmic}
\PROCEDURE{Routing}{$\widehat{\mathbf{u}}_{j | i}, r, l$}
\STATE for all capsule $i$ in layer $l$ and capsule $j$ in layer $\left(l + 1\right)$: $b_{ij} \gets 0$
\FOR{$r$ iterations}
  \STATE for all capsule $i$ in layer $l$: $\mathbf{c}_i \gets \text{softmax} \left(\mathbf{b}_i\right)$
  \STATE for all capsule $j$ in layer $\left(l + 1\right)$: $\mathbf{s}_j \gets \sum_{i} c_{ij} \widehat{\mathbf{u}}_{j | i}$
  \STATE for all capsule $j$ in layer $\left(l + 1\right)$: $\mathbf{v}_j \gets \text{squash} \left(\mathbf{s}_j\right)$
  \STATE for all capsule $i$ in layer $l$ and capsule $j$ in layer $\left(l + 1\right)$: $b_{ij} \gets b_{ij} + \widehat{\mathbf{u}}_{j | i} \cdot \mathbf{v}_j$
\ENDFOR
\RETURN $\mathbf{v}_j$
\ENDPROCEDURE
\end{algorithmic}
\end{algorithm}

1. 第 1 行表示算法的输入为：低层 $l$ 中所有胶囊的输出 $\widehat{\mathbf{u}}$，以及路由迭代计数 $r$。
2. 第 2 行中的 $b_{ij}$ 为一个临时变量，其值在迭代过程中更新，算法运行完毕后其值被保存在 $c_{ij}$ 中。
3. 第 3 行表示如下步骤将会被重复 $r$ 次。
4. 第 4 行利用 $\mathbf{b}_i$ 计算低层胶囊的权重向量 $\mathbf{c}_i$。$\text{softmax}$ 确保了所有权重为非负数，且和为一。第一次迭代后，所有系数 $c_{ij}$ 的值相等，随着算法的继续，这些均匀分布将发生改变。
5. 第 5 行计算经前一步确定的路由系数 $c_{ij}$ 加权后的输入向量的线性组合。该步缩小输入向量并将他们相加，得到输出向量 $\mathbf{s}_j$。
6. 第 6 行对前一步的输出向量应用 $\text{squash}$ 非线性函数。这确保了向量的方向被保留下来，而长度被限制在 1 以下。
7. 第 7 行通过观测低层和高层的胶囊，根据公式更新相应的权重 $b_{ij}$。胶囊 $j$ 的当前输出与从低层胶囊 $i$ 处接收到的输入进行点积，再加上旧的权重作为新的权重。点积检测胶囊输入和输出之间的相似性。
8. 重复 $r$ 次，计算出所有高层胶囊的输出，并确立路由权重。之后正向传导就可以推进到更高层的网络。

点积运算接收两个向量，并输出一个标量。对于给定长度但方向不同的两个向量而言，点积有几种情况：$a$ 最大正值；$b$ 正值；$c$ 零；$d$ 负值；$e$ 最小负值，如下图所示：

我们用紫色向量 $\mathbf{v}_1$ 和 $\mathbf{v}_2$ 表示高层胶囊，橙色向量表示低层胶囊的输入，其他黑色向量表示接收自其他低层胶囊的输入，如下图所示：

左侧的紫色输出 $\mathbf{v}_1$ 和橙色输入 $\widehat{\mathbf{u}}_{1|1}$ 指向相反的方向，这意味着他们的点积是一个负数，从而路由系数 $c_{11}$ 减少；右侧的紫色输出 $\mathbf{v}_2$ 和橙色输入 $\widehat{\mathbf{u}}_{2|1}$ 指向相同的方向，从而路由系数 $c_{12}$ 增加。在所有高层胶囊及其所有输入上重复该过程，得到一个路由系数集合，达成了来自低层胶囊的输出与高层胶囊的输出的最佳匹配。

网络架构

胶囊网络由 6 层神经网络构成，前 3 层是编码器，后 3 层是解码器：

1. 卷积层
2. PrimaryCaps（主胶囊）层
3. DigitCaps（数字胶囊）层
4. 第一全连接层
5. 第二全连接层
6. 第三全连接层

编码器

编码器部分如下图所示：

卷积层用于检测 2D 图像的基本特征。PrimaryCaps 层包含 32 个主胶囊，接收卷积层检测到的基本特征，生成特征的组合。DigitCaps 层包含 10 个数字胶囊，每个胶囊对应一个数字。

对于 $k$ 个类别的数字，我们希望最高层的胶囊当且仅当一个数字出现在图像中时具有一个长的实例化向量。为了允许多个数字，对于每个 DigitCap 使用一个独立的损失函数：

$$ L_{k}=T_{k} \max \left(0, m^{+}-\left\|\mathbf{v}_{k}\right\|\right)^{2}+\lambda\left(1-T_{k}\right) \max \left(0,\left\|\mathbf{v}_{k}\right\|-m^{-}\right)^{2} $$

DigitCaps 层的输出为 10 个 16 维的向量，根据上面的公式计算每个向量的损失值，然后将 10 个损失值相加得到最终损失。

在损失函数中，当正确的标签与特定 DigitCap 的数字对应时 $T_k$ 为 1，否则为 0。加号前一项用于计算正确 DigitCap 的损失，当概率值大于 $m^{+} = 0.9$ 时为 0，当概率值小于 $m^{+} = 0.9$ 时为非零值；加号后一项用于计算错误 DigitCap 的损失，当概率值小于 $m^{-} = 0.1$ 时值为 0，当概率值大于 $m^{-} = 0.1$ 时为非零值。公式中的 $\lambda = 0.5$ 用于确保训练中数值的稳定性。

简单来说，低层的胶囊用于检测一些特定模式的出现概率和姿态，高层的胶囊用于检测更加复杂的图像，如下图所示：

解码器

解码器部分如下图所示：

解码器从正确的 DigitCap 中接收一个 16 维向量，并学习将其解码为数字图像。解码器接收正确的 DigitCap 的输出作为输入，并学习重建一张 $28 \times 28$ 像素的图像，损失函数为重建图像与输入图像之间的欧式距离。

只有道德上的相对民主，没有制度上的绝对公平，求同存异才能长治久安。

无处不在的投票

在古代雅典城邦有一项政治制度称之为陶片放逐制，是由雅典政治家克里斯提尼于公元前 510 年创立。雅典人民可以通过投票强制将某个人放逐，目的在于驱逐可能威胁雅典的民主制度的政治人物。投票者在选票——陶罐碎片较为平坦处，刻上他认为应该被放逐者的名字，投入本部落的投票箱。如果选票总数未达到 6000，此次投票即宣告无效；如果超过 6000，再按票上的名字将票分类，得票最多的人士即为当年放逐的人选。

美国总统选举的方式称为选举人团，是一种间接选举，旨在选出美国总统和副总统。根据《美国宪法》及其修正案，美国各州公民先选出该州的选举人，再由选举人代表该州投票。不采用普选制度的原因，主要是由于美国是联邦制国家，并考虑到各州的特定地理及历史条件，制宪元老决定采取选举人团制度，保障各州权益，所以美国没有公民直选的总统。

离我们最近的可能就是朋友聚会吃什么这个问题了，烧烤还是火锅，这是个问题。当然，只要你想要，还可以：蒸羊羔、蒸熊掌、蒸鹿尾儿、烧花鸭、烧雏鸡、烧子鹅 ……

投票制度

多数制

多数制（Plurality Voting System）的原则是“胜者全取”，又被称为多数代表制（Majoritarian Representation），分成相对多数（Relative Plurality）和绝对多数（Absolute Majority）。相对多数制即不论票数多少，得票最多的候选人便可当选。绝对多数制指候选人需要得到指定的票数方可当选，门槛在设定上须达有效票之过半数、三分之二、四分之三或五分之四等多数，亦可以是更高的比例或数字。

多数制的优点在于简单易行，缺点在于当选票分散的越平均，投票结果的争议性就会越大。例如：有 10 人参与投票，有 3 人选择吃火锅，有 3 人选择吃烧烤，有 4 人选择吃家常菜。根据多数制规则，最终的选择为吃家常菜，但会有 6/10 的人没有得到满意的结果。

波达计数法

波达计数法（Borda Count）是通过投票人对候选者进行排序，如果候选者在选票的排第一位，它就得某个分数，排第二位得一个较小的分数，如此类推，分数累计下来最高分的候选者便取胜。

波达计数法相比于多数制不容易选出比较有争议的选项。假设有一场选举，共 4 位候选人，共收集到有效选票 100 张，选票统计结果（理论山可能出现的选票类型为 $4! = 24$ 种可能，简单起见，示例中仅有 4 种可能）如下：

选举采用排名第 $n$ 位得 $4 - n$ 分的准则，每个人的分数如下：

• 张三：$51 \times 3 + 5 \times 0 + 23 \times 0 + 21 \times 0 = 153$
• 李四：$51 \times 1 + 5 \times 2 + 23 \times 3 + 21 \times 1 = 151$
• 王五：$51 \times 2 + 5 \times 3 + 23 \times 2 + 21 \times 2 = 205$
• 马六：$51 \times 0 + 5 \times 1 + 23 \times 1 + 21 \times 3 = 91$

按照多数制应该是张三获胜（得到第 1 名的票数最多，共计 51 票）。不过通过波达计数法可以发现大家对张三的喜好比较极端：只有特别喜欢（排名第 1）和特别不喜欢（排名第 4）两种情况，所以张三是一个具有争议的人。但王五不同，虽然其获得第 1 的选票并不多，但是获得第 2 的选票很多，说明大部分人都是比较能接受王五的。

波达计数法同时也存在几个问题：

1. 不同的权重的计分规则，可能得到不同结果。以下表为例：

   #	2 票	3 票	4 票	#
   2 分	A	A	C	5 分
   1 分	B	C	B	2 分
   0 分	C	B	A	1 分

   采用左边权重的计分结果为：A：10 分，B：6 分，C：11 分，则 C 胜出。采用右边权重的计分结果为：A：29 分，B：15 分，C：28 分，则 A 胜出。不难看出，多数投票制是波达计数法的一个特例，即第 1 名的权重为非零值，其余名次权重均为零。

2. 容易出现恶意投票局面。参与的人在投票时往往会掺杂个人情感，假设存在这样一次选举：张三、李四、王五三人竞选班长，张三和李四是最有希望竞争班长的人员，而王五则表现平庸。参与投票的同学几乎近一半的人支持张三，近一半的人支持李四，很少人支持王五。参与投票的同学自认为都很“聪明”，担心自己不支持的人（假设为李四）担任班长，同时认为王五没希望竞选成功，因此在排序时会把王五排在第 2 名，把李四排在第 3 名。此时，张三和李四都变成了具有争议的人，那么选举的结果就很有可能是王五获胜。

孔多赛投票制

波达计数法还存在一个严重的问题是，当其中一个选项退出后，投票的结果会发生变化。仍然以上文中的例子为例：

在包含选项 B 时，投票结果为：A：10 分，B：6 分，C：11 分，C 获胜。当把选项 B 去掉后，投票结果为：A：5 分，C：4 分，A 获胜。去掉选项 B，规则没有发生变化（不同排名之间权重相差为 1），投票人的意愿也没有发生变化（候选人的相对名次没有发生变动），但投票结果却截然不同。

为了解决这个问题，孔多赛提供了采用两两对决的方式进行投票。投票人依旧按照类似波达计数法对候选人进行排序，但与波达计数法不同的是并不进行计分而是需要统计出所有两两对决的情况。上面这个例子中两两对决的情况有 6 种：A > B，B > A，B > C，C > B，A > C，C > A，对决的统计结果如下表所示：

由于 A > B 有 5 次，B > A 有 4 次，因此在 A 和 B 的两两对决中获胜的是 A。同理可得，在 A 和 C 的两两对决中获胜的是 A，在 B 和 C 的两两对决中获胜的是 C。当存在很多选项时，假设选项 A 在与任何其它选项的两两比较中都能胜出，那 A 称为孔多塞胜利者。

如果你对 Facebook 历史有了解，早期扎克伯格在哈佛大学就读学士期间，写了一个名为 Facemash 的网站程序，根据哈佛校内报纸《The Harvard Crimson》，Facemash 会从校内的网络上收集照片，每次将两张照片并排后让用户选择“更火辣”的照片。Facemash 就采取了类似孔多塞投票的方法对女生进行投票，下图是电影社交网络中这个原型的截图：

孔多塞投票制由于统计比较麻烦，现实生活中使用的情况不多。同时，孔多塞投票也存在一个问题，即孔多塞循环。假设 A 和 B 对决的优胜者为 A，B 和 C 对决的优胜者为 B，C 和 A 对决的优胜者为 C，则没有一个选项打败其他所有选项，那么这样就无法得到投票的结果。这称之为孔多塞悖论（投票悖论），在这个假想情况中，集体倾向可以是循环性的，即使个人的倾向不是。

所以呢？

所以什么样的投票才算是公平合理的投票呢？肯尼斯·阿罗给出了一个解答。

有 $N$ 种选择，有 $m$ 个决策者，他们每个人都对这 $N$ 个选择有一个从优至劣的排序。我们要设计一种选举法则，使得将这 $m$ 个排序的信息汇总成一个新的排序，称为投票结果。我们希望这种法则满足以下条件：

1. 一致性（Unanimity）。或称为帕累托最优（Pareto Efficiency），即如果所有的 $m$ 个决策者都认为选择 $A$ 优于 $B$，那么在投票结果中，$A$ 也优于 $B$。
2. 非独裁（Non-Dictatorship）。不存在一个决策者 $X$，使得投票结果总是等同于 $X$ 的排序。
3. 独立于无关选项（Independence of Irrelevant Alternatives，IIA)）。如果现在一些决策者改了主意，但是在每个决策者的排序中，$A$ 和 $B$ 的相对位置不变，那么在投票结果中 $A$ 和 $B$ 的相对位置也不变。

如果选项 $N \geq 3$，投票人数 $m \geq 2$ 时，没有任何一种投票规则能够满足以上 3 点，这就是阿罗悖论。所以只有道德上的相对民主，没有制度上的绝对公平，求同存异才能长治久安。

本文参考自《投票公平合理吗？为什么没有绝对的公平？阿罗不可能定理》。

本文为《复杂网络系列》文章

图存储

语义网络与 RDF 存储

1968 年 Ross Quillian 在其博士论文中最先提出语义网络（Semantic Web），把它作为人类联想记忆的一个显式心理学模型，并在他设计的可教式语言理解器 TLC（Teachable Language Comprehenden）中用作知识表示方法。

语义网络的基本思想是在网络中，用“节点”代替概念，用节点间的“连接弧”（称为联想弧）代替概念之间的关系，因此，语义网络又称联想网络。它在形式上是一个带标识的有向图。由于所有的概念节点均通过联想弧彼此相连知识推导。

一个语义网络的基本构成如下：

• 语义网络中的节点：表示各种事物、概念、情况、属性、动作、状态等，每个节点可以带有若干属性，一般用框架或元组表示。此外，节点还可以是一个语义子网络，形成一个多层次的嵌套结构。
• 语义网络中的弧：表示各种语义联系，指明它所连接的节点间某种语义关系。
• 节点和弧都必须带有标识，以便区分各种不同对象以及对象间各种不同的语义联系。

之后 Tim Berners-Lee 又提出了语义网堆栈（Semantic Web Stack）的概念。语义网堆栈利用图示解释是不同层面的语言所构成的层级结构，其中，每一层面都将利用下游层面的能力，语义网堆栈如下图所示：

资源描述框架（Resource Description Framework，RDF）是用于描述网络资源的 W3C 标准，比如网页的标题、作者、修改日期、内容以及版权信息。

RDF 使用 Web 标识符来标识事物，并通过属性和属性值来描述资源。

对资源、属性和属性值的解释：

• 资源是可拥有 URI 的任何事物，比如 http://www.w3school.com.cn/rdf
• 属性是拥有名称的资源，比如 author 或 homepage
• 属性值是某个属性的值，比如 David 或 http://www.w3school.com.cn（请注意一个属性值可以是另外一个资源)

下面是一个 RDF 示例文档（这是一个简化的例子，命名空间被忽略了）：

<?xml version="1.0"?>

<RDF>
  <Description about="http://www.w3school.com.cn/RDF">
    <author>David</author>
    <homepage>http://www.w3school.com.cn</homepage>
  </Description>
</RDF>

资源、属性和属性值的组合可形成一个陈述（被称为陈述的主体、谓语和客体)。上述的 RDF 文档包含了如下两个陈述：

• 陈述：The author of http://www.w3school.com.cn/rdf is David
  • 陈述的主体是：http://www.w3school.com.cn/rdf
  • 谓语是：author
  • 客体是：David
• 陈述：The homepage of http://www.w3school.com.cn/rdf is http://www.w3school.com.cn
  • 陈述的主体是：http://www.w3school.com.cn/rdf
  • 谓语是：homepage
  • 客体是：http://www.w3school.com.cn

更多 RDF 介绍请参见：https://www.w3school.com.cn/rdf/index.asp 。

Apache Jena 是一个用于构建语义网络（Semantic Web）和链接数据（Linked Data）应用的开源 Java 框架。Jena 提供了 3 大部分功能：

1. RDF
   • RDF API：提供构建和读取 RDF 图的核心 API，并利用 RDF/XML 或 Turtle 等数据类型序列化数据。
   • ARQ（SPARQL)：提供一种 SPARQL 1.1 的编译引擎 ARQ 用于查询 RDF。
2. Triple store
   • TDB：提供一种原生高效的 Triple 存储 TDB，全面支持 Jena APIs。
   • Fuseki：提供 REST 风格的 RDF 数据交互方式。
3. OWL
   • Ontology API：通过 RDFS，OWL 等为 RDF 数据添加更多语义信息。
   • Inference API：通过内置的 OWL 和 RDFS 语义推理器 构建个性化的推理规则。

下面以 Graph of The Gods 的关系图对 Jena 的基本功能进行说明。Graph of The Gods 是一张描述希腊神话相关事物之间关系的图，其中顶点的类型有：titan（泰坦，希腊神话中曾经统治师姐的古老神族)，god（神)，demigod（半神)，human（人)，monster（怪物)，location（地点)；关系的类型有：father（父亲)，brother（兄弟)，mother（母亲)，battled（战斗)，lives（居住)。

以 Apache Tomcat 作为容器来安装 Apache Jena Fuseki，下载最新版的 Apache Jena Fuseki 并解压，将其中的 fuseki.war 复制到已经安装并运行的 Apache Tomcat 的 webapps 路径下。安装完毕后，进入 http://127.0.0.1:8080/fuseki 即可使用 Apache Jena Fuseki。

在导入 Graph of The Gods 数据后，执行如下查询语句可以获得 jupiter 的所有兄弟：

PREFIX gods: <http://leovan.me/gods/>

SELECT DISTINCT ?god
WHERE {
  ?god gods:brother gods:jupiter
}

查询结果为：

图数据库

图数据库是一个使用图结构进行语义查询的数据库，它使用节点、边和属性来表示和存储数据。不同于关系型数据库，图数据库为 NoSQL（Not Only SQL）的一种，属于联机事务处理（OLTP）的范畴，可以解决现有关系数据库的局限性。

下图展示了近年来不同类型数据库的流行度趋势，不难看出近年来越来越多的人开始关注图数据库。

截止到 2020 年 12 月，图数据库的排名如下图所示：

其中，Neo4j、JanusGraph、Dgraph、TigerGraph、Nebula Graph 均为时下常用的图数据库。从下图的流行度趋势角度来看，JanusGraph、Dgraph、TigerGraph 和 Nebula Graph 等后起之秀发展迅速。

不同的图数据库有着不同的优劣势，用户可以根据实际业务场景选择合适的图数据库。下面给到一些较新的图数据库对比和评测：

1. 主流开源分布式图数据库 Benchmark
2. 图数据库对比：Neo4j vs Nebula Graph vs HugeGraph
3. 图分析系统基准测试报告
4. 图数据平台产品测试报告

查询语言

图查询语言（Graph Query Language，GQL）是一种用于图数据库的查询语言，类比于关系型数据库的查询语言 SQL。2019 年 9 月，GQL 被提议为一种新的数据库查询语言（ISO/IEC WD 39075），目前仍处于开发当中，因此市面上还没有统一的图查询语言标准。

Gremlin

Gremlin 是 Apache TinkerPop 框架下的图遍历语言。Gremlin 适用于基于 OLTP 的图数据库以及基于 OLAP 的图分析引擎，支持命令式和声明式查询。支持 Gremlin 的图数据库有：Neo4j、JanusGraph 等。

Cypher

Cypher 是一种声明式图查询语言，这使得在不必编写遍历逻辑的情况下可以实现高效的查询。支持 Cypher 的图数据库有：Neo4j、RedisGraph、Nebula Graph 等。

nGQL

nGQL 是一种声明式的图查询语言，支持图遍历、模式匹配、聚合运算和图计算等特性。支持 nGQL 的图数据库有：Nebula Graph。

比较

针对 3 种不同的查询语言，对于图中相关概念的表示也略有不同，如下表所示：

更多不同查询语言之间的详细对比可以参见如下资料：

1. 一文了解各大图数据库查询语言 | 操作入门篇
2. 文档解读 ｜ SQL vs. nGQL

图计算

图计算框架

GraphX

GraphX 是一个基于 Spark 大规模图计算框架。GraphX 通过引入一个包含带有属性的顶点和变的有向图对 Spark 的 RDD 进行了扩展。通过 subgraph、joinVertices 和 aggregateMessages 等算子实现了 PageRank、连通子图、LPA 等图算法。

Plato

Plato 是由腾讯开源的高性能图计算框架。Plato 主要提供两方面的能力：离线图计算和图表示学习，目前支持的图算法如下：

在计算性能上，Plato 与 Spark GraphX 在 PageRank 和 LPA 两个算法上的计算耗时与内存消耗对比如下图所示：

GraphScope

GraphScope 由有阿里巴巴开源的一个统一的分布式图计算平台。GraphScope 提供了一个一站式环境，可以通过用户友好的 Python 接口在集群内对图进行操作。GraphScope 利用一系列开源技术使得集群上的大规模图数据的多阶段处理变得简单，这些技术包括：用于分析的 GRAPE、用于查询的 MaxGraph 、用于图神经网络计算的 Graph-Learn 和用于提供高效内存数据交换的 vineyard。GraphScope 的整体架构如下图所示：

GraphScope Interactive Engine（GIE）是一个用于探索性分析大规模复杂图结构数据的引擎，它通过 Gremlin 提供高级别的图查询语言，同时提供自动并行执行功能。

GraphScope Analytical Engine（GAE）是一个基于 GRAPE ¹ 提供并行图算法的分析引擎。除了提供基础的内置算法以外，GAE 允许用户利用 Python 基于 PIE ¹ 编程模型编写自定义算法，PIE 编程模型的运行方式如下图所示：

GraphScope 还提供以顶点为中心的 Pregel 模型 ²，用户可以使用 Pregel 模型来实现自定义算法。

GraphScope Learning Engine（GLE）是一个用于开发和训练大规模图神经网络的分布式框架。GLE 提供基于全量图（用于 GCN、GAT 等算法）和采样子图（用于 GraphSAGE，FastGCN、GraphSAINT 等算法）两种不同方式训练图模型。整体架构如下图所示：

Galileo

Galileo 是由京东零售研发的图计算平台，提供离线和在线图计算和图数据服务能力。目前 Galileo 暂未开源，待开源后补充相关信息。

图神经网络

关于图神经网络内容，请参见之前的博客 图嵌入 (Graph Embedding) 和图神经网络 (Graph Neural Network)。

:tada::tada::tada: Happe New Year! :tada::tada::tada:

本文为《复杂网络系列》文章
本文内容主要参考自：《网络科学引论》¹

网络基础算法

最短路径

最短路径（shortest path）算法是寻找两个顶点之间的最短路径，寻找网络中最短路径的标准算法称为广度优先搜索（breadth-first search）。算法的基本思想如下图所示：

根据广度优先搜索的基本思想，不难证明距 $s$ 最短距离为 $d$ 的每个顶点都有一个到 $s$ 的最短距离为 $d - 1$ 的邻居顶点。一个简单的实现方式是，创建一个有 $n$ 个元素的数组存储从源顶点 $s$ 到其他所有顶点的距离，同时创建一个距离变量 $d$ 来记录当前在搜索过程中所处的层数，算法的具体流程如下：

1. 遍历距离数组，查找到 $s$ 的距离为 $d$ 的所有顶点。
2. 查找上述顶点的所有邻居顶点，如果同 $s$ 的距离未知，则距离置为 $d + 1$。
3. 如果距离未知的邻居顶点数量为零，则停止算法，否则将 $d$ 的值加一并重复上述过程。

这种方法在最坏的情况下时间复杂度为 $O \left(m + n^2\right)$，考虑多数网络的直径只随 $\log n$ 增长，算法运行的时间复杂度为 $O \left(m + n \log n\right)$。

上述算法中步骤 1 是最耗时的部分，通过使用队列的数据结构我们可以避免每次都遍历列表来找到距离源顶点 $s$ 距离为 $d$ 的顶点。构造一个队列，一个指针指向下一个要读取的元素，另一个指针指向要填充的空位，这样距离为 $d + 1$ 的顶点就会紧跟在距离为 $d$ 的顶点后面，队列如下图所示：

通过队列可以将算法的时间复杂度降至 $O \left(m + n\right)$，对于 $m \propto n$ 的稀疏网络而言，$O \left(m + n\right)$ 相当于 $O \left(n\right)$，所以算法的时间复杂度同顶点数量成正比。

通过对算法进行进一步修改则可以得到源顶点 $s$ 到其他任何顶点的最短路径。方法是在原来的网络上构建一个新的有向网络，该网络代表最短路径，称为最短路径树（shortest path tree），通常情况下，该网络是一个有向非循环网络，而不是树。

对于加权网络，利用广度优先搜索无法找到最短路径，这里需要用到 Dijkstra 算法 ² 进行求解。算法将图中的顶点分成两组 $S$ 和 $U$，整个算法过程如下：

1. 初始状态，$S$ 仅包含源顶点，即 $S = \left\{v\right\}$，$U$ 包含其余顶点。如果 $v$ 与 $U$ 中的顶点 $u$ 为邻居，则距离为边的权重，否则为无穷大。
2. 从 $U$ 中选择一个距离 $v$ 最短的顶点 $k$，并把 $k$ 加入到 $S$ 中。
3. 若从源点 $v$ 经过顶点 $k$ 到达 $u$ 的距离比之前 $v$ 到 $u$ 的距离短，则将距离修改为这个更短的距离。
4. 重复步骤 2 和 3，直至所有顶点都包含在 $S$ 中。

整个算法过程的可视化效果如下图所示：

Dijkstra 算法的时间复杂度为 $O \left(m + n^2\right)$，通过二叉堆的数据结构可以将时间复杂度优化至 $O \left(\left(m + n\right) \log n\right)$。

Dijkstra 算法虽然能够处理加权网络，但不能处理存在负权重的网络，需要利用 Floyd-Warshall 算法 ³ 进行求解。更多 Floyd-Warshall 算法的细节请参见之前的博客计算复杂性 (Computational Complexity) 与动态规划 (Dynamic Programming)。

最大流和最小割

对于连接给定顶点 $s$ 和 $t$ 的两条路径，若没有共享边，则这两条路径是边独立的；若除 $s$ 和 $t$ 外不共享任何其他顶点，则这两条路径是顶点独立的。顶点之间的边连通度和顶点连通度分别是顶点之间边独立路径数和顶点独立路径数。连通度是度量顶点之间连通鲁棒性的简单参数。假设一个网络是一个管线网络，其中每个管线的容量均为单位流量，那么边连通度等于从 $s$ 流向 $t$ 的最大流。

增广路径算法（Ford-Fulkerson Algorithm，FFA）是计算最大流最简单的算法。基本思想是：首先利用广度优先搜索算法找到一条从源 $s$ 到目标 $t$ 的路径。该步骤“消耗”了网络中的一些边，将这些边的容量填充满后，它们不再承载更多流量。之后在剩余边中找到从 $s$ 到 $t$ 的另一条路径，重复该过程直到找不到更多的路径为止。

但这还不是一个有效的算法，如下图中的 (a) 所示，如果在 $s$ 和 $t$ 之间运用广度优先搜索，可以发现黑色标记的路径。一旦这些边的容量被填充满，就不能在剩余边中找到从 $s$ 到 $t$ 的更多路径，但很明显，从 $s$ 到 $t$ 有两条边独立路径（上下各一条）。

解决该问题的一个简单修正方法是允许网络流量在一条边中能够同时在两个方向流动。更一般地，因为一条边容许承载的最大流是在任意方向的单位流量，那么一条边可以有多个单位流量，只要保证他们能够相互抵消，并且最终每条边承载不超过一个单位流量。

增广路径算法的实现利用了剩余图（residual graph），这是一个有向网络，该网络中的有向边连接原网络中相应的顶点对，并在指定方向承载一个或多个单位流量。例如上图中 (c) 和 (d) 就是对应 (a) 和 (b) 的流量状态的剩余图。算法的正确性在这里就不过多展开说明，该算法在计算两个顶点之间的最大流的平均时间复杂度为 $O \left(\left(m + n\right) m / n\right)$。

在图论中，去掉其中所有边使一张网络不再连通的边集为图的割，一张图上最小的割为最小割。通过对增广路径算法进行改动即可以寻找到边独立路径、最小边割集和顶点独立路径。

图划分和社团发现

图划分（graph partitioning）和社团发现（community detection）都是指根据网络中的边的连接模式，把网络顶点划分成群组、簇或社团。将网络顶点划分成群组后最常见的属性是，同一群组内部的顶点之间通过边紧密连接，而不同群组之间只有少数边。

图划分

最简单的图划分问题是把网络划分成两部分，有时也称其为图对分（graph bisection）。图对分是把一个网络中的顶点划分成为两个指定规模的非重叠群组，使得不同群组之间相互连接的边数最小。群组之间的边数称为割集规模（cut size）。 利用穷举搜索解决该问题是极为耗时的，通过启发式算法我们可以找到较好的网络划分。

Kernighan-Lin 算法

Kernighan-Lin 算法是由 Brian Kernighan 和 Shen Lin 在 1970 年提出的 ⁴，是图对分问题中最简单、最知名的启发式算法之一，如下图所示。

先以任意方式将网络顶点按指定规模划分成两个群组，对于任何由分属不同群组的顶点 $i$ 和顶点 $j$ 组成的顶点对 $\left(i, j\right)$，交换 $i$ 和 $j$ 的位置，并计算交换前后两个群组之间割集规模的变化量。在所有顶点对中找到使割集规模减小最多的顶点对，或者若没有使割集规模减小的顶点对，则找到使割集规模增加最小的顶点对，交换这两个顶点。重复这个过程，同时保证网络中的每个顶点只能移动一次。

继续算法，每一步都交换最大程度减少或最小程度增加群组之间边数的顶点对，直到没有可以变换的顶点对，此时本轮算法停止。在完成所有交换后，检查网络在此过程中经过的每一个状态，然后选择割集规模最小的状态。最后，重复执行上述整个过程，每次始于上次发现的最优网络划分，直到割集规模不在出现改善。

Kernighan-Lin 算法的主要缺点是运算速度缓慢，采用一些技巧来改善算法也只能使时间复杂度降至 $O \left(n^3\right)$，因此该算法仅适用于有几百或几千个顶点的网络，而不适用于更大规模的网络。

谱划分

请先了解附录中的拉普拉斯算子和拉普拉斯矩阵等相关概念。

考虑具有 $n$ 个顶点 $m$ 条边的网络，将其划分为两个群组，称为群组 1 和群组 2。可以把该划分的割集规模，也就是两个群组之间的边数表示为：

$$ \label{eq:r_1} R = \dfrac{1}{2} \sum_{i, j \text{ 属于不同群组}} A_{ij} $$

对于每个网络划分，定义有参数 $s_i$ 组成的集合，集合中每个元素对应于一个顶点 $i$，则有：

$$ s_i = \left\{\begin{array}{ll} +1 & \text{顶点 } i \text{ 在群组 1 中} \\ -1 & \text{顶点 } i \text{ 在群组 2 中} \end{array}\right. $$

那么：

$$ \dfrac{1}{2} \left(1 - s_i s_j\right) = \left\{\begin{array}{ll} 1 & \text{顶点 } i \text{ 和 } j \text{ 在不同的群组中} \\ 0 & \text{顶点 } i \text{ 和 } j \text{ 在相同的群组中} \end{array}\right. $$

则式 \ref{eq:r_1} 可以改写为：

$$ \begin{aligned} R & = \dfrac{1}{4} \sum_{ij} A_{ij} \left(1 - s_i s_j\right) \\ & = \dfrac{1}{4} \left(k_i \delta_{ij} - A_{ij}\right) s_i s_j \\ & = \dfrac{1}{4} \sum_{ij} L_{ij} s_i s_j \end{aligned} $$

其中，$\delta_{ij}$ 是克罗内克函数，$L_{ij}$ 是图拉普拉斯矩阵的第 $ij$ 个元素。写成矩阵的形式有：

$$ R = \dfrac{1}{4} \mathbf{s}^{\top} \mathbf{L} \mathbf{s} $$

由于每个 $s_i$ 的取值只能是 $\left\{+1, -1\right\}$，所以在给定 $\mathbf{L}$ 时求解 $\mathbf{s}$ 使其割集规模最小时并不容易。具体求解方法的推导在此不再展开说明，最终谱划分算法的过程如下所示：

1. 计算图拉普拉斯矩阵的第二小特征值 $\lambda_2$，称为网络的代数连通度（algebraic connectivity），及其对应的特征向量 $\mathbf{v}_2$。
2. 按从大到小的顺序对特征向量的元素进行排序。
3. 把前 $n_1$ 个最大元素对应的顶点放入群组 1，其余放入群组 2，计算割集规模。
4. 把前 $n_1$ 个最小（注意：中文译本中有错误）元素对应的顶点放入群组 2，其余放入群组 1，并重新计算割集规模。
5. 在两种网络划分中，选择割集规模较小的那个划分。

谱划分方法在稀疏网络上的时间复杂度为 $O \left(n^2\right)$，这比 Kernighan-Lin 算法时间复杂度少了一个因子 $n$，从而使该算法能应用于更大规模的网络。

社团发现

社团发现（社区发现，社群发现，Community Detection）的基本目的与图划分类似，即把网络分成几个节点点群组，并使节点群组之间的连接较少。主要的差别就是群组的数量和规模是不确定的。社团发现的算法分类和具体实现很多，本文仅介绍几个常用的算法，更多方法及其细节请参见如下开放资源：

1. Community Detection in Graphs ⁵
2. Deep Learning for Community Detection: Progress, Challenges and Opportunities ⁶
3. 复杂网络社团发现算法研究新进展 ⁷
4. benedekrozemberczki/awesome-community-detection

Fast Unfolding (Louvain)

Fast Unfolding (Louvain) ⁸ 是一种基于模块度的社团发现算法，通过模块度来衡量一个社团的紧密程度。算法包含两个阶段：

1. 历遍网络中所有的节点，通过比较将节点给每个邻居社团带来的模块度变化，将这个节点加入到使模块度增加最大的社团中。
2. 对于步骤 1 的结果，将属于同一个社团的节点合并成为一个大的节点，进而重型构造网络。新的节点之间边的权重是所包含的之前所有节点之间相连的边权重之和，然后重复步骤 1。

算法的两个步骤如下图所示：

Label Propagation Algorithm (LPA)

标签传播算法（Label Propagation Algorithm，LPA）是一种基于半监督学习的社团发现算法。对于每个节点都有对应的标签（即节点所隶属的社团），在算法迭代过程中，节点根据其邻居节点更新自身的标签。更新的规则是选择邻居节点中最多的标签作为自身的标签。

标签传播的过程中，节点的标签更新方式分为同步更新和异步更新两种方式。同步更新是指对于节点 $x$，在第 $t$ 步时，根据其所有邻居节点在 $t - 1$ 步时的标签对其进行更新，即：

$$ C_{x}(t)=f\left(C_{x_{1}}(t-1), C_{x_{2}}(t-1), \cdots, C_{x_{k}}(t-1)\right) $$

同步更新对于一个二分或者近似二分的网络来说可能会出现标签震荡的现象。对于异步更新方式，更新公式为：

$$ C_{x}(t)=f\left(C_{x_{i 1}}(t), \cdots, C_{x_{i m}}(t), C_{x_{i(m+1)}}(t-1), \cdots, C_{x_{i k}}(t-1)\right) $$

其中，邻居节点 $x_{i1}, \cdots, x_{im}$ 的标签在第 $t$ 步时已经更新过，而 $x_{i(m+1)}, \cdots, x_{ik}$ 的标签还未更新。

附录

拉普拉斯算子（Laplace operator，Laplacian）是由欧式空间中的一个函数的梯度的散度给出的微分算子，通常写作 $\Delta$，$\nabla^2$ 或 $\nabla \cdot \nabla$。

梯度（gradient）是对多元导数的概括，函数沿着梯度的方向变化最快，变化率则为梯度的模。假设二元函数 $f \left(x, y\right)$ 在区域 $G$ 内具有一阶连续偏导数，点 $P \left(x, y\right) \in G$，则称向量：

$$ \nabla f = \left(\dfrac{\partial f}{\partial x}, \dfrac{\partial f}{\partial y} \right) = \dfrac{\partial f}{\partial x} \mathbf{i} + \dfrac{\partial f}{\partial y} \mathbf{j} $$

为函数 $f$ 在点 $P$ 处的梯度，其中 $\mathbf{i}$ 和 $\mathbf{j}$ 为单位向量，分别指向 $x$ 和 $y$ 坐标方向。

散度（divergence）将向量空间上的一个向量场对应到一个标量场上，记为 $\nabla \cdot$。散度的意义是场的有源性，当 $\nabla \cdot F > 0$ 时，表示该点是发源点；当 $\nabla \cdot F < 0$ 时，表示该点是汇聚点；当 $\nabla \cdot F = 0$ 时，表示该点无源，如下图所示。

拉普拉斯离散化后即为拉普拉斯矩阵（laplacian matrix），也称为调和矩阵（harmonic matrix）。离散化的拉普拉斯算子形式如下：

$$ \begin{aligned} \Delta f & = \dfrac{\partial^2 f}{\partial x^2} + \dfrac{\partial^2 f}{\partial y^2} \\ & = f \left(x + 1, y\right) + f \left(x - 1, y\right) - 2 f \left(x, y\right) + f \left(x, y + 1\right) + f \left(x, y - 1\right) - 2 f \left(x, y\right) \\ & = f \left(x + 1, y\right) + f \left(x - 1, y\right) + f \left(x, y + 1\right) + f \left(x, y - 1\right) - 4 f \left(x, y\right) \end{aligned} $$

从上述离散化后的拉普拉斯算子形式可以看出，拉普拉斯矩阵表示的是对矩阵进行微小扰动后获得的收益。

设图 $G$ 有 $n$ 个节点，节点的邻域为 $N$，图上的函数 $f = \left(f_1, f_2, \cdots, f_n\right)$，其中 $f_i$ 表示节点 $i$ 处的函数值。对 $i$ 进行扰动，其可能变为邻域内的任意一个节点 $j \in N_i$：

$$ \Delta f_{i}=\sum_{j \in N_{i}}\left(f_{i}-f_{j}\right) $$

设每一条边 $e_{ij}$ 的权重为 $w_{ij}$，$w_{ij} = 0$ 表示节点 $i$ 和节点 $j$ 不相邻，则有：

$$ \begin{aligned} \Delta f_i & = \sum_{j \in N} w_{ij} \left(f_i - f_j\right) \\ & = \sum_{j \in N} w_{ij} f_i - \sum_{j \in N} w_{ij} f_i \\ & = d_i f_i - W_{i:} f \end{aligned} $$

对于所有节点有：

$$ \begin{aligned} \Delta f & = \left(\begin{array}{c} \Delta f_{1} \\ \vdots \\ \Delta f_{N} \end{array}\right)=\left(\begin{array}{c} d_{1} f_{1}-W_{1:} f \\ \vdots \\ d_{N} f_{N}-W_{N:} f \end{array}\right) \\ & = \left(\begin{array}{ccc} d_{1} & \cdots & 0 \\ \vdots & \ddots & \vdots \\ 0 & \cdots & d_{N} \end{array}\right) f-\left(\begin{array}{c} W_{1:} \\ \vdots \\ W_{N:} \end{array}\right) f \\ & = diag \left(d_i\right) f - W f \\ & = \left(D - W\right) f \\ & = L f \end{aligned} $$

令图 $G$ 的邻接矩阵为 $W$，度矩阵为 $D$，从上式可知拉普拉斯矩阵 $L = D - W$，其中：

$$ L_{ij} = \left\{\begin{array}{ll} \deg \left(v_i\right) & \text{如果 } i = j \\ -1 & \text{如果 } i \neq j \text{ 且 } v_i \text{ 与 } v_j \text{ 相邻} \\ 0 & \text{其他情况} \end{array}\right. $$

以下面的图为例：

邻接矩阵为：

$$ \left(\begin{array}{llllll} 0 & 1 & 0 & 0 & 1 & 0 \\ 1 & 0 & 1 & 0 & 1 & 0 \\ 0 & 1 & 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 & 1 & 1 \\ 1 & 1 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 \end{array}\right) $$

度矩阵为：

$$ \left(\begin{array}{cccccc} 2 & 0 & 0 & 0 & 0 & 0 \\ 0 & 3 & 0 & 0 & 0 & 0 \\ 0 & 0 & 2 & 0 & 0 & 0 \\ 0 & 0 & 0 & 3 & 0 & 0 \\ 0 & 0 & 0 & 0 & 3 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 \end{array}\right) $$

拉普拉斯矩阵为：

$$ \left(\begin{array}{rrrrrr} 2 & -1 & 0 & 0 & -1 & 0 \\ -1 & 3 & -1 & 0 & -1 & 0 \\ 0 & -1 & 2 & -1 & 0 & 0 \\ 0 & 0 & -1 & 3 & -1 & -1 \\ -1 & -1 & 0 & -1 & 3 & 0 \\ 0 & 0 & 0 & 1 & 0 & 1 \end{array}\right) $$

开放资源

常用网络算法包

不同扩展包之间的性能比较如下表所示 ⁹：

常用网络可视化软件

不同可视化软件之间的比较如下表所示 ¹⁰：

其中，⭑ 表示较弱、⭑⭑ 表示中等、⭑⭑⭑ 表示较好、⭑⭑⭑⭑ 表示优秀。

本文为《复杂网络系列》文章
本文内容主要参考自：《网络科学引论》¹

分支

在无向网络中，一个典型的现象是很多网络都有一个分支，该分支占据了网络的绝大部分，而剩余部分则被划分为大量的小分支，这些小分支之间彼此并不相连。如下图所示：

一个网络通常不能有两个或更多占据网络大部分的大分支。如果将一个 $n$ 个顶点的网络分解为两个分支，每个分支约为 $\dfrac{1}{2} n$ 个顶点，则两个分支的顶点之间会有 $\dfrac{1}{4} n^2$ 个顶点对，这些顶点对有可能一个顶点在一个大分支中，而另一个顶点在另外一个大分支中。如果在任何一个顶点对之间有一条边，那么这两个分支就会合并为一个分支。

有向图中分支分为两种：弱连通分支和强连通分支。弱连通分支的定义与无向网络的分支定义类似，强连通分支是指网络顶点的一个最大子集，该子集中的顶点能够通过有向路径到达其余所有顶点，同时也能够通过有向路径从其余所有顶点到达。

每个连通分支拥有外向分支（即从强连通分支中的任意顶点出发，沿着有向路径能够到达的所有顶点的集合）和内向分支（即沿着有向路径能够到达强连通分支的所有顶点的集合）。利用**“领结”图**可以很好地刻画有向网络的总体情况，万维网的“领结”图如下所示：

小世界效应

小世界效应（small-world effect）是指对于大多数网络而言，网络顶点之间的测地距离都惊人的小，例如：六度分隔理论。网络的数学模型显示出网络测地路径长度的数量级通常与网络定点数 $n$ 成对数关系 ，即 $\log n$。

度分布

顶点的度是指连接到它的边的数量。度分布（degree distribution）$p_k$ 是指网络中节点度的概率分布，也可以理解为从网络中随机选择一个顶点，其度为 $k$ 的概率。度序列（degree sequence）是指所有顶点度的集合。

根据度 $k$ 描述出大型网络的度分布有着非常重要的作用，下图给出了 Internet 的度分布：

现实世界中，几乎所有网络的度分布都有类似的由度较大的核心顶点构成的尾部，统计上称为右偏（right-skewed）的。

幂律和无标度网络

以 Internet 为例，下图给出了度分布的一个有趣特征，下图使用了对数标度重新绘制了上图的直方图：

如上图所示，对数处理后，分布大致遵循一条直线。度分布 $p_k$ 的对数与度 $k$ 的对数之间具有线性函数关系：

$$ \ln p_k = - \alpha \ln k + c $$

对两侧同时做指数运算，有：

$$ p_k = C k^{- \alpha} $$

其中，$C = e^c$ 是一个常数。这种形式的分布，即按照 $k$ 的幂变化，称为幂律（power law）。在不同类型的网络中，幂律度分布是普遍存在的，常数 $\alpha$ 是幂律的指数，该值的典型取值区间为 $2 \leq \alpha \leq 3$。通常，度分布并非在整个区间都遵循幂律分布，当 $k$ 较小时，度分布并不是单调的。具有幂律度分布的网络也称为无标度网络（scale-free network）。

观察幂律分布的另外一种方式是构建累积分布函数，定义如下：

$$ P_k = \sum_{k' = k}^{\infty} p_{k'} $$

假设度分布 $p_k$ 在尾部服从幂律，确切地讲，对于某个 $k_{\min}$，当 $k \geq k_{\min}$ 时有 $p_k = C k^{- \alpha}$，则对于 $k \geq k_{\min}$，有：

$$ P_{k}=C \sum_{k^{\prime}=k}^{\infty} k^{\prime-\alpha} \simeq C \int_{k}^{\infty} k^{\prime-\alpha} \mathrm{d} k^{\prime}=\frac{C}{\alpha-1} k^{-(\alpha-1)} $$

这里通过积分来近似求和是合理的，因为当 $k$ 值较大时，幂律函数的变化率较小。所以，如果度分布 $p_k$ 服从幂律，那么 $p_k$ 的累积分布函数也服从幂律。

聚类系数

聚类系数是度量某个顶点的两个邻居顶点也互为邻居的平均概率。该测度计算值与随机条件下得到的期望值之间有较大的差异，这种巨大差异可能也显示出了真正发挥作用的社会效应。在合作网络中，与随机选择合作者相比，实际的合作网络中包含更多的三角形结构。这种现象背后有很多原因，其中一个原因可能是人们会介绍其合作者认识，而这些合作者两两之间也开始进行合作。

随着度的增加，局部聚类系数不断减少，这种现象的一个可能的解释是顶点分成紧密的群组或社团，同一个群组内部的顶点之间连接较多。在表现出此类行为的网络中，属于小型群组的顶点的度较小，因为这种群组的成员也相对较少，但在较大的群组中的顶点的度较大。同时，小型群组中的顶点的局部聚类系数较高。出现这种情况是因为将每个群组与网络的其余部分隔离开之后，每个群组大体上相当于一个小型网络，较小的网络会有更大的聚类系数。当对不同规模的网络取平均之后，会发现度小的顶点具有较高的聚类系数，如下图所示：

本文为《复杂网络系列》文章
本文内容主要参考自：《网络科学引论》¹

网络（network）也称为图（graph），是一个由多个顶点（vertex）及连接顶点的边（edge）组成的集合。在网络中，我们通常用 $n$ 表示顶点的数目，用 $m$ 表示边的数目。在大多数网络中两个顶点之间都只有一条边，极少数情况下，两个顶点之间有多条边，称之为重边（multiedge）。在极特殊情况下，还会存在连接到顶点自身的边，称之为自边（self-edge）。既没有自边也没有重边的图称之为简单网络（simple network）或简单图（simple graph），存在重边的网络称之为重图（multigraph）。相关概念示例如下：

网络表示

无向网络

对于一个包含 $n$ 个顶点的无向图，可以用整数 $1$ 到 $n$ 对各个顶点进行标注。如果用 $\left(i, j\right)$ 表示顶点 $i$ 和顶点 $j$ 之间的边，那么通过给定 $n$ 的值及所有边的列表就能表示一个完整的网络，这种表示方法称之为边列表（edge list）。

相比于边列表，邻接矩阵（adjacency matrix）可以更好地表示网络。一个简单图的邻接矩阵 $\mathbf{A}$ 中元素 $A_{ij}$ 的含义如下：

$$ A_{ij}=\left\{\begin{array}{ll} 1 & \text{如果顶点 } i \text{ 和顶点 } j \text{ 之间存在一条边} \\ 0 & \text{其他} \end{array}\right. $$

对于一个没有自边的网络，其邻接矩阵有两个特点：

1. 邻接矩阵对角线上的元素取值均为零。
2. 邻接矩阵是对称的。

加权网络

对于加权网络（weighted network）和赋值网络（valued network）可以将邻接矩阵中对应元素的值设定为相应的权重的方式来进行表示。

有向网络

有向网络（directed network）或有向图（directed graph）有时简称为 digraph，在这类网络中，每条边都有方向，从一个顶点指向另一个顶点，称之为有向边（directed edge）。

超图

在某些类型的网络中，一些边会同时连接多个顶点。例如：创建一个社会网络，用来表示一个大规模社区中的各个家庭。每个家庭都可能会有两名或多名成员，因此表示这些家庭之间关系的做好方法就是使用一种广义边来同时连接多个顶点。这样的边称之为超边（hyperedge），含有超边的网络称之为超图（hypergraph）。下图 (a) 表示一个小型超图，其中超边用环的形式表示。

当一个网络中的顶点因为某种群组之间的关系被连接在一起时，可以使用超图来表示这个网络，在社会学中，这样的网络称之为隶属网络。对于超图，可于采用二分图的方式进行表示，通过引入 4 个新的顶点代表 4 个群组，在顶点及其所属群组之间通过边连接，如上图 (b) 所示。

二分网络

群组内成员之间的关系可以用超图中的超边表示，也可以等价地用更方便的二分图（bipartite network）表示。这种网络中有两类顶点，一类顶点代表原始顶点，另一类顶点则表示原始顶点所属的群组。

二分网络中，与邻接矩阵等价的是一个矩形矩阵，称之为关联矩阵（incidence matrix）。如果 $n$ 代表人数或网络中的成员数目，$g$ 是群组的数目，那么关联矩阵 $\mathbf{B}$ 是一个 $g \times n$ 的矩阵，其元素 $B_{ij}$ 的取值含义如下：

$$ B_{ij}=\left\{\begin{array}{ll} 1 & \text{如果顶点 } j \text{ 属于群组 } i \\ 0 & \text{其他} \end{array}\right. $$

研究统一类型顶点之间的直接联系可以通过对二分网络进行单模投影（one-mode projection），推导出同类顶点之间的直接联系，如下图所示。

树

**树（tree）**是连通的、无向的且不包含闭合循环的网络，如下图所示。

连通是指任意两个顶点之间都存在一条相互可达的路径。一个网络可能有两个或多个部分组成，每个部分相互之间不连通，如果任意单独的部分都为树，则称这个网络为森林（forest）。

由于树没有闭合循环，因此任意两个顶点之间有且只有一条相连的路径。如果一个树有 $n$ 个顶点，那么它有且仅有 $n - 1$ 条边。

度

图中顶点的度（degree）是指与其直接相连的边数目。将顶点 $i$ 的度表示为 $k_i$，对于有 $n$ 个顶点构成的无向图，可利用邻接矩阵将度表示为：

$$ k_i = \sum_{j=1}^{n} A_{ij} $$

在无向图中，每个边都有两端，如果一共有 $m$ 条边，那么就有 $2m$ 个边的端点。同时，边的端点数与所有顶点度的总和相等：

$$ 2m = \sum_{j=1}^{n} k_i $$

即

$$ m = \dfrac{1}{2} \sum_{i=1}^{n} k_i = \dfrac{1}{2} \sum_{ij} A_{ij} $$

无向图中顶点度的均值 $c$ 为：

$$ c = \dfrac{1}{n} \sum_{i=1}^{n} k_i $$

综上可得：

$$ c = \dfrac{2m}{n} $$

在一个简单图中，可能的边数的最大值是 $\dbinom{n}{2} = \dfrac{1}{2} n \left(n - 1\right)$ 个。图的连通度（connectance）或密度（density）$\rho$ 是所有图中实际出现的边的数目与边数最大值之间的比值：

$$ \rho = \dfrac{m}{\dbinom{n}{2}} = \dfrac{2m}{n \left(n - 1\right)} = \dfrac{c}{n - 1} $$

在有向图中，每个顶点有两个度：入度（in-degree）是连接到该顶点的入边的数目，出度（out-degree）是出边数目。当从顶点 $j$ 到 $i$ 有一条边时，邻接矩阵中对应的元素 $A_{ij} = 1$，则入度和出度记为：

$$ k_i^{\text{in}} = \sum_{j=1}^{n} A_{ij}, k_j^{\text{out}} = \sum_{i=1}^{n} A_{ij} $$

在有向图中，边的数目 $m$ 等于入边的端点数总和，也等于出边的端点数总和，有：

$$ m=\sum_{i=1}^{n} k_{i}^{\mathrm{in}}=\sum_{j=1}^{n} k_{j}^{\mathrm{out}}=\sum_{i j} A_{i j} $$

每个有向图的入度的均值 $c_{\text{in}}$ 和出度的均值 $c_{\text{out}}$ 是相等的：

$$ c_{\text {in }}=\frac{1}{n} \sum_{i=1}^{n} k_{i}^{\text {in }}=\frac{1}{n} \sum_{j=1}^{n} k_{j}^{\text {out }}=c_{\text {out }} $$

简化后有：

$$ c = \dfrac{m}{n} $$

路径

网络中的路径是指由一组顶点构成的序列，序列中每两个连续顶点都通过网络中的边连接在一起，路径长度等于该路径经过的边的数目（而非顶点的数目）。从顶点 $j$ 到顶点 $i$ 存在长度为 $r$ 的路径总数为：

$$ N_{ij}^{\left(r\right)} = \left[\mathbf{A}^r\right]_{ij} $$

其中，$\left[\cdots\right]_{ij}$ 表示矩阵中的第 $i$ 行、第 $j$ 列的元素。

测地路径（geodesic path），简称为最短路径（shortest path），即两个顶点间不存在更短路径的路径。图的直径（diameter）是指图中任意一对相互连接的顶点之间的最长测地路径长度。欧拉路径（Eulerian path）是经过网络中的所有边且每条边只经过一次的路径。哈密顿路径（Hamiltonian path）是访问网络的所有顶点且每个顶点只访问一次的路径。

分支

如果一个网络中两个顶点之间不存在路径，则称这个网络是非连通（disconnected）的，如果网络中任意两个顶点之间都能找到一条路径，则称这个网络是连通（connected）的。

网络中的子群称为分支（component）。分支是网络中顶点的子集，该子集中任何两个顶点之间至少存在一条路径，在保证该性质的前提下，网络中其他顶点都不能被添加到这个子集中。在保证一个给定性质的前提下，不能再向它添加其他顶点，就称其为最大子集（maximal subset）。

连通度

如果两条路经除了起点和终点外，不共享其他任何顶点，那么这两条路径是顶点独立（vertex-independent）的。如果两条路径是顶点独立的，那么也是边独立的，反之则不成立。

两个顶点之间的独立路径数称为顶点之间的连通度（connectivity），如果明确考虑边还是顶点，则需利用边连通度（edge connectivity）及顶点连通度（vertex connectivity）的概念。

子图

令原图表示为 $G = \left(V, E\right)$，其中，$V$ 是图中所有顶点的集合，$E$ 是图中所有边的集合，有：

1. 子图（subgraph）：$G'$ 中所有顶点和边均包含于原图 $G$ 中，即 $E' \in E, V' \in V$。
2. 生成子图（spanning subgraph）：$G'$ 中顶点同原图 $G$ 相同，且 $E' \in E$。
3. 导出子图（induced subgraph）：$G'$ 中，$V' \in V$，同时对于 $V'$ 中任意一个顶点，只要在原图 $G$ 中有对应的边，则也应包含在 $E'$ 中。

Motif

Motif ² 被定义为反复出现的重要连接模式。这些模式在真实的网络中要比随机网络中出现的更加频繁，如下图所示：

Motif 的显著性定义为：

$$ Z_i = \dfrac{N_i^{\text{real}} - \bar{N}_i^{\text{rand}}}{\text{std} \left(N_i^{\text{rand}}\right)} $$

其中，$N_i^{\text{real}}$ 为模式在真实图中出现的次数，$N_i^{\text{rand}}$ 为模式在随机图中出现的次数。

Graphlets

Graphlets 是对 Motif 的扩展，Motif 是从全局的角度发现模式，而 Graphlets 是从局部角度出发。Graphlets 是连接的非同构子图，这里要求子图为导出子图。下图展示了节点数为 2 至 5 的所有 Graphlets：

更多关于 Motif 和 Graphlets 的细节请参见 ^{3 4} 。

测度和度量

中心性

度中心性

中心性（centrality）是研究“网络中哪些顶点是最重要或最核心的？”这个问题的一个概念。网络中心性的最简单的测度是顶点的度，即与顶点相连的边的数量。有时为了强调度作为中心性测度的用途，在社会学中也称之为度中心性（degree centrality）。

特征向量中心性

度中心性可自然地扩展为特征向量中心性（eigenvector centrality）。可以将度中心性理解为给某顶点所有邻居顶点赋予一个“中心性值”，但并非所有连接顶点的值都是相同的。很多情况下，一个顶点会由于连接到一些本身很重要的点，而使自身的重要性得到提升，这就是特征向量中心性的本质。

对于每个顶点 $i$，假设其中心性为 $x_i$。对于所有 $i$，可以设其初始值 $x_i = 1$，利用该值可以计算出另一个更能体现中心性的值 $x'_i$，将 $x'_i$ 定义为 $i$ 所有邻居顶点的中心性之和：

$$ x'_i = \sum_{j} A_{ij} x_j $$

重复该过程可以得到更好的估计值，重复 $t$ 步后，中心性 $\mathbf{x} \left(t\right)$ 的计算公式如下：

$$ \mathbf{x} \left(t\right) = \mathbf{A}^t \mathbf{x} \left(0\right) $$

当 $t \to \infty$ 时，中心性向量的极限与邻接矩阵中的主特征向量成正比。因此，可以等价地认为中心性 $\mathbf{x}$ 满足：

$$ \mathbf{A} \mathbf{x} = \kappa_1 \mathbf{x} $$

其中，$\kappa_1$ 为矩阵 $\mathbf{A}$ 的特征值中的最大值。

特征向量中心性对于有向图和无向图都适用。在有向图中，邻接矩阵是非对称的，因此网络有两类特征向量，通常情况下我们选择右特征向量来定义中心性。因为在有向网络中，中心性主要是由指向顶点的顶点，而不是由顶点指向的顶点赋予的。

Katz 中心性

Katz 中心性解决了特征向量中心性中节点中心性可能为零的问题。通过为网络中每个顶点赋予少量的“免费”中心性，可以定义：

$$ x_i = \alpha \sum_{j} A_{ij} x_j + \beta $$

其中，$\alpha$ 和 $\beta$ 是正常数。使用矩阵表示可以写成：

$$ \mathbf{x} = \alpha \mathbf{A} \mathbf{x} + \beta \mathbf{1} $$

其中，$\mathbf{1}$ 代表向量 $\left(1, 1, 1, \cdots\right)$。重新整理有 $\mathbf{x} = \beta \left(\mathbf{I} - \alpha \mathbf{A}\right)^{-1} \mathbf{1}$，由于只关心相对值，通常可以设置 $\beta = 1$，则有：

$$ \mathbf{x} = \left(\mathbf{I} - \alpha \mathbf{A}\right)^{-1} \mathbf{1} $$

PageRank

Katz 中心性有一个不足，被一个 Katz 中心性较高的顶点指向的顶点具有较高的 Katz 中心性，但如果这个中心性较高的顶点指向大量顶点，那么这些大量被指向的顶点也会拥有较高的中心性，但这种估计并非总是恰当的。在新的中心性中，那些指向很多其他顶点的顶点，即使本身的中心性很高，但也只能传递给它指向的每个顶点少量的中心性，定义为：

$$ x_{i}=\alpha \sum_{j} A_{i j} \frac{x_{j}}{k_{j}^{\text {out }}}+\beta $$

其中，$k_j^{\text{out}}$ 为顶点的出度，当 $k_j^{\text{out}} = 0$ 时可以将其设定为任何一个非零值，都不会影响计算结果。利用矩阵的形式，可以表示为：

$$ \mathbf{x}=\alpha \mathbf{AD}^{-1} \mathbf{x}+\beta \mathbf{1} $$

其中，$\mathbf{D}$ 为对角矩阵，$D_{ii} = \max \left(k_j^{\text{out}}, 1\right)$。同之前一样，$\beta$ 只是整个公式的因子，设置 $\beta = 1$，有：

$$ \mathbf{x}=\left(\mathbf{I}-\alpha \mathbf{A} \mathbf{D}^{-1}\right)^{-1} \mathbf{1} $$

该中心性即为 PageRank。

上述 4 种中心性的区别和联系如下表所示：

接近度中心性

接近度中心性（closeness centrality）用于度量一个顶点到其他顶点的平均距离。

$$ C_{i}=\frac{1}{\ell_{i}}=\frac{n}{\sum_{j} d_{i j}} $$

其中，$d_{i j}$ 表示从顶点 $i$ 到 $j$ 的测地路径长度，即路径中边的总数，$\ell_{i}$ 表示从 $i$ 到 $j$ 的平均测地距离。在大多数网络中，顶点之间的测地距离一般都较小，并且随着网络规模的增长，该值只是以对数级别速度缓慢增长。

在不同分支中的两个顶点之间的测地距离定义为无穷大，则 $C_i$ 为零。为了解决这个问题，最常见的方法是只计算同一分支内部的顶点的平均测地距离。新的定义使用顶点之间的调和平均测地距离：

$$ C_{i}^{\prime}=\frac{1}{n-1} \sum_{j(\neq i)} \frac{1}{d_{i j}} $$

公式中排除了 $j = i$ 的情况，因为 $d_{ii} = 0$。结果也称之为调和中心性（harmonic centrality）。

介数中心性

介数中心性（betweenness centrality）描述了一个顶点在其他顶点之间路径上的分布程度。假设在网络中每两个顶点之间，在每个单位时间内以相等的概率交换信息，信息总是沿着网络中最短测地路径传播，如果有多条最短测地路径则随机选择。由于消息是沿着最短路径以相同的速率传播，因此经过某个顶点的消息数与经过该顶点的测地路径数成正比。测地路径数就是所谓的介数中心性，简称介数。

定义 $n_{st}^i$ 为从 $s$ 到 $t$ 经过 $i$ 的测地路径数量，定义 $g_{st}$ 为从 $s$ 到 $t$ 的测地路径总数，那么顶点 $i$ 的介数中心性可以表示为：

$$ x_{i}=\sum_{s t} \frac{n_{s t}^{i}}{g_{s t}} $$

高介数中心性的顶点由于控制着其他顶点之间的消息传递，在网络中有着很强的影响力。删除介数最高的顶点，也最有可能破坏其他顶点之间的通信。

不同中心性的可视化如下图所示：

其中，A：介数中心性；B：接近度中心性；C：特征向量中心性；D：度中心性；E：调和中心性；F：Katz 中心性。

传递性

传递性（transitivity）在社会网络中的重要性要比其他网络中重要得多。在数学上，对于关系“$\circ$”，如果 $a \circ b$ 和 $b \circ c$，若能推出 $a \circ c$，则称 $\circ$ 具有传递性。

完全传递性值出现在每一个分支都是全连通的子图或团的网络中。团（clique）是指无向图网络中的一个最大顶点子集，在该子集中任何两个顶点之间都有一条边直接连接。完全传递性没有太多的实际意义，而部分传递性却很有用。在很多网络中，$u$ 认识 $v$ 且 $v$ 认识 $w$，并不能保证 $u$ 认识 $w$，但两者之间相互认识的概率很大。

如果 $u$ 也认识 $w$，则称该路径是闭合的。在社会网络术语中，称 $u, v, w$ 这 3 个顶点形成一个闭合三元组（closed triad）。我们将聚类系数（clustering coefficient）定义为网络中所有长度为 2 的路径中闭合路径所占的比例：

$$ C = \dfrac{\text{长度为 2 的路径中闭合路径数}}{\text{长度为 2 的路径数}} $$

其取值范围在 0 到 1 之间。社会网络的聚类系数比其他网络偏高。

对于顶点 $i$，定地单个顶点的聚类系数为：

$$ C_i = \dfrac{\text{顶点 i 的邻居顶点中直接相连的顶点对数}}{\text{顶点 i 的邻居顶点对总数}} $$

$C_i$ 也称为局部聚类系数（local clustering coefficient），该值代表了 $i$ 的朋友之间互为朋友的平均概率。

相互性

聚类系数观察的是长度为 3 的循环，长度为 2 的循环的频率通过相互性（reciprocity）来度量，该频率描述了两个顶点之间相互指向的概率。

相似性

社会网络分析的另一个核心概念是顶点之间的相似性。构造网络相似性的测度有两种基本方法：结构等价（structural equivalence）和规则等价（regular equivalence），如下图所示：

结构等价

针对无向网络中，最简单和最显而易见的结构等价测度就是计算两个顶点的共享邻居顶点数。在无向网络中，顶点 $i$ 和 $j$ 的共享邻居顶点数表示为 $n_{ij}$，有：

$$ n_{ij} = \sum_{k} A_{ik} A_{kj} $$

利用余弦相似度可以更好的对其进行度量。将邻接矩阵的第 $i$ 和第 $j$ 行分别看成两个向量，然后将这两个向量之间的夹角余弦值用于相似性度量，有：

$$ \sigma_{i j}=\cos \theta=\frac{\sum_{k} A_{i k} A_{k j}}{\sqrt{\sum_{k} A_{i k}^{2}} \sqrt{\Sigma_{k} A_{j k}^{2}}} $$

假设网络是不带权重的简单图，上式可以化简为：

$$ \sigma_{i j}=\frac{\sum_{k} A_{i k} A_{k j}}{\sqrt{k_{i}} \sqrt{k_{j}}}=\frac{n_{i j}}{\sqrt{k_{i} k_{j}}} $$

其中，$k_i$ 是顶点 $i$ 的度。余弦相似度的取值范围为从 0 到 1，1 表示两个顶点之间拥有完全相同的邻居节点。

皮尔逊相关系数通过同随机选择邻居顶点条件下共享邻居顶点数的期望值进行比较的方式进行计算，得到的标准的皮尔逊相关系数为：

$$ r_{i j}=\frac{\sum_{k}\left(A_{i k}-\left\langle A_{i}\right\rangle\right)\left(A_{j k}-\left\langle A_{j}\right\rangle\right)}{\sqrt{\sum_{k}\left(A_{i k}-\left\langle A_{i}\right\rangle\right)^{2}} \sqrt{\sum_{k}\left(A_{j k}-\left\langle A_{j}\right\rangle\right)^{2}}} $$

上式的取值范围从 -1 到 1，数值越大表明两者之间越相似。

规则等价

规则等价的顶点不必共享邻居顶点，但是两个顶点的邻居顶点本身要具有相似性。一些简单的代数测度思想如下：定义一个相似性值 $\sigma_{ij}$，若顶点 $i$ 和 $j$ 各自的邻居顶点 $k$ 和 $l$ 本身具有较高的相似性，则 $i$ 和 $j$ 的相似性也较高。对于无向网络，有以下公式：

$$ \sigma_{i j}=\alpha \sum_{k l} A_{i k} A_{j l} \sigma_{k l} $$

或者利用矩阵性质表示为 $\mathbf{\sigma} = \alpha \mathbf{A \sigma A}$。

同质性

在社会网络中，人们倾向于选择那些他们认为与其自身在某些方面相似的人作为朋友，这种倾向性称为同质性（homophily）或同配混合（assortative mixing）。

依据枚举特征的同配混合

假设有一个网络，其顶点根据某个枚举特征（例如：国籍、种族、性别等）分类，且该特征的取值是一个有限集合。如果网络中连接相同类型顶点之间的边所占比例很大，那么该网络就是同配的。量化同配性简单的方法是观测这部分边占总边数的比例，但这并不是很好的度量方法，因为如果所有顶点都是同一个类型，那么测度值就是 1。

好的测度可以通过首先找出连接同类顶点的边所占的比例，然后减去在不考虑顶点类型时，随机连接的边中，连接两个同类顶点的边所占比例的期望值的方式得到。常用的测度为模块度（modularity）：

$$ Q=\frac{1}{2 m} \sum_{i j}\left(A_{i j}-\frac{k_{i} k_{j}}{2 m}\right) \delta_{g_{i} g_{i}} $$

其中，$k_i$ 为顶点 $i$ 的度，$g_i$ 为顶点 $i$ 的类型，$m$ 为总边数，$\delta_{ij}$ 为克罗内克函数。该值严格小于 1，如果同类顶点之间边数的实际值大于随机条件下的期望值，则该值为正数，否则为负数，值为正说明该网络是同配混合的。

依据标量特征的同配混合

如果根据标量特征（例如：年龄、收入等）来度量网络中的同质性。由于该类特征具有确定的顺序，因此根据标量的数值，不仅可以指出两个顶点在什么情况下是完全相同的，也可以指出它们在真么情况下是近似相同的。

令 $x_i$ 为顶点 $i$ 的标量值，$\left(x_i, x_j\right)$ 为网络中每一条边 $\left(i, j\right)$ 的两个端点的值，利用协方差可以得到同配系数：

$$ r=\frac{\sum_{i j}\left(A_{i j}-k_{i} k_{j} / 2 m\right) x_{i} x_{j}}{\sum_{i j}\left(k_{i} \delta_{i j}-k_{i} k_{j} / 2 m\right) x_{i} x_{j}} $$

该系数在全同配混合网络中取最大值 1，在全异配混合网络中取最小值 -1，值 0 意味着边两端的顶点值是非相关的。

依据度的同配混合

依据度的同配混合是依据标量特征的同配混合的一个特例。依据度的同配混合网络中，高度数顶点倾向于与其他高度数顶点相连，而低度数顶点倾向于与其他低度数顶点相连。

在同配网络中，度大的顶点倾向于聚集在一起的网络中，我们希望得到网络中这些度大的顶点构成的顶点块或核，它们周围是一些度小的顶点构成的低密度边缘（periphery）。这种核心/边缘结构（core/periphery structure）是社会网络的普遍特征。

上图 (a) 给出了一个小型的同配混合网络，其核心/边缘结构明显，上图 (b) 给出了一个小型异配混合网络，通常不具备核心/边缘结构，但顶点的分布更加均匀。

文本表示角度

统计模型

文本切分

在中文和拉丁语系中，文本的直观表示就存在一定的差异，拉丁语系中词与词之间存在天然的分隔符，而中文则没有。

I can eat glass, it doesn’t hurt me.
我能吞下玻璃而不伤身体。

因此针对拉丁语系的文本切分相对中文容易许多。

• N 元语法

N-gram (N 元语法) 是一种文本表示方法，指文中连续出现的 $n$ 个词语。N-gram 模型是基于 $n-1$ 阶马尔科夫链的一种概率语言模型，可以通过前 $n-1$ 个词对第 $n$ 个词进行预测。以 南京市长江大桥 为例，N-gram 的表示如下：

一元语法（unigram）：南/京/市/长/江/大/桥
二元语法（bigram）：南京/京市/市长/长江/江大/大桥
三元语法（trigram）：南京市/京市长/市长江/长江大/江大桥

import re
from nltk.util import ngrams

s = '南京市长江大桥'
tokens = re.sub(r'\s', '', s)

list(ngrams(tokens, 1))
# [('南',), ('京',), ('市',), ('长',), ('江',), ('大',), ('桥',)]

list(ngrams(tokens, 2))
# [('南', '京'), ('京', '市'), ('市', '长'),
#  ('长', '江'), ('江', '大'), ('大', '桥')]

list(ngrams(tokens, 3, pad_left=True, pad_right=True, left_pad_symbol='<s>', right_pad_symbol='</s>'))
# [('<s>', '<s>', '南'),
#  ('<s>', '南', '京'),
#  ('南', '京', '市'),
#  ('京', '市', '长'),
#  ('市', '长', '江'),
#  ('长', '江', '大'),
#  ('江', '大', '桥'),
#  ('大', '桥', '</s>'),
#  ('桥', '</s>', '</s>')]

• 分词

分词就是将连续的字序列按照一定的规范重新组合成词序列的过程。在英文的行文中，单词之间是以空格作为自然分界符的，而中文只是字、句和段能通过明显的分界符来简单划界，唯独词没有一个形式上的分界符，虽然英文也同样存在短语的划分问题，不过在词这一层上，中文比之英文要复杂得多、困难得多。

s = '南京市长江大桥'

# jieba
# https://github.com/fxsjy/jieba
import jieba

list(jieba.cut(s, cut_all=False))
# ['南京市', '长江大桥']

list(jieba.cut(s, cut_all=True))
# ['南京', '南京市', '京市', '市长', '长江', '长江大桥', '大桥']

list(jieba.cut_for_search(s))
# ['南京', '京市', '南京市', '长江', '大桥', '长江大桥']

# THULAC
# https://github.com/thunlp/THULAC-Python
import thulac

thulac_ins = thulac.thulac()

thulac_ins.cut(s)
# [['南京市', 'ns'], ['长江', 'ns'], ['大桥', 'n']]

# PKUSEG
# https://github.com/lancopku/PKUSeg-python
import pkuseg

seg = pkuseg.pkuseg(postag=True)

seg.cut(s)
# [('南京市', 'ns'), ('长江', 'ns'), ('大桥', 'n')]

# HanLP
# https://github.com/hankcs/HanLP
import hanlp

tokenizer = hanlp.load('LARGE_ALBERT_BASE')

tokenizer(s)
# ['南京市', '长江', '大桥']

主题模型

除了对文本进行切分将切分后结果全部用于表示文本外，还可以用部分字词表示一篇文档。主题模型（Topic Model）在机器学习和自然语言处理等领域是用来在一系列文档中发现抽象主题的一种统计模型。

直观来讲，如果一篇文章有一个中心思想，那么一些特定词语会更频繁的出现。比方说，如果一篇文章是在讲狗的，那“狗”和“骨头”等词出现的频率会高些。如果一篇文章是在讲猫的，那“猫”和“鱼”等词出现的频率会高些。而有些词例如“这个”、“和”大概在两篇文章中出现的频率会大致相等。但真实的情况是，一篇文章通常包含多种主题，而且每个主题所占比例各不相同。因此，如果一篇文章 10% 和猫有关，90% 和狗有关，那么和狗相关的关键字出现的次数大概会是和猫相关的关键字出现次数的 9 倍。

一个主题模型试图用数学框架来体现文档的这种特点。主题模型自动分析每个文档，统计文档内的词语，根据统计的信息来断定当前文档含有哪些主题，以及每个主题所占的比例各为多少 ¹。

• TF-IDF

TF-IDF 是 Term Frequency - Inverse Document Frequency 的缩写，即“词频-逆文本频率”。TF-IDF 可以用于评估一个字词在语料中的一篇文档中的重要程度，基本思想是如果某个字词在一篇文档中出现的频率较高，而在其他文档中出现频率较低，则认为这个字词更能够代表这篇文档。

形式化地，对于文档 $y$ 中的字词 $x$ 的 TF-IDF 重要程度可以表示为：

$$ w_{x, y} = tf_{x, y} \times \log \left(\dfrac{N}{df_{x}}\right) $$

其中，$tf_{x, y}$ 表示字词 $x$ 在文档 $y$ 中出现的频率，$df_x$ 为包含字词 $x$ 的文档数量，$N$ 为语料中文档的总数量。

以 14 万歌词语料 为例，通过 TF-IDF 计算周杰伦的《简单爱》中最重要的 3 个词为 ['睡着', '放开', '棒球']。

• BM25

BM25 算法的全称为 Okapi BM25，是一种搜索引擎用于评估查询和文档之间相关程度的排序算法，其中 BM 是 Best Match 的缩写。

对于一个给定的查询 $Q$，包含的关键词为 $q_1, \cdots, q_n$，一个文档 $D$ 的 BM25 值定义为：

$$ \operatorname{score}(D, Q)=\sum_{i=1}^{n} \operatorname{IDF}\left(q_{i}\right) \cdot \frac{f\left(q_{i}, D\right) \cdot\left(k_{1}+1\right)}{f\left(q_{i}, D\right)+k_{1} \cdot\left(1-b+b \cdot \frac{|D|}{\text { avgdl }}\right)} $$

其中，$f\left(q_{i}, D\right)$ 表示 $q_i$ 在文档 $D$ 中的词频，$|D|$ 表示文档 $D$ 中的词数，$\text{avgdl}$ 表示语料中所有文档的平均长度。$k_1$ 和 $b$ 为自由参数，通常取值为 $k_1 \in \left[1.2, 2.0\right], b = 0.75$ ²。$\operatorname{IDF} \left(q_i\right)$ 表示词 $q_i$ 的逆文档频率，通常计算方式如下：

$$ \operatorname{IDF}\left(q_{i}\right)=\ln \left(\frac{N-n\left(q_{i}\right)+0.5}{n\left(q_{i}\right)+0.5}+1\right) $$

其中，$N$ 为语料中文档的总数量，$n \left(q_i\right)$ 表示包含 $q_i$ 的文档数量。

BM25 算法是对 TF-IDF 算法的优化，在词频的计算上，BM25 限制了文档 $D$ 中关键词 $q_i$ 的词频对评分的影响。为了防止词频过大，BM25 将这个值的上限设置为 $k_1 + 1$。

同时，BM25 还引入了平均文档长度 $\text{avgdl}$，不同的平均文档长度 $\text{avgdl}$ 对 TF 分值的影响如下图所示：

• TextRank

TextRank ³ 是基于 PageRank ⁴ 算法的一种关键词提取算法。PageRank 最早是用于 Google 的网页排名，因此以公司创始人拉里·佩奇（Larry Page）的姓氏来命名。PageRank 的计算公式如下：

$$ S\left(V_{i}\right)=(1-d)+d * \sum_{V_{j} \in I n\left(V_{i}\right)} \frac{1}{\left|O u t\left(V_{j}\right)\right|} S\left(V_{j}\right) $$

其中，$V_i$ 表示任意一个网页，$V_j$ 表示链接到网页 $V_i$ 的网页，$S \left(V_i\right)$ 表示网页 $V_i$ 的 PageRank 值，$In \left(V_i\right)$ 表示网页 $V_i$ 所有的入链集合，$Out \left(V_j\right)$ 表示网页 $V_j$ 所有的出链集合，$|\cdot|$ 表示集合的大小，$d$ 为阻尼系数，是为了确保每个网页的 PageRank 值都大于 0。

TextRank 由 PageRank 改进而来，计算公式如下：

$$ WS \left(V_{i}\right)=(1-d)+d * \sum_{V_{j} \in In\left(V_{i}\right)} \frac{w_{j i}}{\sum_{V_{k} \in Out\left(V_{j}\right)} w_{j k}} WS \left(V_{j}\right) $$

相比于 PageRank 公式增加了权重项 $W_{ji}$，用来表示两个节点之间的边的权重。TextRank 提取关键词的算法流程如下：

1. 将文本进行切分得到 $S_i = \left[t_{i1}, t_{i2}, \cdots, t_{in}\right]$。
2. 将 $S_i$ 中大小为 $k$ 的滑动窗口中的词定义为共现关系，构建关键词图 $G = \left(V, E\right)$。
3. 根据 TextRank 的计算公式对每个节点的值进行计算，直至收敛。
4. 对节点的 TextRank 的值进行倒叙排序，获取前 $n$ 个词作为关键词。

• LSA, PLSA, LDA & HDP

潜在语义分析（LSA, Latent Semantic Analysis）⁵ 的核心思想是将文本的高维词空间映射到一个低维的向量空间，我们称之为隐含语义空间。降维可以通过奇异值分解（SVD）实现，令 $X$ 表示语料矩阵，元素 $\left(i, j\right)$ 表示词 $i$ 和文档 $j$ 的共现情况（例如：词频）：

$$ X = \mathbf{d}_{j} \cdot \mathbf{t}_{i}^{T} = \left[\begin{array}{c} x_{1, j} \\ \vdots \\ x_{i, j} \\ \vdots \\ x_{m, j} \end{array}\right] \cdot \left[\begin{array}{ccccc} x_{i, 1} & \ldots & x_{i, j} & \ldots & x_{i, n} \end{array}\right] = \left[\begin{array}{ccccc} x_{1,1} & \ldots & x_{1, j} & \ldots & x_{1, n} \\ \vdots & \ddots & \vdots & \ddots & \vdots \\ x_{i, 1} & \ldots & x_{i, j} & \ldots & x_{i, n} \\ \vdots & \ddots & \vdots & \ddots & \vdots \\ x_{m, 1} & \ldots & x_{m, j} & \ldots & x_{m, n} \end{array}\right] $$

利用奇异值分解：

$$ X = U \Sigma V^{T} $$

取最大的 $K$ 个奇异值，则可以得到原始矩阵的近似矩阵：

$$ \widetilde{X} =U \widetilde{\Sigma} V^{T} $$

在处理一个新的文档时，可以利用下面的公式将原始的词空间映射到潜在语义空间：

$$ \tilde{x} =\tilde{\Sigma} ^{-1} V^{T} x_{test} $$

LSA 的优点：

1. 低维空间可以刻画同义词
2. 无监督模型
3. 降维可以减少噪声，使特征更加鲁棒

LSA 的缺点：

1. 未解决多义词问题
2. 计算复杂度高，增加新文档时需要重新训练
3. 没有明确的物理解释
4. 高斯分布假设不符合文本特征（词频不为负）
5. 维度的确定是 Ad hoc 的

概率潜语义分析（Probabilistic Latent Semantic Analysis, PLSA）⁶ 相比于 LSA 增加了概率模型，每个变量以及相应的概率分布和条件概率分布都有明确的物理解释。

PLSA 认为一篇文档可以由多个主题混合而成，而每个主题都是词上的概率分布，文章中的每个词都是由一个固定的主题生成的，如下图所示：

针对第 $m$ 篇文档 $d_m$ 中的每个词的生成概率为：

$$ p\left(w \mid d_{m}\right)=\sum_{z=1}^{K} p(w \mid z) p\left(z \mid d_{m}\right)=\sum_{z=1}^{K} \varphi_{z w} \theta_{m z} $$

因此整篇文档的生成概率为：

$$ p\left(\vec{w} \mid d_{m}\right)=\prod_{i=1}^{n} \sum_{z=1}^{K} p\left(w_{i} \mid z\right) p\left(z \mid d_{m}\right)=\prod_{i=1}^{n} \sum_{z=1}^{K} \varphi_{z w_{i}} \theta_{d z} $$

PLSA 可以利用 EM 算法求得局部最优解。

PLSA 优点：

1. 定义了概率模型，有明确的物理解释
2. 多项式分布假设更加符合文本特征
3. 可以通过模型选择和复杂度控制来确定主题的维度
4. 解决了同义词和多义词的问题

PLSA 缺点：

1. 随着文本和词的增加，PLSA 模型参数也随之线性增加
2. 可以生成语料中的文档的模型，但不能生成新文档的模型
3. EM 算法求解的计算量较大

隐含狄利克雷分布（Latent Dirichlet Allocation, LDA）⁷ 在 PLSA 的基础上增加了参数的先验分布。在 PLSA 中，对于一个新文档，是无法获取 $p \left(d\right)$ 的，因此这个概率模型是不完备的。LDA 对于 $\vec{\theta}_m$ 和 $\vec{\phi}_k$ 都增加了多项式分布的共轭分布狄利克雷分布作为先验，整个 LDA 模型如下图所示：

LDA 的参数估计可以通过吉布斯采样实现。PLSA 和 LDA 的更多细节请参见《LDA 数学八卦》⁸。

LDA 在使用过程中仍需要指定主题的个数，而层次狄利克雷过程（Hierarchical Dirichlet Processes, HDP）⁹ 通过过程的构造可以自动训练出主题的个数，更多实现细节请参考论文。

LSA，PLSA，LDA 和 HDP 之间的演化关系如下图所示：

本节相关代码详见 这里。

距离度量

本节内容源自 相似性和距离度量 (Similarity & Distance Measurement)。

相似性度量 (Similarity Measurement) 用于衡量两个元素之间的相似性程度或两者之间的距离 (Distance)。距离衡量的是指元素之间的不相似性 (Dissimilarity)，通常情况下我们可以利用一个距离函数定义集合 $X$ 上元素间的距离，即：

$$ d: X \times X \to \mathbb{R} $$

• Jaccard 系数

$$ s = \dfrac{\left|X \cap Y\right|}{\left| X \cup Y \right|} = \dfrac{\left|X \cap Y\right|}{\left|X\right| + \left|Y\right| - \left|X \cap Y\right|} $$

Jaccard 系数的取值范围为：$\left[0, 1\right]$，0 表示两个集合没有重合，1 表示两个集合完全重合。

• Dice 系数

$$ s = \dfrac{2 \left| X \cap Y \right|}{\left|X\right| + \left|Y\right|} $$

与 Jaccard 系数相同，Dice 系数的取值范围为：$\left[0, 1\right]$，两者之间可以相互转换 $s_d = 2 s_j / \left(1 + s_j\right), s_j = s_d / \left(2 - s_d\right)$。不同于 Jaccard 系数，Dice 系数的差异函数 $d = 1 - s$ 并不是一个合适的距离度量，因为其并不满足距离函数的三角不等式。

• Tversky 系数

$$ s = \dfrac{\left| X \cap Y \right|}{\left| X \cap Y \right| + \alpha \left| X \setminus Y \right| + \beta \left| Y \setminus X \right|} $$

其中，$X \setminus Y$ 表示集合的相对补集。Tversky 系数可以理解为 Jaccard 系数和 Dice 系数的一般化，当 $\alpha = \beta = 1$ 时为 Jaccard 系数，当 $\alpha = \beta = 0.5$ 时为 Dice 系数。

• Levenshtein 距离

Levenshtein 距离是 编辑距离 (Editor Distance) 的一种，指两个字串之间，由一个转成另一个所需的最少编辑操作次数。允许的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。例如将 kitten 转成 sitting，转换过程如下：

$$ \begin{equation*} \begin{split} \text{kitten} \to \text{sitten} \left(k \to s\right) \\ \text{sitten} \to \text{sittin} \left(e \to i\right) \\ \text{sittin} \to \text{sitting} \left(\ \to g\right) \end{split} \end{equation*} $$

编辑距离的求解可以利用动态规划的思想优化计算的时间复杂度。

• Jaro-Winkler 距离

对于给定的两个字符串 $s_1$ 和 $s_2$，Jaro 相似度定义为：

$$ sim = \begin{cases} 0 & \text{if} \ m = 0 \\ \dfrac{1}{3} \left(\dfrac{m}{\left|s_1\right|} + \dfrac{m}{\left|s_2\right|} + \dfrac{m-t}{m}\right) & \text{otherwise} \end{cases} $$

其中，$\left|s_i\right|$ 为字符串 $s_i$ 的长度，$m$ 为匹配的字符的个数，$t$ 换位数目的一半。如果字符串 $s_1$ 和 $s_2$ 相差不超过 $\lfloor \dfrac{\max \left(\left|s_1\right|, \left|s_2\right|\right)}{2} \rfloor - 1$，我们则认为两个字符串是匹配的。例如，对于字符串 CRATE 和 TRACE，仅 R, A, E 三个字符是匹配的，因此 $m = 3$，尽管 C, T 均出现在两个字符串中，但是他们的距离超过了 1 (即，$\lfloor \dfrac{5}{2} \rfloor - 1$)，因此 $t = 0$。

Jaro-Winkler 相似度给予了起始部分相同的字符串更高的分数，其定义为：

$$ sim_w = sim_j + l p \left(1 - sim_j\right) $$

其中，$sim_j$ 为字符串 $s_1$ 和 $s_2$ 的 Jaro 相似度，$l$ 为共同前缀的长度 (规定不超过 $4$)，$p$ 为调整系数 (规定不超过 $0.25$)，Winkler 将其设置为 $p = 0.1$。

• 汉明距离

汉明距离为两个等长字符串对应位置的不同字符的个数，也就是将一个字符串变换成另外一个字符串所需要替换的字符个数。例如：1011101 与 1001001 之间的汉明距离是 2，“toned” 与 “roses” 之间的汉明距离是 3。

import textdistance as td

s1 = '南京市长江大桥'
s2 = '北京市三元桥'

td.jaccard(s1, s2)
# 0.6666666666666666

td.sorensen_dice(s1, s2)
# 0.46153846153846156

td.tversky(s1, s2)
# 0.3

td.levenshtein(s1, s2)
# 4

td.jaro(s1, s2)
# 0.6428571428571429

td.hamming(s1, s2)
# 5

表示学习

基于表示学习的文本相似度计算方法的思路如下：

1. 利用表示学习方法将不定长的文本表示为定长的实值向量。
2. 计算转换后的实值向量相似度，用于表示两个文本的相似度。

关于文本表示学习和实值向量相似度计算请参见之前博客：词向量 (Word Embeddings)，相似性和距离度量 (Similarity & Distance Measurement)，预训练自然语言模型 (Pre-trained Models for NLP)。

文本词法，句法和语义角度

本节主要参考自《基于词法、句法和语义的句子相似度计算方法》¹⁰。

一段文本的内容分析由浅及深可以分为词法，句法和语义三个层次。

1. 词法，以词为对象，研究包括分词，词性和命名实体等。
2. 句法，以句子为对象，研究包括句子成分和句子结构等。
3. 语义，研究文字所表达的含义和蕴含的知识等。

词法和句法可以统一成为语法，如下图所示：

词法

词法层以单个句子作为输入，其输出为已标记（词性，命名实体等）的词汇序列。

词汇序列的相似度计算可以采用上文中的距离度量等方式实现。

句法

句法层用于研究句子各个组成部分及其排列顺序，将文本分解为句法单位，以理解句法元素的排列方式。句法层接收词法层分析后的将其转化为依存图。

对于依存图，我们可以利用三元组 $S = \left(V_1, E, V_2\right)$ 表示任意一个依存关系，然后通过统计计算两个文本的依存图的三元组集合之间的相似度来评价句法层的相似度。此外，也可以从树结构的角度直接评价依存句法的相似度，更多细节可参考相关论文 ^{11 12}。

语义

语义层用于研究文本所蕴含的意义。例如“父亲”和“爸爸”在词法层完全不同，但在语义层却具有相同的含义。针对语义相似度的两种深度学习范式如下：

第一种范式首先通过神经网络获取文本的向量表示，再通过向量之间的相似度来衡量文本的语义相似度。这种范式在提取特征时不考虑另一个文本的信息，更适合做大规模的语义相似召回，例如：DSSM ¹³，ARC-I ¹⁴，CNTN ¹⁵，LSTM-RNN ¹⁶ 等。

第二种范式首先通过深度模型提取两个文本的交叉特征，得到匹配信号张量，再聚合为匹配分数。这种范式同时考虑两个文本的输入信息，更适合做小规模的语义相似精排，例如：ARC-II ¹⁴，MatchPyramid ¹⁷，Match-SRNN ¹⁸，Duet ¹⁹ 等。

文本长度角度

从文本长度角度出发，我们可以粗略的将文本分类为短文本和长文本。短文本包括“字词”，“短语”，“句子”等相对比较短的文本形式，长文本包括“段落”，“篇章”等相对比较长的文本形式。

短文本 v.s. 短文本

短文本同短文本的常见比较形式有：关键词（字词）同文本标题（句子）的匹配，相似查询（句子）的匹配等。如果单纯的希望获取字符层面的差异，可以通过距离度量进行相似度比较。如果需要从语义的角度获取相似度，则可以利用表示学习对需要比对的文本进行表示，在通过语义向量之间的相似程度来衡量原始文本之间的相似度，详情可参见上文。

短文本 v.s. 长文本

短文本同长文本的比较多见于文档的搜索，即给定相关的查询（字词），给出最相关的文档（段落和篇章）。对于这类问题常见的解决方式是对长文本利用 TF-IDF，BM25等方法或进行主题建模后，再同查询的关键词进行匹配计算相似度度。

长文本 v.s. 长文本

长文本同长文本的比较多见于文档的匹配和去重，对于这类问题常见的解决方式是利用关键词提取获取长文本的特征向量，然后利用特征向量之间的相似度衡量对应文本的相似程度。在针对海量文本的去重，还以应用 SimHash 等技术对文本生成一个指纹，从而实现快速去重。

有时候会自嘲没有远大的志向和野心，但这样其实很真实，我认为平淡是人生的常态，脑海中记忆更深的才是平淡之外的苦难和幸福。虛泛的东西写多了容易变成鸡汤，简单整理几块内容省身克己，如于他人有益，实则万幸。

三观

总是在说三观，其实容易泛泛而谈，我认为三观会从很大程度上决定应该去做什么、喜欢去做什么，甚至会影响到擅长去做什么。

世界观

世界观是我们对于宇宙的根本看法，我认为这是进行沟通的一个基础，如果两个人在这个层面上就处在对立的位置，感觉无论沟通什么都会失去意义。世界观的两个根本对立即唯物主义和唯心主义，我自己不在任意一个极端，非要占个队，我应该会略微偏向唯物主义。毕竟鸡不打鸣太阳照常会升起，但如果我看不到，于我又有什么意义。

在我认识的人中，没有遇见太过极端的，更多的可能是受到民族、信仰、地域等因素的长期影响吧，或多或少都会有些差异。我认为只要不处在完全的对立面，一切都还是可以去思考、去沟通、去辩解的。

人生观

生而为赢（Born to Win）是高中年代看过的一篇文章，很鸡血，也着实影响了自己的求学年代。但随着环境的改变和自己人生的实践，对于人生态度、目的和意义的思考也在不断转变。现在来看，生而为赢依旧没错，拼搏和奋斗才能创造平淡之中的幸福。当前的我想要追求的是平淡之中不乏波澜，或好或坏，同时在为之努力的过程中也不要给别人添堵，说白了不能损人利己，损人不利己就更要唾弃了。

「认命」是我最近比较喜欢的一个词，也是最近更新了对其理解的词。其实“认命”并不消极，尽人事，听天命，积极做事，结果往往会受到多方面的影响，成则已，不成换个路子继续尽人事。人生观相比世界观可能更容易发生变化，虽然没有世界观那么基础，但我认为对待人生观也应该更多的从“功利主义”而非“个人主义”角度出发，如果从这个层面上就背离社会大多数认可的正道，那么就会容易走上邪路，危害他人，这不就真给人添堵了吗。

价值观

孰好孰坏、孰优孰劣真的不是一个很容易回答的问题。面对比较基础的问题，只要不违背世界观和人生观，还是能够比较明确的给出一个结论的，但细到很小很具体的问题上，每个人的见解就不同了。所以，对待大是大非、大善大恶同上面一样，我更倾向于功利主义，对于小事，我认为要做到有理有据、不自欺欺人，那么就无伤大雅。

价值观包含物质性和精神性两大种类，我想两者也不必割裂而谈，不必不食人间烟火，能与朋友大快朵颐，亦能与朋友谈天论地，岂不快哉？

做有意义的事，不给人添堵，什么有意义，需要自己去思考。

思考

要思考，但也别想太多，多思考做人做事自然是好的，但是天马行空的想太多，容易出现各种妄想症，我略受过其害。

思辨胜于对错

做算法久了，虽然越来越需要更深入的了解业务，但同业务掰扯的时候还是不多的，更多的是围绕抽象出来的问题在做事。做这些事情需要更多的是专业力，是非对错就是一个量化评估的过程，但真遇到一些方向上的问题，或是与人更相关的问题，对错的判断就显得不是那么容易。

即便将来一直沿着技术专家路线发展下去，我认为对上层问题的思考终将占据更重要的地位，而且也如实在这样发展。所以要有一套自己衡量评价事情的方法论，是非对错的评价标准因我们的世界观、人生观、价值观不同而有差异，但方法论还是能够有一定通用性的。方法论并不虚，就像我们做数据挖掘用的 CRISP-DM 一样，能够帮助我们更加客观、全面、系统的去做事。思考如何去评判，感觉比一味地争辩什么是对、什么是错更有意义。

永不停止

无论处于顺势还是逆势，都不要停止思考，顺势思考如何锦上添花，逆势思考如何雪中送炭。浑浑噩噩、自欺欺人、得过且过是最不可取的。读万卷书、行万里路、交万名友，成本最低的就是读万卷书，思考和读书类似，除了时间没什么太大的花销，就看你想不想。

生命不息，思考不止。

自由

自由有很多种，财务自由、意志自由，谈及大多数自由的时候都是我们所追求的。当然自由的首要前提正如《人权宣言》里面说的：「自由即有权做一切无害于他人的任何事情」。也就是自由并不是为所欲为，当然哪怕无害于他人，肆意挥霍、信口开河也是应该是被唾弃的。

读胡适的《容忍与自由》，感觉成事要「养成能够容忍谅解别人的见解的度量」，不要「以吾辈所主张这为绝对之是」。尤其进入到一个新的领域，要谦逊但不谦卑地去学习和理解，懂得尊重和敬畏即为容忍。

我是一个比较喜欢用数据说话的人，但有时也正是这种“所谓的有理有据”会让我“怼人”怼得理所当然。当想要让别人容忍谅解我们的见解，我们自己应该先做到这一点，凡事没有绝对，哪怕概率是一也不一定必然发生，数据说话是好事，只是不要被数字本身所蒙蔽就好。

我年纪越大，越感觉到容忍比自由更重要

精确搜索

暴力查找（Brute-force Search）

最简单的最邻近搜索便是遍历整个点集，计算它们和目标点之间的距离，同时记录目前的最近点。这样的算法较为初级，可以为较小规模的点集所用，但是对于点集的尺寸和空间的维数稍大的情况则不适用。对于 $D$ 维的 $N$ 个样本而言，暴力查找方法的复杂度为 $O \left(DN\right)$。

k-D 树

k-D 树（k-Dimesion Tree）¹ 是一种可以高效处理 $k$ 维空间信息的数据结构。k-D 树具有二叉搜索树的形态，二叉搜索树上的每个结点都对应 $k$ 维空间内的一个点。其每个子树中的点都在一个 $k$ 维的超长方体内，这个超长方体内的所有点也都在这个子树中。k-D 树的构建过程如下：

1. 若当前超长方体中只有一个点，返回这个点。
2. 选择一个维度，将当前超长方体按照这个维度分割为两个超长方体。
3. 选择一个切割点，将小于这个点的归入其中一个超长方体（左子树），其余归入另一个超长方体（右子树）。
4. 递归地对分出的两个超长方体构建左右子树。

一个 $k = 2$ 的例子如下：

构建 k-D 树目前最优方法的时间复杂度为 $O \left(n \log n\right)$。对于单次查询，当 $2$ 维时，查询时间复杂度最优为 $O \left(\log n\right)$，最坏为 $O \left(\sqrt{n}\right)$，扩展至 $k$ 维，最坏为 $O \left(n^{1 - \frac{1}{k}}\right)$。k-D 树对于低维度最近邻搜索比较好，但当 $k$ 增长到很大时，搜索的效率就变得很低，这也是“维数灾难”的一种体现。

Ball 树

为了解决 k-D 树在高维数据上的问题，Ball 树 ² 结构被提了出来。k-D 树是沿着笛卡尔积（坐标轴）方向迭代分割数据，而 Ball 树是通过一系列的超球体分割数据而非超长方体。Ball 树的构建过程如下：

1. 若当前超球体中只有一个点，返回这个点。
2. 定义所有点的质心为 $c$，离质心 $c$ 最远的点为 $c_1$，离 $c_1$ 最远的点为 $c_2$。
3. 将 $c_1$ 和 $c_2$ 作为聚类中心对数据点进行聚类得到两个簇 $\left(c_1, r_1\right), \left(c_2, r_2\right)$，将其归入左子树和右子树，其中 $r$ 为超球的半径。
4. 递归的对分出的两个超球体构建左右子树。

一个二维的例子如下：

每个点必须只能隶属于一个簇，但不同簇的超球体之间是可以相交的。在利用 Ball 树进行查询时，首先自上而下的找到包含查询点的叶子簇 $\left(c, r\right)$，在这个簇中找到距离查询点最近的观测点，这两个点的距离 $d_{upper}$ 即为最近邻的距离上界。之后检查该叶子簇的所有兄弟簇是否包含比这个上界更小的观测点，在检查时，如果查询节点距离兄弟簇圆心的距离大于兄弟簇的半径与之前计算的上界 $d_{upper}$ 之和，则这个兄弟节点不可能包含所需要的最近邻。

构建 Ball 树的时间复杂度为 $O \left(n \left(\log n\right)^2\right)$，查询时间复杂度为 $O \left(\log \left(n\right)\right)$。

近似搜索

基于哈希的算法

基于哈希的算法的目标是将一个高维数据点转换为哈希编码的表示方式，主要包含两类方法：局部敏感哈希（Local Sensitive Hash, LSH）和哈希学习（Learning to Hash, L2H）。

局部敏感哈希

局部敏感哈希采用的是与数据无关的哈希函数，也就是说整个学习处理过程不依赖于任何的数据内容信息。LSH 通过一个局部敏感哈希函数将相似的数据点以更高的概率映射到相同的哈希编码上去。这样我们在进行查询时就可以先找到查询样本落入那个哈希桶，然后再在这个哈希桶内进行遍历比较就可以找到最近邻了。

要使得相近的数据点通过哈希后落入相同的桶中，哈希函数需要满足如下条件：

1. 如果 $d \left(x, y\right) \leq d_1$，则 $Pr \left[h \left(x\right), h \left(y\right)\right] \geq p_1$。
2. 如果 $d \left(x, y\right) \geq d_2$，则 $Pr \left[h \left(x\right), h \left(y\right)\right] \leq p_2$。

其中，$x, y \in \mathbb{R}^n$ 表示 $n$ 维度数据点，$d \left(x, y\right)$ 表示 $x, y$ 之间的距离，$h$ 为哈希函数。满足上述两个条件的哈希函数称为是 $\left(d_1, d_2, p_1, p_2\right)$ 敏感的。

• MinHash（Jaccard 距离）

MinHash 算法的思路是：采用一种哈希函数将元素的位置均匀打乱，然后在新顺序下每个集合的第一个元素作为该集合的特征值。我们以 $s_1 = \left\{a, d\right\}$，$s_2 = \left\{c\right\}$，$s_3 = \left\{b, d, e\right\}$，$s_4 = \left\{a, c, d\right\}$ 为例，集合中可能的元素为 $\left\{a, b, c, d, e\right\}$，则这四个集合可以表示为：

对矩阵进行随机打乱后有：

我们利用每个集合的第一个元素作为该集合的特征值，则有 $h \left(s_1\right) = a$，$h \left(s_2\right) = c$，$h \left(s_3\right) = b$，$h \left(s_4\right) = a$，可以看出 $h \left(s_1\right) = h \left(s_4\right)$。MinHash 能够保证在哈希函数均匀分布的情况下，哈希值相等的概率等于两个集合的 Jaccard 相似度，即：

$$ Pr \left(MinHash \left(s_1\right) = MinHash \left(s_2\right)\right) = Jaccard \left(s_1, s_2\right) $$

• SimHash（汉明距离）

SimHash 是由 Manku 等人 ³ 提出的一种用于用于进行网页去重的哈希算法。SimHash 作为局部敏感哈希算法的一种其主要思想是将高维特征映射到低维特征，再通过两个向量的汉明距离来确定是否存在重复或相似。算法步骤如下：

1. 对文本进行特征抽取（例如：分词），并为每个特征赋予一定的权重（例如：词频）。
2. 计算每个特征的二进制哈希值。
3. 计算加权后的哈希值，当哈希值为 1 时，则对应位置为 $w_i$，否则为 $-w_i$，其中 $w_i$ 为该特征对应的权重。
4. 将所有特征加权后的哈希值按对应的位置进行累加合并。
5. 如果累加位置大于 0 则置为 1，否则置为 0，最终得到哈希结果。

算法流程如下图所示：

在得到 SimHash 的值后，我们可以通过比较之间的汉明距离来判断相似性。为了提高海量数据的去重效率，以 64 位指纹为例，我们可以将其切分为 4 份 16 位的数据块，根据鸽巢原理，汉明距离为 3 的两个文档必定有一个数据块是相等的。将这 4 分数据利用 KV 数据库和倒排索引进行存储，Key 为 16 位的截断指纹，Value 为剩余的指纹集合，从而提高查询的效率。同时可以选择 16，8 和 4 位进行索引，位数越小越精确，但所需的存储空间越大。

• p-stable 分布（欧式距离）

当一个在 $\Re$ 上的分布 $\mathcal{D}$ 为 $p\text{-stable}$ 时，存在 $p \geq 0$ 使得对于任意 $n$ 个实数 $v_1, \cdots, v_n$ 和独立同分布 $\mathcal{D}$ 下的变量 $X_1, \cdots, X_n$，有随机变量 $\sum_{i}{v_i X_i}$ 和 $\left(\sum_{i}{\left|v_i\right|^p}\right)^{1/p} X$ 具有相同的分布，其中 $X$ 为分布 $\mathcal{D}$ 下的随机变量 ⁴。常见的 p-stable 分布有：

1. 柯西分布：密度函数为 $c \left(x\right) = \dfrac{1}{\pi} \dfrac{1}{1 + x^2}$，为 $1\text{-stable}$。
2. 正态分布：密度函数为 $g \left(x\right) = \dfrac{1}{\sqrt{2 \pi}} e^{-x^2 / 2}$，为 $2\text{-stable}$。

p-stable 分布主要可以用于估计 $\left\|v\right\|_p$，对于两个相似的 $v_1, v_2$，它们应该具有更小的 $\left\|v_1 - v_2\right\|_p$，也就是对应的哈希值有更大的概率发生碰撞。对于 $v_1, v_2$，距离的映射 $a \cdot v_1 - a \cdot v_2$ 和 $\left\|v_1 - v_2\right\|_p \cdot X$ 具有相同的分布。$a \cdot v$ 将向量 $v$ 映射到实数集，如果将实轴以宽度 $w$ 进行等分，$a \cdot v$ 落在哪个区间中就将其编号赋予它，这样构造的哈希函数具有局部保持特性。构造的哈希函数族的形式为：

$$ h_{a, b} \left(v\right) = \left\lfloor \dfrac{a \cdot v + b}{w} \right\rfloor $$

其中，向量 $a$ 的元素 $a_i \sim N \left(0, 1\right)$，$b \sim U \left(0, w\right)$。令 $c = \left\|u - v \right\|_p$，则两个向量在被分配到一个桶中的概率为：

$$ Pr \left[h_{a, b} \left(u\right) = h_{a, b} \left(v\right)\right] = \int_{0}^{w} \dfrac{1}{c} \cdot f_p \left(\dfrac{t}{u}\right) \left(1 - \dfrac{t}{w}\right) dt $$

其中，$f_p$ 为概率密度函数。从上式中不难看出，随着距离 $c$ 的减小，两个向量发生碰撞的概率增加。

• 相关问题

局部敏感哈希可以在次线性时间内完成搜索，但缺点在于需要比较长的比特哈希码和比较多的哈希表才能达到预期的性能。

在单表哈希中，当哈希编码位数 $K$ 过小时，每个哈希桶中数据个数较多，从而会增加查询的响应时间。当哈希编码位数 $K$ 较大时，查询样本同最近邻落入同一个桶中的概率会很小。针对这个问题，我们可以通过重复 $L$ 次来增加最近邻的召回率。这个操作可以转化为构建 $L$ 个哈希表，给定一个查询样本，我们可以找到 $L$ 个哈希桶，然后再遍历这 $L$ 个哈希桶中的数据。但这样会增加内存的消耗，因此需要选择合理的 $K$ 和 $L$ 来获得更好的性能。

Multi-probe LSH ⁵ 引入了一种新的策略解决召回的问题。Multi-probe LSH 不仅仅会遍历查询样本所在桶内的元素，同时还会查询一些其他有可能包含最近邻的桶，从而在避免构建多个哈希表的情况下增加召回率。

哈希学习

哈希学习（Learning to Hash）是由 Salakhutdinov 和 Hinton ⁶ 引入到机器学习领域，通过机器学习机制将数据映射成二进制串的形式，能显著减少数据的存储和通信开销，从而有效提高学习系统的效率 ⁷。从原空间中的特征表示直接学习得到二进制的哈希编码是一个 NP-Hard 问题。现在很多的哈希学习方法都采用两步学习策略：

1. 先对原空间的样本采用度量学习（Metric Learning）进行降维，得到 1 个低维空间的实数向量表示。
2. 对得到的实数向量进行量化（即离散化）得到二进制哈希码。

现有的方法对第二步的处理大多很简单，即通过某个阈值函数将实数转换成二进制位。通常使用的量化方法为 1 个阈值为 0 的符号函数，即如果向量中某个元素大于 0，则该元素被量化为 1，否则如果小于或等于 0，则该元素被量化为 0。

哈希学习相关的具体算法不再一一展开，更多细节请参见下文提供的相关 Survey。

矢量量化算法

**矢量量化（Vector Quantization）**是信息论中一种用于数据压缩的方法，其目的是减少表示空间的维度。一个量化器可以表示为由 $D$ 维向量 $x \in \mathbb{R}^D$ 到一个向量 $q \left(x\right) \in \mathcal{C} = \left\{c_i; i \in \mathcal{I}\right\}$ 的映射 $q$，其中下标集合 $\mathcal{I}$ 为有限集合，即 $\mathcal{I} = 0, \cdots, k-1$。$c_i$ 称之为形心（centroids），$\mathcal{C}$ 称之为大小为 $k$ 的码本（codebook）。映射后的向量到一个给定下标 $i$ 的集合 $\mathcal{V}_i \triangleq \left\{x \in \mathbb{R}^D: q \left(x\right) = c_i\right\}$（Voronoi），称之为一个单元（cell）。

以一个图像编码为例，我们通过 K-Means 算法得到 $k$ 个 centroids，然后用这些 centroids 的像素值来替换对应簇中所有点的像素值。当 $k = 2, 10, 100$ 时，压缩后的图像和原始图像的对比结果如下图所示：

当 $k = 100$ 时，压缩后的图像和原始图像已经非常接近了，相关代码请参见这里。

矢量量化以乘积量化（Product Quantization，PQ）最为典型，乘积量化的核心思想还是聚类，乘积量化生成码本和量化过程如下图所示：

在训练阶段，以维度为 128 的 $N$ 个样本为例，我们将其切分为 4 个子空间，则每个子空间的维度为 32 维。对每一个子空间利用 K-Means 对其进行聚类，令聚类个数为 256，这样每个子空间就能得到一个 256 大小的码本。样本的每个子段都可以用子空间的聚类中心来近似，对应的编码即为类中心的 ID。利用这种编码方式可以将样本用一个很短的编码进行表示，从而达到量化的目的。

在查询阶段，我们将查询样本分成相同的子段，然后在每个子空间中计算子段到该子空间中所有聚类中心的距离，这样我们就得到了 $4 \times 256$ 个距离。在计算某个样本到查询样本的距离时，我们仅需要从计算得到的 4 组距离中将对应编码的距离取出相加即可，所有距离计算完毕排序后即可得到结果。

乘积量化有两种计算距离的方式 ⁸：对称距离和非对称距离，如下图所示：

对于 $x$ 和 $y$ 的距离 $d \left(x, y\right)$，对称距离利用 $d \left(q \left(x\right), q \left(y\right)\right)$ 进行估计，非对称距离利用 $d \left(x, q \left(y\right)\right)$ 进行估计。对称距离和非对称距离在不同阶段的时间复杂度如下表所示：

其中，$k^*$ 为 centroids 个数，$D$ 为向量维度，$n$ 为样本个数，$m$ 为分割个数。通常情况下我们采用非对称距离，其更接近真实距离。

IVFADC ⁸ 是乘积量化的的加速版本，乘积量化在计算距离时仍需逐个遍历相加计算。倒排乘积量化首先对 $N$ 个样本采用 K-Means 进行聚类，此处的聚类中心相比乘积量化应设置较小的数值。在得到聚类中心后，针对每一个样本 $x_i$ 找到距离最近的类中心 $c_i$，两者相减后得到残差 $x_i - c_i$，然后对残差再进行乘积量化的全过程。在查询阶段，通过先前较粗力度的量化快速定位隶属于哪一个 $c_i$，然后在 $c_i$ 区域利用乘积量化获取最终结果。整个流程如下图所示：

Optimized Product Quantization (OPQ) ⁹ 是乘积量化的一个优化方法。通常用于检索的原始特征维度较高，实践中利用乘积量化之前会对高维特征利用 PCA 等方法进行降维处理。这样在降低维度的时候还能够使得对向量进行子段切分的时候各个维度不相关。在利用 PCA 降维后，采用顺序切分子段仍存在一些问题，以 Iterative Quantization (ITQ) ¹⁰ 中的一个二维平面例子来说明，如下图所示：

在利用乘积量化进行编码时，对于切分的各个子空间，应尽可能使得各个子空间的方差接近。上图中 $(a)$ 图在 x 和 y 轴上的方差较大，而 $(c)$ 图在两个方向上比较接近。OPQ 致力解决的问题就是对各个子空间方差上的均衡，OPQ 对于该问题的求解分为非参数求解方法和参数求解方法两种，更多算法细节请参见 ITQ 和 OPQ 原文。

基于图的算法

NSW（Navigable Small World）¹¹ 算法是一种由 Malkov 等人提出的基于图的索引的方法。我们将 Navigable Small World 网络表示为一个图 $G \left(V, E\right)$，其中数据集合 $X$ 的点被唯一映射到集合 $V$ 中的一条边，边集 $E$ 由构造算法确定。对于与一个节点 $v_i$ 共享一条边的所有节点，我们称之为该节点的“友集”。

之后我们可以利用一个贪婪搜索的变种算法实现一个基本的 KNN 搜索算法。通过选择友集中未被访问过的距离查询样本最近的节点，可以在图中一个接一个的访问不同的节点，直到达到停止准则。整个过程如下图所示：

上图中的边扮演着两种不同的角色：

1. 短距离边的子集作为 Delaunay 图的近似用于贪婪搜索算法。
2. 长距离边的子集用于对数尺度的贪婪搜索，负责构造图的 Navigable Small World 属性。

其中，黑色的边为短距离边，红色的边为长距离边，箭头为迭代查询路径。整个结构的构建可以通过元素的连续插入实现，对于新的元素，我们从当前结构中找到最接近的邻居集合与之相连。随着越来越多的元素插入到结构中，之前的短距离连接就变成了长距离连接。

NSW 的 KNN 查询过程如下所示：

\begin{algorithm}
\caption{NSW 的 KNN 查询}
\begin{algorithmic}
\REQUIRE 查询样本 $q$，查询结果数量 $k$，最大迭代次数 $m$
\STATE $V_{cand} \gets \varnothing, V_{visited} \gets \varnothing, V_{res} \gets \varnothing$
\FOR{$i \gets 1$ \TO $m$}
  \STATE $V_{tmp} \gets \varnothing$
  \STATE $v_{rand} \gets $ 随机初始节点
  \STATE $V_{cand} \gets V_{cand} \cup v_{rand}$
  \WHILE{True}
    \STATE $v_c \gets V_{cand}$ 中距离 $q$ 最近的元素
    \STATE $V_{cand} \gets V_{cand} \setminus v_c$
    \IF{$v_c$ 比结果中的 $k$ 个元素距离 $q$ 还远}
      \BREAK
    \ENDIF
    \FOR{$v_e \in v_c$ 的“友集”}
      \IF{$v_e \notin V_{visited}$}
        \STATE $V_{visited} \gets V_{visited} \cup v_e, V_{cand} \gets V_{cand} \cup v_e, V_{tmp} \gets V_{tmp} \cup v_e$
      \ENDIF
    \ENDFOR
  \ENDWHILE
  \STATE $V_{res} \gets V_{res} \cup V_{tmp}$
\ENDFOR
\RETURN{$V_{res}$ 中与查询样本最近的 $k$ 个元素}
\end{algorithmic}
\end{algorithm}

HNSW（Hierarchical Navigable Small World）¹² 是对 NSW 的一种改进。HNSW 的思想是根据连接的长度（距离）将连接划分为不同的层，然后就可以在多层图中进行搜索。在这种结构中，搜索从较长的连接（上层）开始，贪婪地遍历所有元素直到达到局部最小值，之后再切换到较短的连接（下层），然后重复该过程，如下图所示：

利用这种结构可以将原来 NSW 的多重对数（Polylogarithmic）计算复杂度降低至对数（Logarithmic）复杂度。更多关于数据插入和搜索的细节请参见原文。

NSG ¹³ 提出了一种新的图结构 Monotonic Relative Neighborhood Graph (MRNG) 用于保证一个平均的低搜索时间复杂度（接近对数复杂度）。同时为了进一步降低索引复杂度，作者从确保连接性、降低平均出度、缩短搜索路径和降低索引大小 4 个方面考虑，提出了一个用于近似 MRNG 的 Spreading-out Graph (NSG)。

基于图的方法 HNSW 和基于乘积量化的方法 OPQ 之间的特性对比如下：

本文部分内容参考自 图像检索：向量索引。

算法对比

常用算法的开源实现的评测如下，更多评测结果请参见 erikbern/ann-benchmarks。

开放资源

Survey

• A Survey on Learning to Hash ¹⁴
• A Survey on Nearest Neighbor Search Methods ¹⁵
• An Investigation of Practical Approximate Nearest Neighbor Algorithms ¹⁶
• Approximate Nearest Neighbor Search on High Dimensional Data - Experiments, Analyses, and Improvement ¹⁷
• Binary Hashing for Approximate Nearest Neighbor Search on Big Data: A Survey ¹⁸
• Hashing for Similarity Search: A Survey ¹⁹

开源库

开源搜索引擎

评测

• https://github.com/erikbern/ann-benchmarks/
• https://github.com/DBWangGroupUNSW/nns_benchmark

本文为《强化学习系列》文章
本文内容主要参考自：
1.《强化学习》¹
2. CS234: Reinforcement Learning ²
3. UCL Course on RL ³

时序差分预测

**时序差分（Temporal Difference，TD）**和蒙特卡洛方法都利用经验来解决预测问题。给定策略 $\pi$ 的一些经验，以及这些经验中的非终止状态 $S_t$，一个适用于非平稳环境的简单的每次访问型蒙特卡洛方法可以表示为：

$$ V\left(S_{t}\right) \gets V\left(S_{t}\right)+\alpha\left[G_{t}-V\left(S_{t}\right)\right] \label{eq:mc-update} $$

其中，$G_t$ 是时刻 $t$ 真实的回报，$\alpha$ 是步长参数，称之为常量 $\alpha$ MC。MC 需要等到一幕的结尾才能确定对 $V \left(S_t\right)$ 的增量（此时才能获得 $G_t$），而 TD 则只需要等到下一个时刻即可。在 $t+1$ 时刻，TD 使用观察到的收益 $R_{t+1}$ 和估计值 $V \left(S_{t+1}\right)$ 来进行一次有效更新：

$$ V\left(S_{t}\right) \gets V\left(S_{t}\right)+\alpha\left[R_{t+1}+\gamma V\left(S_{t+1}\right)-V\left(S_{t}\right)\right] \label{eq:td-update} $$

这种 TD 方法称之为 TD(0)，算法的完整过程如下：

\begin{algorithm}
\caption{表格型 TD(0) 算法，用于估计 $V \approx v_{\pi}$}
\begin{algorithmic}
\REQUIRE 待评估策略 $\pi$
\STATE 对于所有 $s \in \mathcal{S}^+$，任意初始化 $V \left(s\right)$，其中 $V \left(\text{终止状态}\right) = 0$
\FOR{每一幕}
  \STATE 初始化 $S$
  \REPEAT
    \STATE $A \gets$ 策略 $\pi$ 在状态 $S$ 下做出的决策动作
    \STATE 执行动作 $A$，观测到 $R, S'$
    \STATE $V\left(S\right) \gets V\left(S\right)+\alpha\left[R+\gamma V\left(S^{\prime}\right)-V\left(S\right)\right]$
    \STATE $S \gets S'$
  \UNTIL{$S$ 为终止状态}
\ENDFOR
\end{algorithmic}
\end{algorithm}

TD(0) 的更新在某种程度上基于已存在的估计，我们称之为一种自举法。

TD 和 MC 方法都能渐进地收敛于正确的预测，但两种方法谁收敛的更快，目前暂时未能证明。但在如下的随机任务上，TD 方法通常比常量 $\alpha$ MC 方法收敛得更快。假设如下 MRP 所有阶段都同中心 C 开始，每个时刻以相同的概率向左或向右移动一个状态。幕终止于最左侧或最右侧，终止于最右侧时有 +1 的收益，除此之外收益均为零。

由于这个任务没有折扣，因此每个状态的真实价值是从这个状态开始并终止于最右侧的概率，即 A 到 E 的概率分别为 $\frac{1}{6}, \frac{2}{6}, \frac{3}{6}, \frac{4}{6}, \frac{5}{6}$。

上图左侧显示了在经历了不同数量的幕采样序列之后，运行一次 TD(0) 所得到的价值估计。在 100 幕后，估计值已经非常接近真实值了。上图右侧显示了不同的 $\alpha$ 情况下学习到的价值函数和真实价值函数的均方根（RMS）误差，对于所有的 $s$，近似价值函数都被初始化为中间值 $V \left(s\right) = 0.5$，显示的误差是 5 个状态上运行 100 次的平均误差。

给定近似价值函数 $V$，在访问非终止状态的每个时刻 $t$，使用式 $\ref{eq:mc-update}$ 和 $\ref{eq:td-update}$ 计算相应的增量经验，产生新的总增量，以此类推，直到价值函数收敛。我们称这种方法为批量更新，因为只有在处理了整批的训练数据后才进行更新。批量蒙特卡洛方法总是找出最小化训练集上均方误差的估计，而批量 TD(0) 总是找出完全符合马尔可夫过程模型的最大似然估计参数。因此，MC 在非马尔可夫环境中更加高效，而 TD 在马尔可夫环境中更加高效。

DP，MC 和 TD 的状态价值更新回溯过程如下图所示：

$$ \textbf{DP} \quad V\left(S_{t}\right) \leftarrow \mathbb{E}_{\pi}\left[R_{t+1}+\gamma V\left(S_{t+1}\right)\right] $$

$$ \textbf{MC} \quad V\left(S_{t}\right) \leftarrow V\left(S_{t}\right)+\alpha\left(G_{t}-V\left(S_{t}\right)\right) $$

$$ \textbf{TD} \quad V\left(S_{t}\right) \leftarrow V\left(S_{t}\right)+\alpha\left(R_{t+1}+\gamma V\left(S_{t+1}\right)-V\left(S_{t}\right)\right) $$

时序差分控制

利用时序差分方法解决控制问题，我们依然采用广义策略迭代（GPI），只是在评估和预测部分采用时序差分方法。同蒙特卡洛方法一样，我们需要在试探和开发之间做出权衡，因此方法又划分为同轨策略和离轨策略。

Sarsa：同轨策略下的时序差分控制

在同轨策略中，我们需要对所有状态 $s$ 以及动作 $a$ 估计出在当前的行动策略下所有对应的 $q_{\pi} \left(s, a\right)$。确保状态值在 TD(0) 下收敛的定理同样也适用于对应的动作值的算法上

$$ Q\left(S_{t}, A_{t}\right) \leftarrow Q\left(S_{t}, A_{t}\right)+\alpha\left[R_{t+1}+\gamma Q\left(S_{t+1}, A_{t+1}\right)-Q\left(S_{t}, A_{t}\right)\right] $$

每当从非终止状态的 $S_t$ 出现一次转移之后，就进行上述的一次更新，如果 $S_{t+1}$ 是终止状态，那么 $Q \left(S_{t+1}, A_{t+1}\right)$ 则定义为 0。这个更新规则用到了描述这个事件的五元组 $\left(S_t, A_t, R_{t+1}, S_{t+1}, A_{t+1}\right)$，因此根据这五元组将这个算法命名为 Sarsa。Sarsa 控制算法的一般形式如下：

\begin{algorithm}
\caption{Sarsa（同轨策略下的 TD 控制）算法，用于估计 $Q \approx q_*$}
\begin{algorithmic}
\STATE 对于所有 $s \in \mathcal{S}^+, a \in \mathcal{A} \left(s\right)$，任意初始化 $Q \left(s, a\right)$，其中 $Q \left(\text{终止状态}, \cdot\right) = 0$
\FOR{每一幕}
  \STATE 初始化 $S$
  \STATE 使用从 $Q$ 得到的策略（例如 $\epsilon-$ 贪心），在 $S$ 处选择 $A$
  \REPEAT
    \STATE 执行动作 $A$，观测到 $R, S'$
    \STATE 使用从 $Q$ 得到的策略（例如 $\epsilon-$ 贪心），在 $S'$ 处选择 $A'$
    \STATE $Q\left(S, A\right) \gets Q\left(S, A\right)+\alpha\left[R+\gamma Q\left(S', A'\right)-Q\left(S, A\right)\right]$
    \STATE $S \gets S'$
    \STATE $A \gets A'$
  \UNTIL{$S$ 为终止状态}
\ENDFOR
\end{algorithmic}
\end{algorithm}

Q-Learning：离轨策略下的时序差分控制

离轨策略下的时序差分控制算法被称为 Q-Learning，其定义为：

$$ Q\left(S_{t}, A_{t}\right) \gets Q\left(S_{t}, A_{t}\right)+\alpha\left[R_{t+1}+\gamma \max_{a} Q\left(S_{t+1}, a\right)-Q\left(S_{t}, A_{t}\right)\right] $$

在这里，待学习的动作价值函数 $Q$ 采用了对最优动作价值函数 $q_*$ 的直接近似作为学习目标，而与用于生成智能体决策序例轨迹的行动策略是什么无关。Q-Learning 算法的流程如下：

\begin{algorithm}
\caption{Q-Learning（离轨策略下的 TD 控制）算法，用于估计 $\pi \approx \pi_*$}
\begin{algorithmic}
\STATE 对于所有 $s \in \mathcal{S}^+, a \in \mathcal{A} \left(s\right)$，任意初始化 $Q \left(s, a\right)$，其中 $Q \left(\text{终止状态}, \cdot\right) = 0$
\FOR{每一幕}
  \STATE 初始化 $S$
  \REPEAT
    \STATE 使用从 $Q$ 得到的策略（例如 $\epsilon-$ 贪心），在 $S$ 处选择 $A$
    \STATE 执行动作 $A$，观测到 $R, S'$
    \STATE $Q\left(S, A\right) \gets Q\left(S, A\right)+\alpha\left[R+\gamma \max_{a} Q\left(S', a\right)-Q\left(S, A\right)\right]$
    \STATE $S \gets S'$
  \UNTIL{$S$ 为终止状态}
\ENDFOR
\end{algorithmic}
\end{algorithm}

期望 Sarsa

如果将 Q-Learning 中对于下一个“状态-动作”二元组取最大值这一步换成取期望，即更新规则为：

$$ \begin{aligned} Q\left(S_{t}, A_{t}\right) & \gets Q\left(S_{t}, A_{t}\right)+\alpha\left[R_{t+1}+\gamma \mathbb{E}_{\pi}\left[Q\left(S_{t+1}, A_{t+1}\right) \mid S_{t+1}\right]-Q\left(S_{t}, A_{t}\right)\right] \\ & \gets Q\left(S_{t}, A_{t}\right)+\alpha\left[R_{t+1}+\gamma \sum_{a} \pi\left(a \mid S_{t+1}\right) Q\left(S_{t+1}, a\right)-Q\left(S_{t}, A_{t}\right)\right] \end{aligned} $$

给定下一个状态 $S_{t+1}$，这个算法确定地向期望意义上的 Sarsa 算法所决定的方向上移动，因此这个算法被称为期望 Sarsa。期望 Sarsa 在计算上比 Sarsa 更加复杂，但它消除了因为随机选择 $A_{t+1}$ 而产生的方差。

双学习

在上述算法中，在估计值的基础上进行最大化也可以被看做隐式地对最大值进行估计，而这会产生一个显著的正偏差。假设在状态 $s$ 下可以选择多个动作 $a$，这些动作在该状态下的真实价值 $q \left(s, a\right)$ 全为零，但他们的估计值 $Q \left(s, a\right)$ 是不确定的，可能大于零也可能小于零。真实值的最大值是零，但估计值的最大值是正数，因此就产生了正偏差，我们称其为最大化偏差。

我们用下例进行说明，在如下这个 MDP 中有两个非终止节点 A 和 B。每幕都从 A 开始并选择向左或向右的动作。向右则会立即转移到终止状态并得到值为 0 的收益和回报。向左则会是状态转移到 B，得到的收益也是 0。而在 B 这个状态下有很多种可能的动作，每种动作被选择后会立刻停止并得到一个从均值为 -0.1 方差为 1.0 的分布中采样得到的收益。

因此，任何一个以向左开始的轨迹的期望回报均为 -0.1，则在 A 这个状态中根本就不该选择向左。然而使用 $\epsilon-$ 贪心策略来选择动作的 Q-Learning 算法会在开始阶段非常明显地选择向左这个动作。即使在算法收敛到稳定时，它选择向左这个动作的概率也比最优值高了大约 5%，如下图所示：

解决该问题的一种方法为双学习。如果们将样本划分为两个集合，并用它们学习两个独立的对真实价值 $q \left(a\right), \forall a \in A$ 的估计 $Q_1 \left(a\right)$ 和 $Q_2 \left(a\right)$。则我们可以使用其中一个 $Q_1$ 来确认最大的动作 $A^* = \arg\max_a Q_1 \left(a\right)$，用另一个 $Q_2$ 来计算其价值的估计 $Q_2 \left(A^*\right) = Q_2 \left(\arg\max_a Q_1 \left(a \right)\right)$。由于 $\mathbb{E} \left[Q_2 \left(A^*\right)\right] = q \left(A^*\right)$，因此这个估计是无偏的。我们可以交换两个估计 $Q_1 \left(a\right)$ 和 $Q_2 \left(a\right)$ 的角色再执行一遍上面的过程，就可以得到另一个无偏的估计 $Q_1 \left(\arg\max_a Q_2 \left(a\right)\right)$。

双学习的 Q-Learning 版本为 Double Q-Learning。Double Q-Learning 在学习时会以 0.5 的概率进行如下更新：

$$ Q_{1}\left(S_{t}, A_{t}\right) \leftarrow Q_{1}\left(S_{t}, A_{t}\right)+\alpha\left[R_{t+1}+\gamma Q_{2}\left(S_{t+1}, \underset{a}{\arg \max } Q_{1}\left(S_{t+1}, a\right)\right)-Q_{1}\left(S_{t}, A_{t}\right)\right] $$

以 0.5 的概率交换 $Q_1$ 和 $Q_2$ 的角色进行同样的更新。使用 $\epsilon-$ 贪心策略的 Double Q-Learning 的完整算法流程如下：

\begin{algorithm}
\caption{Double Q-Learning，用于估计 $Q_1 \approx Q_2 \approx q_*$}
\begin{algorithmic}
\REQUIRE 步长 $\alpha \in \left(0, 1\right]$，很小的 $\epsilon > 0$
\STATE 对于所有 $s \in \mathcal{S}^+, a \in \mathcal{A} \left(s\right)$，任意初始化 $Q_1 \left(s, a\right), Q_2 \left(s, a\right)$，其中 $Q \left(\text{终止状态}, \cdot\right) = 0$
\FOR{每一幕}
  \STATE 初始化 $S$
  \REPEAT
    \STATE 基于 $Q_1 + Q_2$ 使用 $\epsilon-$ 贪心策略在 $S$ 处选择 $A$
    \STATE 执行动作 $A$，观测到 $R, S'$
    \IF{$Random(0, 1] > 0.5$}
      \STATE $Q_{1}(S, A) \leftarrow Q_{1}(S, A)+\alpha\left(R+\gamma Q_{2}\left(S^{\prime}, \arg \max _{a} Q_{1}\left(S^{\prime}, a\right)\right)-Q_{1}(S, A)\right)$
    \ELSE
      \STATE $Q_{2}(S, A) \leftarrow Q_{2}(S, A)+\alpha\left(R+\gamma Q_{1}\left(S^{\prime}, \arg \max _{a} Q_{2}\left(S^{\prime}, a\right)\right)-Q_{2}(S, A)\right)$
    \ENDIF
    \STATE $S \gets S'$
  \UNTIL{$S$ 为终止状态}
\ENDFOR
\end{algorithmic}
\end{algorithm}

Taxi-v3 示例

我们以 Taxi-v3 为示例来测试 Sarsa，Q-Learning 和 期望 Sarsa 三种不同的算法。Taxi-v3 包含了一个 5x5 的网格，即 25 个可能的位置，我们需要驾驶一辆出租车分别在图中的 R、G、Y、B 四个位置接送乘客。客人共计存在 4 种可能的上车点，4 种可能的下车点，同时考虑出租车的位置，整个环境共有 $5 \times 5 \times \left(4 + 1\right) \times 4 = 500$ 种可能的状态，如下图所示：

出租车需要根据当前环境采取不同的动作，共计 6 种可能的动作：向南走，向北走，向东走，向西走，接上乘客，放下乘客。由于环境中存在墙，出租车每次撞墙不会发生任何移动。每一步动作默认 -1 的回报，当选择错误的地点接上或放下乘客时获得 -10 的回报，在成功运送一个客人后获得 +20 的回报。

分别利用 Sarsa，Q-Learning 和 期望 Sarsa 三种不同的算法训练模型，我们以 100 幕作为窗口计算平均回报，前 1000 个平均回报的对比结果如下图所示：

Taxi-v3 的成绩排行榜可参见 这里。利用训练好的模型执行预测的效果如下图所示：

本文示例代码实现请参见这里。

本文为《强化学习系列》文章
本文内容主要参考自：
1.《强化学习》¹
2. CS234: Reinforcement Learning ²
3. UCL Course on RL ³

蒙特卡洛算法仅需要经验，即从真实或者模拟的环境交互中采样得到的状态、动作、收益的序例。从真实经验中学习不需要关于环境动态变化规律的先验知识，却依然能够达到最优的行为；从模拟经验中学习尽管需要一个模型，但这个模型只需要能够生成状态转移的一些样本，而不需要像动态规划那样生成所有可能的转移概率分布。

蒙特卡洛预测

一个状态的价值是从该状态开始的期望回报，即未来的折扣收益累积值的期望。那么一个显而易见的方式是根据经验进行估计，即对所有经过这个状态之后产生的回报进行平均。随着越来越多的回报被观察到，平均值就会收敛到期望值，这就是蒙特卡洛算法的基本思想。

假设给定策略 $\pi$ 下途径状态 $s$ 的多幕数据，我们需要估计策略 $\pi$ 下状态 $s$ 的价值函数 $v_{\pi} \left(s\right)$。在同一幕中，$s$ 可能多次被访问，因此蒙特卡洛方法分为首次访问型 MC 算法和每次访问型 MC 算法，两者的区别在于更新时是否校验 $S_t$ 已经在当前幕中出现过。以首次访问型 MC 预测算法为例，算法流程如下：

\begin{algorithm}
\caption{首次访问型 MC 预测算法，用于估计 $V \approx v_{\pi}$}
\begin{algorithmic}
\REQUIRE 待评估策略 $\pi$
\STATE 对于所有 $s \in \mathcal{S}$，任意初始化 $V \left(s\right) \in \mathbb{R}$
\STATE 对于所有 $s \in \mathcal{S}$，$Returns \left(s\right) \gets \varnothing$
\WHILE{TRUE}
  \STATE 根据 $\pi$ 生成一幕序列 $S_0, A_0, R_1, \cdots, S_{T-1}, A_{T-1}, R_T$
  \STATE $G \gets 0$
  \FOR{$t \in T-1, T-2, \cdots, 0$}
    \STATE $G \gets \gamma G + R_{t+1}$
    \IF{$S_t$ 在 $S_0, S_1, \cdots, S_{t-1}$ 中出现过}
      \STATE $Returns \left(S_t\right) \gets Resurn \left(S_t\right) \cup G$
      \STATE $V \left(S_t\right) \gets avg \left(Returns \left(S_t\right)\right)$
    \ENDIF
  \ENDFOR
\ENDWHILE
\end{algorithmic}
\end{algorithm}

以二十一点游戏为例，每一局可以看作一幕，胜、负、平分别获得收益 $+1, -1, 0$。每局游戏进行中的收益都为 $0$，并且不打折扣（$\gamma = 1$），最终的收益即为整个游戏的回报。玩家的动作为要牌（Hit）或停牌（Stand），状态则取决于玩家的牌和庄家显示的牌。假设所有牌来自无穷多的一组牌（即每次取出的牌都会再放回牌堆）。如果玩家手上有一张 A，可以视作 11 而不爆掉，那么称这张 A 为可用的，此时这张牌总会被视作 11。因此，玩家做出的选择只会依赖于三个变量：他手牌的总和（12-31），庄家显示的牌（A-10），以及他是否有可用的 A，共计 200 个状态。

考虑如下策略，玩家在手牌点数之和小于 20 时均要牌，否则停牌。通过该策略多次模型二十一点游戏，并且计算每一个状态的回报的平均值。模拟结果如下：

有可用 A 的状态的估计会更不确定、不规律，因为这样的状态更加罕见。无论哪种情况，在大于约 500000 局游戏后，价值函数都能很好地近似。

蒙特卡洛控制

如果无法得到环境的模型，那么计算动作的价值（“状态-动作”二元组的价值）比计算状态的价值更加有用。动作价值函数的策略评估的目标是估计 $q_{\pi} \left(s, a\right)$，即在策略 $\pi$ 下从状态 $s$ 采取动作 $a$ 的期望回报。只需将对状态的访问改为对“状态-动作”二元组的访问，蒙特卡洛算法就可以几乎和之前完全相同的方式解决该问题，唯一复杂之处在于一些“状态-动作”二元组可能永远不会被访问到。为了实现基于动作价值函数的策略评估，我们必须保证持续的试探。一种方式是将指定的“状态-动作”二元组作为起点开始一幕采样，同时保证所有“状态-动作”二元组都有非零的概率可以被选为起点。这样就保证了在采样的幕个数趋于无穷时，每一个“状态-动作”二元组都会被访问到无数次。我们把这种假设称为试探性出发。

策略改进的方法是在当前价值函数上贪心地选择动作。由于我们有动作价值函数，所以在贪心的时候完全不需要使用任何的模型信息。对于任意的一个动作价值函数 $q$，对应的贪心策略为：对于任意一个状态 $s \in \mathcal{S}$，必定选择对应动作价值函数最大的动作：

$$ \pi \left(s\right) = \arg\max_a q \left(s, a\right) $$

策略改进可以通过将 $q_{\pi_k}$ 对应的贪心策略作为 $\pi_{k+1}$ 来进行。这样的 $\pi_k$ 和 $\pi_{k+1}$ 满足策略改进定理，因为对于所有的状态 $s \in \mathcal{S}$：

$$ \begin{aligned} q_{\pi_{k}}\left(s, \pi_{k+1}(s)\right) &=q_{\pi_{k}}\left(s, \underset{a}{\arg \max } q_{\pi_{k}}(s, a)\right) \\ &=\max _{a} q_{\pi_{k}}(s, a) \\ & \geqslant q_{\pi_{k}}\left(s, \pi_{k}(s)\right) \\ & \geqslant v_{\pi_{k}}(s) \end{aligned} $$

对于蒙特卡洛策略迭代，可以逐幕交替进行评估与改进。每一幕结束后，使用观测到的回报进行策略评估，然后在该幕序列访问到的每一个状态上进行策略改进。使用这个思路的一个简单算法称为基于试探性出发的蒙特卡洛（蒙特卡洛 ES），算法流程如下：

\begin{algorithm}
\caption{蒙特卡洛 ES（试探性出发），用于估计 $\pi \approx \pi_*$}
\begin{algorithmic}
\STATE 对于所有 $s \in \mathcal{S}$，任意初始化 $\pi \left(s\right) \in \mathcal{A} \left(s\right)$
\STATE 对于所有 $s \in \mathcal{S}, a \in \mathcal{A} \left(s\right)$，任意初始化 $Q \left(s, a\right) \in \mathbb{R}$
\STATE 对于所有 $s \in \mathcal{S}, a \in \mathcal{A} \left(s\right)$，$Returns \left(s, a\right) \gets \varnothing$
\WHILE{TRUE}
  \STATE 选择 $S_0 \in \mathcal{S}$ 和 $A_0 \in \mathcal{A} \left(S_0\right)$ 以使得所有“状态-动作”二元组的概率都 $> 0$
  \STATE 从 $S_0, A_0$ 开始根据 $\pi$ 生成一幕序列 $S_0, A_0, R_1, \cdots, S_{T-1}, A_{T-1}, R_T$
  \STATE $G \gets 0$
  \FOR{$t \in T-1, T-2, \cdots, 0$}
    \STATE $G \gets \gamma G + R_{t+1}$
    \IF{$S_t, A_t$ 在 $S_0, A_0, S_1, A_1, \cdots, S_{t-1}, A_{t-1}$ 中出现过}
      \STATE $Returns \left(S_t, A_t\right) \gets Resurn \left(S_t, A_t\right) \cup G$
      \STATE $Q \left(S_t, A_t\right) \gets avg \left(Returns \left(S_t, A_t\right)\right)$
      \STATE $\pi \left(S_t\right) \gets \arg\max_a Q \left(S_t, a\right)$
    \ENDIF
  \ENDFOR
\ENDWHILE
\end{algorithmic}
\end{algorithm}

利用蒙特卡洛 ES 可以很直接地解决二十一点游戏，只需随机等概率选择庄家的扑克牌、玩家手牌的点数，以及确定是否有可用的 A 即可。令只在 20 或 21 点停牌为初始策略，初始动作价值函数全部为零，下图展示了蒙特卡洛 ES 得出的最优策略：

同轨策略和离轨策略

同轨策略

为了避免很难被满足的试探性出发假设，一般性的解法是智能体能够持续不断地选择所有可能的动作，有两种方法可以保证这一点，同轨策略（on-policy）和离轨策略（off-policy）。在同轨策略中，用于生成采样数据序列的策略和用于实际决策的待评估和改进的策略是相同的；而在离轨策略中，用于评估或改进的策略与生成采样数据的策略是不同的，即生成的数据“离开”了待优化的策略所决定的决策序列轨迹。

在同轨策略中，策略一般是“软性”的，即对于任意 $s \in \mathcal{S}$ 以及 $a \in \mathcal{A} \left(s\right)$，都有 $\pi \left(a | s\right) > 0$，但他们会逐渐地逼近一个确定性的策略。$\epsilon-$ 贪心策略是指在绝大多数时候都采取获得最大估计值的动作价值函数对应的动作，但同时以一个较小的概率 $\epsilon$ 随机选择一个动作。因此对于所有非贪心的动作都以 $\frac{\epsilon}{|\mathcal{A} \left(s\right)|}$ 的概率被选中，贪心动作则以 $1 - \epsilon + \frac{\epsilon}{|\mathcal{A} \left(s\right)|}$ 的概率被选中。同轨策略的蒙特卡洛控制

\begin{algorithm}
\caption{同轨策略的首次访问型 MC 控制算法（对于 $\epsilon-$ 软性策略），用于估计 $\pi \approx \pi_*$}
\begin{algorithmic}
\STATE $\pi \gets$ 一个任意的 $\epsilon-$ 软性策略
\STATE 对于所有 $s \in \mathcal{S}, a \in \mathcal{A} \left(s\right)$，任意初始化 $Q \left(s, a\right) \in \mathbb{R}$
\STATE 对于所有 $s \in \mathcal{S}, a \in \mathcal{A} \left(s\right)$，$Returns \left(s, a\right) \gets \varnothing$
\WHILE{TRUE}
  \STATE 根据 $\pi$ 生成一幕序列 $S_0, A_0, R_1, \cdots, S_{T-1}, A_{T-1}, R_T$
  \STATE $G \gets 0$
  \FOR{$t \in T-1, T-2, \cdots, 0$}
    \STATE $G \gets \gamma G + R_{t+1}$
    \IF{$S_t, A_t$ 在 $S_0, A_0, S_1, A_1, \cdots, S_{t-1}, A_{t-1}$ 中出现过}
      \STATE $Returns \left(S_t, A_t\right) \gets Resurn \left(S_t, A_t\right) \cup G$
      \STATE $Q \left(S_t, A_t\right) \gets avg \left(Returns \left(S_t, A_t\right)\right)$
      \STATE $A^* \gets \arg\max_a Q \left(S_t, a\right)$
      \STATE 对于所有 $a \in \mathcal{A} \left(S_t\right)$，$\pi\left(a \mid S_{t}\right) \leftarrow\left\{\begin{array}{ll}
1-\varepsilon+\varepsilon /\left|\mathcal{A}\left(S_{t}\right)\right| & \text { if } a=A^{*} \\
\varepsilon /\left|\mathcal{A}\left(S_{t}\right)\right| & \text { if } a \neq A^{*}
\end{array}\right.$
    \ENDIF
  \ENDFOR
\ENDWHILE
\end{algorithmic}
\end{algorithm}

离轨策略

所有的学习控制方法都面临一个困境：它们希望学到的动作可以使随后的智能体行为是最优的，但是为了搜索所有的动作（以保证找到最优动作），它们需要采取非最优的行动。同轨策略采用一种妥协的方法，它并不学习最优策略的动作值，而是学习一个接近最优而且仍能进行试探的策略的动作值。一个更加直接的方法是采用两个策略，一个用来学习并成为最优策略，另一个更加有试探性，用来产生智能体的行动样本。用来学习的策略被称为目标策略，用于生成行动样本的策略被称为行动策略。在这种情况下，我们认为学习所用的数据“离开”了待学习的目标策略，因此整个过程称为离轨策略学习。

几乎所有的离轨策略方法都采用了重要度采样，重要度采样是一种在给定来自其他分布的样本的条件下，估计某种分布的期望值的通用方法。在离轨策略学习中，对回报值根据其轨迹在目标策略与行动策略中出现的相对概率进行加权，这个相对概率称为重要度采样比。给定起始状态 $S_t$，后续的“状态-动作”轨迹 $A_t, S_{t+1}, A_{t+1}, \cdots, S_T$ 在策略 $\pi$ 下发生的概率为：

$$ \begin{aligned} \operatorname{Pr}\left\{A_{t},\right.&\left.S_{t+1}, A_{t+1}, \ldots, S_{T} \mid S_{t}, A_{t: T-1} \sim \pi\right\} \\ &=\pi\left(A_{t} \mid S_{t}\right) p\left(S_{t+1} \mid S_{t}, A_{t}\right) \pi\left(A_{t+1} \mid S_{t+1}\right) \cdots p\left(S_{T} \mid S_{T-1}, A_{T-1}\right) \\ &=\prod_{k=t}^{T-1} \pi\left(A_{k} \mid S_{k}\right) p\left(S_{k+1} \mid S_{k}, A_{k}\right) \end{aligned} $$

其中，$p$ 为状态转移概率函数。因此，在目标策略和行动策略轨迹下的相对概率（重要度采样比）为：

$$ \rho_{t: T-1} \doteq \frac{\prod_{k=t}^{T-1} \pi\left(A_{k} \mid S_{k}\right) p\left(S_{k+1} \mid S_{k}, A_{k}\right)}{\prod_{k=t}^{T-1} b\left(A_{k} \mid S_{k}\right) p\left(S_{k+1} \mid S_{k}, A_{k}\right)}=\prod_{k=t}^{T-1} \frac{\pi\left(A_{k} \mid S_{k}\right)}{b\left(A_{k} \mid S_{k}\right)} $$

化简后，重要度采样比只与两个策略和样本序列数据相关，而与 MDP 的动态特性（状态转移概率）无关。我们希望估计目标策略下的期望回报（价值），但我们只有行动策略中的回报 $G_t$。直接使用行动策略中的回报进行估计是不准的，因此需要使用重要度采样比调整回报从而得到正确的期望值：

$$ \mathbb{E}\left[\rho_{t: T-1} G_{t} \mid S_{t}=s\right]=v_{\pi}(s) $$

定义所有访问过状态 $s$ 的时刻集合为 $\mathcal{T} \left(s\right)$，$T \left(t\right)$ 表示时刻 $t$ 后的首次终止，用 $G_t$ 表示在 $t$ 之后到达 $T \left(t\right)$ 时的回报值。则 $\left\{G_t\right\}_{t \in \mathcal{T} \left(s\right)}$ 就是状态 $s$ 对应的回报值，$\left\{\rho_{t:T \left(t\right) - 1}\right\}_{t \in \mathcal{T} \left(s\right)}$ 是相应的重要度采样比。则为了预测 $v_{\pi} \left(s\right)$，有：

$$ V(s) \doteq \frac{\sum_{t \in \mathcal{T}(s)} \rho_{t: T(t)-1} G_{t}}{|\mathcal{T}(s)|} \label{eq:ordinary-importance-sampling} $$

为一种简单平均实现的重要度采样，称之为普通重要度采样。

$$ V(s) \doteq \frac{\sum_{t \in \mathcal{T}(s)} \rho_{t: T(t)-1} G_{t}}{\sum_{t \in \mathcal{T}(s)} \rho_{t: T(t)-1}} \label{eq:weighted-importance-sampling} $$

为一种加权的重要度采样，称之为加权重要度采样，如果分母为零，则式 $\ref{eq:weighted-importance-sampling}$ 的值也为零。式 $\ref{eq:ordinary-importance-sampling}$ 得到的结果在期望上是 $v_{\pi} \left(s\right)$ 的无偏估计，但其值可能变得很极端，式 $\ref{eq:weighted-importance-sampling}$ 的估计是有偏的，但其估计的方差可以收敛到 0。

我们对二十一点游戏的状态值进行离轨策略估计。评估的状态为玩家有一张 A，一张 2（或者等价情况，有三张 A），从这个状态开始等概率选择要牌或停牌得到采样数据，目标策略只在和达到 20 或 21 时停牌。

在目标策略中，这个状态的值大概为 -0.27726（利用目标策略独立生成 1 亿幕数据后对回报进行平均得到）。两种离轨策略方法在采样随机策略经过 1000 幕离轨策略数据采样后都很好地逼近了这个值，但加权重要度采样在开始时错误率明显较低，这也是实践中的典型现象。

假设一个回报序列 $G_1, G_2, \cdots, G_{n-1}$，它们都从相同的状态开始，且每一个回报都对应一个随机权重 $W_i$，我们希望获得如下式子的估计：

$$ V_{n} \doteq \frac{\sum_{k=1}^{n-1} W_{k} G_{k}}{\sum_{k=1}^{n-1} W_{k}}, \quad n \geq 2 $$

同时在获得一个额外的回报 $G_n$ 时能保持更新。为了能不断跟踪 $V_n$ 的变化，我们必须为每一个状态维护前 $n$ 个回报对应的权值的累加和 $C_n$。$V_n$ 的更新方法如下：

$$ \begin{array}{l} V_{n+1} \doteq V_{n}+\dfrac{W_{n}}{C_{n}}\left[G_{n}-V_{n}\right], \quad n \geq 1 \\ C_{n+1} \doteq C_{n}+W_{n+1} \end{array} $$

其中，$C_0 = 0$，$V_1$ 是任意值。一个完整的用于蒙特卡洛策略评估的逐幕增量算法如下：

\begin{algorithm}
\caption{离轨策略 MC 预测算法（策略评估），用于估计 $Q \approx q_{\pi}$}
\begin{algorithmic}
\REQUIRE 一个任意的目标策略 $\pi$
\STATE 对于所有 $s \in \mathcal{S}, a \in \mathcal{A} \left(s\right)$，任意初始化 $Q \left(s, a\right) \in \mathbb{R}$
\STATE 对于所有 $s \in \mathcal{S}, a \in \mathcal{A} \left(s\right)$，$C \left(s, a\right) \gets 0$
\WHILE{TRUE}
  \STATE $b \gets$ 任何能包括 $\pi$ 的策略
  \STATE 根据 $b$ 生成一幕序列 $S_0, A_0, R_1, \cdots, S_{T-1}, A_{T-1}, R_T$
  \STATE $G \gets 0$
  \STATE $W \gets 1$
  \FOR{$t \in T-1, T-2, \cdots, 0$}
    \STATE $G \gets \gamma G + R_{t+1}$
    \STATE $C \left(S_t, A_t\right) \gets C \left(S_t, A_t\right) + W$
    \STATE $Q \left(S_{t}, A_{t}\right) \leftarrow Q\left(S_{t}, A_{t}\right)+\frac{W}{C\left(S_{t}, A_{t}\right)}\left[G-Q\left(S_{t}, A_{t}\right)\right]$
    \STATE $W \leftarrow W \frac{\pi\left(A_{t} \mid S_{t}\right)}{b\left(A_{t} \mid S_{t}\right)}$
    \IF{$W = 0$}
      \BREAK
    \ENDIF
  \ENDFOR
\ENDWHILE
\end{algorithmic}
\end{algorithm}

在离轨策略中，策略的价值评估和策略的控制是分开的，用于生成行动数据的策略被称为行动策略，行动策略可能与实际上被评估和改善的策略无关，而被评估和改善的策略称为目标策略。这样分离的好处在于当行动策略能对所有可能的动作继续进行采样时，目标策略可以是确定的（贪心的）。

离轨策略蒙特卡洛控制方法要求行动策略对目标策略可能做出的所有动作都有非零的概率被选择。为了试探所有的可能性，要求行动策略是软性的。一个基于通用迭代策略（GPI）和重要度采样的离轨策略蒙特卡洛控制方法如下：

\begin{algorithm}
\caption{离轨策略 MC 控制算法，用于估计 $\pi \approx \pi_*$}
\begin{algorithmic}
\STATE 对于所有 $s \in \mathcal{S}, a \in \mathcal{A} \left(s\right)$，任意初始化 $Q \left(s, a\right) \in \mathbb{R}$
\STATE 对于所有 $s \in \mathcal{S}, a \in \mathcal{A} \left(s\right)$，$C \left(s, a\right) \gets 0$
\STATE 对于所有 $s \in \mathcal{S}, a \in \mathcal{A} \left(s\right)$，$\pi \left(s\right) \gets \arg\max_a Q \left(s, a\right)$
\STATE \COMMENT{出现平分情况选取方法应保持一致}
\WHILE{TRUE}
  \STATE $b \gets$ 任意软性策略
  \STATE 根据 $b$ 生成一幕序列 $S_0, A_0, R_1, \cdots, S_{T-1}, A_{T-1}, R_T$
  \STATE $G \gets 0$
  \STATE $W \gets 1$
  \FOR{$t \in T-1, T-2, \cdots, 0$}
    \STATE $G \gets \gamma G + R_{t+1}$
    \STATE $C \left(S_t, A_t\right) \gets C \left(S_t, A_t\right) + W$
    \STATE $Q \left(S_{t}, A_{t}\right) \leftarrow Q\left(S_{t}, A_{t}\right)+\frac{W}{C\left(S_{t}, A_{t}\right)}\left[G-Q\left(S_{t}, A_{t}\right)\right]$
    \STATE $\pi\left(S_{t}\right) \leftarrow \arg \max _{a} Q\left(S_{t}, a\right)$
    \STATE \COMMENT{出现平分情况选取方法应保持一致}
    \IF{$A_t \neq \pi \left(S_t\right)$}
      \BREAK
    \ENDIF
    \STATE $W \leftarrow W \frac{1}{b\left(A_{t} \mid S_{t}\right)}$
  \ENDFOR
\ENDWHILE
\end{algorithmic}
\end{algorithm}

本文示例代码实现请参见这里。

本文为《强化学习系列》文章
本文内容主要参考自：
1.《强化学习》¹
2. CS234: Reinforcement Learning ²
3. UCL Course on RL ³

动态规划

动态规划（Dynamic Programming，DP）是一种用于解决具有如下两个特性问题的通用算法：

1. 优化问题可以分解为子问题。
2. 子问题出现多次并可以被缓存和复用。

马尔可夫决策过程正符合这两个特性：

1. 贝尔曼方程给定了迭代过程的分解。
2. 价值函数保存并复用了解决方案。

在强化学习中，DP 的核心思想是使用价值函数来结构化地组织对最优策略的搜索。一旦得到了满足贝尔曼最优方程的价值函数 $v_*$ 或 $q_*$，得到最优策略就容易了。对于任意 $s \in \mathcal{S}$（状态集合），$a \in \mathcal{A} \left(s\right)$（动作集合）和 $s' \in \mathcal{S}^{+}$（在分幕式任务下 $\mathcal{S}$ 加上一个终止状态），有：

$$ \begin{aligned} v_{*}(s) &=\max _{a} \mathbb{E}\left[R_{t+1}+\gamma v_{*}\left(S_{t+1}\right) | S_{t}=s, A_{t}=a\right] \\ &=\max _{a} \sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma v_{*}\left(s^{\prime}\right)\right] \end{aligned} $$

$$ \begin{aligned} q_{*}(s, a) &=\mathbb{E}\left[R_{t+1}+\gamma \max _{a^{\prime}} q_{*}\left(S_{t+1}, a^{\prime}\right) | S_{t}=s, A_{t}=a\right] \\ &\left.=\sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma \max _{a^{\prime}}\right] q_{*}\left(s^{\prime}, a^{\prime}\right)\right] \end{aligned} $$

将贝尔曼方程转化成为近似逼近理想价值函数的递归更新公式，我们就得到了 DP 算法。

策略评估

对于一个策略 $\pi$，如何计算其状态价值函数 $v_{\pi}$ 被称为策略评估。对于任意 $s \in \mathcal{S}$，有：

$$ \begin{aligned} v_{\pi}(s) & \doteq \mathbb{E}_{\pi}\left[G_{t} | S_{t}=s\right] \\ &=\mathbb{E}_{\pi}\left[R_{t+1}+\gamma G_{t+1} | S_{t}=s\right] \\ &=\mathbb{E}_{\pi}\left[R_{t+1}+\gamma v_{\pi}\left(S_{t+1}\right) | S_{t}=s\right] \\ &=\sum_{a} \pi(a | s) \sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma v_{\pi}\left(s^{\prime}\right)\right] \end{aligned} $$

其中 $\pi \left(a | s\right)$ 表示在环境 $s$ 中智能体在策略 $\pi$ 下采取动作 $a$ 的概率。只要 $\gamma < 1$ 或者任何状态在 $\pi$ 下都能保证最后终止，则 $v_{\pi}$ 唯一存在。

考虑一个近似的价值函数序列 $v_0, v_1, \cdots$，从 $\mathcal{S}^{+}$ 映射到 $\mathbb{R}$，初始的近似值 $v_0$ 可以任意选取（除了终止状态必须为 0 外）。下一轮迭代的近似可以使用 $v_{\pi}$ 的贝尔曼方程进行更新，对于任意 $s \in \mathcal{S}$ 有：

$$ \begin{aligned} v_{k+1}(s) & \doteq \mathbb{E}_{\pi}\left[R_{t+1}+\gamma v_{k}\left(S_{t+1}\right) | S_{t}=s\right] \\ &=\sum_{a} \pi(a | s) \sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma v_{k}\left(s^{\prime}\right)\right] \end{aligned} $$

显然，$v_k = v_{\pi}$ 是这个更新规则的一个不动点。在保证 $v_{\pi}$ 存在的条件下，序列 $\left\{v_k\right\}$ 在 $k \to \infty$ 时将会收敛到 $v_{\pi}$，这个算法称作 迭代策略评估。

策略改进

对于任意一个确定的策略 $\pi$，我们已经确定了它的价值函数 $v_{\pi}$。对于某个状态 $s$，我们想知道是否应该选择一个不同于给定的策略的动作 $a \neq \pi \left(s\right)$。如果从状态 $s$ 继续使用现有策略，则最后的结果就是 $v \left(s\right)$，但我们并不知道换成一个新策略后是得到更好的结果还是更坏的结果。一种解决方法是在状态 $s$ 选择动作 $a$ 后，继续遵循现有的策略 $\pi$，则这种方法的价值为：

$$ \begin{aligned} q_{\pi}(s, a) & \doteq \mathbb{E}\left[R_{t+1}+\gamma v_{\pi}\left(S_{t+1}\right) | S_{t}=s, A_{t}=a\right] \\ &=\sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma v_{\pi}\left(s^{\prime}\right)\right] \end{aligned} $$

一个关键的准则就是这个值是大于还是小于 $v_{\pi} \left(s\right)$。如果这个值更大，则说明在状态 $s$ 选择动作 $a$，然后继续使用策略 $\pi$ 会比使用始终使用策略 $\pi$ 更优。

上述情况是策略改进定理的一个特例，一般来说，如果 $\pi$ 和 $\pi'$ 是任意两个确定的策略，对于任意 $s \in \mathcal{S}$：

$$ q_{\pi}\left(s, \pi^{\prime}(s)\right) \geq v_{\pi}(s) $$

则称策略 $\pi'$ 相比于 $\pi$ 一样好或更好。也就是说，对于任意状态 $s \in \mathcal{S}$，这样肯定能得到一样或更好的期望回报：

$$ v_{\pi^{\prime}}(s) \geq v_{\pi}(s) $$

延伸到所有状态和所有可能的动作，即在每个状态下根据 $q_{\pi} \left(s, a\right)$ 选择一个最优的，换言之，考虑一个新的贪心策略 $\pi'$，满足：

$$ \begin{aligned} \pi^{\prime}(s) & \doteq \underset{a}{\arg \max } q_{\pi}(s, a) \\ &=\underset{a}{\arg \max } \mathbb{E}\left[R_{t+1}+\gamma v_{\pi}\left(S_{t+1}\right) | S_{t}=s, A_{t}=a\right] \\ &=\underset{a}{\arg \max } \sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma v_{\pi}\left(s^{\prime}\right)\right] \end{aligned} $$

这样构造出的贪心策略满足策略改进定理的条件，所以它和原策略相比一样好或更好。这种根据原策略的价值函数执行贪心算法，来构造一个更好策略的过程称之为策略改进。如果新的贪心策略 $\pi'$ 和原策略 $\pi$ 一样好而不是更好，则有 $v_{\pi} = v_{\pi'}$，对任意 $s \in \mathcal{S}$：

$$ \begin{aligned} v_{\pi^{\prime}}(s) &=\max _{a} \mathbb{E}\left[R_{t+1}+\gamma v_{\pi^{\prime}}\left(S_{t+1}\right) | S_{t}=s, A_{t}=a\right] \\ &=\max _{a} \sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma v_{\pi^{\prime}}\left(s^{\prime}\right)\right] \end{aligned} $$

这同贝尔曼方程完全相同，因此 $v_{\pi}$ 一定与 $v_*$ 相同，$\pi$ 与 $\pi'$ 均必须为最优策略。因此，在除了原策略即为最优策略的情况下，策略改进一定会给出一个更优的结果。

策略迭代

一个策略 $\pi$ 根据 $v_{\pi}$ 产生了一个更好的策略 $\pi'$，进而我们可以通过计算 $v_{\pi'}$ 来得到一个更优的策略 $\pi''$。这样一个链式的方法可以得到一个不断改进的策略和价值函数序列：

$$ \pi_{0} \stackrel{E}{\longrightarrow} v_{\pi_{0}} \stackrel{I}{\longrightarrow} \pi_{1} \stackrel{E}{\longrightarrow} v_{\pi_{1}} \stackrel{I}{\longrightarrow} \pi_{2} \stackrel{E}{\longrightarrow} \cdots \stackrel{I}{\longrightarrow} \pi_{*} \stackrel{E}{\longrightarrow} v_{*} $$

其中 $\stackrel{E}{\longrightarrow}$ 表示策略评估，$\stackrel{I}{\longrightarrow}$ 表示策略改进。每一个策略都能保证同前一个一样或者更优，由于一个有限 MDP 必然只有有限种策略，所以在有限次的迭代后，这种方法一定收敛到一个最优的策略与最优价值函数。这种寻找最优策略的方法叫做策略迭代。整个策略迭代算法如下：

\begin{algorithm}
\caption{迭代策略算法}
\begin{algorithmic}
\FUNCTION{PolicyIteration}{}
\STATE \COMMENT{初始化}
\FOR{$s \in \mathcal{S}$}
  \STATE 初始化 $V \left(s\right) \in \mathbb{R}$
  \STATE 初始化 $\pi \left(s\right) \in \mathcal{A} \left(s\right)$
\ENDFOR
\WHILE{true}
  \STATE \COMMENT{策略评估}
  \REPEAT
    \STATE $\Delta \gets 0$
    \FOR{$s \in \mathcal{S}$}
      \STATE $v \gets V \left(s\right)$
      \STATE $V \left(s\right) \gets \sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, \pi \left(s\right)\right)\left[r+\gamma V\left(s^{\prime}\right)\right]$
      \STATE $\Delta \gets \max\left(\Delta, \left|v - V \left(s\right)\right|\right)$
    \ENDFOR
  \UNTIL{$\Delta < \theta$}
  \STATE \COMMENT{策略改进}
  \STATE policy-stable $\gets$ true
  \FOR{$s \in \mathcal{S}$}
    \STATE $\pi' \left(s\right) \gets \pi \left(s\right)$
    \STATE $\pi \left(s\right) \gets \sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma V\left(s^{\prime}\right)\right]$
    \IF{$\pi' \left(s\right) \neq \pi \left(s\right)$}
      \STATE policy-stable $\gets$ flase
    \ENDIF
  \ENDFOR
  \IF{policy-stable $=$ true}
    \BREAK
  \ENDIF
\ENDWHILE
\RETURN $V, \pi$
\ENDFUNCTION
\end{algorithmic}
\end{algorithm}

以杰克租车（Jack’s Car）问题为例：杰克在两地运营租车公司，每租出一辆车获得 10 元收益，为了保证每个地点有车可用，杰克需要夜间在两地之间移动车辆，每辆车的移动代价为 2 元。假设每个地点租车和还车的数量符合泊松分布 $\dfrac{\lambda^n}{n!} e^{- \lambda}$，其中 $\lambda$ 为期望值，租车的 $\lambda$ 在两地分别为 3 和 4，还车的 $\lambda$ 在两地分别为 3 和 2。假设任何一个地点不超过 20 辆车，每天最多移动 5 辆车，折扣率 $\gamma = 0.9$，将问题描述为一个持续的有限 MPD，时刻按天计算，状态为每天结束时每个地点的车辆数，动作则为夜间在两个地点之间移动的车辆数。策略从不移动任何车辆开始，整个策略迭代过程如下图所示：

上例代码实现请参见这里。

价值迭代

策略迭代算法的一个缺点是每一次迭代都涉及了策略评估，这是一个需要多次遍历状态集合的迭代过程。如果策略评估是迭代进行的，那么收敛到 $v_{\pi}$ 理论上在极限处才成立，实际中不必等到其完全收敛，可以提前截断策略评估过程。有多种方式可以截断策略迭代中的策略评估步骤，并且不影响其收敛，一种重要的特殊情况是在一次遍历后即刻停止策略评估，该算法称为价值迭代。可以将此表示为结合了策略改进与阶段策略评估的简单更新公式，对任意 $s \in \mathcal{S}$：

$$ \begin{aligned} v_{k+1}(s) & \doteq \max _{a} \mathbb{E}\left[R_{t+1}+\gamma v_{k}\left(S_{t+1}\right) | S_{t}=s, A_{t}=a\right] \\ &=\max _{a} \sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma v_{k}\left(s^{\prime}\right)\right] \end{aligned} $$

可以证明，对任意 $v_0$，在 $v_*$ 存在的条件下，序列 $\left\{v_k\right\}$ 都可以收敛到 $v_*$。整个价值迭代算法如下：

\begin{algorithm}
\caption{价值迭代算法}
\begin{algorithmic}
\FUNCTION{ValueIteration}{}
\STATE \COMMENT{初始化}
\FOR{$s \in \mathcal{S}^{+}$}
  \STATE 初始化 $V \left(s\right)$，其中 $V \left(\text{终止状态}\right) = 0$
\ENDFOR
\STATE \COMMENT{价值迭代}
\REPEAT
  \STATE $\Delta \gets 0$
  \FOR{$s \in \mathcal{S}$}
    \STATE $v \gets V \left(s\right)$
    \STATE $V \left(s\right) \gets\sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma V\left(s^{\prime}\right)\right]$
    \STATE $\Delta \gets \max\left(\Delta, \left|v - V \left(s\right)\right|\right)$
  \ENDFOR
\UNTIL{$\Delta < \theta$}
\STATE 输出一个确定的策略 $\pi \approx \pi_*$ 使得 $\pi(s)=\arg \max _{a} \sum_{s^{\prime}, r} p\left(s^{\prime}, r | s, a\right)\left[r+\gamma V\left(s^{\prime}\right)\right]$
\RETURN $V, \pi$
\ENDFUNCTION
\end{algorithmic}
\end{algorithm}

以**赌徒问题（Gambler’s Problem）**为例：一个赌徒下注猜一系列抛硬币实验的结果，如果正面朝上则获得这一次下注的钱，如果背面朝上则失去这一次下注的钱，游戏在达到目标收益 100 元或全部输光时结束。每抛一次硬币，赌徒必须从他的赌资中选取一个整数来下注，这个问题可以表示为一个非折扣的分幕式有限 MDP。状态为赌徒的赌资 $s \in \left\{1, 2, \cdots, 99\right\}$，动作为赌徒下注的金额 $a \in \left\{0, 1, \cdots, \min \left(s, 100 - s\right)\right\}$，收益在一般情况下为 0，只有在赌徒达到获利 100 元的终止状态时为 1。

令 $p_h$ 为抛硬币正面朝上的概率，如果 $p_h$ 已知，那么整个问题可以由价值迭代或其他类似算法解决。下图为当 $p_h = 0.4$ 时，价值迭代连续遍历得到的价值函数和最后的策略。

上例代码实现请参见这里。

异步动态规划

之前讨论的 DP 方法的一个主要缺点是它们涉及对 MDP 的整个状态集的操作，如果状态集很大，即使单次遍历也会十分昂贵。异步动态规划算法是一类就地迭代的 DP 算法，其不以系统遍历状态集的形式来组织算法。这些算法使用任意可用的状态值，以任意顺序来更新状态值，在某些状态的值更新一次之前，另一些状态的值可能已经更新了好几次。然而为了正确收敛，异步算法必须要不断地更新所有状态的值：在某个计算节点后，它不能忽略任何一个状态。

广义策略迭代

策略迭代包含两个同时进行的相互作用的流程，一个使得价值函数与当前策略一致（策略评估），另一个根据当前价值函数贪心地更新策略（策略改进）。在策略迭代中，这两个流程交替进行，每个流程都在另一个开始前完成。然而这也不是必须的，在异步方法中，评估和改进流程则以更细的粒度交替进行。我们利用**广义策略迭代（GPI）**一词来指代策略评估和策略改进相互作用的一般思路，与这两个流程的力度和其他细节无关。

几乎所有的强化学习方法都可以被描述为 GPI，几乎所有方法都包含明确定义的策略和价值函数。策略总是基于特定的价值函数进行改进，价值函数也始终会向对应特定策略的真实价值函数收敛。

GPI 的评估和改进流程可以视为两个约束或目标之间的相互作用的流程。每个流程都把价值函数或策略推向其中的一条线，该线代表了对于两个目标中的某一个目标的解决方案，如下图所示：

本文内容主要参考自：

1. 从高斯分布到高斯过程、高斯过程回归、贝叶斯优化
2. A Visual Exploration of Gaussian Processes
3. Gaussian Process Regression
4. Exploring Bayesian Optimization

高斯分布

一元高斯分布

若随机变量 $X$ 服从一个均值为 $\mu$，方差为 $\sigma^2$ 的高斯分布，则记为：

$$ X \sim N \left(\mu, \sigma^2\right) $$

其概率密度函数为：

$$ f \left(x\right) = \dfrac{1}{\sigma \sqrt{2 \pi}} e^{- \dfrac{\left(x - \mu\right)^2}{2 \sigma^2}} $$

二元高斯分布

若随机变量 $X, Y$ 服从均值为 $\mu = \left(\mu_X, \mu_Y\right)^{\top}$，方差为 $\mu = \left(\sigma_X, \sigma_Y\right)^{\top}$ 的高斯分布，则记为：

$$ \left(X, Y\right) \sim \mathcal{N} \left(\mu, \sigma\right) $$

其概率密度函数为：

$$ f(x, y)=\frac{1}{2 \pi \sigma_{X} \sigma_{Y} \sqrt{1-\rho^{2}}} e^{-\dfrac{1}{2\left(1-\rho^{2}\right)}\left[\dfrac{\left(x-\mu_{X}\right)^{2}}{\sigma_{X}^{2}}+\dfrac{\left(y-\mu_{Y}\right)^{2}}{\sigma_{Y}^{2}}-\dfrac{2 \rho\left(x-\mu_{X}\right)\left(y-\mu_{X}\right)}{\sigma_{X} \sigma_{Y}}\right]} $$

其中，$\rho$ 是 $X$ 和 $Y$ 之间的相关系数，$\sigma_X > 0$ 且 $\sigma_Y > 0$。

多元高斯分布

若 $K$ 维随机向量 $X = \left[X_1, \cdots, X_K\right]^{\top}$ 服从多元高斯分布，则必须满足如下三个等价条件：

1. 任何线性组合 $Y = a_1 X_1 + \cdots a_K X_K$ 均服从高斯分布。
2. 存在随机向量 $Z = \left[Z_1, \cdots, Z_L\right]^{\top}$（每个元素服从独立标准高斯分布），向量 $\mu = \left[\mu_1, \cdots, \mu_K\right]^{\top}$ 以及 $K \times L$ 的矩阵 $A$，满足 $X = A Z + \mu$。
3. 存在 $\mu$ 和一个对称半正定矩阵 $\Sigma$ 满足 $X$ 的特征函数 $\phi_X \left(u; \mu, \Sigma\right) = \exp \left(i \mu^{\top} u - \dfrac{1}{2} u^{\top} \Sigma u\right)$

如果 $\Sigma$ 是非奇异的，则概率密度函数为：

$$ f \left(x_1, \cdots, x_k\right) = \dfrac{1}{\sqrt{\left(2 \pi\right)^k \lvert\Sigma\rvert}} e^{- \dfrac{1}{2} \left(x - \mu\right)^{\top} \Sigma^{-1} \left(x - \mu\right)} $$

其中 $\lvert\Sigma\rvert$ 表示协方差矩阵的行列式。

边缘化和条件化

高斯分布具有一个优秀的代数性质，即在边缘化和条件化下是闭合的，也就是说从这些操作中获取的结果分布也是高斯的。**边缘化（Marginalization）和条件化（Conditioning）**都作用于原始分布的子集上：

$$ P_{X, Y}=\left[\begin{array}{l} X \\ Y \end{array}\right] \sim \mathcal{N}(\mu, \Sigma)=\mathcal{N}\left(\left[\begin{array}{l} \mu_{X} \\ \mu_{Y} \end{array}\right],\left[\begin{array}{l} \Sigma_{X X} \Sigma_{X Y} \\ \Sigma_{Y X} \Sigma_{Y Y} \end{array}\right]\right) $$

其中，$X$ 和 $Y$ 表示原始随机变量的子集。

对于随机向量 $X$ 和 $Y$ 的高斯概率分布 $P \left(X, Y\right)$，其边缘概率分布为：

$$ \begin{array}{l} X \sim \mathcal{N}\left(\mu_{X}, \Sigma_{X X}\right) \\ Y \sim \mathcal{N}\left(\mu_{Y}, \Sigma_{Y Y}\right) \end{array} $$

$X$ 和 $Y$ 两个子集各自只依赖于 $\mu$ 和 $\Sigma$ 中它们对应的值。因此从高斯分布中边缘化一个随机变量仅需从 $\mu$ 和 $\Sigma$ 中舍弃相应的变量即可：

$$ p_{X}(x)=\int_{y} p_{X, Y}(x, y) d y=\int_{y} p_{X | Y}(x | y) p_{Y}(y) d y $$

条件化可以用于得到一个变量在另一个变量条件下的概率分布：

$$ \begin{array}{l} X | Y \sim \mathcal{N}\left(\mu_{X}+\Sigma_{X Y} \Sigma_{Y Y}^{-1}\left(Y-\mu_{Y}\right), \Sigma_{X X}-\Sigma_{X Y} \Sigma_{Y Y}^{-1} \Sigma_{Y X}\right) \\ Y | X \sim \mathcal{N}\left(\mu_{Y}+\Sigma_{Y X} \Sigma_{X X}^{-1}\left(X-\mu_{X}\right), \Sigma_{Y Y}-\Sigma_{Y X} \Sigma_{X X}^{-1} \Sigma_{X Y}\right) \end{array} $$

需要注意新的均值仅依赖于作为条件的变量，协方差矩阵和这个变量无关。

边缘化可以理解为在高斯分布的一个维度上的累加，条件化可以理解为在多元分布上切一刀从而获得一个维数更少的高斯分布，如下图所示：

高斯过程

**高斯过程（Gaussian Process）**是观测值出现在一个连续域（例如时间或空间）的随机过程。在高斯过程中，连续输入空间中每个点都是与一个正态分布的随机变量相关联。此外，这些随机变量的每个有限集合都有一个多元正态分布，换句话说它们的任意有限线性组合是一个正态分布。高斯过程的分布是所有那些（无限多个）随机变量的联合分布，正因如此，它是连续域（例如时间或空间）上函数的分布。

简单而言，高斯过程即为一系列随机变量，这些随机变量的任意有限集合均为一个多元高斯分布。从一元高斯分布到多元高斯分布相当于增加了空间维度，从高斯分布到高斯过程相当于引入了时间维度。一个高斯过程可以被均值函数 $m \left(x\right)$ 和协方差函数 $K \left(x, x'\right)$ 共同唯一确定：

$$ \begin{aligned} m(x) &=\mathbb{E}[f(x)] \\ K\left(x, x'\right) &=\mathbb{E}\left[(f(x)-m(x))\left(f\left(x^{\prime}\right)-m\left(x^{\prime}\right)\right)\right] \end{aligned} $$

则高斯过程可以表示为：

$$ f \left(x\right) \sim \mathcal{GP} \left(m \left(x\right), K \left(x, x'\right)\right) $$

均值函数决定了样本出现的整体位置，如果为零则表示以 $y = 0$ 为基准线。协方差函数描述了不同点之间的关系，从而可以利用输入的训练数据预测未知点的值。常用的协方差函数有：

• 常数：$K_c \left(x, x'\right) = C$
• 线性：$K_L \left(x, x'\right) = x^{\top} x'$
• 高斯噪声：$K_{GN} \left(x, x'\right) = \sigma^2 \delta_{x, x'}$
• 指数平方：$K_{\mathrm{SE}}\left(x, x^{\prime}\right)=\exp \left(-\dfrac{|d|^{2}}{2 \ell^{2}}\right)$
• Ornstein-Uhlenbeck：$K_{\mathrm{OU}}\left(x, x^{\prime}\right)=\exp \left(-\dfrac{|d|}{\ell}\right)$
• Matérn：$K_{\text {Matern }}\left(x, x^{\prime}\right)=\dfrac{2^{1-\nu}}{\Gamma(\nu)}\left(\dfrac{\sqrt{2 \nu}|d|}{\ell}\right)^{\nu} K_{\nu}\left(\dfrac{\sqrt{2 \nu}|d|}{\ell}\right)$
• 周期：$K_{\mathrm{P}}\left(x, x^{\prime}\right)=\exp \left(-\dfrac{2 \sin ^{2}\left(\dfrac{d}{2}\right)}{\ell^{2}}\right)$
• 有理平方：$K_{\mathrm{RQ}}\left(x, x^{\prime}\right)=\left(1+|d|^{2}\right)^{-\alpha}, \quad \alpha \geq 0$

高斯过程回归

回归任务的目标是给定一个输入变量 $x \in \mathbb{R}^D$ 预测一个或多个连续目标变量 $y$ 的值。更确切的说，给定一个包含 $N$ 个观测值的训练集 $\mathbf{X} = \left\{x_n\right\}^N_1$ 和对应的目标值 $\mathbf{Y} = \left\{y_n\right\}^N_1$，回归的目标是对于一个新的 $x$ 预测对应的 $y$。目标值和观测值之间通过一个映射进行关联：

$$ f: X \to Y $$

在贝叶斯模型中，我们通过观测数据 $\mathcal{D} = \left\{\left(\mathbf{x}_n, \mathbf{y}_n\right)\right\}^N_{n=1}$ 更新先验分布 $P \left(\mathbf{\Theta}\right)$。通过贝叶斯公式我们可以利用先验概率 $P \left(\mathbf{\Theta}\right)$ 和似然函数 $P \left(\mathcal{D} | \mathbf{\Theta}\right)$ 推导出后验概率：

$$ p\left(\mathbf{\Theta} | \mathcal{D}\right)=\frac{p\left(\mathcal{D} | \mathbf{\Theta}\right) p\left(\mathbf{\Theta}\right)}{p\left(\mathcal{D}\right)} $$

其中 $p\left(\mathcal{D}\right)$ 为边际似然。在贝叶斯回归中我们不仅希望获得未知输入对应的预测值 $\mathbf{y}_*$ ，还希望知道预测的不确定性。因此我们需要利用联合分布和边缘化模型参数 $\mathbf{\Theta}$ 来构造预测分布：

$$ p\left(\mathbf{y}_{*} | \mathbf{x}_{*}, \mathcal{D}\right)=\int p\left(\mathbf{y}_{*}, \mathbf{\Theta} | \mathbf{x}_{*}, \mathcal{D}\right) \mathrm{d} \Theta=\int p\left(\mathbf{y}_{*} | \mathbf{x}_{*}, \mathbf{\Theta}, \mathcal{D}\right) p(\mathbf{\Theta} | \mathcal{D}) \mathrm{d} \mathbf{\Theta} $$

通常情况下，由于积分形式 $p \left(\Theta | \mathcal{D}\right)$ 不具有解析可解性（Analytically Tractable）：

$$ p\left(\mathcal{D}\right)=\int p\left(\mathcal{D} | \mathbf{\Theta}\right) p\left(\mathbf{\Theta}\right) d \Theta $$

但在高斯似然和高斯过程先验的前提下，后验采用函数的高斯过程的形式，同时是解析可解的。

对于高斯过程回归，我们构建一个贝叶斯模型，首先定义函数输出的先验为一个高斯过程：

$$ p \left(f | \mathbf{X}, \theta\right) = \mathcal{N} \left(\mathbf{0}, K \left(\mathbf{X}, \mathbf{X}\right)\right) $$

其中 $K \left(\cdot, \cdot\right)$ 为协方差函数，$\theta$ 为过程的超参数。假设数据已经变换为零均值，因此我们不需要在先验中设置均值函数，则令似然形式如下：

$$ p \left(\mathbf{Y} | f\right) \sim \mathcal{N} \left(f, \sigma^2_n \mathbf{I}\right) $$

假设观测值为独立同分布的高斯噪音的累加，则整个模型的联合分布为：

$$ p \left(\mathbf{Y} , f | \mathbf{X}, \theta\right) = p \left(\mathbf{Y} | f\right) p \left(f | \mathbf{X}, \theta\right) $$

虽然我们并不关心变量 $f$，但由于我们需要对不确定性进行建模，我们仍需考虑 $\mathbf{Y}$ 和 $f$ 以及 $f$ 和 $\mathbf{X}$ 之间的关系。高斯过程作为一个非参数模型，其先验分布构建于映射 $f$ 之上，$f$ 仅依赖于核函数的超参数 $\theta$，且这些超参数可以通过数据进行估计。我们可以将超参数作为先验，即：

$$ p \left(\mathbf{Y} , f | \mathbf{X}, \theta\right) = p \left(\mathbf{Y} | f\right) p \left(f | \mathbf{X}, \theta\right) p \left(\theta\right) $$

然后进行贝叶斯推断和模型选择，但是通常情况下这是不可解的。David MacKay 引入了一个利用最优化边际似然来估计贝叶斯平均的框架，即计算如下积分：

$$ p \left(\mathbf{Y} | \mathbf{X}, \theta\right) = \int p \left(\mathbf{Y} | f\right) p \left(f | \mathbf{X}, \theta\right) df $$

其中，高斯似然 $p \left(\mathbf{Y} | f\right)$ 表示模型拟合数据的程度，$p \left(f | \mathbf{X}, \theta\right)$ 为高斯过程先验。经过边缘化后，$\mathbf{Y}$ 不在依赖于 $f$ 而仅依赖于 $\theta$。

假设采用零均值函数，对于一个高斯过程先验，我们仅需指定一个协方差函数。以指数平方协方差函数为例，选择一系列测试输入点 $X_*$，利用协方差矩阵和测试输入点可以生成一个高斯向量：

$$ \mathbf{f}_* \sim \mathcal{N} \left(\mathbf{0}, K \left(X_*, X_*\right)\right) $$

从高斯先验中进行采样，我们首先需要利用标准正态来表示多元正态：

$$ \mathbf{f}_* \sim \mu + \mathbf{B} \mathcal{N} \left(0, \mathbf{I}\right) $$

其中，$\mathbf{BB}^{\top} = K \left(X_*, X_*\right)$，$\mathbf{B}$ 本质上是协方差矩阵的平方根，可以通过 Cholesky 分解获得。

上图（左）为从高斯先验中采样的 10 个序列，上图（右）为先验的协方差。如果输入点 $x_n$ 和 $x_m$ 接近，则对应的 $f \left(x_n\right)$ 和 $f \left(x_m\right)$ 相比于不接近的点是强相关的。

我们关注的并不是这些随机的函数，而是如何将训练数据中的信息同先验进行合并。假设观测数据为 $\left\{\left(\mathbf{x}_{i}, f_{i}\right) | i=1, \ldots, n\right\}$，则训练目标 $\mathbf{f}$ 和测试目标 $\mathbf{f}_*$ 之间的联合分布为：

$$ \left[\begin{array}{l} \mathbf{f} \\ \mathbf{f}_{*} \end{array}\right] \sim \mathcal{N}\left(\mathbf{0},\left[\begin{array}{ll} K(X, X) & K\left(X, X_{*}\right) \\ K\left(X_{*}, X\right) & K\left(X_{*}, X_{*}\right) \end{array}\right]\right) $$

根据观测值对联合高斯先验分布进行条件化处理可以得到高斯过程回归的关键预测方程：

$$ \mathbf{f}_{*} | X, X_{*}, \mathbf{f} \sim \mathcal{N}\left(\overline{\mathbf{f}}_{*}, \operatorname{cov}\left(\mathbf{f}_{*}\right)\right) $$

其中

$$ \begin{aligned} \overline{\mathbf{f}}_{*} & \triangleq \mathbb{E}\left[\mathbf{f}_{*} | X, X_{*}, \mathbf{f}\right]=K\left(X_{*}, X\right) K(X, X)^{-1} \mathbf{f} \\ \operatorname{cov}\left(\mathbf{f}_{*}\right) &=K\left(X_{*}, X_{*}\right)-K\left(X_{*}, X\right) K(X, X)^{-1} K\left(X, X_{*}\right) \end{aligned} $$

函数值可以通过对联合后验分布采样获得。

我们以三角函数作为给定的函数，并随机采样一些训练数据 $\left\{\left(\mathbf{x}_{i}, f_{i}\right) | i=1, \ldots, n\right\}$，如下图所示：

我们希望将训练数据和高斯过程先验进行合并得到联合后验分布，我们可以通过在观测值上条件化联合高斯先验分布，预测的均值和协方差为：

$$ \begin{aligned} \overline{\mathbf{f}}_{*} &=K\left(X_{*}, X\right) K(X, X)^{-1} \mathbf{f} \\ \operatorname{cov}\left(\mathbf{f}_{*}\right) &=K\left(X_{*}, X_{*}\right)-K\left(X_{*}, X\right) K(X, X)^{-1} K\left(X, X_{*}\right) \end{aligned} $$

Rasmussen 和 Williams 给出了一个实现高斯过程回归的实用方法：

\begin{algorithm}
\caption{高斯过程回归算法}
\begin{algorithmic}
\REQUIRE \\
    输入 $\mathbf{X}$ \\
    目标 $\mathbf{y}$ \\
    协方差函数 $k$ \\
    噪音水平 $\sigma^2_n$ \\
    测试输入 $\mathbf{x}_*$
\ENSURE \\
    均值 $\bar{f}_*$ \\
    方差 $\mathbb{V}\left[f_{*}\right]$
\FUNCTION{GaussianProcessRegression}{$\mathbf{X}, \mathbf{y}, k, \sigma^2_n, \mathbf{x}_*$}
\STATE $L \gets \text{cholesky} \left(K + \sigma^2_n I\right)$
\STATE $\alpha \gets L^{\top} \setminus \left(L \setminus \mathbf{y}\right)$
\STATE $\bar{f}_* \gets \mathbf{k}^{\top}_* \alpha$
\STATE $\mathbf{v} \gets L \setminus \mathbf{k}_*$
\STATE $\mathbb{V}\left[f_{*}\right] \gets k \left(\mathbf{x}_*, \mathbf{x}_*\right) - \mathbf{v}^{\top} \mathbf{v}$
\RETURN $\bar{f}_*, \mathbb{V}\left[f_{*}\right]$
\ENDFUNCTION
\end{algorithmic}
\end{algorithm}

高斯过程后验和采样的序列如下图所示：

先验的协方差矩阵和后验的协方差矩阵可视化如下图所示：

本小结代码请参见这里。

贝叶斯优化

主动学习

在很多机器学习问题中，数据标注往往需要耗费很大成本。**主动学习（Active Learning）**在最大化模型准确率时最小化标注成本，例如对不确定性最高的数据进行标注。由于我们仅知道少量数据点，因此我们需要一个代理模型（Surrogate Model）来建模真正的模型。高斯过程因其灵活性和具有估计不确定性估计的特性不失为一个常用的代理模型。

在估计 $f \left(x\right)$ 的过程中，我们希望最小化评估的次数，因此我们可以通过主动学习来“智能”地选择下一个评估的数据点。通过不断的选择具有最高不确定性的数据点来获得 $f \left(x\right)$ 更准确的估计，直至收敛或达到停止条件。下图展示了利用主动学习估计真实数据分布的过程：

/images/cn/2020-06-06-bayesian-optimization/ active-gp- png 300

贝叶斯优化问题

贝叶斯优化的核心问题是：基于现有的已知情况，如果选择下一步评估的数据点？在主动学习中我们选择不确定性最大的点，但在贝叶斯优化中我们需要在探索不确定性区域（探索）和关注已知具有较优目标值的区域之间进行权衡（开发）。这种评价的依据称之为采集函数（Acquisition Functions），采集函数通过当前模型启发式的评估是否选择一个数据点。

贝叶斯优化的目标是找到一个函数 $f: \mathbb{R}^d \mapsto \mathbb{R}$ 最大值（或最小值）对应的位置 $x \in \mathbb{R}^d$。为了解决这个问题，我们遵循如下算法：

1. 选择一个代理模型用于建模真实函数 $f$ 和定义其先验。
2. 给定观测集合，利用贝叶斯公式获取后验。
3. 利用采集函数 $\alpha \left(x\right)$ 确性下一个采样点 $x_t = \arg\max_x \alpha \left(x\right)$。
4. 将采样的点加入观测集合，重复步骤 2 直至收敛或达到停止条件。

采集函数

• Probability of Improvement (PI)

Probability of Improvement (PI) 采集函数会选择具有最大可能性提高当前最大的 $f \left(x^{+}\right)$ 值的点作为下一个查询点，即：

$$ x_{t+1} = \arg\max \left(\alpha_{PI} \left(x\right)\right) = \arg\max \left(P \left(f \left(x\right)\right) \geq \left(f \left(x^{+}\right) + \epsilon\right)\right) $$

其中，$P \left(\cdot\right)$ 表示概率，$\epsilon$ 为一个较小的正数，$x^{+} = \arg\max_{x_i \in x_{1:t}} f \left(x_i\right)$，$x_i$ 为第 $i$ 步查询点的位置。如果采用高斯过程作为代理模型，上式则转变为：

$$ x_{t+1} = \arg\max_x \Phi \left(\dfrac{\mu_t \left(x\right) - f \left(x^{+}\right) - \epsilon}{\sigma_t \left(x\right)}\right) $$

其中，$\Phi \left(\cdot\right)$ 表示标准正态分布累积分布函数。PI 利用 $\epsilon$ 来权衡探索和开发，增加 $\epsilon$ 的值会更加倾向进行探索。

• Expected Improvement (EI)

PI 仅关注了有多大的可能性能够提高，而没有关注能够提高多少。Expected Improvement (EI) 则会选择具有最大期望提高的点作为下一个查询点，即：

$$ x_{t+1} = \arg\min_x \mathbb{E} \left(\left\|h_{t+1} \left(x\right) - f \left(x^*\right)\right\| | \mathcal{D}_t\right) $$

其中，$f$ 为真实函数，$h_{t+1}$ 为代理模型在 $t+1$ 步的后验均值，$\mathcal{D}_t = \left\{\left(x_i, f\left(x_i\right)\right)\right\}, \forall x \in x_{1:t}$ 为训练数据，$x^*$ 为 $f$ 取得最大值的真实位置。

上式中我们希望选择能够最小化与最大目标值之间距离的点，由于我们并不知道真实函数 $f$，Mockus ¹ 提出了一种解决办法：

$$ x_{t+1} = \arg\max_x \mathbb{E} \left(\max \left\{0, h_{t+1} \left(x\right) - f \left(x^{+}\right)\right\} | \mathcal{D}_t\right) $$

其中，$f \left(x^{+}\right)$ 为到目前为止遇见的最大函数值，如果采用高斯过程作为代理模型，上式则转变为：

$$ \begin{aligned} EI(x) &= \left\{\begin{array}{ll} \left(\mu_{t}(x)-f\left(x^{+}\right)-\epsilon\right) \Phi(Z)+\sigma_{t}(x) \phi(Z), & \text { if } \sigma_{t}(x)>0 \\ 0 & \text { if } \sigma_{t}(x)=0 \end{array}\right. \\ Z &= \frac{\mu_{t}(x)-f\left(x^{+}\right)-\epsilon}{\sigma_{t}(x)} \end{aligned} $$

其中 $\Phi \left(\cdot\right)$ 表示标准正态分布累积分布函数，$\phi \left(\cdot\right)$ 表示标准正态分布概率密度函数。类似 PI，EI 也可以利用 $\epsilon$ 来权衡探索和开发，增加 $\epsilon$ 的值会更加倾向进行探索。

• 对比和其他采集函数

上图展示了在仅包含一个训练观测数据 $\left(0.5, f \left(0.5\right)\right)$ 情况下不同点的采集函数值。可以看出 $\alpha_{EI}$ 和 $\alpha_{PI}$ 的最大值分别为 0.3 和 0.47。选择一个具有较小的 $\alpha_{PI}$ 和一个较大的 $\alpha_{EI}$ 的点可以理解为一个高的风险和高的回报。因此，当多个点具有相同的 $\alpha_{EI}$ 时，我们应该优先选择具有较小风险（高 $\alpha_{PI}$）的点，类似的，当多个点具有相同的 $\alpha_{PI}$ 时，我们应该优先选择具有较大回报（高 $\alpha_{EI}$）的点。

其他采集函数还有 Thompson Sampling ²，Upper Confidence Bound (UCB)，Gaussian Process Upper Confidence Bound (GP-UCB) ³，Entropy Search ⁴，Predictive Entropy Search ⁵ 等，细节请参见原始论文或 A Tutorial on Bayesian Optimization ⁶。

开放资源

• scikit-optimize/scikit-optimize
• hyperopt/hyperopt
• automl/SMAC3
• fmfn/BayesianOptimization
• pytorch/botorch
• GPflow/GPflowOpt
• keras-team/keras-tuner
• tobegit3hub/advisor

本文为《强化学习系列》文章
本文内容主要参考自：
1.《强化学习》¹
2. CS234: Reinforcement Learning ²
3. UCL Course on RL ³

马尔可夫模型

马尔可夫模型是一种用于序列数据建模的随机模型，其假设未来的状态仅取决于当前的状态，即：

$$ \mathbb{P} \left[S_{t+1} | S_t\right] = \mathbb{P} \left[S_{t+1} | S_1, \cdots, S_t\right] $$

也就是认为当前状态捕获了历史中所有相关的信息。根据系统状态是否完全可被观测以及系统是自动的还是受控的，可以将马尔可夫模型分为 4 种，如下表所示：

马尔可夫链（Markov Chain，MC）为从一个状态到另一个状态转换的随机过程，当马尔可夫链的状态只能部分被观测到时，即为隐马尔可夫模型（Hidden Markov Model，HMM），也就是说观测值与系统状态有关，但通常不足以精确地确定状态。马尔可夫决策过程（Markov Decision Process，MDP）也是马尔可夫链，但其状态转移取决于当前状态和采取的动作，通常一个马尔可夫决策过程用于计算依据期望回报最大化某些效用的行动策略。部分可观测马尔可夫决策过程（Partially Observable Markov Decision Process，POMDP）即为系统状态仅部分可见情况下的马尔可夫决策过程。

马尔可夫过程

对于一个马尔可夫状态 $s$ 和一个后继状态 $s'$，状态转移概率定义为：

$$ \mathcal{P}_{ss'} = \mathbb{P} \left[S_t = s' | S_{t-1} = s\right] $$

状态概率矩阵 $\mathcal{P}$ 定义了从所有状态 $s$ 到后继状态 $s'$ 的转移概率：

$$ \mathcal{P} = \left[\begin{array}{ccc} \mathcal{P}_{11} & \cdots & \mathcal{P}_{1 n} \\ \vdots & & \\ \mathcal{P}_{n 1} & \cdots & \mathcal{P}_{n n} \end{array}\right] $$

其中每一行的加和为 1。

**马尔可夫过程（马尔可夫链）**是一个无记忆的随机过程，一个马尔可夫过程可以定义为 $\langle \mathcal{S}, \mathcal{P} \rangle$，其中 $\mathcal{S}$ 是一个有限状态集合，$\mathcal{P}_{ss'} = \mathbb{P} \left[S_t = s' | S_{t-1} = s\right]$，$\mathcal{P}$ 为状态转移概率矩阵。以一个学生的日常生活为例，Class $i$ 表示第 $i$ 门课程，Facebook 表示在 Facebook 上进行社交，Pub 表示去酒吧，Pass 表示通过考试，Sleep 表示睡觉，这个马尔可夫过程如下图所示：

从而可以产生多种不同的序列，例如：

C1 -> C2 -> C3 -> Pass -> Sleep
C1 -> FB -> FB -> C1 -> C2 -> Sleep
C1 -> C2 -> C3 -> Pub -> C2 -> C3 -> Pass -> Sleep

状态转移概率矩阵如下所示：

据此我们可以定义马尔可夫奖励过程（Markov Reward Process，MRP）为 $\langle \mathcal{S, P, R}, \gamma \rangle$，其中 $\mathcal{S}$ 和 $\mathcal{P}$ 同马尔可夫过程定义中的参数相同，$\mathcal{R}$ 为收益函数，$\mathcal{R}_s = \mathbb{E} \left[R_t | S_{t-1} = s\right]$，$\gamma \in \left[0, 1\right]$ 为折扣率。如下图所示：

期望回报 $G_t$ 定义为从时刻 $t$ 之后的所有衰减的收益之和，即：

$$ G_t = R_{t+1} + \gamma R_{t+2} + \cdots = \sum_{k=0}^{\infty} \gamma^k R_{t+k+1} $$

当 $\gamma$ 接近 $0$ 时，智能体更倾向于近期收益，当 $\gamma$ 接近 $1$ 时，智能体更侧重考虑长远收益。邻接时刻的收益可以按如下递归方式表示：

$$ G_t = R_{t+1} + \gamma G_{t+1} $$

对于存在“最终时刻”的应用中，智能体和环境的交互能被自然地分成一个系列子序列，每个子序列称之为“幕（episodes）”，例如一盘游戏、一次走迷宫的过程，每幕都以一种特殊状态结束，称之为终结状态。这些幕可以被认为在同样的终结状态下结束，只是对不同的结果有不同的收益，具有这种分幕重复特性的任务称之为分幕式任务。

MRP 的状态价值函数 $v \left(s\right)$ 给出了状态 $s$ 的长期价值，定义为：

$$ \begin{aligned} v(s) &=\mathbb{E}\left[G_{t} | S_{t}=s\right] \\ &=\mathbb{E}\left[R_{t+1}+\gamma R_{t+2}+\gamma^{2} R_{t+3}+\ldots | S_{t}=s\right] \\ &=\mathbb{E}\left[R_{t+1}+\gamma\left(R_{t+2}+\gamma R_{t+3}+\ldots\right) | S_{t}=s\right] \\ &=\mathbb{E}\left[R_{t+1}+\gamma G_{t+1} | S_{t}=s\right] \\ &=\mathbb{E}\left[R_{t+1}+\gamma v\left(S_{t+1}\right) | S_{t}=s\right] \end{aligned} $$

价值函数可以分解为两部分：即时收益 $R_{t+1}$ 和后继状态的折扣价值 $\gamma v \left(S_{t+1}\right)$。上式我们称之为贝尔曼方程（Bellman Equation），其衡量了状态价值和后继状态价值之间的关系。

马尔可夫决策过程

一个**马尔可夫决策过程（Markov Decision Process，MDP）**定义为包含决策的马尔可夫奖励过程 $\langle\mathcal{S}, \mathcal{A}, \mathcal{P}, \mathcal{R}, \gamma\rangle$，在这个环境中所有的状态均具有马尔可夫性。其中，$\mathcal{S}$ 为有限的状态集合，$\mathcal{A}$ 为有限的动作集合，$\mathcal{P}$ 为状态转移概率矩阵，$\mathcal{P}_{s s^{\prime}}^{a}=\mathbb{P}\left[S_{t+1}=s^{\prime} | S_{t}=s, A_{t}=a\right]$，$\mathcal{R}$ 为奖励函数，$\mathcal{R}_{s}^{a}=\mathbb{E}\left[R_{t+1} | S_{t}=s, A_{t}=a\right]$，$\gamma \in \left[0, 1\right]$ 为折扣率。上例中的马尔可夫决策过程如下图所示：

**策略（Policy）**定义为给定状态下动作的概率分布：

$$ \pi \left(a | s\right) = \mathbb{P} \left[A_t = a | S_t = s\right] $$

一个策略完全确定了一个智能体的行为，同时 MDP 策略仅依赖于当前状态。给定一个 MDP $\mathcal{M}=\langle\mathcal{S}, \mathcal{A}, \mathcal{P}, \mathcal{R}, \gamma\rangle$ 和一个策略 $\pi$，状态序列 $S_1, S_2, \cdots$ 为一个马尔可夫过程 $\langle \mathcal{S}, \mathcal{P}^{\pi} \rangle$，状态和奖励序列 $S_1, R_2, S_2, \cdots$ 为一个马尔可夫奖励过程 $\left\langle\mathcal{S}, \mathcal{P}^{\pi}, \mathcal{R}^{\pi}, \gamma\right\rangle$，其中

$$ \begin{aligned} \mathcal{P}_{s s^{\prime}}^{\pi} &=\sum_{a \in \mathcal{A}} \pi(a | s) \mathcal{P}_{s s^{\prime}}^{a} \\ \mathcal{R}_{s}^{\pi} &=\sum_{a \in \mathcal{A}} \pi(a | s) \mathcal{R}_{s}^{a} \end{aligned} $$

在策略 $\pi$ 下，状态 $s$ 的价值函数记为 $v_{\pi} \left(s\right)$，即从状态 $s$ 开始，智能体按照策略进行决策所获得的回报的概率期望值，对于 MDP 其定义为：

$$ \begin{aligned} v_{\pi} \left(s\right) &= \mathbb{E}_{\pi} \left[G_t | S_t = s\right] \\ &= \mathbb{E}_{\pi} \left[\sum_{k=0}^{\infty} \gamma^k R_{t+k+1} | S_t = s\right] \end{aligned} $$

在策略 $\pi$ 下，在状态 $s$ 时采取动作 $a$ 的价值记为 $q_\pi \left(s, a\right)$，即根据策略 $\pi$，从状态 $s$ 开始，执行动作 $a$ 之后，所有可能的决策序列的期望回报：

$$ \begin{aligned} q_\pi \left(s, a\right) &= \mathbb{E}_{\pi} \left[G_t | S_t = s, A_t = a\right] \\ &= \mathbb{E}_{\pi} \left[\sum_{k=0}^{\infty} \gamma^k R_{t+k+1} | S_t = s, A_t = a\right] \end{aligned} $$

状态价值函数 $v_{\pi}$ 和动作价值函数 $q_{\pi}$ 都能从经验中估计得到，两者都可以分解为当前和后继两个部分：

$$ \begin{aligned} v_{\pi}(s) &= \mathbb{E}_{\pi}\left[R_{t+1}+\gamma v_{\pi}\left(S_{t+1}\right) | S_{t}=s\right] \\ q_{\pi}(s, a) &= \mathbb{E}_{\pi}\left[R_{t+1}+\gamma q_{\pi}\left(S_{t+1}, A_{t+1}\right) | S_{t}=s, A_{t}=a\right] \end{aligned} $$

从一个状态 $s$ 出发，采取一个行动 $a$，状态价值函数为：

$$ v_{\pi}(s)=\sum_{a \in \mathcal{A}} \pi(a | s) q_{\pi}(s, a) $$

从一个动作 $s$ 出发，再采取一个行动 $a$ 后，动作价值函数为：

$$ q_{\pi}(s, a)=\mathcal{R}_{s}^{a}+\gamma \sum_{s^{\prime} \in \mathcal{S}} \mathcal{P}_{s s^{\prime}}^{a} v_{\pi}\left(s^{\prime}\right) $$

利用后继状态价值函数表示当前状态价值函数为：

$$ v_{\pi}(s)=\sum_{a \in \mathcal{A}} \pi(a | s)\left(\mathcal{R}_{s}^{a}+\gamma \sum_{s^{\prime} \in \mathcal{S}} \mathcal{P}_{s s^{\prime}}^{a} v_{\pi}\left(s^{\prime}\right)\right) $$

利用后继动作价值函数表示当前动作价值函数为：

$$ q_{\pi}(s, a)=\mathcal{R}_{s}^{a}+\gamma \sum_{s^{\prime} \in \mathcal{S}} \mathcal{P}_{s s^{\prime}}^{a} \sum_{a^{\prime} \in \mathcal{A}} \pi\left(a^{\prime} | s^{\prime}\right) q_{\pi}\left(s^{\prime}, a^{\prime}\right) $$

最优状态价值函数 $v_* \left(s\right)$ 定义为所有策略上最大值的状态价值函数：

$$ v_* \left(s\right) = \mathop{\max}_{\pi} v_{\pi} \left(s\right) $$

最优动作价值函数 $q_* \left(s, a\right)$ 定义为所有策略上最大值的动作价值函数：

$$ q_* \left(s, a\right) = \mathop{\max}_{\pi} q_{\pi} \left(s, a\right) $$

定义不同策略之间的大小关系为：

$$ \pi \geq \pi^{\prime} \text { if } v_{\pi}(s) \geq v_{\pi^{\prime}}(s), \forall s $$

对于任意一个马尔可夫决策过程有：

• 存在一个比其他策略更优或相等的策略，$\pi_* \geq \pi, \forall \pi$
• 所有的最优策略均能够获得最优的状态价值函数，$v_{\pi_*} \left(s\right) = v_* \left(s\right)$
• 所有的最优策略均能够获得最优的动作价值函数，$q_{\pi_*} \left(s, a\right) = q_* \left(s, a\right)$

一个最优策略可以通过最大化 $q_* \left(s, a\right)$ 获得：

$$ \pi_{*}(a | s)=\left\{\begin{array}{ll} 1 & \text { if } a=\underset{a \in \mathcal{A}}{\operatorname{argmax}} q_{*}(s, a) \\ 0 & \text { otherwise } \end{array}\right. $$

对于任意一个 MDP 均会有一个确定的最优策略，如果已知 $q_* \left(s, a\right)$ 即可知晓最优策略。

最优状态价值函数循环依赖于贝尔曼最优方程：

$$ v_{*}(s)=\max _{a} q_{*}(s, a) $$

$$ q_{*}(s, a)=\mathcal{R}_{s}^{a}+\gamma \sum_{s^{\prime} \in \mathcal{S}} \mathcal{P}_{s s^{\prime}}^{a} v_{*}\left(s^{\prime}\right) $$

$$ v_{*}(s)=\max _{a} \mathcal{R}_{s}^{a}+\gamma \sum_{s^{\prime} \in \mathcal{S}} \mathcal{P}_{s s^{\prime}}^{a} v_{*}\left(s^{\prime}\right) $$

$$ q_{*}(s, a)=\mathcal{R}_{s}^{a}+\gamma \sum_{s^{\prime} \in \mathcal{S}} \mathcal{P}_{s s^{\prime}}^{a} \max _{a^{\prime}} q_{*}\left(s^{\prime}, a^{\prime}\right) $$

显式求解贝尔曼最优方程给出了找到一个最优策略的方法，但这种解法至少依赖于三条实际情况很难满足的假设：

1. 准确地知道环境的动态变化特性
2. 有足够的计算资源来求解
3. 马尔可夫性质

尤其是假设 2 很难满足，现实问题中状态的数量一般很大，即使利用最快的计算机也需要花费难以接受的时间才能求解完成。

本文为《强化学习系列》文章
本文内容主要参考自《强化学习》¹

多臂赌博机问题

一个赌徒，要去摇老虎机，走进赌场一看，一排老虎机，外表一模一样，但是每个老虎机吐钱的概率可不一样，他不知道每个老虎机吐钱的概率分布是什么，那么每次该选择哪个老虎机可以做到最大化收益呢？这就是多臂赌博机问题 (Multi-armed bandit problem, K- or N-armed bandit problem, MAB) ²。

$k$ 臂赌博机问题中，$k$ 个动作的每一个在被选择时都有一个期望或者平均收益，称之为这个动作的**“价值”**。令 $t$ 时刻选择的动作为 $A_t$，对应的收益为 $R_t$，任一动作 $a$ 对应的价值为 $q_* \left(a\right)$，即给定动作 $a$ 时收益的期望：

$$ q_* \left(a\right) = \mathbb{E} \left[R_t | A_t = a\right] $$

我们将对动作 $a$ 在时刻 $t$ 的价值的估计记做 $Q_t \left(a\right)$，我们希望它接近 $q_* \left(a\right)$。

如果持续对动作的价值进行估计，那么在任一时刻都会至少有一个动作的估计价值是最高的，将这些对应最高估计价值的动作成为贪心的动作。当从这些动作中选择时，称此为开发当前所知道的关于动作的价值的知识。如果不是如此，而是选择非贪心的动作，称此为试探，因为这可以让你改善对非贪心动作的价值的估计。“开发”对于最大化当前这一时刻的期望收益是正确的做法，但是“试探”从长远来看可能会带来总体收益的最大化。到底选择“试探”还是“开发”一种复杂的方式依赖于我们得到的函数估计、不确定性和剩余时刻的精确数值。

动作价值估计方法

我们以一种自然的方式，就是通过计算实际收益的平均值来估计动作的价值：

$$ \begin{aligned} Q_t \left(a\right) &= \dfrac{t \text{ 时刻前执行动作 } a \text{ 得到的收益总和 }}{t \text{ 时刻前执行动作 } a \text{ 的次数}} \\ &= \dfrac{\sum_{i=1}^{t-1}{R_i \cdot \mathbb{1}_{A_i = a}}}{\sum_{i=1}^{t-1}{\mathbb{1}_{A_i = a}}} \end{aligned} $$

其中，$\mathbb{1}_{\text{predicate}}$ 表示随机变量，当 predicate 为真时其值为 1，反之为 0。当分母为 0 时，$Q_t \left(a\right) = 0$，当分母趋向无穷大时，根据大数定律，$Q_t \left(a\right)$ 会收敛到 $q_* \left(a\right)$。这种估计动作价值的方法称为采样平均方法，因为每一次估计都是对相关收益样本的平均。

当然，这只是估计动作价值的一种方法，而且不一定是最好的方法。例如，我们也可以利用累积遗憾（Regret）来评估动作的价值：

$$ \rho = T \mu^* - \sum_{t=1}^{T} \hat{r}_t $$

其中，$\mu^* = \mathop{\max}_{k} \left\{\mu_k\right\}$ 为最大的回报，$\hat{r}_t$ 为 $t$ 时刻的回报。

多臂赌博机算法

以 10 臂赌博机为例，动作的收益分布如下图所示：

动作的真实价值 $q_* \left(a\right), a = 1, \cdots, 10$ 为从一个均值为 0 方差为 1 的标准正态分布中选择。当对于该问题的学习方法在 $t$ 时刻选择 $A_t$ 时，实际的收益 $R_t$ 则由一个均值为 $q_* \left(A_t\right)$ 方差为 1 的正态分布决定。

$\epsilon$-Greedy

$\epsilon$-Greedy 采用的动作选择逻辑如下：

• 确定一个 $\epsilon \in \left(0, 1\right)$。
• 每次以 $\epsilon$ 的概率随机选择一个臂，以 $1 - \epsilon$ 选择平均收益最大的那个臂。

下图分别展示了 $\epsilon = 0$（贪婪），$\epsilon = 0.01$ 和 $\epsilon = 0.1$ 三种情况下的平均收益和最优动作占比随训练步数的变化情况。

$\epsilon$-Greedy 相比于 $\epsilon = 0$（贪婪）算法的优势如下：

• 对于更大方差的收益，找到最优的动作需要更多次的试探。
• 对于非平稳的任务，即动作的真实价值会随着时间而改变，这种情况下即使有确定性的情况下，也需要进行试探。

令 $R_i$ 表示一个动作被选择 $i$ 次后获得的收益，$Q_n$ 表示被选择 $n - 1$ 次后它的估计的动作价值，其可以表示为增量计算的形式：

$$ \begin{aligned} Q_{n+1} &= \dfrac{1}{n} \sum_{i=1}^{n}{R_i} \\ &= \dfrac{1}{n} \left(R_n + \sum_{i=1}^{n-1}{R_i}\right) \\ &= \dfrac{1}{n} \left(R_n + \left(n - 1\right) \dfrac{1}{n-1} \sum_{i=1}^{n-1}{R_i}\right) \\ &= \dfrac{1}{n} \left(R_n + \left(n - 1\right) Q_n\right) \\ &= \dfrac{1}{n} \left(R_n + n Q_n - Q_n\right) \\ &= Q_n + \dfrac{1}{n} \left[R_n - Q_n\right] \end{aligned} $$

上述我们讨论的都是平稳的问题，即收益的概率分布不随着时间变化的赌博机问题。对于非平稳的问题，给近期的收益赋予比过去更高的权值是一个合理的处理方式。则收益均值 $Q_n$ 的增量更新规则为：

$$ \begin{aligned} Q_{n+1} &= Q_n + \alpha \left[R_n - Q_n\right] \\ &= \left(1 - \alpha\right)^n Q_1 + \sum_{i=1}^{n} \alpha \left(1 - \alpha\right)^{n-i} R_i \end{aligned} $$

赋给收益 $R_i$ 的权值 $\alpha \left(1 - \alpha\right)^{n-i}$ 依赖于它被观测到的具体时刻和当前时刻的差，权值以指数形式递减，因此这个方法也称之为指数近因加权平均。

上述讨论中所有方法都在一定程度上依赖于初始动作值 $Q_1 \left(a\right)$ 的选择。从统计学角度，初始估计值是有偏的，对于平均采样来说，当所有动作都至少被选择一次时，偏差会消失；对于步长为常数的情况，偏差会随时间而减小。

下图展示了不同初始动作估计值下最优动作占比随训练步数的变化情况：

设置较大初始动作估计值会鼓励进行试探，这种方法称之为乐观初始价值，该方法在平稳问题中非常有效。

UCB

$\epsilon$-Greedy 在进行尝试时是盲目地选择，因为它不大会选择接近贪心或者不确定性特别大的动作。在非贪心动作中，最好是根据它们的潜力来选择可能事实上是最优的动作，这要考虑它们的估计有多接近最大值，以及这些估计的不确定性。

一种基于置信度上界（Upper Confidence Bound，UCB）思想的选择动作依据如下：

$$ A_t = \mathop{\arg\max}_{a} \left[Q_t \left(a\right) + c \sqrt{\dfrac{\ln t}{N_t \left(a\right)}}\right] $$

其中，$N_t \left(a\right)$ 表示在时刻 $t$ 之前动作 $a$ 被选择的次数，$c > 0$ 用于控制试探的程度。平方根项是对 $a$ 动作值估计的不确定性或方差的度量，最大值的大小是动作 $a$ 的可能真实值的上限，参数 $c$ 决定了置信水平。

下图展示了 UCB 算法和 $\epsilon$-Greedy 算法平均收益随着训练步数的变化：

梯度赌博机算法

针对每个动作 $a$，考虑学习一个数值化的偏好函数 $H_t \left(a\right)$，偏好函数越大，动作就约频繁地被选择，但偏好函数的概念并不是从“收益”的意义上提出的。基于随机梯度上升的思想，在每个步骤中，在选择动作 $A_t$ 并获得收益 $R_t$ 之后，偏好函数会按如下方式更新：

$$ \begin{aligned} H_{t+1} \left(A_t\right) &eq H_t \left(A_t\right) + \alpha \left(R_t - \bar{R}_t\right) \left(1 - \pi_t \left(A_t\right)\right) \\ H_{t+1} \left(a\right) &eq H_t \left(a\right) - \alpha \left(R_t - \bar{R}_t\right) \pi_t \left(a\right) \end{aligned} $$

其中，$\alpha > 0$ 表示步长，$\bar{R}_t \in \mathbb{R}$ 表示时刻 $t$ 内所有收益的平均值。$\bar{R}_t$ 项作为比较收益的一个基准项，如果收益高于它，那么在未来选择动作 $A_t$ 的概率就会增加，反之概率就会降低，未选择的动作被选择的概率会上升。

下图展示了在 10 臂测试平台问题的变体上采用梯度赌博机算法的结果，在这个问题中，它们真实的期望收益是按照平均值为 4 而不是 0 的正态分布来选择的。所有收益的这种变化对梯度赌博机算法没有任何影响，因为收益基准项让它可以马上适应新的收益水平，如果没有基准项，那么性能将显著降低。

算法性能比较

$\epsilon$-Greedy 方法在一段时间内进行随机的动作选择；UCB 方法虽然采用确定的动作选择，但可以通过每个时刻对具有较少样本的动作进行优先选择来实现试探；梯度赌博机算法则不估计动作价值，而是利用偏好函数，使用 softmax 分布来以一种分级的、概率式的方式选择更优的动作；简单地将收益的初值进行乐观的设置，可以让贪心方法也能进行显示试探。

下图展示了上述算法在不同参数下的平均收益，每条算法性能曲线都看作一个自己参数的函数。$x$ 轴上参数值的变化是 2 的倍数，并以对数坐标轴进行表示。

在评估方法时，不仅要关注它在最佳参数设置上的表现，还要注意它对参数值的敏感性。总的来说，在本文的问题上，UCB 表现最好。

本文为《强化学习系列》文章

强化学习简介

**强化学习（Reinforcement Learning，RL）**是机器学习中的一个领域，是学习“做什么（即如何把当前的情景映射成动作）才能使得数值化的收益信号最大化”。学习者不会被告知应该采取什么动作，而是必须自己通过尝试去发现哪些动作会产生最丰厚的收益。

强化学习同机器学习领域中的有监督学习和无监督学习不同，有监督学习是从外部监督者提供的带标注训练集中进行学习（任务驱动型），无监督学习是一个典型的寻找未标注数据中隐含结构的过程（数据驱动型）。强化学习是与两者并列的第三种机器学习范式，强化学习带来了一个独有的挑战——**“试探”与“开发”**之间的折中权衡，智能体必须开发已有的经验来获取收益，同时也要进行试探，使得未来可以获得更好的动作选择空间（即从错误中学习）。

在强化学习中，有两个可以进行交互的对象：智能体（Agnet）和环境（Environment）：

• 智能体：可以感知环境的状态（State），并根据反馈的奖励（Reward）学习选择一个合适的动作（Action），来最大化长期总收益。
• 环境：环境会接收智能体执行的一系列动作，对这一系列动作进行评价并转换为一种可量化的信号反馈给智能体。

除了智能体和环境之外，强化学习系统有四个核心要素：策略（Policy）、回报函数（收益信号，Reward Function）、价值函数（Value Function）和环境模型（Environment Model），其中环境模型是可选的。

• 策略：定义了智能体在特定时间的行为方式。策略是环境状态到动作的映射。
• 回报函数：定义了强化学习问题中的目标。在每一步中，环境向智能体发送一个称为收益的标量数值。
• 价值函数：表示了从长远的角度看什么是好的。一个状态的价值是一个智能体从这个状态开始，对将来累积的总收益的期望。
• 环境模型：是一种对环境的反应模式的模拟，它允许对外部环境的行为进行推断。

强化学习是一种对目标导向的学习与决策问题进行理解和自动化处理的计算方法。它强调智能体通过与环境的直接互动来学习，而不需要可效仿的监督信号或对周围环境的完全建模，因而与其他的计算方法相比具有不同的范式。

强化学习使用马尔可夫决策过程的形式化框架，使用状态，动作和收益定义学习型智能体与环境的互动过程。这个框架力图简单地表示人工智能问题的若干重要特征，这些特征包含了对因果关系的认知，对不确定性的认知，以及对显式目标存在性的认知。

价值与价值函数是强化学习方法的重要特征，价值函数对于策略空间的有效搜索来说十分重要。相比于进化方法以对完整策略的反复评估为引导对策略空间进行直接搜索，使用价值函数是强化学习方法与进化方法的不同之处。

示例和应用

以经典的 Flappy Bird 游戏为例，智能体就是游戏中我们操作的小鸟，整个游戏中的天空和遮挡管道即为环境，动作为玩家单击屏幕使小鸟飞起的行为，如下图所示：

目前，强化学习在包括游戏，广告和推荐，对话系统，机器人等多个领域均展开了广泛的应用。

游戏

AlphaGo ¹ 是于 2014 年开始由英国伦敦 Google DeepMind 开发的人工智能围棋软件。AlphaGo 使用蒙特卡洛树搜索（Monte Carlo tree search），借助估值网络（value network）与走棋网络（policy network）这两种深度神经网络，通过估值网络来评估大量选点，并通过走棋网络选择落点。

AlphaStar ^{2 3} 是由 DeepMind 开发的玩 星际争霸 II 游戏的人工智能程序。AlphaStar 是由一个深度神经网路生成的，它接收来自原始游戏界面的输入数据，并输出一系列指令，构成游戏中的一个动作。

更具体地说，神经网路体系结构将 Transformer 框架运用于模型单元（类似于关系深度强化学习），结合一个深度 LSTM 核心、一个带有 pointer network 的自回归策略前端和一个集中的值基线。这种先进的模型将有助于解决机器学习研究中涉及长期序列建模和大输出空间（如翻译、语言建模和视觉表示）的许多其他挑战。

AlphaStar 还使用了一种新的多智能体学习算法。该神经网路最初是通过在 Blizzard 发布的匿名人类游戏中进行监督学习来训练的。这使得 AlphaStar 能够通过模仿学习星际争霸上玩家所使用的基本微观和宏观策略。这个初级智能体在 95% 的游戏中击败了内置的「精英」AI 关卡（相当于人类玩家的黄金级别）。

OpenAI Five ⁴ 是一个由 OpenAI 开发的用于多人视频游戏 Dota 2 的人工智能程序。OpenAI Five 通过与自己进行超过 10,000 年时长的游戏进行优化学习，最终获得了专家级别的表现。

Pluribus ⁵ 是由 Facebook 开发的第一个在六人无限注德州扑克中击败人类专家的 AI 智能程序，其首次在复杂游戏中击败两个人或两个团队。

广告和推荐

对话系统

机器人

开放资源

开源实验平台

• openai/gym
• MuJoCo
• openai/mujoco-py
• deepmind/lab

开源框架

• deepmind/trfl/
• deepmind/open_spiel
• google/dopamine
• tensorflow/agents
• keras-rl/keras-rl
• tensorforce/tensorforce
• facebookresearch/ReAgent
• thu-ml/tianshou
• astooke/rlpyt
• NervanaSystems/coach
• PaddlePaddle/PARL

开源模型

• dennybritz/reinforcement-learning
• openai/baselines

其他资源

• ShangtongZhang/reinforcement-learning-an-introduction
• aikorea/awesome-rl
• openai/spinningup
• udacity/deep-reinforcement-learning

登录 NAS 控制台，在系统根目录创建 toolkit 目录：

sudo mkdir /toolkit
sudo chown -R username:users /toolkit

其中 username 为使用的用户名，如果后续使用过程中出现磁盘空间不足的问题，可以在其他具有较大容量的分区建立 toolkit，再在根目录建立软链进行使用：

mkdir /xxx/toolkit
sudo ln -s /xxx/toolkit /toolkit
sudo chown -R username:users /toolkit

之后下载相关工具脚本：

cd /toolkit
git clone https://github.com/SynologyOpenSource/pkgscripts-ng.git

工具脚本使用 Python 3 实现，请确保 NAS 已经安装 Python 3，后续使用过程中如果提示相关 Python 扩展包未安装的情况请自行安装后重试。实验的 Synology NAS 为 DS418play，系统版本为 DSM 6.2.2 系统，处理器为 INTEL Celeron J3355 处理器（产品代号：Apollo Lake），首先利用 EnvDeploy 下载所需的编译环境：

cd /toolkit/pkgscripts-ng
sudo ./EnvDeploy -v 6.2 -p apollolake

请根据自己机器的系统版本和处理器类型自行调整 -v 和 -p 参数。如果下载速度较慢可以手动从 https://sourceforge.net/projects/dsgpl/files/toolkit/DSM6.2/ 下载下列文件：

base_env-6.2.txz
ds.apollolake-6.2.dev.txz
ds.apollolake-6.2.env.txz

将其放置到 /toolkit/toolkit_tarballs 目录中，然后通过如下命令进行部署安装：

sudo ./EnvDeploy -v 6.2 -p apollolake -t /toolkit/toolkit_tarballs

编译 tmux

在 /toolkit 目录下建立 source 文件夹，并将 tmux 源代码（本文以 3.1b 版本为例）下载到该文件夹中：

cd /toolkit
mkdir source
cd source
wget https://github.com/tmux/tmux/releases/download/3.1b/tmux-3.1b.tar.gz
tar -zxvf tmux-3.1b.tar.gz
mv tmux-3.1b tmux

在 tmux 源代码根目录中建立 SynoBuildConf 文件夹，并在文件夹中创建如下文件：

cd /toolkit/source/tmux
mkdir SynoBuildConf

build

#!/bin/bash

case ${MakeClean} in
	[Yy][Ee][Ss])
		make distclean
		;;
esac

NCURSES_INCS="$(pkg-config ncurses --cflags)"
NCURSES_LIBS="$(pkg-config ncurses --libs)"

CFLAGS="${CFLAGS} ${NCURSES_INCS}"
LDFLAGS="${LDFLAGS} ${NCURSES_LIBS}"

env CC="${CC}" AR="${AR}" CFLAGS="${CFLAGS}" LDFLAGS="${LDFLAGS}" \
./configure ${ConfigOpt}

make ${MAKE_FLAGS}

depends

[default]
all="6.2"

install

#!/bin/bash

PKG_NAME="tmux"
TGZ_DIR="/tmp/_${PKG_NAME}_tgz"
PKG_DIR="/tmp/_${PKG_NAME}_pkg"
PKG_DEST="/image/packages"

source /pkgscripts-ng/include/pkg_util.sh

create_package_tgz() {
	### clear destination directory
	for dir in $TGZ_DIR $PKG_DIR; do
		rm -rf "$dir"
	done
	for dir in $TGZ_DIR $PKG_DIR; do
		mkdir -p "$dir"
	done

	### install needed file into TGZ_DIR
	DESTDIR="${TGZ_DIR}" make install

	### create package.tgz
	pkg_make_package $TGZ_DIR $PKG_DIR
}

create_package_spk(){
	### Copy package center scripts to PKG_DIR
	cp -r synology/scripts/ $PKG_DIR

	### Copy package icon
	cp -av synology/PACKAGE_ICON*.PNG $PKG_DIR

	### Generate INFO file
	synology/INFO.sh > INFO
	cp INFO $PKG_DIR

	### Create the final spk.
	mkdir -p $PKG_DEST
	pkg_make_spk $PKG_DIR $PKG_DEST
}

main() {
	create_package_tgz
	create_package_spk
}

main "$@"

在 tmux 源代码根目录中建立 synology 文件夹，并在文件夹中创建如下文件：

cd /toolkit/source/tmux
mkdir synology

INFO.sh

#!/bin/sh

. /pkgscripts-ng/include/pkg_util.sh

package="tmux"
version="3.1b"
displayname="tmux"
arch="$(pkg_get_platform) "
maintainer="tmux"
maintainer_url="https://github.com/tmux"
distributor="Leo Van"
distributor_url="https://leovan.me"
description="tmux is a terminal multiplexer: it enables a number of terminals to be created, accessed, and controlled from a single screen. tmux may be detached from a screen and continue running in the background, then later reattached."
support_url="https://github.com/tmux/tmux"
thirdparty="yes"
startable="no"
silent_install="yes"
silent_upgrade="yes"
silent_uninstall="yes"

[ "$(caller)" != "0 NULL" ] && return 0

pkg_dump_info

并为其添加运行权限：

cd /toolkit/source/tmux/scripts
chmod u+x INFO.sh

下载 tmux 图标并将其重命名：

cd /toolkit/source/tmux/synology
wget https://raw.githubusercontent.com/tmux/tmux/master/logo/tmux-logo-huge.png
convert tmux-logo-huge.png -crop 480x480+0+0 -resize 72x PACKAGE_ICON.PNG
convert tmux-logo-huge.png -crop 480x480+0+0 -resize 256x PACKAGE_ICON_256.PNG

此处需要使用 ImageMagick 对图标进行裁剪和缩放，请自行安装，或在本地对图片进行处理后上传到指定目录。在 /toolkit/source/tmux/synology 目录中建立 scripts 文件夹，并在文件夹中创建如下文件：

cd /toolkit/source/tmux/synology
mkdir scripts

postinst

#!/bin/sh

ln -sf "$SYNOPKG_PKGDEST/usr/local/bin/tmux" /usr/bin/

postuninst

#!/bin/sh

rm -f /usr/local/bin/tmux
rm -f /usr/bin/tmux

postupgrade

#!/bin/sh

exit 0

preinst

#!/bin/sh

exit 0

preuninst

#!/bin/sh

exit 0

preupgrade

#!/bin/sh

exit 0

start-stop-status

#!/bin/sh

case $1 in
	start)
		exit 0
	;;
	stop)
		exit 0
	;;
	status)
		if [ -h "/usr/bin/tmux" ]; then
			exit 0
		else
			exit 1
		fi
	;;
	killall)
        ;;
	log)
		exit 0
	;;
esac

为所有文件添加运行权限：

cd /toolkit/source/tmux/synology/scripts
chmod u+x *

利用 PkgCreate.py 构建 tmux 扩展包：

sudo ./PkgCreate.py -v 6.2 -p apollolake tmux

最终构建完毕的扩展包位于 /toolkit/build_env/ds.apollolake-6.2/image/packages 中。

安装 tmux

在 /toolkit/build_env/ds.apollolake-6.2/image/packages 目录中有两个编译好的扩展包，分别是 tmux-apollolake-3.1b_debug.spk 和 tmux-apollolake-3.1b.spk。其中 tmux-apollolake-3.1b.spk 为 Release 版本，传输到本地，通过 NAS 的套件中心手动安装即可。安装完毕后，套件中心的“已安装”会出现 tmux，如下图所示：

进入 NAS 控制台，运行 tmux -V 可以得到安装好的 tmux 版本信息：

tmux 3.1b

在此放出编译好的 tmux 扩展包，方便和 DS418play 具有相同系统的 CPU 架构的小伙伴直接使用。

本文主要参考了 Synology 官方的扩展包构建指南：https://help.synology.com/developer-guide/create_package/index.html

隐马尔可夫模型（Hidden Markov Model，HMM）是一个描述包含隐含未知参数的马尔可夫过程的统计模型。马尔可夫过程（Markov Process）是因俄国数学家安德雷·安德耶维齐·马尔可夫（Андрей Андреевич Марков）而得名一个随机过程，在该随机过程中，给定当前状态和过去所有状态的条件下，其下一个状态的条件概率分布仅依赖于当前状态，通常具备离散状态的马尔可夫过程称之为马尔可夫链（Markov Chain）。因此，马尔可夫链可以理解为一个有限状态机，给定了当前状态为 $S_i$ 时，下一时刻状态为 $S_j$ 的概率，不同状态之间变换的概率称之为转移概率。下图描述了 3 个状态 $S_a, S_b, S_c$ 之间转换状态的马尔可夫链。

隐马尔可夫模型中包含两种序列：随机生成的状态构成的序列称之为状态序列（state sequence），状态序列是不可被观测到的；每个状态对应的观测值组成的序列称之为观测序列（observation sequence）。令 $I = \left(i_1, i_2, \cdots, i_T\right)$ 为状态序列，其中 $i_t$ 为第 $t$ 时刻系统的状态值，对应的有 $O = \left(o_1, o_2, \cdots, o_T\right)$ 为观测序列，其中 $o_t$ 为第 $t$ 时刻系统的观测值，系统的所有可能的状态集合为 $Q = \{q_1, q_2, \cdots, q_N\}$，所有可能的观测集合为 $V= \{v_1, v_2, \cdots, v_M\}$。

隐马尔可夫模型主要由三组参数构成：

1. 状态转移矩阵： $$ A = \left[a_{ij}\right]_{N \times N} $$ 其中， $$ a_{ij} = P \left(i_{t+1} = q_j | i_t = q_i\right), 1 \leq i, j \leq N $$ 表示 $t$ 时刻状态为 $q_i$ 的情况下，在 $t+1$ 时刻状态转移到 $q_j$ 的概率。
2. 观测概率矩阵： $$ B = \left[b_j \left(k\right)\right]_{N \times M} $$ 其中， $$ b_j \left(k\right) = P \left(o_t = v_k | i_t = q_j\right), k = 1, 2, \cdots, M, j = 1, 2, \cdots, N $$ 表示 $t$ 时刻状态为 $q_i$ 的情况下，观测值为 $v_k$ 的概率。
3. 初始状态概率向量： $$ \pi = \left(\pi_i\right) $$ 其中， $$ \pi_i = P \left(i_1 = q_i\right), i = 1, 2, \cdots, N $$ 表示 $t = 1$ 时刻，系统处于状态 $q_i$ 的概率。

初始状态概率向量 $\pi$ 和状态转移矩阵 $A$ 决定了状态序列，观测概率矩阵 $B$ 决定了状态序列对应的观测序列，因此马尔可夫模型可以表示为：

$$ \lambda = \left(A, B, \pi\right) $$

对于马尔可夫模型 $\lambda = \left(A, B, \pi\right)$，通过如下步骤生成观测序列 $\{o_1, o_2, \cdots, o_T\}$：

1. 按照初始状态分布 $\pi$ 产生状态 $i_1$.
2. 令 $t = 1$。
3. 按照状态 $i_t$ 的观测概率分布 $b_{i_t} \left(k\right)$ 生成 $o_t$。
4. 按照状态 $i_t$ 的状态转移概率分布 $\left\{a_{i_t i_{t+1}}\right\}$ 产生状态 $i_{t+1}$，$i_{t+1} = 1, 2, \cdots, N$。
5. 令 $t = t + 1$，如果 $t < T$，转步骤 3；否则，终止。

马尔可夫模型在应用过程中有 3 个基本问题 ¹：

1. 概率计算问题。给定模型 $\lambda = \left(A, B, \pi\right)$ 和观测序列 $O = \{o_1, o_2, \cdots, o_T\}$，计算在模型 $\lambda$ 下观测序列 $O$ 出现的概率 $P\left(O | \lambda \right)$。
2. 学习问题。已知观测序列 $O = \{o_1, o_2, \cdots, o_T\}$，估计模型 $\lambda = \left(A, B, \pi\right)$ 参数，使得在该模型下观测序列概率 $P\left(X | \lambda \right)$ 最大。即用极大似然估计的方法估计参数。
3. 预测问题，也称为解码（decoding）问题。已知模型 $\lambda = \left(A, B, \pi\right)$ 和观测序列 $O = \{o_1, o_2, \cdots, o_T\}$，求对给定观测序列条件概率 $P \left(I | O\right)$ 最大的状态序列 $I = \{i_1, i_2, \cdots, i_T\}$。即给定观测序列，求最有可能的对应的状态序列。

概率计算

直接计算法

给定模型 $\lambda = \left(A, B, \pi \right)$ 和观测序列 $O = \{o_1, o_2, ..., o_T\}$，计算在模型 $\lambda$ 下观测序列 $O$ 出现的概率 $P\left(O | \lambda \right)$。最简单的办法就是列举出左右可能的状态序列 $I = \{i_1, i_2, ..., i_T\}$，再根据观测概率矩阵 $B$，计算每种状态序列对应的联合概率 $P \left(O, I | \lambda\right)$，对其进行求和得到概率 $P\left(O | \lambda \right)$。

状态序列 $I = \{i_1, i_2, ..., i_T\}$ 的概率是：

$$ P \left(I | \lambda \right) = \pi_{y_1} \prod_{t = 1}^{T - 1} a_{{i_t}{i_{t+1}}} $$

对于固定的状态序列 $I = \{i_1, i_2, ..., i_T\}$，观测序列 $O = \{o_1, o_2, ..., o_T\}$ 的概率是：

$$ P \left(O | I, \lambda \right) = \prod_{t = 1}^{T} b_{i_t} \left(o_t\right) $$

$O$ 和 $I$ 同时出现的联合概率为：

$$ \begin{split} P \left(O, I | \lambda \right) &= P \left(O | I, \lambda \right) P \left(I | \lambda \right) \\ &= \pi_{y_1} \prod_{t = 1}^{T - 1} a_{{i_t}{i_{t+1}}} \prod_{t = 1}^{T} b_{i_t} \left(o_t\right) \end{split} $$

然后，对于所有可能的状态序列 $I$ 求和，得到观测序列 $O$ 的概率 $P \left(O | \lambda\right)$，即：

$$ \begin{split} P\left(O | \lambda \right) &= \sum_{I} P \left(O | I, \lambda \right) P \left(I | \lambda \right) \\ &= \sum_{i_1, i_2, \cdots, i_T} \pi_{y_1} \prod_{t = 1}^{T - 1} a_{{i_t}{i_{t+1}}} \prod_{t = 1}^{T} b_{i_t} \left(o_t\right) \end{split} $$

但利用上式的计算量很大，是 $O \left(T N^T\right)$ 阶的，这种算法不可行。

前向算法

前向概率：给定马尔可夫模型 $\lambda$，给定到时刻 $t$ 部分观测序列为 $o_1, o_2, \cdots, o_t$ 且状态为 $q_i$ 的概率为前向概率，记作：

$$ \alpha_t \left(i\right) = P \left(o_1, o_2, \cdots, o_t, i_t = q_i | \lambda\right) $$

可以递推地求得前向概率 $\alpha_t \left(i\right)$ 及观测序列概率 $P \left(O | \lambda\right)$，前向算法如下：

1. 初值 $$ \alpha_{1}(i)=\pi_{i} b_{i}\left(o_{1}\right), \quad i=1,2, \cdots, N $$
2. 递推，对 $t = 1, 2, \cdots, T-1$ $$ \alpha_{t+1}(i)=\left[\sum_{j=1}^{N} \alpha_{t}(j) a_{j i}\right] b_{i}\left(o_{t+1}\right), \quad i=1,2, \cdots, N $$
3. 终止 $$ P(O | \lambda)=\sum_{i=1}^{N} \alpha_{T}(i) $$

后向算法

后向概率：给定隐马尔可夫模型 $\lambda$，给定在时刻 $t$ 状态为 $q_i$ 的条件下，从 $t+1$ 到 $T$ 的部分观测序列为 $o_{t+1}, o_{t+2}, \cdots, o_T$ 的概率为后向概率，记作：

$$ \beta_{t}(i)=P\left(o_{t+1}, o_{t+2}, \cdots, o_{T} | i_{t}=q_{i}, \lambda\right) $$

可以递推地求得后向概率 $\alpha_t \left(i\right)$ 及观测序列概率 $P \left(O | \lambda\right)$，后向算法如下：

1. 初值 $$ \beta_{T}(i)=1, \quad i=1,2, \cdots, N $$
2. 递推，对 $t = T-1, T-2, \cdots, 1$ $$ \beta_{t}(i)=\sum_{j=1}^{N} a_{i j} b_{j}\left(o_{t+1}\right) \beta_{t+1}(j), \quad i=1,2, \cdots, N $$
3. 终止 $$ P(O | \lambda)=\sum_{i=1}^{N} \pi_{i} b_{i}\left(o_{1}\right) \beta_{1}(i) $$

学习算法

监督学习算法

假设以给训练数据包含 $S$ 个长度相同的观测序列和对应的状态序列 $\left\{\left(O_1, I_1\right), \left(O_2, I_2\right), \cdots, \left(O_S, I_S\right)\right\}$，那么可以利用极大似然估计法来估计隐马尔可夫模型的参数。

设样本中时刻 $t$ 处于状态 $i$ 时刻 $t+1$ 转移到状态 $j$ 的频数为 $A_{ij}$，那么转移概率 $a_{ij}$ 的估计是：

$$ \hat{a}_{i j}=\frac{A_{i j}}{\sum_{j=1}^{N} A_{i j}}, \quad i=1,2, \cdots, N ; \quad j=1,2, \cdots, N $$

设样本中状态为 $j$ 并观测为 $k$ 的频数是 $B_{jk}$，那么状态为 $j$ 观测为 $k$ 的概率 $b_j \left(k\right)$ 的估计是：

$$ \hat{b}_{j}(k)=\frac{B_{j k}}{\sum_{k=1}^{M} B_{j k}}, \quad j=1,2, \cdots, N ; \quad k=1,2, \cdots, M $$

初始状态概率 $\pi_i$ 的估计 $\hat{\pi}_i$ 为 $S$ 个样本中初始状态为 $q_i$ 的频率。

无监督学习算法

假设给定训练数据值包含 $S$ 个长度为 $T$ 的观测序列 $\left\{O_1, O_2, \cdots, O_S\right\}$ 而没有对应的状态序例，目标是学习隐马尔可夫模型 $\lambda = \left(A, B, \pi\right)$ 的参数。我们将观测序列数据看做观测数据 $O$，状态序列数据看作不可观测的隐数据 $I$，那么马尔可夫模型事实上是一个含有隐变量的概率模型：

$$ P(O | \lambda)=\sum_{I} P(O | I, \lambda) P(I | \lambda) $$

它的参数学习可以由 EM 算法实现。EM 算法在隐马尔可夫模型学习中的具体实现为 Baum-Welch 算法：

1. 初始化。对 $n = 0$，选取 $a_{i j}^{(0)}, b_{j}(k)^{(0)}, \pi_{i}^{(0)}$，得到模型 $\lambda^{(0)}=\left(A^{(0)}, B^{(0)}, \pi^{(0)}\right)$。
2. 递推。对 $n = 1, 2, \cdots$： $$ \begin{aligned} a_{i j}^{(n+1)} &= \frac{\sum_{t=1}^{T-1} \xi_{t}(i, j)}{\sum_{t=1}^{T-1} \gamma_{t}(i)} \\ b_{j}(k)^{(n+1)} &= \frac{\sum_{t=1, o_{t}=v_{k}}^{T} \gamma_{t}(j)}{\sum_{t=1}^{T} \gamma_{t}(j)} \\ \pi_{i}^{(n+1)} &= \gamma_{1}(i) \end{aligned} $$ 右端各按照观测 $O=\left(o_{1}, o_{2}, \cdots, o_{T}\right)$ 和模型 $\lambda^{(n)}=\left(A^{(n)}, B^{(n)}, \pi^{(n)}\right)$ 计算， $$ \begin{aligned} \gamma_{t}(i) &= \frac{\alpha_{t}(i) \beta_{t}(i)}{P(O | \lambda)}=\frac{\alpha_{t}(i) \beta_{t}(i)}{\sum_{j=1}^{N} \alpha_{t}(j) \beta_{t}(j)} \\ \xi_{t}(i, j) &= \frac{\alpha_{t}(i) a_{i j} b_{j}\left(o_{t+1}\right) \beta_{t+1}(j)}{\sum_{i=1}^{N} \sum_{j=1}^{N} \alpha_{t}(i) a_{i j} b_{j}\left(o_{t+1}\right) \beta_{t+1}(j)} \end{aligned} $$
3. 终止。得到模型参数 $\lambda^{(n+1)}=\left(A^{(n+1)}, B^{(n+1)}, \pi^{(n+1)}\right)$。

预测算法

近似算法

近似算法的思想是，在每个时刻 $t$ 选择在该时刻最有可能出现的状态 $i_t^*$，从而得到一个状态序列 $I^{*}=\left(i_{1}^{*}, i_{2}^{*}, \cdots, i_{T}^{*}\right)$，将它作为预测的结果。给定隐马尔可夫模型 $\lambda$ 和观测序列 $O$，在时刻 $t$ 处于状态 $q_i$ 的概率 $\gamma_t \left(i\right)$ 是：

$$ \gamma_{t}(i)=\frac{\alpha_{t}(i) \beta_{t}(i)}{P(O | \lambda)}=\frac{\alpha_{t}(i) \beta_{t}(i)}{\sum_{j=1}^{N} \alpha_{t}(j) \beta_{t}(j)} $$

在每一时刻 $t$ 最有可能的状态 $i_t^*$ 是：

$$ i_{t}^{*}=\arg \max _{1 \leqslant i \leqslant N}\left[\gamma_{t}(i)\right], \quad t=1,2, \cdots, T $$

从而得到状态序列 $I^{*}=\left(i_{1}^{*}, i_{2}^{*}, \cdots, i_{T}^{*}\right)$。

近似算法的优点是计算简单，其缺点是不能保证预测的状态序列整体是最有可能的状态序列，因为预测的状态序列可能有实际不发生的部分。事实上，上述方法得到的状态序列中有可能存在转移概率为0的相邻状态，即对某些 $i, j, a_{ij} = 0$ 。尽管如此，近似算法仍然是有用的。

维特比算法

维特比算法（Viterbi Algorithm）实际是用动态规划（Dynamic Programming）解隐马尔可夫模型预测问题，即用动态规划求概率最大路径（最优路径）。这时一条路径对应着一个状态序列。

首先导入两个变量 $\sigma$ 和 $\Psi$。定义在时刻 $t$ 状态为 $i$ 的所有单个路径 $\left(i_1, i_2, \cdots, i_t\right)$ 中概率最大值为：

$$ \delta_{t}(i)=\max _{i_{1}, i_{2}, \cdots, i_{t-1}} P\left(i_{t}=i, i_{t-1}, \cdots, i_{1}, o_{t}, \cdots, o_{1} | \lambda\right), \quad i=1,2, \cdots, N $$

由定义可得变量 $\sigma$ 的递推公式：

$$ \begin{aligned} \delta_{t+1}(i) &=\max _{i_{1}, i_{2}, \cdots, i_{t}} P\left(i_{t+1}=i, i_{t}, \cdots, i_{1}, o_{t+1}, \cdots, o_{1} | \lambda\right) \\ &=\max _{1 \leqslant j \leqslant N}\left[\delta_{t}(j) a_{j i}\right] b_{i}\left(o_{t+1}\right), \quad i=1,2, \cdots, N ; \quad t=1,2, \cdots, T-1 \end{aligned} $$

定义在时刻 $t$ 状态为 $i$ 的所有单个路径 $\left(i_1, i_2, \cdots, i_{t-1}, i\right)$ 中概率最大的路径的第 $t - 1$ 个结点为：

$$ \Psi_{t}(i)=\arg \max _{1 \leqslant j \leqslant N}\left[\delta_{t-1}(j) a_{j i}\right], \quad i=1,2, \cdots, N $$

维特比算法流程如下：

1. 初始化 $$ \begin{array}{c} \delta_{1}(i)=\pi_{i} b_{i}\left(o_{1}\right), \quad i=1,2, \cdots, N \\ \Psi_{1}(i)=0, \quad i=1,2, \cdots, N \end{array} $$
2. 递推。对 $t = 2, 3, \cdots, T$ $$ \begin{array}{c} \delta_{t}(i)=\max _{1 \leqslant j \leqslant N}\left[\delta_{t-1}(j) a_{j i}\right] b_{i}\left(o_{t}\right), \quad i=1,2, \cdots, N \\ \Psi_{t}(i)=\arg \max _{1 \leqslant j \leqslant N}\left[\delta_{t-1}(j) a_{j i}\right], \quad i=1,2, \cdots, N \end{array} $$
3. 终止。 $$ \begin{array}{c} P^{*}=\max _{1 \leqslant i \leqslant N} \delta_{T}(i) \\ i_{T}^{*}=\arg \max _{1 \leqslant i \leqslant N}\left[\delta_{T}(i)\right] \end{array} $$
4. 最优路径回溯。对 $t = T - 1, T - 2, \cdots, 1$ $$ i_{t}^{*}=\Psi_{t+1}\left(i_{t+1}^{*}\right) $$

求的最优路径 $I^{*}=\left(i_{1}^{*}, i_{2}^{*}, \cdots, i_{T}^{*}\right)$。

条件随机场

概率无向图模型（Probabilistic Undirected Graphical Model）又称为马尔可夫随机场（Markov Random Field），是一个可以由无向图表示的联合概率分布。概率图模型（Probabilistic Graphical Model）是由图表示的概率分布，设有联合概率分布 $P \left(Y\right), Y \in \mathcal{Y}$ 是一组随机变量。由无向图 $G = \left(V, E\right)$ 表示概率分布 $P \left(Y\right)$，即在图 $G$ 中，结点 $v \in V$ 表示一个随机变量 $Y_v, Y = \left(Y_v\right)_{v \in V}$，边 $e \in E$ 表示随机变量之间的概率依赖关系。

成对马尔可夫性：设 $u$ 和 $v$ 是无向图 $G$ 中任意两个没有边连接的结点，结点 $u$ 和 $v$ 分别对应随机变量 $Y_u$ 和 $Y_v$。其他所有结点为 $O$，对应的随机变量组是 $Y_O$。成对马尔可夫是指给定随机变量组 $Y_O$ 的条件下随机变量 $Y_u$ 和 $Y_v$ 是条件独立的，即：

$$ P\left(Y_{u}, Y_{v} | Y_{O}\right)=P\left(Y_{u} | Y_{O}\right) P\left(Y_{v} | Y_{O}\right) $$

局部马尔可夫性：设 $v \in V$ 是无向图 $G$ 中任意一个结点，$W$ 是与 $v$ 有边连接的所有结点，$O$ 是 $v$ 和 $W$ 以外的其他所有结点。$v$ 表示的随机变量是 $Y_v$，$W$ 表示的随机变量组是 $Y_W$，$O$ 表示的随机变量组是 $Y_O$。局部马尔可夫性是指在给定随机变量组 $Y_W$ 的条件下随机变量 $Y_v$ 与随机变量组 $Y_O$ 是独立的，即：

$$ P\left(Y_{v}, Y_{O} | Y_{W}\right)=P\left(Y_{v} | Y_{W}\right) P\left(Y_{O} | Y_{W}\right) $$

在 $P \left(Y_O | Y_W\right) > 0$ 时，等价地：

$$ P\left(Y_{v} | Y_{W}\right)=P\left(Y_{v} | Y_{W}, Y_{O}\right) $$

局部马尔可夫性如下图所示：

全局马尔可夫性：设结点结合 $A, B$ 是在无向图 $G$ 中被结点集合 $C$ 分开的任意结点集合，如下图所示。结点集合 $A, B$ 和 $C$ 所对应的随机变量组分别是 $Y_A, Y_B$ 和 $Y_C$。全局马尔可夫性是指给定随机变量组 $Y_C$ 条件下随机变量组 $Y_A$ 和 $Y_B$ 是条件独立的，即：

$$ P\left(Y_{A}, Y_{B} | Y_{C}\right)=P\left(Y_{A} | Y_{C}\right) P\left(Y_{B} | Y_{C}\right) $$

概率无向图模型定义为：设有联合概率分布 $P \left(Y\right)$，由无向图 $G = \left(V, E\right)$ 表示，在图 $G$ 中，结点表示随机变量，边表示随机变量之间的依赖关系。如果联合概率分布 $P \left(Y\right)$ 满足成对、局部或全局马尔可夫性，就称此联合概率分布为概率无向图模型（Probabilistic Undirected Graphical Model），或马尔可夫随机场（Markov Random Field）。

团与最大团：无向图 $G$ 中任何两个结点均有边连接的结点子集称为团（Clique）。若 $C$ 是无向图 $G$ 的一个团，并且不能再加进任何一个 $G$ 的结点时期成为一个更大的团，则称此 $C$ 为最大团（Maximal Clique）。

上图表示 4 个结点组成的无向图。图中有 2 个结点组成的团有 5 个：$\left\{Y_1, Y_2\right\}$，$\left\{Y_2, Y_3\right\}$，$\left\{Y_3, Y_4\right\}$，$\left\{Y_4, Y_2\right\}$ 和 $\left\{Y_1, Y_3\right\}$。有 2 个最大团：$\left\{Y_1, Y_2, Y_3\right\}$ 和 $\left\{Y_2, Y_3, Y_4\right\}$。而 $\left\{Y_1, Y_2, Y_3, Y_4\right\}$ 不是一个团，因为 $Y_1$ 和 $Y_4$ 没有边连接。

将概率无向图模型的联合概率分布表示为其最大团上的随机变量的函数的乘积形式的操作，称为概率无向图模型的因子分解。给定无向图模型，设其无向图为 $G$，$C$ 为 $G$ 上的最大团，$Y_C$ 表示 $C$ 对应的随机变量。那么概率无向图模型的联合概率分布 $P \left(Y\right)$ 可以写作图中所有最大团 $C$ 上的函数 $\Psi_C \left(Y_C\right)$ 的乘积形式，即：

$$ P(Y)=\frac{1}{Z} \prod_{C} \Psi_{C}\left(Y_{C}\right) $$

其中，$Z$ 是规范化因子：

$$ Z=\sum_{Y} \prod_{C} \Psi_{C}\left(Y_{C}\right) $$

规范化因子保证 $P \left(Y\right)$ 构成一个概率分布。函数 $\Psi_C \left(Y_C\right)$ 称为势函数，这里要求势函数 $\Psi_C \left(Y_C\right)$ 是严格正的，通常定义为指数函数：

$$ \Psi_{C}\left(Y_{C}\right)=\exp \left\{-E\left(Y_{C}\right)\right\} $$

概率无向图模型的因子分解由这个 Hammersley-Clifford 定理来保证。

条件随机场（Conditional Random Field）是给定随机变量 $X$ 条件下，随机变量 $Y$ 的马尔可夫随机场。设 $X$ 与 $Y$ 是随机变量，$P \left(Y | X\right)$ 是给定 $X$ 的条件下 $Y$ 的条件概率分布。若随机变量 $Y$ 构成一个有无向图 $G = \left(V, E\right)$ 表示的马尔可夫随机场，即：

$$ P\left(Y_{v} | X, Y_{w}, w \neq v\right)=P\left(Y_{v} | X, Y_{w}, w \sim v\right) $$

对任意结点 $v$ 成立，则称条件概率分布 $P \left(Y | X\right)$ 为条件随机场。其中，$w \sim v$ 表示在图 $G = \left(V, E\right)$ 中与结点 $v$ 有边连接的所有结点 $w$，$w \neq v$ 表示结点 $v$ 以外的所有结点，$Y_v, Y_u$ 与 $Y_w$ 为结点 $v, u$ 和 $w$ 对应的随机变量。

定义中并没有要求 $X$ 和 $Y$ 具有相同的结构，一般假设 $X$ 和 $Y$ 有相同的图结构，下图展示了无向图的线性链情况，即：

$$ G=(V=\{1,2, \cdots, n\}, E=\{(i, i+1)\}), \quad i=1,2, \cdots, n-1 $$

此情况下，$X=\left(X_{1}, X_{2}, \cdots, X_{n}\right), Y=\left(Y_{1}, Y_{2}, \cdots, Y_{n}\right)$，最大团是相邻两个结点的集合。

线性链条件随机场：设 $X=\left(X_{1}, X_{2}, \cdots, X_{n}\right), Y=\left(Y_{1}, Y_{2}, \cdots, Y_{n}\right)$ 均为线性链表示的随机变量序列，若在给定随机变量序列 $X$ 的条件下，随机变量序列 $Y$ 的条件概率分布 $P \left(Y | X\right)$ 构成条件随机场，即满足马尔可夫性：

$$ \begin{array}{c} P\left(Y_{i} | X, Y_{1}, \cdots, Y_{i-1}, Y_{i+1}, \cdots, Y_{n}\right)=P\left(Y_{i} | X, Y_{i-1}, Y_{i+1}\right) \\ i=1,2, \cdots, n \quad (\text { 在 } i=1 \text { 和 } n \text { 时只考虑单边 }) \end{array} $$

则称 $P \left(Y | X\right)$ 为线性链条件随机场。在标注问题中，$X$ 表示输入观测序列，$Y$ 表示对应的输出标记序列或状态序列。

根据 Hammersley-Clifford 定理，设 $P \left(Y | X\right)$ 为线性链条件随机场，则在随机变量 $X$ 取值为 $x$ 的条件下，随机变量 $Y$ 取值为 $y$ 的条件概率有如下形式：

$$ P(y | x)=\frac{1}{Z(x)} \exp \left(\sum_{i, k} \lambda_{k} t_{k}\left(y_{i-1}, y_{i}, x, i\right)+\sum_{i, l} \mu_{l} s_{l}\left(y_{i}, x, i\right)\right) $$

其中，

$$ Z(x)=\sum_{y} \exp \left(\sum_{i, k} \lambda_{k} t_{k}\left(y_{i-1}, y_{i}, x, i\right)+\sum_{i, l} \mu_{l} s_{l}\left(y_{i}, x, i\right)\right) $$

其中，$t_k$ 和 $s_l$ 是特征函数，$\lambda_k$ 和 $\mu_l$ 是对应的权值。$Z \left(x\right)$ 是规范化因子，求和是在所有可能的输出序列上进行的。

条件随机场的概率计算，学习算法和预测算法类似隐马尔可夫模型，在此不进行过多赘述，有兴趣的同学可以参见 ¹。

综上所述，隐马尔可夫模型和条件随机场的主要联系和区别如下：

1. HMM 是概率有向图，CRF 是概率无向图
2. HMM 是生成模型，CRF 是判别模型

如上图所示，上面部分为生成式模型，下面部分为判别式模型，生成式模型尝试构建联合分布 $P \left(Y, X\right)$，而判别模型则尝试构建条件分布 $P \left(Y | X\right)$。

序列标注

序列标注（Sequence Labeling）是自然语言处理中的一项重要任务，对于给定的文本序列需要给出对应的标注序列。常见的序列标注任务包含：组块分析（Chunking），词性标注（Part-of-Speech，POS）和命名实体识别（Named Entity Recognition，NER）。

上图为一段文本的词性标注和命名实体识别的结果。

词性标注

词性标注是指为分词结果中的每个单词标注一个正确的词性，即确定每个词是名词、动词、形容词或其他词性的过程。

一些常用中文标注规范如下：

1. 北京大学现代汉语语料库基本加工规范 ²
2. 北大语料库加工规范：切分·词性标注·注音 ³
3. 计算所汉语词性标记集 3.0（ICTPOS 3.0）⁴
4. The Part-Of-Speech Tagging Guidelines for the Penn Chinese Treebank (3.0) ⁵
5. 中文文本标注规范（微软亚洲研究院）⁶

命名实体识别

命名实体识别，又称作“专名识别”，是指识别文本中具有特定意义的实体，主要包括人名、地名、机构名、专有名词等。简单的讲，就是识别自然文本中的实体指称的边界和类别。

常用的标注标准有 IO，BIO，BIOES，BMEWO 和 BMEWO+ 等。（参考自：Coding Chunkers as Taggers: IO, BIO, BMEWO, and BMEWO+）

1. IO 标注标准是最简单的标注方式，对于命名实体类别 X 标注为 I_X，其他则标注为 O。由于没有标签界线表示，这种方式无法表示两个相邻的同类命名实体。
2. BIO 标注标准将命名实体的起始部分标记为 B_X，其余部分标记为 I_X。
3. BIOES 标注标准将命名实体的起始部分标记为 B_X，中间部分标记为 I_X，结尾部分标记为 E_X，对于单个字符成为命名实体的情况标记为 S_X。
4. BMEWO 标注标准将命名实体的起始部分标记为 B_X，中间部分标记为 M_X，结尾部分标记为 E_X，对于单个字符成为命名实体的情况标记为 W_X。
5. BMEWO+ 标注标准在 BMEWO 的基础上针对不同情况的非命名实体标签的标注进行了扩展，同时增加了一个句外（out-of-sentence）标签 W_OOS，句子起始标签 BB_O_OOS 和句子结束标签 WW_O_OOS，如 下表 所示：

不同标注标准的差别示例如下：

不同标准的标签数量如下表所示：

其中，N 为命名实体类型的数量。

BiLSTM CRF ⁷

本小节内容参考和修改自 CRF-Layer-on-the-Top-of-BiLSTM。

Huang 等人提出了一种基于 BiLSTM 和 CRF 的神经网络模型用于序例标注。整个网络如下图所示：

关于模型中的 BiLSTM 部分在此不过多赘述，相关细节可以参见之前的博客：循环神经网络 (Recurrent Neural Network, RNN) 和 预训练自然语言模型 (Pre-trained Models for NLP)。BiLSTM-CRF 模型的输入是词嵌入向量，输出是对应的预测标注标签，如下图所示：

BiLSTM 层的输出为每个标签的分数，对于 $w_0$，BiLSTM 的输出为 1.5 (B_PER)，0.9 (I_PER)，0.1 (B_ORG)，0.08 (I_ORG) 和 0.05 (O)，这些分数为 CRF 层的输入，如下图所示：

经过 CRF 层后，具有最高分数的预测序列被选择为最优预测结果。如果没有 CRF 层，我们可以直接选择 BiLSTM 层输出分数的最大值对应的序列为预测结果。例如，对于 $w_0$，最高分数为 1.5，对应的预测标签则为 B_PER，类似的 $w_1, w_2, w_3, w_4$ 对应的预测标签为 I_PER, O, B_ORG, O，如下图所示：

虽然我们在上例中得到了正确的结果，但通常情况下并非如此。对于如下的示例，预测结果为 I_ORG, I_PER, O, I_ORG, I_PER，这显然是不正确的。

CRF 层在进行预测时可以添加一些约束，这些约束可以在训练时被 CRF 层学习得到。可能的约束有：

• 句子的第一个词的标签可以是 B_X 或 O，而非 I_X。
• B_X, I_X 是有效的标签，而 B_X, I_Y 是无效的标签。
• 一个命名实体的起始标签应为 B_X 而非 I_X。

CRF 层的损失包含两部分，这两部分构成了 CRF 层的关键：

• 发射分数（Emission Score）

发射分数即为 BiLSTM 层的输出分数，例如 $w_0$ 对应的标签 B_PER 的分数为 1.5。为了方便起见，对于每类标签给定一个索引：

我们利用 $x_{i y_{j}}$ 表示发射分数，$i$ 为词的索引，$y_i$ 为标注标签的索引。例如：$x_{i=1, y_{j}=2} = x_{w_1, \text{B_ORG}} = 0.1$，表示 $w_1$ 为 B_ORG 的分数为 0.1。

• 转移分数（Transition Score）

我们利用 $t_{y_i, y_j}$ 表示转移分数，例如 $t_{\text{B_PER}, \text{I_PER}} = 0.9$ 表示由标签 B_PER 转移到 I_PER 的分数为 0.9。因此，需要一个转移分数矩阵用于存储所有标注标签之间的转移分数。为了使得转移分数矩阵更加鲁棒，需要添加两个标签 START 和 END，分别表示一个句子的开始和结束。下表为一个转移分数矩阵的示例：

转移分数矩阵作为 BiLSTM-CRF 模型的一个参数，随机初始化并通过模型的训练不断更新，最终学习得到约束条件。

CRF 层的损失函数包含两个部分：真实路径分数和所有可能路径的总分数。假设每个可能的路径有一个分数 $P_i$，共 $N$ 种可能的路径，所有路径的总分数为：

$$ P_{\text {total}}=P_{1}+P_{2}+\ldots+P_{N}=e^{S_{1}}+e^{S_{2}}+\ldots+e^{S_{N}} $$

则损失函数定义为：

$$ \text{Loss} = \dfrac{P_{\text{RealPath}}}{\sum_{i=1}^{N} P_i} $$

对于 $S_i$，共包含两部分：发射分数和转移分数。以路径 START -> B_PER -> I_PER -> O -> B_ORG -> O -> END 为例，发射分数为：

$$ \begin{aligned} \text{EmissionScore} = \ &x_{0, \text{START}} + x_{1, \text{B_PER}} + x_{2, \text{I_PER}} \\ &+ x_{3, \text{O}} + x_{4, \text{B_ORG}} + x_{5, \text{O}} + x_{6, \text{END}} \end{aligned} $$

其中 $x_{i, y_j}$ 表示第 $i$ 个词标签为 $y_j$ 的分数，为 BiLSTM 的输出，$x_{0, \text{START}}$ 和 $x_{6, \text{END}}$ 可以设置为 0。转换分数为：

$$ \begin{aligned} \text{TransitionScore} = \ &t_{\text{START}, \text{B_PER}} + t_{\text{B_PER}, \text{I_PER}} + t_{\text{I_PER}, \text{O}} \\ &+ t_{\text{O}, \text{B_ORG}} + t_{\text{B_ORG}, \text{O}} + t_{\text{O}, \text{END}} \end{aligned} $$

其中 $t_{y_i, y_j}$ 表示标注标签由 $y_i$ 转移至 $y_j$ 的分数。

对于所有路径的总分数的计算过程采用了类似 动态规划 的思想，整个过程计算比较复杂，在此不再详细展开，详细请参见参考文章。

利用训练好的 BiLSTM-CRF 模型进行预测时，首先我们可以得到序列的发射分数和转移分数，其次用维特比算法可以得到最终的预测标注序列。

Lattice LSTM ⁸

Zhang 等人针对中文提出了一种基于 Lattice LSTM 的命名实体识别方法，Lattice LSTM 的结构如下图所示：

模型的基本思想是将句子中的词汇（例如：南京，长江大桥等）信息融入到基于字符的 LSTM 模型中，从而可以显性地利用词汇信息。

模型的输入为一个字符序列 $c_1, c_2, \cdots, c_m$ 和词汇表 $\mathbb{D}$ 中所有匹配的字符子序列，其中词汇表 $\mathbb{D}$ 利用大量的原始文本通过分词构建。令 $w_{b, e}^d$ 表示有以第 $b$ 个字符起始，以第 $e$ 个字符结尾的子序列，例如：$w_{1,2}^d$ 表示“南京 ”，$w_{7,8}^d$ 表示“大桥”。

不同于一般的字符级模型，LSTM 单元的状态考虑了句子中的子序列 $w_{b,e}^d$，每个子序列 $w_{b,e}^d$ 表示为：

$$ \mathbf{x}_{b, e}^{w}=\mathbf{e}^{w}\left(w_{b, e}^{d}\right) $$

其中，$\mathbf{e}^{w}$ 为词向量查询表。一个词单元 $\mathbf{c}_{b,e}^w$ 用于表示 $\mathbf{x}_{b,e}^w$ 的循环状态：

$$ \begin{aligned} \left[\begin{array}{c} \mathbf{i}_{b, e}^{w} \\ \mathbf{f}_{b, e}^{w} \\ \widetilde{c}_{b, e}^{w} \end{array}\right] &=\left[\begin{array}{c} \sigma \\ \sigma \\ \tanh \end{array}\right]\left(\mathbf{W}^{w \top}\left[\begin{array}{c} \mathbf{x}_{b, e}^{w} \\ \mathbf{h}_{b}^{c} \end{array}\right]+\mathbf{b}^{w}\right) \\ \mathbf{c}_{b, e}^{w} &=\mathbf{f}_{b, e}^{w} \odot \mathbf{c}_{b}^{c}+\mathbf{i}_{b, e}^{w} \odot \widetilde{c}_{b, e}^{w} \end{aligned} $$

其中，$\mathbf{i}_{b, e}^{w}$ 和 $\mathbf{f}_{b, e}^{w}$ 分别为输入门和遗忘门。由于仅在字符级别上进行标注，因此对于词单元来说没有输出门。

对于 $\mathbf{c}_{j}^c$ 来说可能有多条信息流，例如 $\mathbf{c}_7^c$ 的输入包括 $\mathbf{x}_7^c$（桥），$\mathbf{c}_{6,7}^w$（大桥）和 $\mathbf{c}_{4,7}^w$（长江大桥）。论文采用了一个新的门 $\mathbf{i}_{b,e}^c$ 来控制所有子序列单元 $\mathbf{c}_{b,e}^w$ 对 $\mathbf{c}_{j}^c$ 的贡献：

$$ \mathbf{i}_{b, e}^{c}=\sigma\left(\mathbf{W}^{l \top}\left[\begin{array}{c} \mathbf{x}_{e}^{c} \\ \mathbf{c}_{b, e}^{w} \end{array}\right]+\mathbf{b}^{l}\right) $$

则单元状态 $\mathbf{c}_j^c$ 的计算变为：

$$ \mathbf{c}_{j}^{c}=\sum_{b \in\left\{b^{\prime} | w_{b^{\prime}, j} \in \mathbb{D}\right\}} \boldsymbol{\alpha}_{b, j}^{c} \odot \boldsymbol{c}_{b, j}^{w}+\boldsymbol{\alpha}_{j}^{c} \odot \widetilde{\boldsymbol{c}}_{j}^{c} $$

在上式中，$\mathbf{i}_{b,j}^c$ 和 $\mathbf{i}_j^c$ 标准化为 $\boldsymbol{\alpha}_{b, j}^{c}$ 和 $\boldsymbol{\alpha}_{j}^{c}$：

$$ \begin{aligned} \boldsymbol{\alpha}_{b, j}^{c} &=\frac{\exp \left(\mathbf{i}_{b, j}^{c}\right)}{\exp \left(\mathbf{i}_{j}^{c}\right)+\sum_{b^{\prime} \in\left\{b^{\prime \prime} | w_{b^{\prime \prime}, j}^{d} \in \mathbb{D}\right\}} \exp \left(\mathbf{i}_{b^{\prime}, j}^{c}\right)} \\ \boldsymbol{\alpha}_{j}^{c} &=\frac{\exp \left(\mathbf{i}_{j}^{c}\right)}{\exp \left(\mathbf{i}_{j}^{c}\right)+\sum_{b^{\prime} \in\left\{b^{\prime \prime} | w_{b^{\prime \prime}, j}^{d} \in \mathbb{D}\right\}} \exp \left(\mathbf{i}_{b^{\prime}, j}^{c}\right)} \end{aligned} $$

开放资源

标注工具

1. synyi/poplar
2. nlplab/brat
3. doccano/doccano
4. heartexlabs/label-studio
5. deepwel/Chinese-Annotator
6. jiesutd/YEDDA

开源模型，框架和代码

1. pytorch/text
2. flairNLP/flair
3. PetrochukM/PyTorch-NLP
4. allenai/allennlp
5. fastnlp/fastNLP
6. Stanford CoreNLP
7. NeuroNER
8. spaCy
9. NLTK
10. BrikerMan/Kashgari
11. Hironsan/anago
12. crownpku/Information-Extraction-Chinese
13. thunlp/OpenNRE
14. hankcs/HanLP
15. jiesutd/NCRFpp

其他资源

1. keon/awesome-nlp
2. crownpku/Awesome-Chinese-NLP
3. sebastianruder/NLP-progress
4. thunlp/NREPapers

通常定义一个图 $G = \left(V, E\right)$，其中 $V$ 为顶点（Vertices）集合，$E$ 为边（Edges）集合。对于一条边 $e = u, v$ 包含两个端点（Endpoints） $u$ 和 $v$，同时 $u$ 可以称为 $v$ 的邻居（Neighbor）。当所有的边为有向边时，图称之为有向（Directed）图，当所有边为无向边时，图称之为无向（Undirected）图。对于一个顶点 $v$，令 $d \left(v\right)$ 表示连接的边的数量，称之为度（Degree）。对于一个图 $G = \left(V, E\right)$，其邻接矩阵（Adjacency Matrix） $A \in \mathbb{A}^{|V| \times |V|}$ 定义为：

$$ A_{i j}=\left\{\begin{array}{ll} 1 & \text { if }\left\{v_{i}, v_{j}\right\} \in E \text { and } i \neq j \\ 0 & \text { otherwise } \end{array}\right. $$

作为一个典型的非欧式数据，对于图数据的分析主要集中在节点分类，链接预测和聚类等。对于图数据而言，**图嵌入（Graph / Network Embedding）和图神经网络（Graph Neural Networks, GNN）**是两个类似的研究领域。图嵌入旨在将图的节点表示成一个低维向量空间，同时保留网络的拓扑结构和节点信息，以便在后续的图分析任务中可以直接使用现有的机器学习算法。一些基于深度学习的图嵌入同时也属于图神经网络，例如一些基于图自编码器和利用无监督学习的图卷积神经网络等。下图描述了图嵌入和图神经网络之间的差异：

图嵌入

本节内容主要参考自：
A Comprehensive Survey of Graph Embedding: Problems, Techniques and Applications ¹
Graph Embedding Techniques, Applications, and Performance: A Survey ²
Representation Learning on Graphs: Methods and Applications ³

使用邻接矩阵的网络表示存在计算效率的问题，邻接矩阵 $A$ 使用 $|V| \times |V|$ 的存储空间表示一个图，随着节点个数的增长，这种表示所需的空间成指数增长。同时，在邻接矩阵中绝大多数是 0，数据的稀疏性使得快速有效的学习方式很难被应用。

网路表示学习是指学习得到网络中节点的低维向量表示，形式化地，网络表示学习的目标是对每个节点 $v \in V$ 学习一个实值向量 $R_v \in \mathbb{R}^k$，其中 $k \ll |V|$ 表示向量的维度。经典的 Zachary’s karate club 网络的嵌入可视化如下图所示：

Random Walk

基于随机游走的图嵌入通过使得图上一个短距的随机游走中共现的节点具有更相似的表示的方式来优化节点的嵌入。

DeepWalk

DeepWalk ⁴ 算法主要包含两个部分：一个随机游走序列生成器和一个更新过程。随机游走序列生成器首先在图 $G$ 中均匀地随机抽样一个随机游走 $\mathcal{W}_{v_i}$ 的根节点 $v_i$，接着从节点的邻居中均匀地随机抽样一个节点直到达到设定的最大长度 $t$。对于一个生成的以 $v_i$ 为中心左右窗口为 $w$ 的随机游走序列 $v_{i-w}, \dotsc, v_{i-1}, v_i, v_{i+1}, \dotsc, v_{i+m}$，DeepWalk 利用 SkipGram 算法通过最大化以 $v_i$ 为中心，左右 $w$ 为窗口的同其他节点共现概率来优化模型：

$$ \text{Pr} \left(\left\{v_{i-w}, \dotsc, v_{i+w}\right\} \setminus v_i \mid \Phi \left(v_i\right)\right) = \prod_{j=i-w, j \neq i}^{i+w} \text{Pr} \left(v_j \mid \Phi \left(v_i\right)\right) $$

DeepWalk 和 Word2Vec 的类比如下表所示：

node2vec

node2vec ⁵ 通过改变随机游走序列生成的方式进一步扩展了 DeepWalk 算法。DeepWalk 选取随机游走序列中下一个节点的方式是均匀随机分布的，而 node2vec 通过引入两个参数 $p$ 和 $q$，将宽度优先搜索和深度优先搜索引入了随机游走序列的生成过程。 宽度优先搜索注重邻近的节点并刻画了相对局部的一种网络表示， 宽度优先中的节点一般会出现很多次，从而降低刻画中心节点的邻居节点的方差， 深度优先搜索反映了更高层面上的节点之间的同质性。

node2vec 中的两个参数 $p$ 和 $q$ 控制随机游走序列的跳转概率。假设上一步游走的边为 $\left(t, v\right)$， 那么对于节点 $v$ 的不同邻居，node2vec 根据 $p$ 和 $q$ 定义了不同的邻居的跳转概率，$p$ 控制跳向上一个节点的邻居的概率，$q$ 控制跳向上一个节点的非邻居的概率，具体的未归一的跳转概率值 $\pi_{vx} = \alpha_{pq} \left(t, x\right)$ 如下所示：

$$ \alpha_{p q}(t, x)=\left\{\begin{array}{cl} \dfrac{1}{p}, & \text { if } d_{t x}=0 \\ 1, & \text { if } d_{t x}=1 \\ \dfrac{1}{q}, & \text { if } d_{t x}=2 \end{array}\right. $$

其中，$d_{tx}$ 表示节点 $t$ 和 $x$ 之间的最短距离。为了获得最优的超参数 $p$ 和 $q$ 的取值，node2vec 通过半监督形式，利用网格搜索最合适的参数学习节点表示。

APP

之前的基于随机游走的图嵌入方法，例如：DeepWalk，node2vec 等，都无法保留图中的非对称信息。然而非对称性在很多问题，例如：社交网络中的链路预测、电商中的推荐等，中至关重要。在有向图和无向图中，非对称性如下图所示：

为了保留图的非对称性，对于每个节点 $v$ 设置两个不同的角色：源和目标，分别用 $\overrightarrow{s_{v}}$ 和 $\overrightarrow{t_{v}}$ 表示。对于每个从 $u$ 开始以 $v$ 结尾的采样序列，利用 $(u, v)$ 表示采样的节点对。则利用源节点 $u$ 预测目标节点 $v$ 的概率如下：

$$ p(v | u)=\frac{\exp (\overrightarrow{s_{u}} \cdot \overrightarrow{t_{v}})}{\sum_{n \in V} \exp (\overrightarrow{s_{u}} \cdot \overrightarrow{t_{n}})} $$

通过 Skip-Gram 和负采样对模型进行优化，损失函数如下：

$$ \begin{aligned} \ell &= \log \sigma(\overrightarrow{s_{u}} \cdot \overrightarrow{t_{v}})+k \cdot E_{t_{n} \sim P_{D}}[\log \sigma(-\overrightarrow{s_{u}} \cdot \overrightarrow{t_{n}})] \\ &= \sum_{u} \sum_{v} \# \text {Sampled}_{u}(v) \cdot \left(\log \sigma(\overrightarrow{s_{u}} \cdot \overrightarrow{t_{v}}) + k \cdot E_{t_{n} \sim P_{D}}[\log \sigma(-\overrightarrow{s_{u}} \cdot \overrightarrow{t_{n}})]\right) \end{aligned} $$

其中，我们根据分布 $P_D \left(n\right) \sim \dfrac{1}{|V|}$ 随机负采样 $k$ 个节点对，$\# \text{Sampled}_{u}(v)$ 为采样的 $\left(u, v\right)$ 对的个数，$\sigma$ 为 sigmoid 函数。通常情况下，$\# \text{Sampled}_{u}(v) \neq \# \text{Sampled}_{v}(u)$，即 $\left(u, v\right)$ 和 $\left(v, u\right)$ 的观测数量是不同的。模型利用 Monte-Carlo End-Point 采样方法 ⁶ 随机的以 $v$ 为起点和 $\alpha$ 为停止概率采样 $p$ 条路径。这种采样方式可以用于估计任意一个节点对之间的 Rooted PageRank ⁷ 值，模型利用这个值估计由 $v$ 到达 $u$ 的概率。

Matrix Fractorization

GraRep

GraRep ⁸ 提出了一种基于矩阵分解的图嵌入方法。对于一个图 $G$，利用邻接矩阵 $S$ 定义图的度矩阵：

$$ D_{i j}=\left\{\begin{array}{ll} \sum_{p} S_{i p}, & \text { if } i=j \\ 0, & \text { if } i \neq j \end{array}\right. $$

则一阶转移概率矩阵定义如下：

$$ A = D^{-1} S $$

其中，$A_{i, j}$ 表示通过一步由 $v_i$ 转移到 $v_j$ 的概率。所谓的全局特征包含两个部分：

1. 捕获两个节点之间的长距离特征
2. 分别考虑按照不同转移步数的连接

下图展示了 $k = 1, 2, 3, 4$ 情况下的强（上）弱（下）关系：

利用 Skip-Gram 和 NCE（noise contrastive estimation）方法，对于一个 $k$ 阶转移，可以将模型归结到一个矩阵 $Y_{i, j}^k$ 的分解问题：

$$ Y_{i, j}^{k}=W_{i}^{k} \cdot C_{j}^{k}=\log \left(\frac{A_{i, j}^{k}}{\sum_{t} A_{t, j}^{k}}\right)-\log (\beta) $$

其中，$W$ 和 $C$ 的每一行分别为节点 $w$ 和 $c$ 的表示，$\beta = \lambda / N$，$\lambda$ 为负采样的数量，$N$ 为图中边的个数。

之后为了减少噪音，模型将 $Y^k$ 中所有的负值替换为 0，通过 SVD（方法详情见参见之前博客）得到节点的 $d$ 维表示：

$$ \begin{aligned} X_{i, j}^{k} &= \max \left(Y_{i, j}^{k}, 0\right) \\ X^{k} &= U^{k} \Sigma^{k}\left(V^{k}\right)^{T} \\ X^{k} \approx X_{d}^{k} &= U_{d}^{k} \Sigma_{d}^{k}\left(V_{d}^{k}\right)^{T} \\ X^{k} \approx X_{d}^{k} &= W^{k} C^{k} \\ W^{k} &= U_{d}^{k}\left(\Sigma_{d}^{k}\right)^{\frac{1}{2}} \\ C^{k} &= \left(\Sigma_{d}^{k}\right)^{\frac{1}{2}} V_{d}^{k T} \end{aligned} $$

最终，通过对不同 $k$ 的表示进行拼接得到节点最终的表示。

HOPE

HOPE ⁹ 对于每个节点最终生成两个嵌入表示：一个是作为源节点的嵌入表示，另一个是作为目标节点的嵌入表示。模型通过近似高阶相似性来保留非对称传递性，其优化目标为：

$$ \min \left\|\mathbf{S}-\mathbf{U}^{s} \cdot \mathbf{U}^{t^{\top}}\right\|_{F}^{2} $$

其中，$\mathbf{S}$ 为相似矩阵，$\mathbf{U}^s$ 和 $\mathbf{U}^t$ 分别为源节点和目标节点的向量表示。下图展示了嵌入向量可以很好的保留非对称传递性：

对于 $\mathbf{S}$ 有多种可选近似度量方法：Katz Index，Rooted PageRank（RPR），Common Neighbors（CN），Adamic-Adar（AA）。这些度量方法可以分为两类：全局近似（Katz Index 和 RPR）和局部近似（CN 和 AA）。

算法采用了一个广义 SVD 算法（JDGSVD）来解决使用原始 SVD 算法计算复杂度为$O \left(N^3\right)$ 过高的问题，从而使得算法可以应用在更大规模的图上。

Meta Paths

matapath2vec

matapath2vec ¹⁰ 提出了一种基于元路径的异构网络表示学习方法。在此我们引入 3 个定义：

1. **异构网络（(Heterogeneous information network，HIN）**可以定义为一个有向图 $G = \left(V, E\right)$，一个节点类型映射 $\tau: V \to A$ 和一个边类型映射 $\phi: E \to R$，其中对于 $v \in V$ 有 $\tau \left(v\right) \in A$，$e \in E$ 有 $\phi \left(e\right) \in R$，且 $|A| + |R| > 1$。
2. **网络模式（Network schema）**定义为 $T_G = \left(A, R\right)$，为一个包含节点类型映射 $\tau \left(v\right) \in A$ 和边映射 $\phi \left(e\right) \in R$ 异构网络的 $G = \left(V, E\right)$ 的元模板。
3. **元路径（Meta-path）**定义为网络模式 $T_G = \left(A, R\right)$ 上的一条路径 $P$，形式为 $A_{1} \stackrel{R_{1}}{\longrightarrow} A_{2} \stackrel{R_{2}}{\longrightarrow} \cdots \stackrel{R_{l}}{\longrightarrow} A_{l+1}$。

下图展示了一个学术网络和部分元路径：

其中，APA 表示一篇论文的共同作者，APVPA 表示两个作者在同一个地方发表过论文。

metapath2vec 采用了基于元路径的随机游走来生成采样序列，这样就可以保留原始网络中的语义信息。对于一个给定的元路径模板 $P: A_{1} \stackrel{R_{1}}{\longrightarrow} A_{2} \stackrel{R_{2}}{\longrightarrow} \cdots A_{t} \stackrel{R_{t}}{\longrightarrow} A_{t+1} \cdots \stackrel{R_{l}}{\longrightarrow} A_{l}$，第 $i$ 步的转移概率为：

$$ p\left(v^{i+1} | v_{t}^{i}, P\right)=\left\{\begin{array}{ll} \dfrac{1}{\left|N_{t+1}\left(v_{t}^{i}\right)\right|} & \left(v_{t}^{i}, v^{i+1}\right) \in E, \phi\left(v^{i+1}\right)=A_{t+1} \\ 0 & \left(v_{t}^{i}, v^{i+1}\right) \in E, \phi\left(v^{i+1}\right) \neq A_{t+1} \\ 0 & \left(v_{t}^{i}, v^{i+1}\right) \notin E \end{array}\right. $$

其中，$v^i_t \in A_t$，$N_{t+1} \left(v^i_t\right)$ 表示节点 $v^i_t$ 类型为 $A_{t+1}$ 的邻居。之后，则采用了类似 DeepWalk 的方式进行训练得到节点表示。

HIN2Vec

HIN2Vec ¹¹ 提出了一种利用多任务学习通过多种关系进行节点和元路径表示学习的方法。模型最初是希望通过一个多分类模型来预测任意两个节点之间所有可能的关系。假设对于任意两个节点，所有可能的关系集合为 $R = \{\text{P-P, P-A, A-P, P-P-P, P-P-A, P-A-P, A-P-P, A-P-A}\}$。假设一个实例 $P_1$ 和 $A_1$ 包含两种关系：$\text{P-A}$ 和 $\text{P-P-A}$，则对应的训练数据为 $\langle x: P_1, y: A_1, output: \left[0, 1, 0, 0, 1, 0, 0, 0\right] \rangle$。

但实际上，扫描整个网络寻找所有可能的关系是不现实的，因此 HIN2Vec 将问题简化为一个给定两个节点判断之间是否存在一个关系的二分类问题，如下图所示：

模型的三个输入分别为节点 $x$ 和 $y$，以及关系 $r$。在隐含层输入被转换为向量 $W_{X}^{\prime} \vec{x}, W_{Y}^{\prime} \vec{y}$ 和 $f_{01}\left(W_{R}^{\prime} \vec{r}\right)$。需要注意对于关系 $r$，模型应用了一个正则化函数 $f_{01} \left(\cdot\right)$ 使得 $r$ 的向量介于 $0$ 和 $1$ 之间。之后采用逐元素相乘对三个向量进行汇总 $W_{X}^{\prime} \vec{x} \odot W_{Y}^{\prime} \vec{y} \odot f_{01}\left(W_{R}^{\prime} \vec{r}\right)$。在最后的输出层，通过计算 $sigmoid \left(\sum W_{X}^{\prime} \vec{x} \odot W_{Y}^{\prime} \vec{y} \odot f_{01}\left(W_{R}^{\prime} \vec{r}\right)\right)$ 得到最终的预测值。

在生成训练数据时，HIN2Vec 采用了完全随机游走进行节点采样，而非 metapath2vec 中的按照给定的元路径的方式。通过随机替换 $x, y, r$ 中的任何一个可以生成负样本，但当网络中的关系数量较少，节点数量远远大于关系数量时，这种方式很可能产生错误的负样本，因此 HIN2Vec 只随机替换 $x, y$，保持 $r$ 不变。

Deep Learning

SDNE

SDNE ¹² 提出了一种利用自编码器同时优化一阶和二阶相似度的图嵌入算法，学习得到的向量能够保留局部和全局的结构信息。SDNE 使用的网络结构如下图所示：

对于二阶相似度，自编码器的目标是最小化输入和输出的重构误差。SDNE 采用邻接矩阵作为自编码器的输入，$\mathbf{x}_i = \mathbf{s}_i$，每个 $\mathbf{s}_i$ 包含了节点 $v_i$ 的邻居结构信息。模型的损失函数如下：

$$ \mathcal{L}=\sum_{i=1}^{n}\left\|\hat{\mathbf{x}}_{i}-\mathbf{x}_{i}\right\|_{2}^{2} $$

由于网络的稀疏性，邻接矩阵中的非零元素远远少于零元素，因此模型采用了一个带权的损失函数：

$$ \begin{aligned} \mathcal{L}_{2nd} &=\sum_{i=1}^{n}\left\|\left(\hat{\mathbf{x}}_{i}-\mathbf{x}_{i}\right) \odot \mathbf{b}_{i}\right\|_{2}^{2} \\ &=\|(\hat{X}-X) \odot B\|_{F}^{2} \end{aligned} $$

其中，$\odot$ 表示按位乘，$\mathbf{b}_i = \left\{b_{i, j}\right\}_{j=1}^{n}$，如果 $s_{i, j} = 0$ 则 $b_{i, j} = 1$ 否则 $b_{i, j} = \beta > 1$。

对于一阶相似度，模型利用了一个监督学习模块最小化节点在隐含空间中距离。损失函数如下：

$$ \begin{aligned} \mathcal{L}_{1st} &=\sum_{i, j=1}^{n} s_{i, j}\left\|\mathbf{y}_{i}^{(K)}-\mathbf{y}_{j}^{(K)}\right\|_{2}^{2} \\ &=\sum_{i, j=1}^{n} s_{i, j}\left\|\mathbf{y}_{i}-\mathbf{y}_{j}\right\|_{2}^{2} \end{aligned} $$

最终，模型联合损失函数如下：

$$ \begin{aligned} \mathcal{L}_{mix} &=\mathcal{L}_{2nd}+\alpha \mathcal{L}_{1st}+\nu \mathcal{L}_{reg} \\ &=\|(\hat{X}-X) \odot B\|_{F}^{2}+\alpha \sum_{i, j=1}^{n} s_{i, j}\left\|\mathbf{y}_{i}-\mathbf{y}_{j}\right\|_{2}^{2}+\nu \mathcal{L}_{reg} \end{aligned} $$

其中，$\mathcal{L}_{reg}$ 为 L2 正则项。

DNGR

DNGR ¹³ 提出了一种利用基于 Stacked Denoising Autoencoder（SDAE）提取特征的网络表示学习算法。算法的流程如下图所示：

模型首先利用 Random Surfing 得到一个概率共现（PCO）矩阵，之后利用其计算得到 PPMI 矩阵，最后利用 SDAE 进行特征提取得到节点的向量表示。

对于传统的将图结构转换为一个线性序列方法存在几点缺陷：

1. 采样序列边缘的节点的上下文信息很难被捕捉。
2. 很难直接确定游走的长度和步数等超参数，尤其是对于大型网络来说。

受 PageRank 思想影响，作者采用了 Random Surfing 模型。定义转移矩阵 $A$，引入行向量 $p_k$，第 $j$ 个元素表示通过 $k$ 步转移之后到达节点 $j$ 的概率。$p_0$ 为一个初始向量，其仅第 $i$ 个元素为 1，其它均为 0。在考虑以 $1 - \alpha$ 的概率返回初始节点的情况下有：

$$ p_{k}=\alpha \cdot p_{k-1} A+(1-\alpha) p_{0} $$

在不考虑返回初始节点的情况下有：

$$ p_{k}^{*}=p_{k-1}^{*} A=p_{0} A^{k} $$

直观而言，两个节点越近，两者的关系越亲密，因此通过同当前节点的相对距离来衡量上下文节点的重要性是合理的。基于此，第 $i$ 个节点的表示可以用如下方式构造：

$$ r=\sum_{k=1}^{K} w(k) \cdot p_{k}^{*} $$

其中，$w \left(\cdot\right)$ 是一个衰减函数。

利用 PCO 计算得到 PPMI 后，再利用一个 SDAE 进行特征提取。Stacking 策略可以通过不同的网络层学习得到不同层级的表示，Denoising 策略则通过去除数据中的噪声，增加结果的鲁棒性。同时，SNGR 相比基于 SVD 的方法效率更高。

Others

LINE

LINE ¹⁴ 提出了一个用于大规模网络嵌入的方法，其满足如下 3 个要求：

1. 同时保留节点之间的一阶相似性（first-order proximity）和二阶相似性（second-order proximity）。
2. 可以处理大规模网络，例如：百万级别的顶点和十亿级别的边。
3. 可以处理有向，无向和带权的多种类型的图结构。

给定一个无向边 $\left(i, j\right)$，点 $v_i$ 和 $v_j$ 的联合概率如下：